added all files to project

tests/unit/functions/calendar_spec.js

@@ -0,0 +1,128 @@
+global.moment = require("moment");
+
+describe("Functions into modules/default/calendar/calendar.js", function () {
+	// Fake for use by calendar.js
+	Module = {};
+	Module.definitions = {};
+	Module.register = function (name, moduleDefinition) {
+		Module.definitions[name] = moduleDefinition;
+	};
+
+	beforeAll(function () {
+		// load calendar.js
+		require("../../../modules/default/calendar/calendar.js");
+	});
+
+	describe("capFirst", function () {
+		const words = {
+			rodrigo: "Rodrigo",
+			"123m": "123m",
+			"magic mirror": "Magic mirror",
+			",a": ",a",
+			ñandú: "Ñandú"
+		};
+
+		Object.keys(words).forEach((word) => {
+			it(`for '${word}' should return '${words[word]}'`, function () {
+				expect(Module.definitions.calendar.capFirst(word)).toBe(words[word]);
+			});
+		});
+	});
+
+	describe("getLocaleSpecification", function () {
+		it("should return a valid moment.LocaleSpecification for a 12-hour format", function () {
+			expect(Module.definitions.calendar.getLocaleSpecification(12)).toEqual({ longDateFormat: { LT: "h:mm A" } });
+		});
+
+		it("should return a valid moment.LocaleSpecification for a 24-hour format", function () {
+			expect(Module.definitions.calendar.getLocaleSpecification(24)).toEqual({ longDateFormat: { LT: "HH:mm" } });
+		});
+
+		it("should return the current system locale when called without timeFormat number", function () {
+			expect(Module.definitions.calendar.getLocaleSpecification()).toEqual({ longDateFormat: { LT: moment.localeData().longDateFormat("LT") } });
+		});
+
+		it("should return a 12-hour longDateFormat when using the 'en' locale", function () {
+			const localeBackup = moment.locale();
+			moment.locale("en");
+			expect(Module.definitions.calendar.getLocaleSpecification()).toEqual({ longDateFormat: { LT: "h:mm A" } });
+			moment.locale(localeBackup);
+		});
+
+		it("should return a 12-hour longDateFormat when using the 'au' locale", function () {
+			const localeBackup = moment.locale();
+			moment.locale("au");
+			expect(Module.definitions.calendar.getLocaleSpecification()).toEqual({ longDateFormat: { LT: "h:mm A" } });
+			moment.locale(localeBackup);
+		});
+
+		it("should return a 12-hour longDateFormat when using the 'eg' locale", function () {
+			const localeBackup = moment.locale();
+			moment.locale("eg");
+			expect(Module.definitions.calendar.getLocaleSpecification()).toEqual({ longDateFormat: { LT: "h:mm A" } });
+			moment.locale(localeBackup);
+		});
+
+		it("should return a 24-hour longDateFormat when using the 'nl' locale", function () {
+			const localeBackup = moment.locale();
+			moment.locale("nl");
+			expect(Module.definitions.calendar.getLocaleSpecification()).toEqual({ longDateFormat: { LT: "HH:mm" } });
+			moment.locale(localeBackup);
+		});
+
+		it("should return a 24-hour longDateFormat when using the 'fr' locale", function () {
+			const localeBackup = moment.locale();
+			moment.locale("fr");
+			expect(Module.definitions.calendar.getLocaleSpecification()).toEqual({ longDateFormat: { LT: "HH:mm" } });
+			moment.locale(localeBackup);
+		});
+
+		it("should return a 24-hour longDateFormat when using the 'uk' locale", function () {
+			const localeBackup = moment.locale();
+			moment.locale("uk");
+			expect(Module.definitions.calendar.getLocaleSpecification()).toEqual({ longDateFormat: { LT: "HH:mm" } });
+			moment.locale(localeBackup);
+		});
+	});
+
+	describe("shorten", function () {
+		const strings = {
+			" String with whitespace at the beginning that needs trimming": { length: 16, return: "String with whit…" },
+			"long string that needs shortening": { length: 16, return: "long string that…" },
+			"short string": { length: 16, return: "short string" },
+			"long string with no maxLength defined": { return: "long string with no maxLength defined" }
+		};
+
+		Object.keys(strings).forEach((string) => {
+			it(`for '${string}' should return '${strings[string].return}'`, function () {
+				expect(Module.definitions.calendar.shorten(string, strings[string].length)).toBe(strings[string].return);
+			});
+		});
+
+		it("should return an empty string if shorten is called with a non-string", function () {
+			expect(Module.definitions.calendar.shorten(100)).toBe("");
+		});
+
+		it("should not shorten the string if shorten is called with a non-number maxLength", function () {
+			expect(Module.definitions.calendar.shorten("This is a test string", "This is not a number")).toBe("This is a test string");
+		});
+
+		it("should wrap the string instead of shorten it if shorten is called with wrapEvents = true (with maxLength defined as 20)", function () {
+			expect(Module.definitions.calendar.shorten("This is a wrapEvent test. Should wrap the string instead of shorten it if called with wrapEvent = true", 20, true)).toBe(
+				"This is a <br>wrapEvent test. Should wrap <br>the string instead of <br>shorten it if called with <br>wrapEvent = true"
+			);
+		});
+
+		it("should wrap the string instead of shorten it if shorten is called with wrapEvents = true (without maxLength defined, default 25)", function () {
+			expect(Module.definitions.calendar.shorten("This is a wrapEvent test. Should wrap the string instead of shorten it if called with wrapEvent = true", undefined, true)).toBe(
+				"This is a wrapEvent <br>test. Should wrap the string <br>instead of shorten it if called <br>with wrapEvent = true"
+			);
+		});
+
+		it("should wrap and shorten the string in the second line if called with wrapEvents = true and maxTitleLines = 2", function () {
+			expect(Module.definitions.calendar.shorten("This is a wrapEvent and maxTitleLines test. Should wrap and shorten the string in the second line if called with wrapEvents = true and maxTitleLines = 2", undefined, true, 2)).toBe(
+				"This is a wrapEvent and <br>maxTitleLines test. Should wrap and &hellip;"
+			);
+		});
+	});
+});

