/**

* DataFormsJS Unit Testing

*

* This is the main file for testing the Framework.

*

* Unit Testing runs in the Browser using QUnit.

* See instructions in [../server.js].

*

* NOTE - Vue was added several years after this file was created

* and because the behavior of Vue is different from Templating (Handlebars, etc)

* many tests and checks have to be skipped for Vue. Because many tests

* are skipped it's important that demos be manually tested when

* updates are made and when new versions of Vue are released.

*/

/* Validates with both [jshint] and [eslint] */

/* global QUnit, app, DataFormsJS, tester, nunjucks, Vue */

/* jshint strict: true */

/* eslint-env browser */

/* eslint quotes: ["error", "single", { "avoidEscape": true }] */

/* eslint strict: ["error", "function"] */

/* eslint spaced-comment: ["error", "always"] */

/* eslint no-console: ["error", { allow: ["log", "warn", "error"] }] */

/* eslint no-prototype-builtins: "off" */

(function () {

'use strict';

var isIE = (navigator.userAgent.indexOf('Trident/') !== -1);

var isFirefox = (navigator.userAgent.indexOf('Firefox/') !== -1);

document.addEventListener('DOMContentLoaded', function () {

// Default expected DataFormJS Settings based on the current page

// Controllers and Plugins are variable which allows for different

// builds to be tested. The required pages/plugins are checked at setup.

tester.controllersCount = 19;

tester.modelsCount = 5;

tester.pagesCount = Object.keys(app.pages).length; // min=2

tester.pluginsCount = Object.keys(app.plugins).length; // min=1

tester.compiledTemplates = 1;

tester.submittedRequestCount = 0;

// Run tests in the order that they are defined

QUnit.config.reorder = false;

QUnit.test('DataFormsJS Version, Settings, Automatic Setup, and Initial View Rendering Test', function (assert) {

assert.ok(app === DataFormsJS, 'Global Variables [app] and [DataFormsJS] are Defined');

assert.equal(app.settings.viewSelector, '#view', 'Default Settings for app.settings.viewSelector: ' + app.settings.viewSelector);

assert.equal(app.settings.defaultRoute, '/', 'Default Settings for app.settings.defaultRoute: ' + app.settings.defaultRoute);

assert.equal(app.settings.logFetchRequests, false, 'Default Settings for app.settings.logFetchRequests: ' + app.settings.logFetchRequests);

assert.deepEqual(app.settings.requestHeaders, {}, 'Default Settings for app.settings.requestHeaders: ' + JSON.stringify(app.settings.requestHeaders));

assert.deepEqual(app.settings.requestHeadersByHostName, {}, 'Default Settings for app.settings.requestHeadersByHostName: ' + JSON.stringify(app.settings.requestHeadersByHostName));

assert.equal(app.settings.errors.pageLoading, 'Error loading the current page because the previous page is still loading and is taking a long time. Please refresh the page and try again.', 'Default settings for app.settings.errors.pageLoading: ' + app.settings.errors.pageLoading);

assert.equal(Object.keys(app.settings).length, 12, 'Number of properties in app.settings');

var version = app.version.match(/^5.\d+.\d+$/);

assert.ok(version !== null, 'app.version is major version 5, full version: ' + version);

switch (app.viewEngine()) {

case 'Handlebars':

case 'Nunjucks':

case 'Underscore':

case 'Vue':

assert.ok(true, 'app.viewEngine() - ' + app.viewEngine());

break;

default:

assert.ok(false, 'app.viewEngine() - ' + app.viewEngine());

}

switch (app.viewEngine()) {

case 'Handlebars':

tester.controllersCount++;

break;

case 'Nunjucks':

tester.controllersCount += 2;

break;

default:

break;

}

tester.setup();

tester.checkCounts(assert);

// Required Pages/Plugins

// Tests will fail if required files are not included in the build

assert.ok(app.pages.jsonData !== undefined, 'Checking for required page: app.pages.jsonData');

assert.ok(app.pages.unitTestEventOrder !== undefined, 'Checking for required page: app.pages.unitTestEventOrder');

assert.ok(app.plugins.unitTestEventOrder !== undefined, 'Checking for required plugin: app.plugins.unitTestEventOrder');

var text = document.getElementById('view').textContent.trim();

var expectedText = 'Initial view has loaded';

assert.equal(text, expectedText, 'Checking for Initial Template: ' + text);

assert.equal(app.activeController.settings.content, expectedText, 'app.activeController.settings.content: ' + app.activeController.settings.content);

var template0 = document.querySelector('#template0[data-route="/"]');

var isValid = (template0 !== null && template0.tagName === 'SCRIPT');

assert.ok(isValid, 'Checking assigned Template ID');

assert.equal(template0.getAttribute('data-content'), expectedText, 'Template [data-content]: ' + template0.getAttribute('data-content'));

// Verify that [app.viewEngine()] is being determined by <script [type="*"]> only.

// This is done because each of the pages that call this file use one one type of

// view engine but include all View Engines on the page

assert.ok((window.Handlebars !== undefined), 'Including Handlebars on this page');

assert.ok((window.nunjucks !== undefined), 'Including Nunjucks on this page');

assert.ok((window._ !== undefined), 'Including Underscore on this page');

// Error Default Properties

var expectedCss = '.dataformsjs-error,.dataformsjs-fatal-error{color:#fff;background-color:red;box-shadow:0 1px 5px 0 rgba(0,0,0,.5);background-image:linear-gradient(#e00,#c00);/*white-space:pre;*/text-align:left;}.dataformsjs-error{padding:10px;font-size:1em;margin:5px;display:inline-block;}.dataformsjs-fatal-error{z-index:1000000;padding:20px;font-size:1.5em;margin:20px;position:fixed;top:10px;}@media only screen and (min-width:1000px){.dataformsjs-fatal-error{max-width:1000px;left:calc(50% - 520px);}}.dataformsjs-fatal-error span{padding:5px 10px;float:right;border:1px solid darkred;cursor:pointer;margin-left:10px;box-shadow:0 0 2px 1px rgba(0,0,0,0.3);background-image:linear-gradient(#c00,#a00);border-radius:5px;}';

assert.equal(app.errorClass, 'dataformsjs-error', 'Default Settings for app.errorClass: ' + app.errorClass);

assert.equal(app.fatalErrorClass, 'dataformsjs-fatal-error', 'Default Settings for app.fatalErrorClass: ' + app.fatalErrorClass);

assert.equal(app.errorStyleId, 'dataformsjs-style-errors', 'Default Settings for app.errorStyleId: ' + app.errorStyleId);

assert.equal(app.errorCss, expectedCss, 'Default Settings for app.errorClass: ' + app.errorCss);

// Test setup() when a script with the attribute [data-route] is defined but the value is missing

// Normally this would be a fatal error which is why the script type is defined and re-defined after testing.

var expectedMessage = 'TypeError: A script element <script id="template-invalid-path" type="text/x-template" data-engine="null"> has the attribute [data-route] defined however the attribute value is empty. This error must be fixed, scripts that include a route path attribute must have the value defined.';

var script = document.getElementById('template-invalid-path');

var startingScriptType = script.type;

script.type = 'text/x-template';

app.setup();

// Check error alert and close it

var div = document.querySelector('.dataformsjs-fatal-error');

assert.ok(div.childNodes[1].textContent, expectedMessage);

div.querySelector('span').click();

script.type = startingScriptType;

});

QUnit.test('Check Polyfills from [js/scripts/polyfills.js]', function (assert) {

assert.equal('\t\n test '.trimLeft(), 'test ', 'String.prototype.trimLeft()');

assert.equal('\t\n test '.trimStart(), 'test ', 'String.prototype.trimStart()');

assert.equal(' test \t\n'.trimRight(), ' test', 'String.prototype.trimRight()');

assert.equal(' test \t\n'.trimEnd(), ' test', 'String.prototype.trimEnd()');

});

QUnit.test('Redirect with [app.settings.defaultRoute] with [/404] Route', function (assert) {

// Asynchronous test

var done = assert.async();

// Define hash to a view that doesn't exist

var hash = '#/404';

// Make sure that content get's overwritten on the redirect

var html = 'This will be overwritten';

document.getElementById('view').innerHTML = html;

tester.checkElement('view', html, assert);

// Define a Global App Function to check the page after it is rendered

app.onUpdateViewComplete = function () {

// Check the URL Hash and View Contents

var expectedHtml = 'Initial view has loaded';

assert.equal(window.location.hash, '#' + app.settings.defaultRoute, 'Current URL Hash [' + window.location.hash + '] after setting [' + hash + ']');

tester.checkElement('view', expectedHtml, assert);

// Reset Global App Function

app.onUpdateViewComplete = null;

// Mark the test as complete

done();

};

// Change the hash

window.location.hash = hash;

});

// Test when controller/script for [app.settings.defaultRoute] doesn't exist

QUnit.test('Redirect with [app.settings.defaultRoute] with missing [/500] Route', function (assert) {

// Asynchronous test

var done = assert.async();

// These don't exist

var hash = '#/404';

app.settings.defaultRoute = '/500';

// Define a custom hash change event because this type unexpected

// error can't be handled from app routing functions.

function hashChange() {

// Check results

var expected = 'Error - The route [/404] does not have a <script data-route> element or [Controller] defined. Check to make sure that a controller or script for default route [/500] exists.';

assert.equal(window.location.hash, hash, 'Current URL Hash [' + window.location.hash + '] after setting [' + hash + ']');

assert.equal(app.settings.defaultRoute, '/500', 'Current Default Route: ' + app.settings.defaultRoute);

tester.checkElement('view', expected, assert);

// Reset

app.settings.defaultRoute = '/';

window.removeEventListener('hashchange', hashChange);

document.head.removeChild(document.getElementById('dataformsjs-style-errors')); // Created from the error

// Mark the test as complete

done();

}

// Change the hash

window.addEventListener('hashchange', hashChange);

window.location.hash = hash;

});

QUnit.test('Render a <template> View and check properties', function (assert) {

var done = assert.async();

var hash = '#/template-view';

var expectedHtml = 'Template View';

var shouldCompileTemplate = true;

tester.pageTester(hash, shouldCompileTemplate, expectedHtml, assert, done, function () {

// script[data-engine="text"] is for IE

var type = app.getTemplateType(document.querySelector('template[data-route="/template-view"],script[data-engine="text"][data-route="/template-view"]'));

assert.equal(type, 'Text', 'app.getTemplateType(<template>): ' + type);

});

});

QUnit.test('app.routeMatches() Validation', function (assert) {

var routes = [

{

path: '/page1',

routePath: '/page2',

expected: { isMatch: false }

},

{

path: '/show-all',

routePath: '/show-all',

expected: { isMatch: true, args: [], namedArgs: {} }

},

{

path: '/record/123',

routePath: '/record/:id',

expected: { isMatch: true, args: ['123'], namedArgs: { id: '123'} }

},

{

path: '/orders/edit/123',

routePath: '/:record/:view/:id',

expected: {

isMatch: true,

args: ['orders', 'edit', '123'],

namedArgs: {

record: 'orders',

view: 'edit',

id: '123'

}

}

}

];

routes.forEach(function (route) {

var result = app.routeMatches(route.path, route.routePath);

assert.deepEqual(route.expected, result, 'Comparing [' + route.path + '] to [' + route.routePath + ']');

});

});

QUnit.test('app.deepClone() Validation', function (assert) {

var expectedMessage,

expectedResult,

result,

obj1,

obj2,

obj3,

dateValue;

try {

expectedMessage = 'No arguments specified when app.deepClone() was called.';

app.deepClone();

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'No arguments specified when app.deepClone() was called.';

app.deepClone();

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'Only one argument was specified when app.deepClone() was called.';

app.deepClone({});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[argument] was not defined as a object when the function app.deepClone() was called';

app.deepClone({}, '');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

expectedResult = { name: 'Conrad' };

obj1 = { name: 'Conrad' };

result = app.deepClone({}, obj1);

assert.deepEqual(expectedResult, result, 'app.deepClone() Test 1');

expectedResult = { name: 'Conrad', numberValue: 123 };

obj1 = { name: 'Conrad' };

obj2 = { numberValue: 123 };

result = app.deepClone({}, obj1, obj2);

assert.deepEqual(expectedResult, result, 'app.deepClone() Test 2');

expectedResult = { name: 'Conrad', numberValue: 456 };

obj1 = { name: 'Conrad' };

obj2 = { numberValue: 123 };

obj3 = { numberValue: 456 };

result = app.deepClone(obj1, obj2, obj3);

assert.deepEqual(expectedResult, result, 'app.deepClone() Test 3');

expectedResult = { name: 'Conrad' };

obj1 = { name: 'Conrad' };

result = app.deepClone(obj1, obj1);

assert.deepEqual(expectedResult, result, 'app.deepClone() Test 4 - Copy object to itself');

dateValue = new Date();

expectedResult = {

type: 'Parent Class',

childObj: {

prop1: 'Value1',

prop2: 'Value2'

},

arrayData: [

{ index: 1 },

{ index: 2 },

{ index: 3 }

],

dateValue: dateValue

};

obj1 = {

type: 'Parent Class',

childObj: {

prop1: 'Value1',

prop2: 'Value2'

},

arrayData: [

{ index: 1 },

{ index: 2 },

{ index: 3 }

],

dateValue: dateValue

};

result = app.deepClone({}, obj1);

assert.deepEqual(expectedResult, result, 'app.deepClone() Test 5 - Deep Copy');

// Make changes to the copied item

result.type = 'Updated';

result.dateValue = new Date(2015, 0, 1);

result.childObj.prop1 = 'abc';

result.arrayData[0].index = 0;

// Make sure the original item was not updated

assert.equal(obj1.type, 'Parent Class', 'Checking result of deep copy - obj1.type');

assert.equal(obj1.dateValue, dateValue, 'Checking result of deep copy - obj1.dateValue');

assert.equal(obj1.childObj.prop1, 'Value1', 'Checking result of deep copy - obj1.childObj.prop1');

assert.equal(obj1.arrayData[0].index, 1, 'Checking result of deep copy - obj1.arrayData[0].index');

});

QUnit.test('app.addModel() Validation', function (assert) {

var expectedMessage;

try {

expectedMessage = '[name] was not defined as a string when the function app.addModel() was called';

app.addModel({});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[name] must have a value when defined when the function app.addModel() is called';

app.addModel('');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[model] was not defined as a object when the function app.addModel() was called';

app.addModel('Test');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

app.addModel('Test', {});

tester.modelsCount++;

assert.ok(true, 'Add Model Test');

} catch (e) {

assert.ok(false, e);

}

try {

expectedMessage = '[app.models.Test] is already defined';

app.addModel('Test', {});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

});

QUnit.test('app.addPlugin() Validation', function (assert) {

var expectedMessage;

try {

expectedMessage = '[name] was not defined as a string when the function app.addPlugin() was called';

app.addPlugin({});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[name] must have a value when defined when the function app.addPlugin() is called';

app.addPlugin('');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[plugin] was not defined as a object when the function app.addPlugin() was called';

app.addPlugin('Test');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

var functions = ['onBeforeRender', 'onRendered', 'onRouteUnload'];

functions.forEach(function(func) {

var expectedMessage;

try {

expectedMessage = 'plugin[Test].' + func + ' is not defined as a function.';

var plugin = {};

plugin[func] = '';

app.addPlugin('Test', plugin);

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

});

try {

expectedMessage = 'plugin[Test] must have one of the following properties defined: onRouteLoad, onBeforeRender, onRendered';

app.addPlugin('Test', { onRouteUnload:function(){} });

assert.ok(true, 'Add Model Test');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

app.addPlugin('Test', { onBeforeRender: function () { } });

assert.ok(true, 'Add Plugin Test');

tester.pluginsCount++;

} catch (e) {

assert.ok(false, e);

}

try {

expectedMessage = '[app.plugins.Test] is already defined';

app.addPlugin('Test', { onBeforeRender: function () { } });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

});

QUnit.test('app.addPage() Validation', function (assert) {

var expectedMessage;

try {

expectedMessage = '[name] was not defined as a string when the function app.addPage() was called';

app.addPage({});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[name] must have a value when defined when the function app.addPage() is called';

app.addPage('');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'Page [Test] must be defined as an object or a class when the function app.addPage() is called';

app.addPage('Test');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

var functions = ['onRouteLoad', 'onBeforeRender', 'onRendered', 'onRouteUnload'];

functions.forEach(function(func) {

var expectedMessage;

try {

expectedMessage = 'page[Test].' + func + ' is not defined as a function.';

var page = {};

page[func] = '';

app.addPage('Test', page);

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

});

try {

expectedMessage = 'page[Test] must have one of the following properties defined: onRouteLoad, onBeforeRender, onRendered';

app.addPage('Test', {});

assert.ok(false, 'Add Model Test');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[page.Test.model] must first be defined before the function app.addPage() is called';

app.addPage('Test', { onBeforeRender: function () { } });

assert.ok(false, 'Add Model Test');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[page.Test.model] was not defined as an object when the function app.addPage() was called';

app.addPage('Test', { onBeforeRender: function () { }, model: function () { } });

assert.ok(false, 'Add Model Test');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

app.addPage('Test', {

onBeforeRender: function () { },

model: {}

});

tester.pagesCount++;

assert.ok(true, 'Add Page Test');

} catch (e) {

assert.ok(false, e);

}

try {

expectedMessage = '[app.pages.Test] is already defined';

app.addPage('Test', {

onBeforeRender: function () { },

model: {}

});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

tester.checkCounts(assert);

});

QUnit.test('app.addController() Validation', function (assert) {

var expectedMessage;

try {

expectedMessage = '[controller] was not defined as a object when the function app.addController() was called';

app.addController('');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.path] was not defined as a string when the function app.addController() was called';

app.addController({});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.path] must have a value when defined when the function app.addController() is called';

app.addController({ path: '' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.viewId] was not defined as a string when the function app.addController(path=Test) was called';

app.addController({ path: 'Test', viewId: {} });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.viewId] must have a value when defined when the function app.addController(path=Test) is called';

app.addController({ path: 'Test', viewId: '' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.viewUrl] was not defined as a string when the function app.addController(path=Test) was called';

app.addController({ path: 'Test', viewUrl: function () { return 'url'; } });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.viewUrl] must have a value when defined when the function app.addController(path=Test) is called';

app.addController({ path: 'Test', viewUrl: '' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'A controller cannot have both [viewId] and [viewUrl] defined when calling app.addController(path=Test)';

app.addController({ path: 'Test', viewId: 'view', viewUrl: 'url' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'An element was not found on the page with [controller.viewId][id=missing-template] when the function app.addController(path=Test) was called';

app.addController({ path: 'Test', viewId: 'missing-template' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.modelName] was not defined as a string when the function app.addController(path=Test) was called';

app.addController({ path: 'Test', modelName: {} });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.modelName] must have a value when defined when the function app.addController(path=Test) is called';

app.addController({ path: 'Test', modelName: '' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'When a controller uses the [viewEngine] property either [viewId] or [viewUrl] must also be defined when calling app.addController(path=Test)';

app.addController({ path: 'Test', viewEngine: 'Error' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'Invalid [viewEngine] property when calling app.addController(path=Test). Valid values are: Handlebars, Vue, Nunjucks, Underscore, Text';

app.addController({ path: 'Test', viewUrl: 'Error', viewEngine: 'Error' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[app.models.MissingModel] must first be defined before the function app.addController(path=Test) is called';

app.addController({ path: 'Test', modelName: 'MissingModel' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

// First add an invalid model manually without using app.addModel()

// This error would happen if the developer overwrites a model object

// as a different type or if they manually add an invalid model.

app.models.InvalidModel = '';

tester.modelsCount++;

// Run the test

expectedMessage = '[app.models.InvalidModel] was not defined as an object when the function app.addController(path=Test) was called';

app.addController({ path: 'Test', modelName: 'InvalidModel' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.pageType] was not defined as a string when the function app.addController(path=Test) was called';

app.addController({ path: 'Test', pageType: {} });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[controller.pageType] must have a value when defined when the function app.addController(path=Test) is called';

app.addController({ path: 'Test', pageType: '' });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

var functions = ['onRouteLoad', 'onBeforeRender', 'onRendered', 'onRouteUnload'];

functions.forEach(function(func) {

var expectedMessage;

try {

expectedMessage = 'controller[Test].' + func + ' is not defined as a function.';

var controller = { path:'Test' };

controller[func] = '';

app.addController(controller);

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

});

try {

expectedMessage = 'controller[Test] must have one of the following properties defined: onRouteLoad, onBeforeRender, onRendered, viewId, viewUrl';

app.addController({ path: 'Test', onRouteUnload:function(){} });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

app.addController({

path: 'Test',

onRendered: function () { }

});

tester.controllersCount++;

assert.ok(true, 'Add Page Test');

} catch (e) {

assert.ok(false, e);

}

try {

expectedMessage = '[app.controllers(path=Test)] is already defined';

app.addController({

path: 'Test',

onRendered: function () { }

});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

app.addController({

path: 'ModelNameTest',

modelName: 'Test',

onRendered: function () { }

});

tester.controllersCount++;

assert.ok(true, 'Add Page with modelName=Test');

} catch (e) {

assert.ok(false, e);

}

try {

app.addController({

path: 'PageTypeTest',

pageType: 'Test'

});

tester.controllersCount++;

assert.ok(true, 'Add Controller with pageType=Test');

} catch (e) {

assert.ok(false, e);

}

try {

var controller = {

path: 'DynamicModel',

onRouteLoad: function () { },

settings: { prop1: '' }

};

app.addController(controller);

tester.controllersCount++;

assert.ok(true, 'Add Controller with Dynamic Model (Settings Defined and without an existing Model)');

// Check the [app.controller()] function

assert.ok(controller === app.controller('DynamicModel'), 'Fetching controller from app.controller(path)');

assert.ok(null === app.controller('Unknown'), 'Returning null from app.controller(path)');

} catch (e) {

assert.ok(false, e);

}

tester.checkCounts(assert);

});

QUnit.test('app.addControl() Validation', function (assert) {

var expectedMessage;

assert.ok(app.controls['unit-test'] === undefined, 'Control [unit-test] must not exist');

try {

expectedMessage = '[name] was not defined as a string when the function app.addControl() was called';

app.addControl({});

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[name] must have a value when defined when the function app.addControl() is called';

app.addControl('');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'Control names must be all lower-case. [app.addControl()] was called with: [unitTest]';

app.addControl('unitTest');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'Control names must contain a dash [-] character. [app.addControl()] was called with: [unittest]';

app.addControl('unittest');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'Control names cannot contain a space. [app.addControl()] was called with: [-unit test]';

app.addControl('-unit test');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = 'Control names cannot contain HTML characters that need to be escaped. Invalid characters are [& < > " \' /]. [app.addControl()] was called with: [<unit-test>]';

app.addControl('<unit-test>');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[control] was not defined as a object when the function app.addControl() was called';

app.addControl('unit-test', '');

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

expectedMessage = '[control.css] was not defined as a string when the function app.addControl() was called';

app.addControl('unit-test', { css:false });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

var functions = ['onLoad', 'html', 'onUnload'];

functions.forEach(function(func) {

var expectedMessage;

try {

expectedMessage = 'control[unit-test].' + func + ' is not defined as a function.';

var controller = {};

controller[func] = '';

app.addControl('unit-test', controller);

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

});

try {

expectedMessage = 'control[unit-test] must have one of the following properties defined: onLoad, html';

app.addControl('unit-test', { onUnload:function() {} });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

try {

app.addControl('unit-test', { onLoad:function() {} });

assert.ok(app.controls['unit-test'] !== undefined, 'Control Added');

} catch (e) {

assert.ok(false, e);

}

try {

expectedMessage = '[app.controls.unit-test] is already defined';

app.addControl('unit-test', { onLoad:function() {} });

assert.ok(false, 'Test should have failed');

} catch (e) {

assert.ok(e instanceof TypeError, 'Execption should be a TypeError');

assert.equal(e.message, expectedMessage, expectedMessage);

}

// Reset

delete app.controls['unit-test'];

assert.ok(app.controls['unit-test'] === undefined, 'Control [unit-test] should be deleted');

});

// Manually trigger an error alert, validate, then close dialog

// Unlike most tests this runs synchronously

QUnit.test('app.showErrorAlert()', function (assert) {

// Make sure the error style element does not yet exist

// It gets created by calls to [showErrorAlert()] and [showError()]

var errorStyle = document.getElementById('dataformsjs-style-errors');

assert.ok(errorStyle === null, 'Checking for Style Element [dataformsjs-style-errors] before [app.showErrorAlert()]');

// Create and show error

var errorText = 'Test';

app.showErrorAlert(errorText);

var div = document.querySelector('.dataformsjs-fatal-error');

var span = div.querySelector('span');

// Make sure error style element was created

errorStyle = document.getElementById('dataformsjs-style-errors');

assert.ok(errorStyle !== null, 'Checking for Style Element [dataformsjs-style-errors] after [app.showErrorAlert()]');

assert.equal(errorStyle.innerHTML, app.errorCss, 'Error Style CSS: ' + errorStyle.innerHTML);

// Basic Element Checks

assert.ok(div !== null, 'Found Element ".dataformsjs-fatal-error"');

assert.ok(span !== null, 'Found Element ".dataformsjs-fatal-error span"');

assert.equal(div.childNodes.length, 2, 'Correct Child Node Count: ' + div.childNodes.length);

assert.equal(div.tagName, 'DIV', 'Correct Element Type for Container: ' + div.tagName);

assert.equal(div.childNodes[1].textContent, 'Error: ' + errorText, 'Div textContent: ' + div.childNodes[1].textContent);

assert.equal(div.className, 'dataformsjs-fatal-error', 'Div className: ' + div.className);

assert.equal(span.tagName, 'SPAN', 'Correct Element Type for [X] Button: ' + span.tagName);

assert.equal(span.textContent, '✕', 'Span textContent: ' + span.textContent);

// Check CSS Computed Properties which get set

// from the dynamically created Style Sheet.

var elements = [

{

el: div,

cssProps: {

'color': 'rgb(255, 255, 255)',

'background-color': 'rgb(255, 0, 0)',

'background-image': 'linear-gradient(rgb(238, 0, 0), rgb(204, 0, 0))',

// Browsers may return [boxShadow] in a different

// format so handle any known valid value.

'box-shadow': [

'0px 1px 5px 0px rgba(0,0,0,0.5)',

'0 1px 5px 0 rgba(0,0,0,.5)',

'rgba(0, 0, 0, 0.5) 0px 1px 5px 0px',

'rgba(0, 0, 0, 0.498039) 0px 1px 5px 0px',

],

'z-index': '1000000',