refactor tests in 3 categories unit, e2e and electron

tests/electron/dev_console.js

@@ -0,0 +1,53 @@
+const helpers = require("./global-setup");
+
+describe("Development console tests", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeAll(function () {
+		// Set config sample for use in test
+		process.env.MM_CONFIG_FILE = "tests/configs/env.js";
+	});
+
+	describe("Without 'dev' commandline argument", function () {
+		beforeAll(function () {
+			return helpers
+				.startApplication({
+					args: ["js/electron.js"]
+				})
+				.then(function (startedApp) {
+					app = startedApp;
+				});
+		});
+
+		afterAll(function () {
+			return helpers.stopApplication(app);
+		});
+
+		it("should not open dev console when absent", async function () {
+			await app.client.waitUntilWindowLoaded();
+			return expect(await app.browserWindow.isDevToolsOpened()).toBe(false);
+		});
+	});
+
+	describe("With 'dev' commandline argument", function () {
+		beforeAll(function () {
+			return helpers
+				.startApplication({
+					args: ["js/electron.js", "dev"]
+				})
+				.then(function (startedApp) {
+					app = startedApp;
+				});
+		});
+
+		afterAll(function () {
+			return helpers.stopApplication(app);
+		});
+
+		it("should open dev console when provided", async function () {
+			expect(await app.client.getWindowCount()).toBe(2);
+		});
+	});
+});

tests/electron/env_spec.js

@@ -0,0 +1,40 @@
+const helpers = require("./global-setup");
+
+describe("Electron app environment", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeAll(function () {
+		// Set config sample for use in test
+		process.env.MM_CONFIG_FILE = "tests/configs/env.js";
+	});
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	it("should open a browserwindow", async function () {
+		await app.client.waitUntilWindowLoaded();
+		app.browserWindow.focus();
+		expect(await app.client.getWindowCount()).toBe(1);
+		expect(await app.browserWindow.isMinimized()).toBe(false);
+		expect(await app.browserWindow.isDevToolsOpened()).toBe(false);
+		expect(await app.browserWindow.isVisible()).toBe(true);
+		expect(await app.browserWindow.isFocused()).toBe(true);
+		const bounds = await app.browserWindow.getBounds();
+		expect(bounds.width).toBeGreaterThan(0);
+		expect(bounds.height).toBeGreaterThan(0);
+		expect(await app.browserWindow.getTitle()).toBe("MagicMirror²");
+	});
+});

tests/electron/global-setup.js

@@ -0,0 +1,53 @@
+/*
+ * Magic Mirror Global Setup Test Suite
+ *
+ * By Rodrigo Ramírez Norambuena https://rodrigoramirez.com
+ * MIT Licensed.
+ */
+const Application = require("spectron").Application;
+const assert = require("assert");
+const path = require("path");
+const EventEmitter = require("events");
+
+exports.getElectronPath = function () {
+	let electronPath = path.join(__dirname, "..", "..", "node_modules", ".bin", "electron");
+	if (process.platform === "win32") {
+		electronPath += ".cmd";
+	}
+	return electronPath;
+};
+
+// Set timeout - if this is run as CI Job, increase timeout
+exports.setupTimeout = function (test) {
+	if (process.env.CI) {
+		jest.setTimeout(30000);
+	} else {
+		jest.setTimeout(10000);
+	}
+};
+
+exports.startApplication = function (options) {
+	const emitter = new EventEmitter();
+	emitter.setMaxListeners(100);
+
+	options.path = exports.getElectronPath();
+	if (process.env.CI) {
+		options.startTimeout = 30000;
+	}
+
+	const app = new Application(options);
+	return app.start().then(function () {
+		assert.strictEqual(app.isRunning(), true);
+		return app;
+	});
+};
+
+exports.stopApplication = function (app) {
+	if (!app || !app.isRunning()) {
+		return;
+	}
+
+	return app.stop().then(function () {
+		assert.strictEqual(app.isRunning(), false);
+	});
+};

tests/electron/modules/alert_spec.js

@@ -0,0 +1,32 @@
+const helpers = require("../global-setup");
+
+describe("Alert module", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("Default configuration", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/alert/default.js";
+		});
+
+		it("should show the welcome message", function () {
+			return app.client.waitUntilTextExists(".ns-box .ns-box-inner .light.bright.small", "Welcome, start was successful!", 10000);
+		});
+	});
+});

tests/electron/modules/basic-auth.js

@@ -0,0 +1,29 @@
+const path = require("path");
+const auth = require("express-basic-auth");
+const express = require("express");
+const app = express();
+
+const basicAuth = auth({
+	realm: "MagicMirror Area restricted.",
+	users: { MagicMirror: "CallMeADog" }
+});
+
+app.use(basicAuth);
+
+// Set available directories
+const directories = ["/tests/configs"];
+const rootPath = path.resolve(__dirname + "/../../");
+
+for (let directory of directories) {
+	app.use(directory, express.static(path.resolve(rootPath + directory)));
+}
+
+let server;
+
+exports.listen = function () {
+	server = app.listen.apply(app, arguments);
+};
+
+exports.close = function (callback) {
+	server.close(callback);
+};

tests/electron/modules/calendar_spec.js