tests/unit/functions/cmp_versions_spec.js

@@ -0,0 +1,31 @@
+const path = require("path");
+const { JSDOM } = require("jsdom");
+
+describe("Test function cmpVersions in js/module.js", function () {
+	let cmp;
+
+	beforeAll(function (done) {
+		const dom = new JSDOM(
+			`<script>var Class = {extend: function() { return {}; }};</script>\
+				<script src="file://${path.join(__dirname, "..", "..", "..", "js", "module.js")}">`,
+			{ runScripts: "dangerously", resources: "usable" }
+		);
+		dom.window.onload = function () {
+			const { cmpVersions } = dom.window;
+			cmp = cmpVersions;
+			done();
+		};
+	});
+
+	it("should return -1 when comparing 2.1 to 2.2", function () {
+		expect(cmp("2.1", "2.2")).toBe(-1);
+	});
+
+	it("should be return 0 when comparing 2.2 to 2.2", function () {
+		expect(cmp("2.2", "2.2")).toBe(0);
+	});
+
+	it("should be return 1 when comparing 1.1 to 1.0", function () {
+		expect(cmp("1.1", "1.0")).toBe(1);
+	});
+});

tests/unit/functions/currentweather_spec.js

@@ -0,0 +1,66 @@
+/* eslint no-multi-spaces: 0 */
+describe("Functions module currentweather", function () {
+	// Fake for use by currentweather.js
+	Module = {};
+	config = {};
+	Module.definitions = {};
+	Module.register = function (name, moduleDefinition) {
+		Module.definitions[name] = moduleDefinition;
+	};
+
+	beforeAll(function () {
+		require("../../../modules/default/currentweather/currentweather.js");
+		Module.definitions.currentweather.config = {};
+	});
+
+	describe("roundValue", function () {
+		describe("this.config.roundTemp is true", function () {
+			beforeAll(function () {
+				Module.definitions.currentweather.config.roundTemp = true;
+			});
+
+			const values = [
+				// index 0 value
+				// index 1 expect
+				[1, "1"],
+				[1.0, "1"],
+				[1.02, "1"],
+				[10.12, "10"],
+				[2.0, "2"],
+				["2.12", "2"],
+				[10.1, "10"]
+			];
+
+			values.forEach((value) => {
+				it(`for ${value[0]} should be return ${value[1]}`, function () {
+					expect(Module.definitions.currentweather.roundValue(value[0])).toBe(value[1]);
+				});
+			});
+		});
+
+		describe("this.config.roundTemp is false", function () {
+			beforeAll(function () {
+				Module.definitions.currentweather.config.roundTemp = false;
+			});
+
+			const values = [
+				// index 0 value
+				// index 1 expect
+				[1, "1.0"],
+				[1.0, "1.0"],
+				[1.02, "1.0"],
+				[10.12, "10.1"],
+				[2.0, "2.0"],
+				["2.12", "2.1"],
+				[10.1, "10.1"],
+				[10.1, "10.1"]
+			];
+
+			values.forEach((value) => {
+				it(`for ${value[0]} should be return ${value[1]}`, function () {
+					expect(Module.definitions.currentweather.roundValue(value[0])).toBe(value[1]);
+				});
+			});
+		});
+	});
+});

