Merge pull request #4293 from RaananW/viewer-tests

Viewer tests

Viewer/src/configuration/mappers.ts

@@ -163,7 +163,7 @@ export class MapperManager {
         if (!this._mappers[type]) {
             Tools.Error("No mapper defined for " + type);
         }
-        return this._mappers[type] || this._mappers[MapperManager.DefaultMapper];
+        return this._mappers[type];
     }
 
     /**

Viewer/src/viewer/viewer.ts

@@ -232,14 +232,16 @@ export abstract class AbstractViewer {
      * Is the engine currently set to rende even when the page is in background
      */
     public get renderInBackground() {
-        return this.engine.renderEvenInBackground;
+        return this.engine && this.engine.renderEvenInBackground;
     }
 
     /**
      * Set the viewer's background rendering flag.
      */
     public set renderInBackground(value: boolean) {
-        this.engine.renderEvenInBackground = value;
+        if (this.engine) {
+            this.engine.renderEvenInBackground = value;
+        }
     }
 
     /**

Viewer/src/viewer/viewerManager.ts

@@ -98,9 +98,14 @@ export class ViewerManager {
      * dispose the manager and all of its associated viewers
      */
     public dispose() {
+        delete this._onViewerAdded;
+
         for (let id in this._viewers) {
             this._viewers[id].dispose();
         }
+
+        this.onViewerAddedObservable.clear();
+        this.onViewerRemovedObservable.clear();
     }
 }
 

Viewer/tests/unit/src/configuration/loader.ts

@@ -0,0 +1,55 @@
+import { Helper } from "../../../commons/helper";
+import { assert, expect, should } from "../viewerReference";
+import { mapperManager, ViewerConfiguration } from "..";
+import { IMapper } from "../../../../src/configuration/mappers";
+import { ConfigurationLoader } from "../../../../src/configuration/loader";
+
+export let name = "configuration loader";
+
+describe("Configuration loader", () => {
+
+    it("should call callback when configuration is loaded", (done) => {
+        let configurationLoader = new ConfigurationLoader();
+
+        configurationLoader.loadConfiguration({}, (newConfig) => {
+            done();
+        });
+    });
+
+    it("should resolve the promise when configuration is loaded", (done) => {
+        let configurationLoader = new ConfigurationLoader();
+
+        configurationLoader.loadConfiguration({}).then(() => {
+            done();
+        });
+    });
+
+    it("should not change configuration is not needed initConfig", (done) => {
+        let configurationLoader = new ConfigurationLoader();
+
+        let config: ViewerConfiguration = {
+            version: "" + Math.random(),
+            extends: "none"
+        };
+        configurationLoader.loadConfiguration(config, (newConfig) => {
+            assert.deepEqual(config, newConfig);
+            done();
+        });
+    });
+
+    it("should load default configuration is no configuration extension provided", (done) => {
+        let configurationLoader = new ConfigurationLoader();
+
+        let config: ViewerConfiguration = {
+            version: "" + Math.random()
+        };
+        configurationLoader.loadConfiguration(config, (newConfig) => {
+            assert.equal(config.version, newConfig.version);
+            assert.notDeepEqual(config, newConfig);
+            assert.isDefined(newConfig.engine);
+            assert.isDefined(newConfig.scene);
+            assert.isDefined(newConfig.templates);
+            done();
+        });
+    });
+});

Viewer/tests/unit/src/configuration/mappers.ts