@@ -0,0 +1,150 @@
+const helpers = require("../global-setup");
+const serverBasicAuth = require("./basic-auth.js");
+
+describe("Calendar module", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("Default configuration", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/default.js";
+		});
+
+		it("should show the default maximumEntries of 10", async () => {
+			await app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+			const events = await app.client.$$(".calendar .event");
+			return expect(events.length).toBe(10);
+		});
+
+		it("should show the default calendar symbol in each event", async () => {
+			await app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+			const icons = await app.client.$$(".calendar .event .fa-calendar");
+			return expect(icons.length).not.toBe(0);
+		});
+	});
+
+	describe("Custom configuration", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/custom.js";
+		});
+
+		it("should show the custom maximumEntries of 4", async () => {
+			await app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+			const events = await app.client.$$(".calendar .event");
+			return expect(events.length).toBe(4);
+		});
+
+		it("should show the custom calendar symbol in each event", async () => {
+			await app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+			const icons = await app.client.$$(".calendar .event .fa-birthday-cake");
+			return expect(icons.length).toBe(4);
+		});
+
+		it("should show two custom icons for repeating events", async () => {
+			await app.client.waitUntilTextExists(".calendar", "TestEventRepeat", 10000);
+			const icons = await app.client.$$(".calendar .event .fa-undo");
+			return expect(icons.length).toBe(2);
+		});
+
+		it("should show two custom icons for day events", async () => {
+			await app.client.waitUntilTextExists(".calendar", "TestEventDay", 10000);
+			const icons = await app.client.$$(".calendar .event .fa-calendar-day");
+			return expect(icons.length).toBe(2);
+		});
+	});
+
+	describe("Recurring event", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/recurring.js";
+		});
+
+		it("should show the recurring birthday event 6 times", async () => {
+			await app.client.waitUntilTextExists(".calendar", "Mar 25th", 10000);
+			const events = await app.client.$$(".calendar .event");
+			return expect(events.length).toBe(6);
+		});
+	});
+
+	describe("Changed port", function () {
+		beforeAll(function () {
+			serverBasicAuth.listen(8010);
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/changed-port.js";
+		});
+
+		afterAll(function (done) {
+			serverBasicAuth.close(done());
+		});
+
+		it("should return TestEvents", function () {
+			return app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+		});
+	});
+
+	describe("Basic auth", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/basic-auth.js";
+		});
+
+		it("should return TestEvents", function () {
+			return app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+		});
+	});
+
+	describe("Basic auth by default", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/auth-default.js";
+		});
+
+		it("should return TestEvents", function () {
+			return app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+		});
+	});
+
+	describe("Basic auth backward compatibility configuration: DEPRECATED", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/old-basic-auth.js";
+		});
+
+		it("should return TestEvents", function () {
+			return app.client.waitUntilTextExists(".calendar", "TestEvent", 10000);
+		});
+	});
+
+	describe("Fail Basic auth", function () {
+		beforeAll(function () {
+			serverBasicAuth.listen(8020);
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/calendar/fail-basic-auth.js";
+		});
+
+		afterAll(function (done) {
+			serverBasicAuth.close(done());
+		});
+
+		it("should show Unauthorized error", function () {
+			return app.client.waitUntilTextExists(".calendar", "Error in the calendar module. Authorization failed", 10000);
+		});
+	});
+});

tests/electron/modules/clock_es_spec.js

@@ -0,0 +1,86 @@
+const helpers = require("../global-setup");
+
+describe("Clock set to spanish language module", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	const testMatch = async function (element, regex) {
+		await app.client.waitUntilWindowLoaded();
+		const elem = await app.client.$(element);
+		const txt = await elem.getText(element);
+		return expect(txt).toMatch(regex);
+	};
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("with default 24hr clock config", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/es/clock_24hr.js";
+		});
+
+		it("shows date with correct format", async function () {
+			const dateRegex = /^(?:lunes|martes|miércoles|jueves|viernes|sábado|domingo), \d{1,2} de (?:enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre) de \d{4}$/;
+			return testMatch(".clock .date", dateRegex);
+		});
+
+		it("shows time in 24hr format", async function () {
+			const timeRegex = /^(?:2[0-3]|[01]\d):[0-5]\d[0-5]\d$/;
+			return testMatch(".clock .time", timeRegex);
+		});
+	});
+
+	describe("with default 12hr clock config", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/es/clock_12hr.js";
+		});
+
+		it("shows date with correct format", async function () {
+			const dateRegex = /^(?:lunes|martes|miércoles|jueves|viernes|sábado|domingo), \d{1,2} de (?:enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre) de \d{4}$/;
+			return testMatch(".clock .date", dateRegex);
+		});
+
+		it("shows time in 12hr format", async function () {
+			const timeRegex = /^(?:1[0-2]|[1-9]):[0-5]\d[0-5]\d[ap]m$/;
+			return testMatch(".clock .time", timeRegex);
+		});
+	});
+
+	describe("with showPeriodUpper config enabled", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/es/clock_showPeriodUpper.js";
+		});
+
+		it("shows 12hr time with upper case AM/PM", async function () {
+			const timeRegex = /^(?:1[0-2]|[1-9]):[0-5]\d[0-5]\d[AP]M$/;
+			return testMatch(".clock .time", timeRegex);
+		});
+	});
+
+	describe("with showWeek config enabled", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/es/clock_showWeek.js";
+		});
+
+		it("shows week with correct format", async function () {
+			const weekRegex = /^Semana [0-9]{1,2}$/;
+			return testMatch(".clock .week", weekRegex);
+		});
+	});
+});

tests/electron/modules/clock_spec.js

