openmct/platform/representation/test/TemplateLinkerSpec.js
2018-05-14 15:46:17 -07:00

240 lines
9.8 KiB
JavaScript

/*****************************************************************************
* Open MCT, Copyright (c) 2014-2018, United States Government
* as represented by the Administrator of the National Aeronautics and Space
* Administration. All rights reserved.
*
* Open MCT is licensed under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
* Open MCT includes source code licensed under additional open source
* licenses. See the Open Source Licenses file (LICENSES.md) included with
* this source code distribution or the Licensing information page available
* at runtime from the About dialog for additional information.
*****************************************************************************/
define(
["../src/TemplateLinker"],
function (TemplateLinker) {
var JQLITE_METHODS = ['replaceWith', 'empty', 'html', 'contents'],
SCOPE_METHODS = ['$on', '$new', '$destroy'];
describe("TemplateLinker", function () {
var mockTemplateRequest,
mockSce,
mockCompile,
mockLog,
mockScope,
mockElement,
mockTemplates,
mockElements,
mockContents,
mockNewScope,
mockPromise,
linker;
function testExtension(path, res, templatePath) {
return {
bundle: {
path: path,
resources: res
},
templateUrl: templatePath
};
}
beforeEach(function () {
mockTemplateRequest = jasmine.createSpy('$templateRequest');
mockSce = jasmine.createSpyObj('$sce', ['trustAsResourceUrl']);
mockCompile = jasmine.createSpy('$compile');
mockLog = jasmine.createSpyObj('$log', ['error', 'warn']);
mockScope = jasmine.createSpyObj('$scope', SCOPE_METHODS);
mockNewScope = jasmine.createSpyObj('$scope', SCOPE_METHODS);
mockElement = jasmine.createSpyObj('element', JQLITE_METHODS);
mockPromise = jasmine.createSpyObj('promise', ['then']);
mockTemplates = {};
mockElements = {};
mockContents = {};
mockTemplateRequest.andReturn(mockPromise);
mockCompile.andCallFake(function (toCompile) {
var html = typeof toCompile === 'string' ?
toCompile : toCompile.testHtml;
mockTemplates[html] = jasmine.createSpy('template');
mockElements[html] =
jasmine.createSpyObj('templateEl', JQLITE_METHODS);
mockTemplates[html].andReturn(mockElements[html]);
return mockTemplates[html];
});
mockSce.trustAsResourceUrl.andCallFake(function (url) {
return { trusted: url };
});
mockScope.$new.andReturn(mockNewScope);
mockElement.html.andCallFake(function (html) {
mockContents[html] =
jasmine.createSpyObj('contentsEl', JQLITE_METHODS);
mockContents[html].testHtml = html;
});
mockElement.contents.andCallFake(function () {
return mockContents[
mockElement.html.mostRecentCall.args[0]
];
});
linker = new TemplateLinker(
mockTemplateRequest,
mockSce,
mockCompile,
mockLog
);
});
it("resolves extension paths", function () {
var testExt = testExtension('a', 'b', 'c/d.html');
expect(linker.getPath(testExt)).toEqual('a/b/c/d.html');
});
describe("when linking elements", function () {
var changeTemplate,
commentElement;
function findCommentElement() {
mockCompile.calls.forEach(function (call) {
var html = call.args[0];
if (html.indexOf("<!--") > -1) {
commentElement = mockElements[html];
}
});
}
beforeEach(function () {
changeTemplate = linker.link(mockScope, mockElement);
findCommentElement();
});
it("compiles a comment to use to replace element", function () {
expect(commentElement).toBeDefined();
});
it("initially replaces elements with comments", function () {
expect(mockElement.replaceWith)
.toHaveBeenCalledWith(commentElement);
});
it("provides a function to change templates", function () {
expect(changeTemplate).toEqual(jasmine.any(Function));
});
describe("and then changing templates", function () {
var testExt,
testUrl,
testTemplate;
beforeEach(function () {
testExt = testExtension('some', 'url', 'template.html');
testUrl = linker.getPath(testExt);
testTemplate = "<div>Some template!</div>";
changeTemplate(testExt);
mockPromise.then.mostRecentCall
.args[0](testTemplate);
});
it("loads templates using $templateRequest", function () {
expect(mockTemplateRequest).toHaveBeenCalledWith({
trusted: testUrl
}, false);
});
it("compiles element contents with a new scope", function () {
expect(mockCompile)
.toHaveBeenCalledWith(mockContents[testTemplate]);
expect(mockTemplates[testTemplate])
.toHaveBeenCalledWith(mockNewScope);
});
it("replaces comments with specified element", function () {
expect(commentElement.replaceWith)
.toHaveBeenCalledWith(mockElement);
});
it("inserts HTML content into the specified element", function () {
expect(mockElement.html)
.toHaveBeenCalledWith(testTemplate);
});
it("clears templates when called with undefined", function () {
expect(mockElement.replaceWith.callCount)
.toEqual(1);
changeTemplate(undefined);
expect(mockElement.replaceWith.callCount)
.toEqual(2);
expect(mockElement.replaceWith.mostRecentCall.args[0])
.toEqual(commentElement);
});
it("logs no warnings for nominal changes", function () {
expect(mockLog.warn).not.toHaveBeenCalled();
});
describe("which cannot be found", function () {
beforeEach(function () {
changeTemplate(
testExtension("some", "bad", "template.html")
);
// Reject the template promise
mockPromise.then.mostRecentCall.args[1]();
});
it("removes the element from the DOM", function () {
expect(mockElement.replaceWith.callCount)
.toEqual(2);
expect(
mockElement.replaceWith.mostRecentCall.args[0]
).toEqual(commentElement);
});
it("logs a warning", function () {
expect(mockLog.warn)
.toHaveBeenCalledWith(jasmine.any(String));
});
});
});
});
describe("when an initial template URL is provided", function () {
var testExt,
testUrl;
beforeEach(function () {
testExt = testExtension('some', 'test', 'template.html');
testUrl = linker.getPath(testExt);
linker.link(mockScope, mockElement, testExt);
});
it("does not remove the element initially", function () {
expect(mockElement.replaceWith)
.not.toHaveBeenCalled();
});
it("loads the specified template", function () {
expect(mockTemplateRequest).toHaveBeenCalledWith({
trusted: testUrl
}, false);
});
});
});
}
);