tests/unit/functions/newsfeed_spec.js

@@ -0,0 +1,15 @@
+describe("Functions into modules/default/newsfeed/newsfeed.js", function () {
+	// Fake for use by newsletter.js
+	Module = {};
+	Module.definitions = {};
+	Module.register = function (name, moduleDefinition) {
+		Module.definitions[name] = moduleDefinition;
+	};
+
+	beforeAll(function () {
+		// load newsfeed.js
+		require("../../../modules/default/newsfeed/newsfeed.js");
+	});
+
+	test.skip("skip", () => {});
+});

tests/unit/functions/updatenotification_spec.js

@@ -0,0 +1,126 @@
+const path = require("path");
+const git_Helper = require("../../../modules/default/updatenotification/git_helper.js");
+const gitHelper = new git_Helper.gitHelper();
+gitHelper.add("default");
+
+const test1 = {
+	module: "test1",
+	folder: "",
+	res: {
+		stdout: "## master...origin/master [behind 8]",
+		stderr: ""
+	},
+	gitInfo: {
+		module: "default",
+		// commits behind:
+		behind: 0,
+		// branch name:
+		current: "develop",
+		// current hash:
+		hash: "",
+		// remote branch:
+		tracking: "",
+		isBehindInStatus: false
+	}
+};
+
+const test2 = {
+	module: "test2",
+	folder: "",
+	res: {
+		stdout: "## develop...origin/develop",
+		stderr: ""
+	}
+};
+
+const test3 = {
+	module: "test3",
+	folder: "",
+	res: {
+		stdout: "",
+		stderr: "error"
+	},
+	gitInfo: {
+		module: "default",
+		// commits behind:
+		behind: 2,
+		// branch name:
+		current: "develop",
+		// current hash:
+		hash: "",
+		// remote branch:
+		tracking: "",
+		isBehindInStatus: true
+	}
+};
+
+const test4 = {
+	module: "default",
+	folder: path.join(__dirname, "../../.."),
+	res: {
+		stdout: "",
+		stderr: "   e40ddd4..06389e3  develop    -> origin/develop"
+	},
+	gitInfo: {
+		module: "default",
+		// commits behind:
+		behind: 0,
+		// branch name:
+		current: "develop",
+		// current hash:
+		hash: "",
+		// remote branch:
+		tracking: "",
+		isBehindInStatus: false
+	}
+};
+
+describe("Updatenotification", function () {
+	it("should return valid output for git status", async function () {
+		const arr = await gitHelper.getStatus();
+		expect(arr.length).toBe(1);
+		const gitInfo = arr[0];
+		expect(gitInfo.current).not.toBe("");
+		expect(gitInfo.hash).not.toBe("");
+	}, 15000);
+
+	it("should return behind=8 for test1", async function () {
+		const gitInfo = await gitHelper.getStatusInfo(test1);
+		expect(gitInfo.behind).toBe(8);
+		expect(gitInfo.isBehindInStatus).toBe(true);
+	});
+
+	it("should return behind=0 for test2", async function () {
+		const gitInfo = await gitHelper.getStatusInfo(test2);
+		expect(gitInfo.behind).toBe(0);
+		expect(gitInfo.isBehindInStatus).toBe(false);
+	});
+
+	it("should return empty status object for test3", async function () {
+		const gitInfo = await gitHelper.getStatusInfo(test3);
+		expect(gitInfo).toBe(undefined);
+	});
+
+	it("should return empty repo object for test2", async function () {
+		// no gitInfo provided in res, so returns undefined
+		const gitInfo = await gitHelper.getRepoInfo(test2);
+		expect(gitInfo).toBe(undefined);
+	});
+
+	it("should return empty repo object for test1", async function () {
+		// no regex match for refs in empty string, so returns undefined
+		const gitInfo = await gitHelper.getRepoInfo(test1);
+		expect(gitInfo).toBe(undefined);
+	});
+
+	it("should return empty repo object for test4", async function () {
+		// git ref list throws error, so returns undefined
+		const gitInfo = await gitHelper.getRepoInfo(test4);
+		expect(gitInfo).toBe(undefined);
+	});
+
+	it("should return behind=2 for test3", async function () {
+		const gitInfo = await gitHelper.getRepoInfo(test3);
+		expect(gitInfo.behind).toBe(2);
+	});
+});

tests/unit/functions/weather_object_spec.js

