File: test/HydraTest.js

TestCase("HydraInitializationTest", sinon.testCase({
	setUp: function () {},
	"test should return an object for window.Hydra or Hydra": function () {
		assertObject(window.Hydra);
		assertObject(Hydra);
	},
	"test should return a function for action property of Hydra": function () {
		assertFunction(Hydra.action);
	},
	"test should return a function for action property of Hydra": function () {
		assertFunction(Hydra.action);
	},
	"test should return a function for errorHandler property of Hydra": function () {
		assertFunction(Hydra.errorHandler);
	},
	"test should return a function for setErrorHandler property of Hydra": function () {
		assertFunction(Hydra.setErrorHandler);
	},
	"test should return a Module object for module property of Hydra": function () {
		assertObject(Hydra.module);
		assertEquals("Module", Hydra.module.type);
	},
	tearDown: function () {}
}));

TestCase("HydraActionTest", sinon.testCase({
	setUp: function () {},
	"test should return the Action Class": function () {
		var oResult = null;

		oResult = Hydra.action();

		assertEquals("Action", oResult.type);
	},
	"test should return an instance of Action": function () {
		var oInstance = null;

		var oClass = Hydra.action();
		oInstance = new (oClass);

		assertInstanceOf(oClass, oInstance);
	},
	tearDown: function () {}
}));

TestCase("HydraErrorHandlerTest", sinon.testCase({
	setUp: function () {},
	"test should return the ErrorHandler Class": function () {
		var oResult = null;

		oResult = Hydra.errorHandler();

		assertEquals("ErrorHandler", oResult.type);
	},
	"test should return an instance of ErrorHandler": function () {
		var oInstance = null;

		var oClass = Hydra.errorHandler();
		oInstance = new (oClass);

		assertInstanceOf(oClass, oInstance);
	},
	tearDown: function () {}
}));

TestCase("HydraSetErrorHandlerTest", sinon.testCase({
	setUp: function () {
		this.ErrorHandler = Hydra.errorHandler();
		var FakeClass = function () {};
		FakeClass.type = 'Fake';

		Hydra.setErrorHandler(FakeClass);
	},
	"test should change the ErrorHandler Class to a Fake Class": function () {
		var oResult = null;

		oResult = Hydra.errorHandler();

		assertEquals("Fake", oResult.type);
	},
	"test should return an instance of Fake Class": function () {
		var oInstance = null;
		var oClass =  null;

		oClass = Hydra.errorHandler();
		oInstance = new (oClass);

		assertInstanceOf(oClass, oInstance);
	},
	tearDown: function () {
		Hydra.setErrorHandler(this.ErrorHandler);
	}
}));

TestCase("HydraModuleRegisterTest", sinon.testCase({
	setUp: function () {
		this.sModuleId = 'test';
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {

				},
				handleAction: function () {

				},
				destroy: function () {

				}
			}
		};
	},
	"test should throw an error if we try to create a module without register if the ErrorHandler Class": function () {
		var self = this;
		assertException(function()
		{
			Hydra.module.test(self.sModuleId, function (oModule) {});
		});
	},
	"test should return a module if we create a module registering it": function () {

		Hydra.module.register(this.sModuleId, this.fpModuleCreator);

		Hydra.module.test(this.sModuleId, function (oModule) {
			assertObject(oModule);
		});
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
	}
}));

TestCase("HydraModuleRemoveTest", sinon.testCase({
	setUp: function () {
		this.sModuleId = 'test';
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {

				},
				handleAction: function () {

				},
				destroy: function () {

				}
			}
		};

		sinon.spy(Hydra.module, "_delete");
	},
	"test should not call the delete native if the module is not registered before remove it": function () {
		Hydra.module.remove(this.sModuleId);

		assertEquals(0, Hydra.module._delete.callCount);
	},
	"test should call the delete native one time if the module is registered before remove it": function () {
		Hydra.module.register(this.sModuleId, this.fpModuleCreator);

		Hydra.module.remove(this.sModuleId);

		assertTrue(Hydra.module._delete.calledOnce);
	},
	tearDown: function () {
		Hydra.module._delete.restore();
	}
}));

TestCase("HydraModuleStartTest", sinon.testCase({
	setUp: function () {
		this.sModuleId = 'test';
		this.fpInitStub = sinon.stub();
		var self = this;
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {
					self.fpInitStub();
				},
				handleAction: function () {

				},
				destroy: function () {

				}
			}
		};
		Hydra.module.register(this.sModuleId, this.fpModuleCreator);
	},
	"test should call the init method of the module if the module is registered before start": function () {
		Hydra.module.start(this.sModuleId);

		assertTrue(this.fpInitStub.calledOnce);
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
	}
}));