@@ -0,0 +1,97 @@
+import { Helper } from "../../../commons/helper";
+import { assert, expect, should } from "../viewerReference";
+import { mapperManager } from "..";
+import { IMapper } from "../../../../src/configuration/mappers";
+
+export let name = "configuration mappers";
+
+describe("Configuration mappers", () => {
+
+    it("should have html, json and dom mappers", (done) => {
+        assert.isDefined(mapperManager);
+        assert.isDefined(mapperManager.getMapper("html"));
+        assert.isDefined(mapperManager.getMapper("json"));
+        assert.isDefined(mapperManager.getMapper("dom"));
+        done();
+    });
+
+    it("should map html elements correctly", (done) => {
+        let htmlMappers = mapperManager.getMapper("html");
+
+        let randomNumber = Math.random();
+        let randomString = "test-" + Math.random();
+        let htmlString = `<test-element model.rotation-offset-angle="${randomNumber}" model.cast-shadow="true" model.id="${randomString}"></test-element>`;
+
+        var d = document.createElement('div');
+        d.innerHTML = htmlString;
+        let htmlElement = d.firstChild;
+
+        let config = htmlMappers.map(htmlElement);
+
+        if (config.model && typeof config.model === 'object') {
+            assert.equal(config.model.rotationOffsetAngle, randomNumber);
+            assert.isTrue(config.model.castShadow);
+            assert.equal(config.model.id, randomString);
+            done();
+        } else {
+            assert.fail();
+        }
+    });
+
+    it("should map dom elements correctly", (done) => {
+        let domMappers = mapperManager.getMapper("dom");
+
+        let randomNumber = Math.random();
+        let randomString = "test-" + Math.random();
+        let htmlString = `<test-element>
+    <model rotation-offset-angle="${randomNumber}" cast-shadow="true" id="${randomString}">
+    </model>
+</test-element>`;
+
+        var d = document.createElement('div');
+        d.innerHTML = htmlString;
+        let htmlElement = d.firstChild;
+
+        let config = domMappers.map(htmlElement);
+
+        if (config.model && typeof config.model === 'object') {
+            assert.equal(config.model.rotationOffsetAngle, randomNumber);
+            assert.isTrue(config.model.castShadow);
+            assert.equal(config.model.id, randomString);
+            done();
+        } else {
+            assert.fail();
+        }
+    });
+
+    it("should register a new mapper and allow to use it", (done) => {
+
+        let randomVersion = "version" + Math.random();
+        let randomName = "test" + Math.random();
+        randomName = randomName.replace(".", "");
+        let newMapper: IMapper = {
+            map: (rawSource) => {
+                return {
+                    version: randomVersion
+                }
+            }
+        }
+
+        console.log("Next error log is expected");
+
+        assert.isUndefined(mapperManager.getMapper(randomName));
+
+        mapperManager.registerMapper(randomName, newMapper);
+
+        let mapperTest = mapperManager.getMapper(randomName);
+        assert.isDefined(mapperTest);
+        assert.equal(mapperTest, newMapper);
+
+        let config = mapperTest.map("");
+
+        assert.equal(config.version, randomVersion);
+        done();
+
+    });
+
+});

Viewer/tests/unit/src/helper.ts

@@ -0,0 +1,84 @@
+import { Helper } from "./../../commons/helper";
+import { assert, expect, should } from "./viewerReference";
+import { mapperManager, ViewerConfiguration } from ".";
+import { camelToKebab, kebabToCamel, isUrl, extendClassWithConfig } from "../../../src/helper";
+
+export let name = "viewer helper tests";
+
+describe("viewer helper", () => {
+
+    it("should convert camelCase to kebab-case and back", (done) => {
+
+        let camelString = "oneTestTwoTestThreeTest";
+
+        let kebab = camelToKebab(camelString);
+
+        assert.equal(kebab, "one-test-two-test-three-test");
+
+        assert.equal(kebabToCamel(kebab), camelString);
+
+        done();
+    });
+
+    it("should find absolute and relative http urls", (done) => {
+
+        let url = "http://test.url/?param=123";
+        let https = "https://https.url.to.check/"
+        let relativeUrl = "/url/to/find";
+        let notUrl = "not a url!";
+        let ftp = "ftp://test.ftp.server";
+
+        assert.isTrue(isUrl(url));
+        assert.isTrue(isUrl(https));
+        assert.isTrue(isUrl(relativeUrl));
+        assert.isFalse(isUrl(notUrl));
+        assert.isFalse(isUrl(ftp));
+
+        done();
+    });
+
+    it("should extend objects correctly", (done) => {
+
+        let finalKey = Math.random();
+
+        let toAugoment: any = {
+            definedKey: Math.random(),
+            color: {
+                r: 0,
+                g: 0
+            },
+            test: function () {
+
+            }
+        }
+
+        let augmentation: any = {
+            definedKey: finalKey,
+            color: {
+                r: finalKey,
+                g: finalKey,
+                b: finalKey
+            },
+            undefinedKey: "shouldNotBeAugmented",
+            test: "should be ignored"
+        }
+
+        assert.notEqual(toAugoment.definedKey, augmentation.definedKey);
+
+        extendClassWithConfig(toAugoment, augmentation);
+
+        //defined keys should be replaced
+        assert.equal(toAugoment.definedKey, finalKey);
+        //undefined keys should not be set
+        assert.isUndefined(toAugoment.undefinedKey);
+        // functions should be ignored
+        assert.isFunction(toAugoment.test);
+        //should iterate to deep objects
+        assert.equal(toAugoment.color.r, finalKey);
+        assert.equal(toAugoment.color.g, finalKey);
+        //b should not be set!
+        assert.isUndefined(toAugoment.color.b);
+
+        done();
+    });
+});