@@ -0,0 +1,134 @@
+const helpers = require("../global-setup");
+const moment = require("moment");
+
+describe("Clock module", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	const testMatch = async function (element, regex) {
+		await app.client.waitUntilWindowLoaded();
+		const elem = await app.client.$(element);
+		const txt = await elem.getText(element);
+		return expect(txt).toMatch(regex);
+	};
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("with default 24hr clock config", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/clock_24hr.js";
+		});
+
+		it("should show the date in the correct format", async function () {
+			const dateRegex = /^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (?:January|February|March|April|May|June|July|August|September|October|November|December) \d{1,2}, \d{4}$/;
+			return testMatch(".clock .date", dateRegex);
+		});
+
+		it("should show the time in 24hr format", async function () {
+			const timeRegex = /^(?:2[0-3]|[01]\d):[0-5]\d[0-5]\d$/;
+			return testMatch(".clock .time", timeRegex);
+		});
+	});
+
+	describe("with default 12hr clock config", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/clock_12hr.js";
+		});
+
+		it("should show the date in the correct format", async function () {
+			const dateRegex = /^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (?:January|February|March|April|May|June|July|August|September|October|November|December) \d{1,2}, \d{4}$/;
+			return testMatch(".clock .date", dateRegex);
+		});
+
+		it("should show the time in 12hr format", async function () {
+			const timeRegex = /^(?:1[0-2]|[1-9]):[0-5]\d[0-5]\d[ap]m$/;
+			return testMatch(".clock .time", timeRegex);
+		});
+	});
+
+	describe("with showPeriodUpper config enabled", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/clock_showPeriodUpper.js";
+		});
+
+		it("should show 12hr time with upper case AM/PM", async function () {
+			const timeRegex = /^(?:1[0-2]|[1-9]):[0-5]\d[0-5]\d[AP]M$/;
+			return testMatch(".clock .time", timeRegex);
+		});
+	});
+
+	describe("with displaySeconds config disabled", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/clock_displaySeconds_false.js";
+		});
+
+		it("should show 12hr time without seconds am/pm", async function () {
+			const timeRegex = /^(?:1[0-2]|[1-9]):[0-5]\d[ap]m$/;
+			return testMatch(".clock .time", timeRegex);
+		});
+	});
+
+	describe("with showTime config disabled", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/clock_showTime.js";
+		});
+
+		it("should show not show the time when digital clock is shown", async function () {
+			await app.client.waitUntilWindowLoaded();
+			const time = await app.client.$$(".clock .digital .time");
+			return expect(time.length).toBe(0);
+		});
+	});
+
+	describe("with showWeek config enabled", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/clock_showWeek.js";
+		});
+
+		it("should show the week in the correct format", async function () {
+			const weekRegex = /^Week [0-9]{1,2}$/;
+			return testMatch(".clock .week", weekRegex);
+		});
+
+		it("should show the week with the correct number of week of year", async function () {
+			const currentWeekNumber = moment().week();
+			const weekToShow = "Week " + currentWeekNumber;
+			await app.client.waitUntilWindowLoaded();
+			const elem = await app.client.$(".clock .week");
+			const txt = await elem.getText(".clock .week");
+			return expect(txt).toBe(weekToShow);
+		});
+	});
+
+	describe("with analog clock face enabled", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/clock/clock_analog.js";
+		});
+
+		it("should show the analog clock face", async () => {
+			await app.client.waitUntilWindowLoaded();
+			const clock = await app.client.$$(".clockCircle");
+			return expect(clock.length).toBe(1);
+		});
+	});
+});

tests/electron/modules/compliments_spec.js

@@ -0,0 +1,107 @@
+const helpers = require("../global-setup");
+
+describe("Compliments module", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("parts of days", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/compliments/compliments_parts_day.js";
+		});
+
+		it("if Morning compliments for that part of day", async function () {
+			const hour = new Date().getHours();
+			if (hour >= 3 && hour < 12) {
+				// if morning check
+				const elem = await app.client.$(".compliments");
+				return elem.getText(".compliments").then(function (text) {
+					expect(["Hi", "Good Morning", "Morning test"]).toContain(text);
+				});
+			}
+		});
+
+		it("if Afternoon show Compliments for that part of day", async function () {
+			const hour = new Date().getHours();
+			if (hour >= 12 && hour < 17) {
+				// if afternoon check
+				const elem = await app.client.$(".compliments");
+				return elem.getText(".compliments").then(function (text) {
+					expect(["Hello", "Good Afternoon", "Afternoon test"]).toContain(text);
+				});
+			}
+		});
+
+		it("if Evening show Compliments for that part of day", async function () {
+			const hour = new Date().getHours();
+			if (!(hour >= 3 && hour < 12) && !(hour >= 12 && hour < 17)) {
+				// if evening check
+				const elem = await app.client.$(".compliments");
+				return elem.getText(".compliments").then(function (text) {
+					expect(["Hello There", "Good Evening", "Evening test"]).toContain(text);
+				});
+			}
+		});
+	});
+
+	describe("Feature anytime in compliments module", function () {
+		describe("Set anytime and empty compliments for morning, evening and afternoon ", function () {
+			beforeAll(function () {
+				// Set config sample for use in test
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/compliments/compliments_anytime.js";
+			});
+
+			it("Show anytime because if configure empty parts of day compliments and set anytime compliments", async function () {
+				const elem = await app.client.$(".compliments");
+				return elem.getText(".compliments").then(function (text) {
+					expect(["Anytime here"]).toContain(text);
+				});
+			});
+		});
+
+		describe("Only anytime present in configuration compliments", function () {
+			beforeAll(function () {
+				// Set config sample for use in test
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/compliments/compliments_only_anytime.js";
+			});
+
+			it("Show anytime compliments", async function () {
+				const elem = await app.client.$(".compliments");
+				return elem.getText(".compliments").then(function (text) {
+					expect(["Anytime here"]).toContain(text);
+				});
+			});
+		});
+	});
+
+	describe("Feature date in compliments module", function () {
+		describe("Set date and empty compliments for anytime, morning, evening and afternoon", function () {
+			beforeAll(function () {
+				// Set config sample for use in test
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/compliments/compliments_date.js";
+			});
+
+			it("Show happy new year compliment on new years day", async function () {
+				const elem = await app.client.$(".compliments");
+				return elem.getText(".compliments").then(function (text) {
+					expect(["Happy new year!"]).toContain(text);
+				});
+			});
+		});
+	});
+});