TestCase("HydraModuleStartAllTest", sinon.testCase({
	setUp: function () {
		this.sModuleId = 'test';
		this.sModuleId2 = 'test2';
		this.fpInitStub = sinon.stub();
		var self = this;
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {
					self.fpInitStub();
				},
				handleAction: function () {

				},
				destroy: function () {

				}
			}
		};
		Hydra.module.register(this.sModuleId, this.fpModuleCreator);
		Hydra.module.register(this.sModuleId2, this.fpModuleCreator);
	},
	"test should call the init method of the two registered modules": function () {
		Hydra.module.startAll();

		assertTrue(this.fpInitStub.calledTwice);
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
	}
}));

TestCase("HydraModuleStopTest", sinon.testCase({
	setUp: function () {
		var self = this;
		this.sModuleId = 'test';
		this.oModule = null;
		this.fpDestroyStub = sinon.stub();
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {

				},
				handleAction: function () {

				},
				destroy: function () {
					self.fpDestroyStub();
				}
			}
		};
		Hydra.module.register(this.sModuleId, this.fpModuleCreator);
	},
	"test should not call the destroy method if the module is registered but not started": function () {
		Hydra.module.stop(this.sModuleId);

		assertEquals(0, this.fpDestroyStub.callCount);
	},
	"test should call the destroy method one time if the module is registered and started": function () {
		Hydra.module.start(this.sModuleId);

		Hydra.module.stop(this.sModuleId);

		assertTrue(this.fpDestroyStub.calledOnce);
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
	}
}));

TestCase("HydraModuleStopAllTest", sinon.testCase({
	setUp: function () {
		var self = this;
		this.sModuleId = 'test';
		this.sModuleId2 = 'test2';
		this.fpDestroyStub = sinon.stub();
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {

				},
				handleAction: function () {

				},
				destroy: function () {
					self.fpDestroyStub();
				}
			}
		};
		Hydra.module.register(this.sModuleId, this.fpModuleCreator);
		Hydra.module.register(this.sModuleId2, this.fpModuleCreator);
		Hydra.module.startAll();
	},
	"test should call the destroy method of the two registered modules": function () {
		Hydra.module.stopAll();

		assertTrue(this.fpDestroyStub.calledTwice);
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
	}
}));

TestCase("HydraModuleExtendTest", sinon.testCase({
	setUp: function () {
		var self = this;
		this.sModuleId = 'test';
		this.fpInitStub = sinon.stub();
		this.fpDestroyStub = sinon.stub();
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {

				},
				handleAction: function () {

				},
				destroy: function () {
					self.fpDestroyStub();
				}
			}
		};
		this.fpModuleExtendedCreator = function (oAction) {
			return {
				init: function () {
					self.fpInitStub();
				},
				handleAction: function () {

				},
				destroy: function () {

				}
			}
		};
		Hydra.module.register(this.sModuleId, this.fpModuleCreator);
		sinon.spy(Hydra.module, "merge");
	},
	"test should call the merge method one time": function () {
		Hydra.module.extend(this.sModuleId, this.fpModuleExtendedCreator);

		assertTrue(Hydra.module.merge.calledOnce);
	},
	"test should call the init method of the final extended module": function () {
		Hydra.module.extend(this.sModuleId, this.fpModuleExtendedCreator);

		Hydra.module.start(this.sModuleId);

		assertTrue(this.fpInitStub.calledOnce);
	},
	"test should call the destroy method of the final extended module": function () {
		Hydra.module.extend(this.sModuleId, this.fpModuleExtendedCreator);

		Hydra.module.start(this.sModuleId);

		assertEquals(0, this.fpDestroyStub.callCount);
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
		Hydra.module.merge.restore();
	}
}));

TestCase("HydraModuleTestTest", sinon.testCase({
	setUp: function () {
		var self = this;
		this.sModuleId = 'test';
		this.fpCallback = sinon.stub();
		this.fpDestroyStub = sinon.stub();
		this.fpModuleCreator = function (oAction) {
			return {
				init: function () {

				},
				handleAction: function () {

				},
				destroy: function () {
					self.fpDestroyStub();
				}
			}
		};
		Hydra.module.register(this.sModuleId, this.fpModuleCreator);
	},
	"test should call the callback": function () {
		Hydra.module.test(this.sModuleId, this.fpCallback);

		assertTrue(this.fpCallback.calledOnce);
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
	}
}));

