@microsoft/applicationinsights-core-js 2.7.2-nightly.2111-08 → 2.7.2-nightly.2111-09

package/Tests/Unit/src/CookieManager.Tests.ts

@@ -0,0 +1,477 @@
+import { Assert, AITestClass } from "@microsoft/ai-test-framework";
+import { AppInsightsCore, CoreUtils, createCookieMgr, IAppInsightsCore, IConfiguration, ICookieMgrConfig, IPlugin, ITelemetryItem, newId, _legacyCookieMgr } from "../../../src/applicationinsights-core-js"
+import { _InternalMessageId, LoggingSeverity } from "../../../src/JavaScriptSDK.Enums/LoggingEnums";
+import { _InternalLogMessage, DiagnosticLogger } from "../../../src/JavaScriptSDK/DiagnosticLogger";
+
+export class CookieManagerTests extends AITestClass {
+    private _cookieMgrCfg: ICookieMgrConfig = {};
+    private _config: IConfiguration = {
+        cookieCfg: this._cookieMgrCfg
+    };
+    private _testCookies = {};
+
+    constructor(emulateEs3: boolean) {
+        super("CookieManagerTests", emulateEs3);
+    }
+
+    public testInitialize() {
+        let _self = this;
+        super.testInitialize();
+        _self._cookieMgrCfg = {
+            getCookie: (name) => {
+                let theValue = _self._testCookies[name] || "";
+                return theValue.split(";")[0];
+            },
+            setCookie: (name, value) => {
+                _self._testCookies[name] = value;
+            },
+            delCookie: (name) => {
+                delete _self._testCookies[name]
+            }
+        }
+        _self._config.cookieCfg = _self._cookieMgrCfg;
+    }
+
+    public testCleanup() {
+        super.testCleanup();
+    }
+
+    public registerTests() {
+
+        this.testCase({
+            name: "CookieManager: Initialization",
+            test: () => {
+                let manager = createCookieMgr();
+
+                Assert.equal("", manager.get("Test"), "Getting a non existent cookie returns empty string");
+
+                manager = createCookieMgr(null);
+                Assert.equal("", manager.get("Test"), "Getting a non existent cookie returns empty string");
+
+                manager = createCookieMgr(undefined);
+                Assert.equal("", manager.get("Test"), "Getting a non existent cookie returns empty string");
+
+                manager = createCookieMgr({});
+                Assert.equal("", manager.get("Test"), "Getting a non existent cookie returns empty string");
+
+                manager = createCookieMgr({
+                    cookieCfg: null
+                });
+                Assert.equal("", manager.get("Test"), "Getting a non existent cookie returns empty string");
+
+                manager = createCookieMgr({
+                    cookieCfg: undefined
+                });
+                Assert.equal("", manager.get("Test"), "Getting a non existent cookie returns empty string");
+
+                manager = createCookieMgr({
+                    cookieCfg: {}
+                });
+                Assert.equal("", manager.get("Test"), "Getting a non existent cookie returns empty string");
+            }
+        });
+
+        this.testCase({
+            name: "CookieManager: Session get set delete",
+            test: () => {
+                let manager = createCookieMgr(this._config);
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+
+                manager.set(newKey, newValue + "; path=/my-path");
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/my-path", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: Session get set delete with configured path",
+            test: () => {
+                this._cookieMgrCfg.path = "/sub-path";
+                let manager = createCookieMgr(this._config);
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/sub-path", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+
+                manager.set(newKey, newValue + "; path=/my-path");
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/my-path", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: Session get set delete with configured domain",
+            test: () => {
+                this._cookieMgrCfg.domain = "MyDomain.com";
+                let manager = createCookieMgr(this._config);
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; domain=MyDomain.com; path=/", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: Encoded expiry value for get set delete",
+            test: () => {
+                let manager = createCookieMgr(this._config);
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue + "; path=/subfield; expires=Thu, 12 Feb 2190 00:00:00 GMT");
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/subfield; expires=Thu, 12 Feb 2190 00:00:00 GMT", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: Encoded max-age for get set delete",
+            test: () => {
+                let manager = createCookieMgr(this._config);
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue + "; path=/subfield; max-age=42");
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/subfield; max-age=42", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: Test with setting max-age",
+            useFakeTimers: true,
+            test: () => {
+                let manager = createCookieMgr(this._config);
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                let maxAge = 42 * 24 * 60 * 60;
+                manager.set(newKey, newValue, maxAge);
+                Assert.equal(newValue, manager.get(newKey));
+                if (this.isEmulatingEs3) {
+                    Assert.equal(newValue + "; expires=Thu, 12 Feb 1970 00:00:00 GMT; path=/", this._testCookies[newKey]);
+                } else {
+                    Assert.equal(newValue + "; expires=Thu, 12 Feb 1970 00:00:00 GMT; max-age=" + maxAge + "; path=/", this._testCookies[newKey]);
+                }
+
+                // With existing max-age
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+
+                manager.set(newKey, newValue + "; expires=Thu, 12 Feb 2170 00:00:00 GMT", maxAge);
+                Assert.equal(newValue, manager.get(newKey));
+                if (this.isEmulatingEs3) {
+                    Assert.equal(newValue + "; expires=Thu, 12 Feb 2170 00:00:00 GMT; path=/", this._testCookies[newKey]);
+                } else {
+                    Assert.equal(newValue + "; expires=Thu, 12 Feb 2170 00:00:00 GMT; max-age=" + maxAge + "; path=/", this._testCookies[newKey]);
+                }
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });
+
+        this.testCase({
+            name: "CookieManager: Set as Disabled",
+            test: () => {
+                let manager = createCookieMgr({
+                    cookieCfg: {
+                        enabled: false,
+                        getCookie: () => { throw "Should not be called" },
+                        setCookie: () => { throw "Should not be called" },
+                        delCookie: () => { throw "Should not be called" }
+                    }
+                });
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal("", manager.get(newKey));
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+            }
+        });
+
+        this.testCase({
+            name: "CookieManager: disable cookies using the legacy setting",
+            test: () => {
+
+                let core = new AppInsightsCore();
+                core.initialize({
+                    instrumentationKey: "testiKey",
+                    isCookieUseDisabled: true,
+                    cookieCfg: {
+                        getCookie: () => { throw "Should not be called" },
+                        setCookie: () => { throw "Should not be called" },
+                        delCookie: () => { throw "Should not be called" }
+                    }
+                } as any, [new ChannelPlugin()]);
+
+                let manager = core.getCookieMgr();
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal("", manager.get(newKey));
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: disable cookies using legacy and new setting both enabled",
+            test: () => {
+
+                let core = new AppInsightsCore();
+                core.initialize({
+                    instrumentationKey: "testiKey",
+                    isCookieUseDisabled: true,
+                    disableCookiesUsage: true,
+                    cookieCfg: {
+                        getCookie: () => { throw "Should not be called" },
+                        setCookie: () => { throw "Should not be called" },
+                        delCookie: () => { throw "Should not be called" }
+                    }
+                } as any, [new ChannelPlugin()]);
+
+                let manager = core.getCookieMgr();
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal("", manager.get(newKey));
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: disable cookies using legacy disabled and new setting enabled",
+            test: () => {
+
+                let core = new AppInsightsCore();
+                core.initialize({
+                    instrumentationKey: "testiKey",
+                    isCookieUseDisabled: false,
+                    disableCookiesUsage: true,
+                    cookieCfg: {
+                        getCookie: () => { throw "Should not be called" },
+                        setCookie: () => { throw "Should not be called" },
+                        delCookie: () => { throw "Should not be called" }
+                    }
+                } as any, [new ChannelPlugin()]);
+
+                let manager = core.getCookieMgr();
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal("", manager.get(newKey));
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: disable cookies using disableCookiesUsage",
+            test: () => {
+
+                let core = new AppInsightsCore();
+                core.initialize({
+                    instrumentationKey: "testiKey",
+                    disableCookiesUsage: true,
+                    cookieCfg: {
+                        getCookie: () => { throw "Should not be called" },
+                        setCookie: () => { throw "Should not be called" },
+                        delCookie: () => { throw "Should not be called" }
+                    }
+                }, [new ChannelPlugin()]);
+
+                let manager = core.getCookieMgr();
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal("", manager.get(newKey));
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+            }
+        });
+
+        this.testCase({
+            name: "CookieManager: set cookie path at the root config setting",
+            test: () => {
+
+                let core = new AppInsightsCore();
+                core.initialize({
+                    instrumentationKey: "testiKey",
+                    cookiePath: "/sub-path",
+                    cookieCfg: this._cookieMgrCfg
+                }, [new ChannelPlugin()]);
+
+                let manager = core.getCookieMgr();
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/sub-path", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+
+                manager.set(newKey, newValue + "; path=/my-path");
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; path=/my-path", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });        
+
+        this.testCase({
+            name: "CookieManager: set cookie domain at the root config setting",
+            test: () => {
+
+                let core = new AppInsightsCore();
+                core.initialize({
+                    instrumentationKey: "testiKey",
+                    cookieDomain: "MyDomain.com",
+                    cookieCfg: this._cookieMgrCfg
+                }, [new ChannelPlugin()]);
+
+                let manager = core.getCookieMgr();
+
+                let newKey = "test." + newId();
+                let newValue = newId();
+                manager.set(newKey, newValue);
+                Assert.equal(newValue, manager.get(newKey));
+                Assert.equal(newValue + "; domain=MyDomain.com; path=/", this._testCookies[newKey]);
+
+                manager.del(newKey);
+                Assert.equal("", manager.get(newKey));
+                Assert.equal(undefined, this._testCookies[newKey]);
+            }
+        });        
+
+
+        this.testCase({
+            name: "CookieManager: validate setting _canUseCookies correctly enables or blocks cookie usage",
+            test: () => {
+                CoreUtils._canUseCookies = undefined;
+                // initialize the global cookie manager
+                let globalMgr = _legacyCookieMgr();
+                Assert.equal(true, globalMgr.isEnabled());
+                Assert.equal(true, globalMgr.isEnabled());
+                CoreUtils._canUseCookies = false;
+                Assert.equal(false, globalMgr.isEnabled());
+                CoreUtils._canUseCookies = true;
+                Assert.equal(true, globalMgr.isEnabled());
+
+                let core = new AppInsightsCore();
+                let manager = core.getCookieMgr();
+                manager.setEnabled(true);
+                Assert.equal(true, manager.isEnabled());
+                CoreUtils._canUseCookies = false;
+                Assert.equal(false, manager.isEnabled());
+
+                manager.setEnabled(false);
+                CoreUtils._canUseCookies = true;
+                Assert.equal(true, globalMgr.isEnabled());
+                Assert.equal(false, manager.isEnabled());
+
+                manager.setEnabled(true);
+                Assert.equal(true, globalMgr.isEnabled());
+                Assert.equal(true, manager.isEnabled());
+            }
+        });        
+    }
+}
+
+class ChannelPlugin implements IPlugin {
+    public isFlushInvoked = false;
+    public isTearDownInvoked = false;
+    public isResumeInvoked = false;
+    public isPauseInvoked = false;
+  
+    public identifier = "Sender";
+  
+    public priority: number = 1001;
+  
+    constructor() {
+      this.processTelemetry = this._processTelemetry.bind(this);
+    }
+    public pause(): void {
+      this.isPauseInvoked = true;
+    }
+  
+    public resume(): void {
+      this.isResumeInvoked = true;
+    }
+  
+    public teardown(): void {
+      this.isTearDownInvoked = true;
+    }
+  
+    flush(async?: boolean, callBack?: () => void): void {
+      this.isFlushInvoked = true;
+      if (callBack) {
+        callBack();
+      }
+    }
+  
+    public processTelemetry(env: ITelemetryItem) { }
+  
+    setNextPlugin(next: any) {
+      // no next setup
+    }
+  
+    public initialize = (config: IConfiguration, core: IAppInsightsCore, plugin: IPlugin[]) => {
+    }
+  
+    private _processTelemetry(env: ITelemetryItem) {
+  
+    }
+  }

package/Tests/Unit/src/HelperFunc.Tests.ts

@@ -0,0 +1,59 @@
+import { Assert, AITestClass } from "@microsoft/ai-test-framework";
+import { _InternalMessageId, LoggingSeverity } from "../../../src/JavaScriptSDK.Enums/LoggingEnums";
+import { _InternalLogMessage, DiagnosticLogger } from "../../../src/JavaScriptSDK/DiagnosticLogger";
+import { isObject, objForEachKey, objForEachKey as objKeys, optimizeObject, setValue, strEndsWith, strStartsWith } from "../../../src/JavaScriptSDK/HelperFuncs";
+
+export class HelperFuncTests extends AITestClass {
+
+    public testInitialize() {
+        super.testInitialize();
+    }
+
+    public testCleanup() {
+        super.testCleanup();
+    }
+
+    public registerTests() {
+
+        this.testCase({
+            name: "strEndsWith",
+            test: () => {
+                Assert.ok(!strEndsWith(null, null));
+                Assert.ok(!strEndsWith("", null));
+                Assert.ok(!strEndsWith(null, ""));
+                Assert.ok(!strEndsWith("", ""));
+                Assert.ok(!strEndsWith("", "a"));
+                Assert.ok(!strEndsWith("a", "b"));
+                Assert.ok(!strEndsWith("a", ""));
+                Assert.ok(!strEndsWith("a", "ab"));
+                Assert.ok(strEndsWith("a", "a"));
+                Assert.ok(strEndsWith("ba", "a"));
+                Assert.ok(strEndsWith("zyxyvutsrqponmlkjihgfedcba", "cba"));
+                Assert.ok(!strEndsWith("a", "ba"));
+                Assert.ok(!strEndsWith("abba", "cba"));
+                Assert.ok(!strEndsWith("abba", "bb"));
+            }
+        });
+
+        this.testCase({
+            name: "strStartsWith",
+            test: () => {
+                Assert.ok(!strStartsWith(null, null));
+                Assert.ok(!strStartsWith("", null));
+                Assert.ok(!strStartsWith(null, ""));
+                Assert.ok(!strStartsWith("", ""));
+                Assert.ok(!strStartsWith("", "a"));
+                Assert.ok(!strStartsWith("a", ""));
+                Assert.ok(!strStartsWith("a", "b"));
+                Assert.ok(!strStartsWith("a", "ba"));
+                Assert.ok(strStartsWith("ab", "a"));
+                Assert.ok(!strStartsWith("zyxyvutsrqponmlkjihgfedcba", "a"));
+                Assert.ok(strStartsWith("zyxwvutsrqponmlkjihgfedcba", "zyxw"));
+                Assert.ok(!strStartsWith("a", "ab"));
+                Assert.ok(!strStartsWith("abba", "abc"));
+                Assert.ok(!strStartsWith("abba", "bb"));
+            }
+        });
+
+    }
+}

package/Tests/Unit/src/aiunittests.ts

@@ -0,0 +1,13 @@
+import '@microsoft/applicationinsights-shims';
+import { ApplicationInsightsCoreTests } from "./ApplicationInsightsCore.Tests";
+import { CookieManagerTests } from "./CookieManager.Tests";
+import { HelperFuncTests } from './HelperFunc.Tests';
+import { AppInsightsCoreSizeCheck } from "./AppInsightsCoreSize.Tests";
+
+export function runTests() {
+    new ApplicationInsightsCoreTests().registerTests();
+    new CookieManagerTests(false).registerTests();
+    new CookieManagerTests(true).registerTests();
+    new HelperFuncTests().registerTests();
+    new AppInsightsCoreSizeCheck().registerTests();
+}

package/Tests/UnitTests.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="Cache-control" content="no-Cache" />
+    <title>Tests for Application Insights JavaScript Core SDK</title>
+    <link rel="stylesheet" href="https://code.jquery.com/qunit/qunit-1.23.1.css">
+    <script src="http://sinonjs.org/releases/sinon-2.3.8.js"></script>
+    <!-- <script src="http://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.js"></script> -->
+    <script src="../../../common/Tests/External/require-2.2.0.js"></script>    
+    <script src="../../../common/Tests/Selenium/ModuleLoader.js"></script>
+    <script src="../../../common/Tests/Selenium/SimpleSyncPromise.js"></script>
+
+    <script>
+        var modules = new ModuleLoader({
+            baseUrl: '../',
+            paths: {
+                qunit: "../../common/Tests/External/qunit-1.23.1",
+                "whatwg-fetch": "../../common/Tests/External/whatwg-fetch.3.0.0"
+            }
+        });
+
+        // Load qunit here instead of with tests, otherwise will not work
+        modules.add("qunit");
+        modules.add("pako","./node_modules/pako/dist/pako");
+
+        loadFetchModule(modules, "whatwg-fetch");
+        loadCommonModules(modules);
+
+        var testModule = modules.add("Tests/Unit/src/aiunittests", "./Unit/dist/aicoreunit.tests.js")
+        testModule.run = function (tests) {
+            console && console.log("Starting tests");
+            QUnit.start();
+            tests.runTests();
+        };
+
+        modules.run();
+    </script>
+</head>
+
+<body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture"></div>
+    <div id="error-message"></div>
+</body>
+
+</html>

package/Tests/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "inlineSources": true,
+    "noImplicitAny": false,
+    "module": "amd",
+    "moduleResolution": "node",
+    "target": "es6",
+    "importHelpers": true,
+    "noEmitHelpers": true,
+    "skipLibCheck": true,
+    "alwaysStrict": true,
+    "declaration": true
+  },
+  "files": []
+}
+