tests/electron/modules/helloworld_spec.js

@@ -0,0 +1,45 @@
+const helpers = require("../global-setup");
+
+describe("Test helloworld module", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("helloworld set config text", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/helloworld/helloworld.js";
+		});
+
+		it("Test message helloworld module", async function () {
+			const elem = await app.client.$(".helloworld");
+			return expect(await elem.getText(".helloworld")).toBe("Test HelloWorld Module");
+		});
+	});
+
+	describe("helloworld default config text", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/helloworld/helloworld_default.js";
+		});
+
+		it("Test message helloworld module", async function () {
+			const elem = await app.client.$(".helloworld");
+			return expect(await elem.getText(".helloworld")).toBe("Hello World!");
+		});
+	});
+});

tests/electron/modules/mocks/index.js

@@ -0,0 +1,4 @@
+const generateWeather = require("./weather_current");
+const generateWeatherForecast = require("./weather_forecast");
+
+module.exports = { generateWeather, generateWeatherForecast };

tests/electron/modules/mocks/weather_current.js

@@ -0,0 +1,64 @@
+const _ = require("lodash");
+
+/**
+ * @param {object} extendedData extra data to add to the default mock data
+ * @returns {string} mocked current weather data
+ */
+function generateWeather(extendedData = {}) {
+	return JSON.stringify(
+		_.merge(
+			{},
+			{
+				coord: {
+					lon: 11.58,
+					lat: 48.14
+				},
+				weather: [
+					{
+						id: 615,
+						main: "Snow",
+						description: "light rain and snow",
+						icon: "13d"
+					},
+					{
+						id: 500,
+						main: "Rain",
+						description: "light rain",
+						icon: "10d"
+					}
+				],
+				base: "stations",
+				main: {
+					temp: 1.49,
+					pressure: 1005,
+					humidity: 93.7,
+					temp_min: 1,
+					temp_max: 2
+				},
+				visibility: 7000,
+				wind: {
+					speed: 11.8,
+					deg: 250
+				},
+				clouds: {
+					all: 75
+				},
+				dt: 1547387400,
+				sys: {
+					type: 1,
+					id: 1267,
+					message: 0.0031,
+					country: "DE",
+					sunrise: 1547362817,
+					sunset: 1547394301
+				},
+				id: 2867714,
+				name: "Munich",
+				cod: 200
+			},
+			extendedData
+		)
+	);
+}
+
+module.exports = generateWeather;

tests/electron/modules/mocks/weather_forecast.js

@@ -0,0 +1,115 @@
+const _ = require("lodash");
+
+/**
+ * @param {object} extendedData extra data to add to the default mock data
+ * @returns {string} mocked forecast weather data
+ */
+function generateWeatherForecast(extendedData = {}) {
+	return JSON.stringify(
+		_.merge(
+			{},
+			{
+				city: {
+					id: 2867714,
+					name: "Munich",
+					coord: { lon: 11.5754, lat: 48.1371 },
+					country: "DE",
+					population: 1260391,
+					timezone: 7200
+				},
+				cod: "200",
+				message: 0.9653487,
+				cnt: 7,
+				list: [
+					{
+						dt: 1568372400,
+						sunrise: 1568350044,
+						sunset: 1568395948,
+						temp: { day: 24.44, min: 15.35, max: 24.44, night: 15.35, eve: 18, morn: 23.03 },
+						pressure: 1031.65,
+						humidity: 70,
+						weather: [{ id: 801, main: "Clouds", description: "few clouds", icon: "02d" }],
+						speed: 3.35,
+						deg: 314,
+						clouds: 21
+					},
+					{
+						dt: 1568458800,
+						sunrise: 1568436525,
+						sunset: 1568482223,
+						temp: { day: 20.81, min: 13.56, max: 21.02, night: 13.56, eve: 16.6, morn: 15.88 },
+						pressure: 1028.81,
+						humidity: 72,
+						weather: [{ id: 500, main: "Rain", description: "light rain", icon: "10d" }],
+						speed: 2.21,
+						deg: 81,
+						clouds: 100
+					},
+					{
+						dt: 1568545200,
+						sunrise: 1568523007,
+						sunset: 1568568497,
+						temp: { day: 22.65, min: 13.76, max: 22.88, night: 15.27, eve: 17.45, morn: 13.76 },
+						pressure: 1023.75,
+						humidity: 64,
+						weather: [{ id: 800, main: "Clear", description: "sky is clear", icon: "01d" }],
+						speed: 1.15,
+						deg: 7,
+						clouds: 0
+					},
+					{
+						dt: 1568631600,
+						sunrise: 1568609489,
+						sunset: 1568654771,
+						temp: { day: 23.45, min: 13.95, max: 23.45, night: 13.95, eve: 17.75, morn: 15.21 },
+						pressure: 1020.41,
+						humidity: 64,
+						weather: [{ id: 800, main: "Clear", description: "sky is clear", icon: "01d" }],
+						speed: 3.07,
+						deg: 298,
+						clouds: 7
+					},
+					{
+						dt: 1568718000,
+						sunrise: 1568695970,
+						sunset: 1568741045,
+						temp: { day: 20.55, min: 10.95, max: 20.55, night: 10.95, eve: 14.82, morn: 13.24 },
+						pressure: 1019.4,
+						humidity: 66,
+						weather: [{ id: 800, main: "Clear", description: "sky is clear", icon: "01d" }],
+						speed: 2.8,
+						deg: 333,
+						clouds: 2
+					},
+					{
+						dt: 1568804400,
+						sunrise: 1568782452,
+						sunset: 1568827319,
+						temp: { day: 18.15, min: 7.75, max: 18.15, night: 7.75, eve: 12.45, morn: 9.41 },
+						pressure: 1017.56,
+						humidity: 52,
+						weather: [{ id: 800, main: "Clear", description: "sky is clear", icon: "01d" }],
+						speed: 2.92,
+						deg: 34,
+						clouds: 0
+					},
+					{
+						dt: 1568890800,
+						sunrise: 1568868934,
+						sunset: 1568913593,
+						temp: { day: 14.85, min: 5.56, max: 15.05, night: 5.56, eve: 9.56, morn: 6.25 },
+						pressure: 1022.7,
+						humidity: 59,
+						weather: [{ id: 800, main: "Clear", description: "sky is clear", icon: "01d" }],
+						speed: 2.89,
+						deg: 51,
+						clouds: 1
+					}
+				]
+			},
+			extendedData
+		)
+	);
+}
+
+module.exports = generateWeatherForecast;