Viewer/tests/unit/src/index.ts

@@ -2,5 +2,9 @@ import { main } from '../../commons/boot';
 if (window && !window['validation']) {
     main();
 }
-export * from './viewer/viewer';
+import './viewer/viewer';
+import './viewer/viewerManager';
+import './configuration/mappers';
+import './configuration/loader';
+import './helper';
 export * from '../../../src'

Viewer/tests/unit/src/viewer/viewerManager.ts

@@ -0,0 +1,86 @@
+import { Helper } from "../../../commons/helper";
+import { assert, expect, should } from "../viewerReference";
+import { DefaultViewer, AbstractViewer, Version, viewerManager } from "../../../../src";
+
+export let name = "viewer manager tests";
+
+describe('Viewer Manager', function () {
+    it("should be defined when the library is loaded", (done) => {
+        assert.isDefined(viewerManager, "viewerManager is not defined");
+        done();
+    });
+
+    it("should add and remove a viewer when viewer constructed and disposed", (done) => {
+        let element = document.createElement("div");
+        let randomString = "" + Math.random();
+        element.id = randomString;
+
+        assert.isUndefined(viewerManager.getViewerByHTMLElement(element));
+        assert.isUndefined(viewerManager.getViewerById(randomString));
+        let viewer = Helper.getNewViewerInstance(element);
+        assert.isDefined(viewerManager.getViewerByHTMLElement(element));
+        assert.isDefined(viewerManager.getViewerById(randomString));
+        viewer.dispose();
+        assert.isUndefined(viewerManager.getViewerByHTMLElement(element));
+        assert.isUndefined(viewerManager.getViewerById(randomString));
+        done();
+    });
+
+    it("should trigger the promsie when viewer was added", (done) => {
+        let element = document.createElement("div");
+        let randomString = "" + Math.random();
+        element.id = randomString;
+
+        let viewer = Helper.getNewViewerInstance(element);
+        viewerManager.getViewerPromiseById(randomString).then(() => {
+            viewer.dispose();
+            done();
+        }, (error) => {
+            assert.fail();
+        });
+    });
+
+    it("should trigger observers when viewer constructed and disposed", (done) => {
+        let element = document.createElement("div");
+        let randomString = "" + Math.random();
+        element.id = randomString;
+
+        let addedFlag = false;
+
+        viewerManager.onViewerAddedObservable.add((addedViewer) => {
+            assert.equal(addedViewer.baseId, randomString);
+            addedFlag = true;
+        });
+
+        viewerManager.onViewerRemovedObservable.add((viewerId) => {
+            assert.equal(randomString, viewerId);
+            if (addedFlag) {
+                viewerManager.dispose();
+                done();
+            } else {
+                assert.fail();
+            }
+        });
+
+        let viewer = Helper.getNewViewerInstance(element);
+        viewer.dispose();
+    });
+
+    it("should dispose viewer(s) when disposed", (done) => {
+        let element = document.createElement("div");
+        let randomString = "" + Math.random();
+        element.id = randomString;
+
+        let viewer = Helper.getNewViewerInstance(element);
+
+        let dispose = viewer.dispose;
+
+        viewer.dispose = () => {
+            dispose.call(viewer);
+            done();
+        }
+
+        viewerManager.dispose();
+
+    });
+});