TestCase("HydraErrorHandlerCreateDomTest", sinon.testCase({
	setUp: function () {
		document.body.innerHTML = '';
		Hydra.errorHandler().list = null;
		this.nChilds = document.body.childNodes.length;
		this.nDivs = document.body.getElementsByTagName("div").length;
		this.nLists = document.body.getElementsByTagName("ul").length;
	},
	"test should return null for list before create_dom": function () {
		assertNull(Hydra.errorHandler().list);
	},
	"test should return one list after create_dom": function () {
		Hydra.errorHandler().create_dom();

		assertTagName("UL", Hydra.errorHandler().list);
	},
	"test should add one layer and one list in the dom": function () {
		Hydra.errorHandler().create_dom();

		assertTrue(document.body.childNodes.length > this.nChilds);
		assertTrue(document.body.getElementsByTagName("div").length > this.nDivs);
		assertTrue(document.body.getElementsByTagName("ul").length > this.nLists);
	},
	"test should return fixed for the position of the created layer": function () {
		var aDivs = [];
		var oDiv = null;

		Hydra.errorHandler().create_dom();
		aDivs = document.body.getElementsByTagName("div");
		oDiv = aDivs[aDivs.length-1];

		assertEquals("fixed", oDiv.style.position);
	},
	"test should return 0px for the bottom of the created layer": function () {
		var aDivs = [];
		var oDiv = null;

		Hydra.errorHandler().create_dom();
		aDivs = document.body.getElementsByTagName("div");
		oDiv = aDivs[aDivs.length-1];

		assertEquals("0px", oDiv.style.bottom);
	},
	"test should return 100px for the height of the created layer": function () {
		var aDivs = [];
		var oDiv = null;

		Hydra.errorHandler().create_dom();
		aDivs = document.body.getElementsByTagName("div");
		oDiv = aDivs[aDivs.length-1];

		assertEquals("100px", oDiv.style.height);
	},
	"test should return 100% for the width of the created layer": function () {
		var aDivs = [];
		var oDiv = null;

		Hydra.errorHandler().create_dom();
		aDivs = document.body.getElementsByTagName("div");
		oDiv = aDivs[aDivs.length-1];

		assertEquals("100%", oDiv.style.width);
	},
	tearDown: function () {
	}
}));

TestCase("HydraErrorHandlerAddItemTest", sinon.testCase({
	setUp: function () {
		document.body.innerHTML = '';
		Hydra.errorHandler().list = null;
		this.nChilds = document.body.childNodes.length;
		this.nDivs = document.body.getElementsByTagName("div").length;
		this.nLists = document.body.getElementsByTagName("ul").length;
		Hydra.errorHandler().create_dom();
	},
	"test should return 0 for li items in the list if addItem is not called": function () {
		var oList = Hydra.errorHandler().list;
		var aLiItems = [];

		aLiItems = Hydra.errorHandler().list.getElementsByTagName("li");

		assertEquals(0, aLiItems.length);
	},
	"test should return 1 for li items in the list if addItem is called one time": function () {
		var oList = Hydra.errorHandler().list;
		var aLiItems = [];
		var sModuleId = 'test1module';
		var sMethod = 'testmethod';
		var erError = {
			message: 'testmessage'
		};

		Hydra.errorHandler().addItem(sModuleId, sMethod, erError);

		aLiItems = Hydra.errorHandler().list.getElementsByTagName("li");

		assertEquals(1, aLiItems.length);
	},
	"test should return 2 for li items in the list if addItem is called two times": function () {
		var oList = Hydra.errorHandler().list;
		var aLiItems = [];
		var sModuleId = 'test1module';
		var sMethod = 'testmethod';
		var erError = {
			message: 'testmessage'
		};

		Hydra.errorHandler().addItem(sModuleId, sMethod, erError);
		Hydra.errorHandler().addItem(sModuleId, sMethod, erError);

		aLiItems = Hydra.errorHandler().list.getElementsByTagName("li");

		assertEquals(2, aLiItems.length);
	},
	tearDown: function () {
	}
}));