tests/electron/modules/newsfeed_spec.js

@@ -0,0 +1,67 @@
+const helpers = require("../global-setup");
+
+describe("Newsfeed module", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("Default configuration", function () {
+		beforeAll(function () {
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/newsfeed/default.js";
+		});
+
+		it("should show the newsfeed title", function () {
+			return app.client.waitUntilTextExists(".newsfeed .newsfeed-source", "Rodrigo Ramirez Blog", 10000);
+		});
+
+		it("should show the newsfeed article", function () {
+			return app.client.waitUntilTextExists(".newsfeed .newsfeed-title", "QPanel", 10000);
+		});
+
+		it("should NOT show the newsfeed description", async () => {
+			await app.client.waitUntilTextExists(".newsfeed .newsfeed-title", "QPanel", 10000);
+			const events = await app.client.$$(".newsfeed .newsfeed-desc");
+			return expect(events.length).toBe(0);
+		});
+	});
+
+	describe("Custom configuration", function () {
+		beforeAll(function () {
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/newsfeed/prohibited_words.js";
+		});
+
+		it("should not show articles with prohibited words", function () {
+			return app.client.waitUntilTextExists(".newsfeed .newsfeed-title", "Problema VirtualBox", 10000);
+		});
+
+		it("should show the newsfeed description", async () => {
+			await app.client.waitUntilTextExists(".newsfeed .newsfeed-title", "Problema VirtualBox", 10000);
+			const events = await app.client.$$(".newsfeed .newsfeed-desc");
+			return expect(events.length).toBe(1);
+		});
+	});
+
+	describe("Invalid configuration", function () {
+		beforeAll(function () {
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/newsfeed/incorrect_url.js";
+		});
+
+		it("should show malformed url warning", function () {
+			return app.client.waitUntilTextExists(".newsfeed .small", "Error in the Newsfeed module. Malformed url.", 10000);
+		});
+	});
+});

tests/electron/modules/weather_spec.js