@@ -0,0 +1,31 @@
+const WeatherObject = require("../../../modules/default/weather/weatherobject.js");
+
+global.moment = require("moment-timezone");
+global.SunCalc = require("suncalc");
+
+describe("WeatherObject", function () {
+	let originalTimeZone;
+	let weatherobject;
+
+	beforeAll(function () {
+		originalTimeZone = moment.tz.guess();
+		moment.tz.setDefault("Africa/Dar_es_Salaam");
+		weatherobject = new WeatherObject("metric", "metric", "metric", true);
+	});
+
+	it("should return true for daytime at noon", function () {
+		weatherobject.date = moment(12, "HH");
+		weatherobject.updateSunTime(-6.774877582342688, 37.63345667023327);
+		expect(weatherobject.isDayTime()).toBe(true);
+	});
+
+	it("should return false for daytime at midnight", function () {
+		weatherobject.date = moment(0, "HH");
+		weatherobject.updateSunTime(-6.774877582342688, 37.63345667023327);
+		expect(weatherobject.isDayTime()).toBe(false);
+	});
+
+	afterAll(function () {
+		moment.tz.setDefault(originalTimeZone);
+	});
+});

tests/unit/functions/weatherforecast_spec.js

@@ -0,0 +1,116 @@
+/* eslint no-multi-spaces: 0 */
+const moment = require("moment-timezone");
+const data = require("../../configs/data/weatherforecast_data.json");
+
+describe("Functions module weatherforecast", function () {
+	beforeAll(function () {
+		Module = {};
+		config = {};
+		Module.definitions = {};
+		Module.register = function (name, moduleDefinition) {
+			Module.definitions[name] = moduleDefinition;
+		};
+		require("../../../modules/default/weatherforecast/weatherforecast.js");
+		Module.definitions.weatherforecast.config = {};
+	});
+
+	describe("roundValue", function () {
+		describe("this.config.roundTemp is true", function () {
+			beforeAll(function () {
+				Module.definitions.weatherforecast.config.roundTemp = true;
+			});
+
+			const values = [
+				// index 0 value
+				// index 1 expect
+				[1, "1"],
+				[1.0, "1"],
+				[1.02, "1"],
+				[10.12, "10"],
+				[2.0, "2"],
+				["2.12", "2"],
+				[10.1, "10"]
+			];
+
+			values.forEach((value) => {
+				it(`for ${value[0]} should be return ${value[1]}`, function () {
+					expect(Module.definitions.weatherforecast.roundValue(value[0])).toBe(value[1]);
+				});
+			});
+		});
+
+		describe("this.config.roundTemp is false", function () {
+			beforeAll(function () {
+				Module.definitions.weatherforecast.config.roundTemp = false;
+			});
+
+			const values = [
+				// index 0 value
+				// index 1 expect
+				[1, "1.0"],
+				[1.0, "1.0"],
+				[1.02, "1.0"],
+				[10.12, "10.1"],
+				[2.0, "2.0"],
+				["2.12", "2.1"],
+				[10.1, "10.1"],
+				[10.1, "10.1"]
+			];
+
+			values.forEach((value) => {
+				it(`for ${value[0]} should be return ${value[1]}`, function () {
+					expect(Module.definitions.weatherforecast.roundValue(value[0])).toBe(value[1]);
+				});
+			});
+		});
+	});
+
+	describe("forecastIcons", function () {
+		Log = {
+			error: function () {}
+		};
+
+		let originalLocale;
+		let originalTimeZone;
+		beforeAll(function () {
+			originalLocale = moment.locale();
+			originalTimeZone = moment.tz.guess();
+			moment.locale("hi");
+			moment.tz.setDefault("Europe/Warsaw");
+		});
+
+		describe("forecastIcons sunset specified", function () {
+			beforeAll(function () {
+				Module.definitions.weatherforecast.Log = {};
+				Module.definitions.weatherforecast.forecast = [];
+				Module.definitions.weatherforecast.show = Module.definitions.weatherforecast.updateDom = function () {};
+				Module.definitions.weatherforecast.config = Module.definitions.weatherforecast.defaults;
+			});
+
+			it(`returns correct icons with sunset time`, function () {
+				Module.definitions.weatherforecast.processWeather(data.withSunset, moment);
+				let forecastData = Module.definitions.weatherforecast.forecast;
+				expect(forecastData.length).toBe(4);
+				expect(forecastData[2].icon).toBe("wi-rain");
+			});
+		});
+
+		describe("forecastIcons sunset not specified", function () {
+			beforeAll(function () {
+				Module.definitions.weatherforecast.forecast = [];
+			});
+
+			it(`returns correct icons with out sunset time`, function () {
+				Module.definitions.weatherforecast.processWeather(data.withoutSunset, moment);
+				let forecastData = Module.definitions.weatherforecast.forecast;
+				expect(forecastData.length).toBe(4);
+				expect(forecastData[2].icon).toBe("wi-rain");
+			});
+		});
+
+		afterAll(function () {
+			moment.locale(originalLocale);
+			moment.tz.setDefault(originalTimeZone);
+		});
+	});
+});