TestCase("HydraErrorHandlerLogTest", sinon.testCase({
	setUp: function () {
		document.body.innerHTML = '';
		this.oLog = Hydra.errorHandler().log;

		if(typeof Hydra.errorHandler().create_dom.restore !== "undefined")
		{
			Hydra.errorHandler().create_dom.restore();
		}
		if(typeof Hydra.errorHandler().addItem.restore !== "undefined")
		{
			Hydra.errorHandler().addItem.restore();
		}
		sinon.spy(Hydra.errorHandler(), "create_dom");
		sinon.spy(Hydra.errorHandler(), "addItem");
		this.oConsole = window.console;
		this.sModuleId = 'test1module';
		this.sMethod = 'testmethod';
		this.erError = {
			message: 'testmessage'
		};
	},
	"test should call the create_dom one time if window.console is undefined": function () {
		Hydra.errorHandler().list = null;

		Hydra.errorHandler().log(this.sModuleId, this.sMethod, this.erError, false);

		assertTrue(Hydra.errorHandler().create_dom.calledOnce);
	},
	"test should call the addItem one time if window.console is undefined": function () {
		Hydra.errorHandler().list = null;

		Hydra.errorHandler().log(this.sModuleId, this.sMethod, this.erError, false);

		assertTrue(Hydra.errorHandler().addItem.calledOnce);
	},
	tearDown: function () {
		Hydra.module.remove(this.sModuleId);
		window.console = this.oConsole;
		Hydra.errorHandler().log = Hydra.errorHandler().__old_log__;
		if(typeof Hydra.errorHandler().create_dom.restore !== "undefined")
		{
			Hydra.errorHandler().create_dom.restore();
		}
		if(typeof Hydra.errorHandler().addItem.restore !== "undefined")
		{
			Hydra.errorHandler().addItem.restore();
		}
	}
}));

TestCase("HydraActionListenTest", sinon.testCase({
	setUp: function () {
		var self = this;
		this.sListener = 'test';
		this.fpHandler = function (oAction) {};
		this.oModule = {
			init: function () {},
			handleAction: this.fpHandler,
			destroy: function () {}
		};
		this.fpAction = Hydra.action();
		this.oAction = new this.fpAction();
		this.oAction.__restore__();
	},
	"test should return undefined for Action.oActions.test if listen is not called": function () {
		assertUndefined(this.fpAction.oActions.test);
	},
	"test should return an object with module and handler for Action.oActions.test if listen is called": function () {
		this.oAction.listen([this.sListener], this.fpHandler, this.oModule);

		var oTestAction = this.fpAction.oActions.test[0];

		assertObject(oTestAction);
		assertSame(this.fpHandler, oTestAction.handler);
		assertSame(this.oModule, oTestAction.module);
	},
	tearDown: function () {
		this.oAction.__restore__();
	}
}));

TestCase("HydraActionNotifyTest", sinon.testCase({
	setUp: function () {
		this.oAction = Hydra.action();
		var self = this;
		this.fpListen = sinon.stub();
		this.sListener = 'test';
		this.sOtherListener = 'test2';
		this.nData = 1;
		this.oNotifier = {
			type: this.sListener,
			data: this.nData
		};
		this.oOtherNotifier = {
			type: this.sOtherListener,
			data: this.nData
		};
		this.fpHandler = function (oAction) {
			if(oAction.type === self.sListener){
				self.fpListen();
			}
		};
		this.oModule = {
			init: function () {},
			handleAction: this.fpHandler,
			destroy: function () {}
		};
		this.fpAction = Hydra.action();
		this.oAction = new this.fpAction();
		this.oAction.__restore__();
		this.oAction.listen([this.sListener], this.fpHandler, this.oModule);
	},
	"test should not call the fpListen callback if the action called is test2": function () {
		this.oAction.notify(this.oOtherNotifier);

		assertEquals(0, this.fpListen.callCount);
	},
	"test should call the fpListen callback if the action called is test": function () {
		this.oAction.notify(this.oNotifier);

		assertTrue(this.fpListen.calledOnce);
	},
	tearDown: function () {
		this.oAction.__restore__();
	}
}));

TestCase("HydraActionStopListenTest", sinon.testCase({
	setUp: function () {
		this.oAction = Hydra.action();
		var self = this;
		this.fpListen = sinon.stub();
		this.sListener = 'test';
		this.nData = 1;
		this.oNotifier = {
			type: this.sListener,
			data: this.nData
		};
		this.fpHandler = function (oAction) {
			if(oAction.type === self.sListener){
				self.fpListen();
			}
		};
		this.oModule = {
			init: function () {},
			handleAction: function()
			{
				self.fpHandler();
			},
			destroy: function () {}
		};
		this.fpAction = Hydra.action();
		this.oAction = new this.fpAction();
		this.oAction.__restore__();
		this.oAction.listen([this.sListener], this.fpHandler, this.oModule);
	},
	"test should call the fpListen callback if the action called is test if not stopListen": function () {
		this.oAction.notify(this.oNotifier);

		assertEquals(1, this.fpListen.callCount);
	},
	"test should not call the fpListen callback if the action called is test if stopListen is called before": function () {
		this.oAction.stopListen([this.sListener], this.oModule);

		this.oAction.notify(this.oNotifier);

		assertEquals(0, this.fpListen.callCount);
	},
	tearDown: function () {
		this.oAction.__restore__();
	}
}));