@@ -0,0 +1,309 @@
+const fs = require("fs");
+const moment = require("moment");
+const path = require("path");
+const wdajaxstub = require("webdriverajaxstub");
+
+const helpers = require("../global-setup");
+
+const { generateWeather, generateWeatherForecast } = require("./mocks");
+
+describe("Weather module", function () {
+	let app;
+
+	helpers.setupTimeout(this);
+
+	/**
+	 *
+	 * @param {object} responses mocked data to be returned
+	 * @returns {Promise} Resolved once the electron app is started
+	 */
+	async function setup(responses) {
+		app = await helpers.startApplication({
+			args: ["js/electron.js"],
+			waitTimeout: 100000
+		});
+
+		wdajaxstub.init(app.client, responses);
+
+		app.client.setupStub();
+	}
+
+	/**
+	 *
+	 * @param {string} element css selector
+	 * @returns {Promise<Element>} Promise with the element once it is rendered
+	 */
+	async function getElement(element) {
+		return await app.client.$(element);
+	}
+
+	/**
+	 * @param {string} element css selector
+	 * @param {string} result Expected text in given selector
+	 * @returns {Promise<boolean>} Promise with True if the text matches
+	 */
+	async function getText(element, result) {
+		const elem = await getElement(element);
+		return await elem.getText(element).then(function (text) {
+			expect(text.trim()).toBe(result);
+		});
+	}
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("Current weather", function () {
+		let template;
+
+		beforeAll(function () {
+			template = fs.readFileSync(path.join(__dirname, "..", "..", "..", "modules", "default", "weather", "current.njk"), "utf8");
+		});
+
+		describe("Default configuration", function () {
+			beforeAll(function () {
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/weather/currentweather_default.js";
+			});
+
+			it("should render wind speed and wind direction", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				return getText(".weather .normal.medium span:nth-child(2)", "6 WSW");
+			});
+
+			it("should render sunrise", async function () {
+				const sunrise = moment().startOf("day").unix();
+				const sunset = moment().startOf("day").unix();
+
+				const weather = generateWeather({ sys: { sunrise, sunset } });
+				await setup({ template, data: weather });
+
+				return getText(".weather .normal.medium span:nth-child(4)", "12:00 am");
+			});
+
+			it("should render sunset", async function () {
+				const sunrise = moment().startOf("day").unix();
+				const sunset = moment().endOf("day").unix();
+
+				const weather = generateWeather({ sys: { sunrise, sunset } });
+				await setup({ template, data: weather });
+
+				return getText(".weather .normal.medium span:nth-child(4)", "11:59 pm");
+			});
+
+			it("should render temperature with icon", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				return getText(".weather .large.light span.bright", "1.5°");
+			});
+
+			it("should render feels like temperature", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				return getText(".weather .normal.medium.feelslike span.dimmed", "Feels like -5.6°");
+			});
+		});
+
+		describe("Compliments Integration", function () {
+			beforeAll(function () {
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/weather/currentweather_compliments.js";
+			});
+
+			it("should render a compliment based on the current weather", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				return app.client.waitUntilTextExists(".compliments .module-content span", "snow");
+			});
+		});
+
+		describe("Configuration Options", function () {
+			beforeAll(function () {
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/weather/currentweather_options.js";
+			});
+
+			it("should render useBeaufort = false", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				return getText(".weather .normal.medium span:nth-child(2)", "12");
+			});
+
+			it("should render showWindDirectionAsArrow = true", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				const elem = await getElement(".weather .normal.medium sup i.fa-long-arrow-up");
+				return elem.getHTML(".weather .normal.medium sup i.fa-long-arrow-up").then(function (text) {
+					expect(text).toContain("transform:rotate(250deg);");
+				});
+			});
+
+			it("should render showHumidity = true", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				return getText(".weather .normal.medium span:nth-child(3)", "93.7");
+			});
+
+			it("should render degreeLabel = true", async function () {
+				const weather = generateWeather();
+				await setup({ template, data: weather });
+
+				return (await getText(".weather .large.light span.bright", "1°C")) && (await getText(".weather .normal.medium.feelslike span.dimmed", "Feels like -6°C"));
+			});
+		});
+
+		describe("Current weather units", function () {
+			beforeAll(function () {
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/weather/currentweather_units.js";
+			});
+
+			it("should render imperial units", async function () {
+				const weather = generateWeather({
+					main: {
+						temp: (1.49 * 9) / 5 + 32,
+						temp_min: (1 * 9) / 5 + 32,
+						temp_max: (2 * 9) / 5 + 32
+					},
+					wind: {
+						speed: 11.8 * 2.23694
+					}
+				});
+				await setup({ template, data: weather });
+
+				return (await getText(".weather .normal.medium span:nth-child(2)", "6 WSW")) && (await getText(".weather .large.light span.bright", "34,7°")) && getText(".weather .normal.medium.feelslike span.dimmed", "Feels like 22,0°");
+			});
+
+			it("should render custom decimalSymbol = ','", async function () {
+				const weather = generateWeather({
+					main: {
+						temp: (1.49 * 9) / 5 + 32,
+						temp_min: (1 * 9) / 5 + 32,
+						temp_max: (2 * 9) / 5 + 32
+					},
+					wind: {
+						speed: 11.8 * 2.23694
+					}
+				});
+				await setup({ template, data: weather });
+
+				return (await getText(".weather .normal.medium span:nth-child(3)", "93,7")) && (await getText(".weather .large.light span.bright", "34,7°")) && getText(".weather .normal.medium.feelslike span.dimmed", "Feels like 22,0°");
+			});
+		});
+	});
+
+	describe("Weather Forecast", function () {
+		let template;
+
+		beforeAll(function () {
+			template = fs.readFileSync(path.join(__dirname, "..", "..", "..", "modules", "default", "weather", "forecast.njk"), "utf8");
+		});
+
+		describe("Default configuration", function () {
+			beforeAll(function () {
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/weather/forecastweather_default.js";
+			});
+
+			it("should render days", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				const days = ["Today", "Tomorrow", "Sun", "Mon", "Tue"];
+
+				for (const [index, day] of days.entries()) {
+					await getText(`.weather table.small tr:nth-child(${index + 1}) td:nth-child(1)`, day);
+				}
+			});
+
+			it("should render icons", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				const icons = ["day-cloudy", "rain", "day-sunny", "day-sunny", "day-sunny"];
+
+				for (const [index, icon] of icons.entries()) {
+					await getElement(`.weather table.small tr:nth-child(${index + 1}) td:nth-child(2) span.wi-${icon}`);
+				}
+			});
+
+			it("should render max temperatures", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				const temperatures = ["24.4°", "21.0°", "22.9°", "23.4°", "20.6°"];
+
+				for (const [index, temp] of temperatures.entries()) {
+					await getText(`.weather table.small tr:nth-child(${index + 1}) td:nth-child(3)`, temp);
+				}
+			});
+
+			it("should render min temperatures", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				const temperatures = ["15.3°", "13.6°", "13.8°", "13.9°", "10.9°"];
+
+				for (const [index, temp] of temperatures.entries()) {
+					await getText(`.weather table.small tr:nth-child(${index + 1}) td:nth-child(4)`, temp);
+				}
+			});
+
+			it("should render fading of rows", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				const opacities = [1, 1, 0.8, 0.5333333333333333, 0.2666666666666667];
+
+				const elem = await getElement(".weather table.small");
+
+				for (const [index, opacity] of opacities.entries()) {
+					const html = await elem.getHTML(`.weather table.small tr:nth-child(${index + 1})`);
+					expect(html).toContain(`<tr style="opacity: ${opacity};">`);
+				}
+			});
+		});
+
+		describe("Configuration Options", function () {
+			beforeAll(function () {
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/weather/forecastweather_options.js";
+			});
+
+			it("should render custom table class", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				await getElement(".weather table.myTableClass");
+			});
+
+			it("should render colored rows", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				const rows = await app.client.$$(".weather table.myTableClass tr.colored");
+
+				expect(rows.length).toBe(5);
+			});
+		});
+
+		describe("Forecast weather units", function () {
+			beforeAll(function () {
+				process.env.MM_CONFIG_FILE = "tests/configs/modules/weather/forecastweather_units.js";
+			});
+
+			it("should render custom decimalSymbol = '_'", async function () {
+				const weather = generateWeatherForecast();
+				await setup({ template, data: weather });
+
+				const temperatures = ["24_4°", "21_0°", "22_9°", "23_4°", "20_6°"];
+
+				for (const [index, temp] of temperatures.entries()) {
+					await getText(`.weather table.small tr:nth-child(${index + 1}) td:nth-child(3)`, temp);
+				}
+			});
+		});
+	});
+});

tests/electron/modules_display_spec.js

@@ -0,0 +1,38 @@
+const helpers = require("./global-setup");
+
+describe("Display of modules", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	describe("Using helloworld", function () {
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/display.js";
+		});
+
+		it("should show the test header", async () => {
+			const elem = await app.client.$("#module_0_helloworld .module-header", 10000);
+			return expect(await elem.getText("#module_0_helloworld .module-header")).toBe("TEST_HEADER");
+		});
+
+		it("should show no header if no header text is specified", async () => {
+			const elem = await app.client.$("#module_1_helloworld .module-header", 10000);
+			return expect(await elem.getText("#module_1_helloworld .module-header")).toBe("");
+		});
+	});
+});

tests/electron/modules_position_spec.js

@@ -0,0 +1,38 @@
+const helpers = require("./global-setup");
+
+describe("Position of modules", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	describe("Using helloworld", function () {
+		afterAll(function () {
+			return helpers.stopApplication(app);
+		});
+
+		beforeAll(function () {
+			// Set config sample for use in test
+			process.env.MM_CONFIG_FILE = "tests/configs/modules/positions.js";
+			return helpers
+				.startApplication({
+					args: ["js/electron.js"]
+				})
+				.then(function (startedApp) {
+					app = startedApp;
+				});
+		});
+
+		const positions = ["top_bar", "top_left", "top_center", "top_right", "upper_third", "middle_center", "lower_third", "bottom_left", "bottom_center", "bottom_right", "bottom_bar", "fullscreen_above", "fullscreen_below"];
+
+		for (const position of positions) {
+			const className = position.replace("_", ".");
+			it("should show text in " + position, function () {
+				return app.client.$("." + className).then((result) => {
+					return result.getText("." + className).then((text) => {
+						return expect(text).toContain("Text in " + position);
+					});
+				});
+			});
+		}
+	});
+});

tests/electron/translations_spec.js

@@ -0,0 +1,227 @@
+const fs = require("fs");
+const path = require("path");
+const translations = require("../../translations/translations.js");
+const helmet = require("helmet");
+const { JSDOM } = require("jsdom");
+const express = require("express");
+const sinon = require("sinon");
+
+describe("Translations", function () {
+	let server;
+
+	beforeAll(function () {
+		const app = express();
+		app.use(helmet());
+		app.use(function (req, res, next) {
+			res.header("Access-Control-Allow-Origin", "*");
+			next();
+		});
+		app.use("/translations", express.static(path.join(__dirname, "..", "..", "translations")));
+
+		server = app.listen(3000);
+	});
+
+	afterAll(function () {
+		server.close();
+	});
+
+	it("should have a translation file in the specified path", function () {
+		for (let language in translations) {
+			const file = fs.statSync(translations[language]);
+			expect(file.isFile()).toBe(true);
+		}
+	});
+
+	describe("loadTranslations", () => {
+		let dom;
+
+		beforeEach(() => {
+			dom = new JSDOM(
+				`<script>var Translator = {}; var Log = {log: function(){}}; var config = {language: 'de'};</script>\
+					<script src="file://${path.join(__dirname, "..", "..", "js", "class.js")}"></script>\
+					<script src="file://${path.join(__dirname, "..", "..", "js", "module.js")}"></script>`,
+				{ runScripts: "dangerously", resources: "usable" }
+			);
+		});
+
+		it("should load translation file", (done) => {
+			dom.window.onload = async function () {
+				const { Translator, Module, config } = dom.window;
+				config.language = "en";
+				Translator.load = sinon.stub().callsFake((_m, _f, _fb, callback) => callback());
+
+				Module.register("name", { getTranslations: () => translations });
+				const MMM = Module.create("name");
+
+				const loaded = sinon.stub();
+				MMM.loadTranslations(loaded);
+
+				expect(loaded.callCount).toBe(1);
+				expect(Translator.load.args.length).toBe(1);
+				expect(Translator.load.calledWith(MMM, "translations/en.json", false, sinon.match.func)).toBe(true);
+
+				done();
+			};
+		});
+
+		it("should load translation + fallback file", (done) => {
+			dom.window.onload = async function () {
+				const { Translator, Module } = dom.window;
+				Translator.load = sinon.stub().callsFake((_m, _f, _fb, callback) => callback());
+
+				Module.register("name", { getTranslations: () => translations });
+				const MMM = Module.create("name");
+
+				const loaded = sinon.stub();
+				MMM.loadTranslations(loaded);
+
+				expect(loaded.callCount).toBe(1);
+				expect(Translator.load.args.length).toBe(2);
+				expect(Translator.load.calledWith(MMM, "translations/de.json", false, sinon.match.func)).toBe(true);
+				expect(Translator.load.calledWith(MMM, "translations/en.json", true, sinon.match.func)).toBe(true);
+
+				done();
+			};
+		});
+
+		it("should load translation fallback file", (done) => {
+			dom.window.onload = async function () {
+				const { Translator, Module, config } = dom.window;
+				config.language = "--";
+				Translator.load = sinon.stub().callsFake((_m, _f, _fb, callback) => callback());
+
+				Module.register("name", { getTranslations: () => translations });
+				const MMM = Module.create("name");
+
+				const loaded = sinon.stub();
+				MMM.loadTranslations(loaded);
+
+				expect(loaded.callCount).toBe(1);
+				expect(Translator.load.args.length).toBe(1);
+				expect(Translator.load.calledWith(MMM, "translations/en.json", true, sinon.match.func)).toBe(true);
+
+				done();
+			};
+		});
+
+		it("should load no file", (done) => {
+			dom.window.onload = async function () {
+				const { Translator, Module } = dom.window;
+				Translator.load = sinon.stub();
+
+				Module.register("name", {});
+				const MMM = Module.create("name");
+
+				const loaded = sinon.stub();
+				MMM.loadTranslations(loaded);
+
+				expect(loaded.callCount).toBe(1);
+				expect(Translator.load.callCount).toBe(0);
+
+				done();
+			};
+		});
+	});
+
+	const mmm = {
+		name: "TranslationTest",
+		file(file) {
+			return `http://localhost:3000/${file}`;
+		}
+	};
+
+	describe("Parsing language files through the Translator class", function () {
+		for (let language in translations) {
+			it(`should parse ${language}`, function (done) {
+				const dom = new JSDOM(
+					`<script>var translations = ${JSON.stringify(translations)}; var Log = {log: function(){}};</script>\
+					<script src="file://${path.join(__dirname, "..", "..", "js", "translator.js")}">`,
+					{ runScripts: "dangerously", resources: "usable" }
+				);
+				dom.window.onload = function () {
+					const { Translator } = dom.window;
+
+					Translator.load(mmm, translations[language], false, function () {
+						expect(typeof Translator.translations[mmm.name]).toBe("object");
+						expect(Object.keys(Translator.translations[mmm.name]).length).toBeGreaterThanOrEqual(1);
+						done();
+					});
+				};
+			});
+		}
+	});
+
+	describe("Same keys", function () {
+		let base;
+		let missing = [];
+
+		beforeAll(function (done) {
+			const dom = new JSDOM(
+				`<script>var translations = ${JSON.stringify(translations)}; var Log = {log: function(){}};</script>\
+					<script src="file://${path.join(__dirname, "..", "..", "js", "translator.js")}">`,
+				{ runScripts: "dangerously", resources: "usable" }
+			);
+			dom.window.onload = function () {
+				const { Translator } = dom.window;
+
+				Translator.load(mmm, translations.en, false, function () {
+					base = Object.keys(Translator.translations[mmm.name]).sort();
+					done();
+				});
+			};
+		});
+
+		afterAll(function () {
+			console.log(missing);
+		});
+
+		for (let language in translations) {
+			if (language === "en") {
+				continue;
+			}
+
+			describe(`Translation keys of ${language}`, function () {
+				let keys;
+
+				beforeAll(function (done) {
+					const dom = new JSDOM(
+						`<script>var translations = ${JSON.stringify(translations)}; var Log = {log: function(){}};</script>\
+					<script src="file://${path.join(__dirname, "..", "..", "js", "translator.js")}">`,
+						{ runScripts: "dangerously", resources: "usable" }
+					);
+					dom.window.onload = function () {
+						const { Translator } = dom.window;
+
+						Translator.load(mmm, translations[language], false, function () {
+							keys = Object.keys(Translator.translations[mmm.name]).sort();
+							done();
+						});
+					};
+				});
+
+				it(`${language} keys should be in base`, function () {
+					keys.forEach(function (key) {
+						expect(base.indexOf(key)).toBeGreaterThanOrEqual(0);
+					});
+				});
+
+				it(`${language} should contain all base keys`, function () {
+					// TODO: when all translations are fixed, use
+					// expect(keys).toEqual(base);
+					// instead of the try-catch-block
+
+					try {
+						expect(keys).toEqual(base);
+					} catch (e) {
+						if (e.message.match(/expect.*toEqual/)) {
+							const diff = base.filter((key) => !keys.includes(key));
+							missing.push(`Missing Translations for language ${language}: ${diff}`);
+						} else {
+							throw e;
+						}
+					}
+				});
+			});
+		}
+	});
+});

tests/electron/without_modules.js

@@ -0,0 +1,36 @@
+const helpers = require("./global-setup");
+
+describe("Check configuration without modules", function () {
+	helpers.setupTimeout(this);
+
+	let app = null;
+
+	beforeEach(function () {
+		return helpers
+			.startApplication({
+				args: ["js/electron.js"]
+			})
+			.then(function (startedApp) {
+				app = startedApp;
+			});
+	});
+
+	afterEach(function () {
+		return helpers.stopApplication(app);
+	});
+
+	beforeAll(function () {
+		// Set config sample for use in test
+		process.env.MM_CONFIG_FILE = "tests/configs/without_modules.js";
+	});
+
+	it("Show the message MagicMirror title", async function () {
+		const elem = await app.client.$("#module_1_helloworld .module-content");
+		return expect(await elem.getText("#module_1_helloworld .module-content")).toBe("Magic Mirror2");
+	});
+
+	it("Show the text Michael's website", async function () {
+		const elem = await app.client.$("#module_5_helloworld .module-content");
+		return expect(await elem.getText("#module_5_helloworld .module-content")).toBe("www.michaelteeuw.nl");
+	});
+});