@microsoft/applicationinsights-common 2.7.2-nightly.2111-05 → 2.7.2-nightly.2111-09

package/Tests/Unit/src/AppInsightsCommon.tests.ts

@@ -0,0 +1,291 @@
+import { Assert, AITestClass } from "@microsoft/ai-test-framework";
+import {
+    ITelemetryItem, AppInsightsCore,
+    IPlugin, IConfiguration, DiagnosticLogger
+} from "@microsoft/applicationinsights-core-js";
+
+import { DataSanitizer } from "../../../src/Telemetry/Common/DataSanitizer";
+
+export class ApplicationInsightsTests extends AITestClass {
+    logger = new DiagnosticLogger();
+
+    public testInitialize() {
+    }
+
+    public testCleanup() {
+    }
+
+    public registerTests() {
+        // test cases for sanitizeMessage function
+        this.testCase({
+            name: 'DataSanitizerTests: messages are well processed.',
+            test: () => {
+                // const define
+                const MAX_MESSAGE_LENGTH = DataSanitizer.MAX_MESSAGE_LENGTH;
+               
+                // use cases
+                const messageShort: String = "hi";
+                const messageLong = new Array(MAX_MESSAGE_LENGTH + 1).join('abc');
+                
+                // Assert
+                Assert.equal(messageShort.length, DataSanitizer.sanitizeMessage(this.logger, messageShort).length);
+                Assert.notEqual(messageLong.length, DataSanitizer.sanitizeMessage(this.logger, messageLong).length);
+                Assert.equal(MAX_MESSAGE_LENGTH, DataSanitizer.sanitizeMessage(this.logger, messageLong).length);
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: throwInternal function is called correctly in sanitizeMessage function',
+            test: () => {
+                // const define
+                const loggerStub = this.sandbox.stub(this.logger , "throwInternal");
+                const MAX_MESSAGE_LENGTH = DataSanitizer.MAX_MESSAGE_LENGTH;
+                
+                // use cases
+                const messageShort: String = "hi";
+                const messageLong = new Array(MAX_MESSAGE_LENGTH + 2).join('a');
+
+                // Act
+                DataSanitizer.sanitizeMessage(this.logger, messageShort);
+                Assert.ok(loggerStub.notCalled);
+                Assert.equal(0, loggerStub.callCount);
+
+                DataSanitizer.sanitizeMessage(this.logger, messageLong);
+                Assert.ok(loggerStub.calledOnce);
+                Assert.equal(1, loggerStub.callCount);
+
+                DataSanitizer.sanitizeMessage(this.logger, messageLong);
+                Assert.ok(loggerStub.calledTwice);
+                Assert.equal(2, loggerStub.callCount);
+
+                loggerStub.restore();
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: messages are fully logged through console',
+            test: () => {
+                const saniMsgSpy = this.sandbox.spy(DataSanitizer, "sanitizeMessage");
+
+                // const define
+                const MAX_MESSAGE_LENGTH = DataSanitizer.MAX_MESSAGE_LENGTH;
+               
+                // use cases
+                const messageShort: String = "hi";
+                const messageLong = new Array(MAX_MESSAGE_LENGTH + 1).join('a');
+
+                const msgShortResult = DataSanitizer.sanitizeMessage(this.logger, messageShort);
+                Assert.ok(saniMsgSpy.returned(msgShortResult));
+
+                const msgLongResult = DataSanitizer.sanitizeMessage(this.logger, messageLong);
+                Assert.ok(saniMsgSpy.returned(msgLongResult));
+
+                saniMsgSpy.restore();
+            }
+        });
+
+        // test cases for sanitizeString function
+        this.testCase({
+            name: 'DataSanitizerTest: strings are well processed',
+            test: () => {
+                // const define
+                const MAX_STRING_LENGTH = DataSanitizer.MAX_STRING_LENGTH;
+               
+                // use cases
+                const strShort: String = "hi";
+                const strLong = new Array(MAX_STRING_LENGTH + 2).join('a');
+                
+                // Assert
+                Assert.equal(strShort.length, DataSanitizer.sanitizeString(this.logger, strShort).length);
+                Assert.notEqual(strLong.length, DataSanitizer.sanitizeString(this.logger, strLong).length);
+                Assert.equal(MAX_STRING_LENGTH, DataSanitizer.sanitizeString(this.logger, strLong).length);
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: throrwInternal function is called correctly in sanitizeString function',
+            test: () => {
+                // const define
+                const loggerStub = this.sandbox.stub(this.logger , "throwInternal");
+                const MAX_STRING_LENGTH = DataSanitizer.MAX_STRING_LENGTH;
+                
+                // use cases
+                const strShort: String = "hi";
+                const strLong = new Array(MAX_STRING_LENGTH + 2).join('a');
+
+                // Act
+                DataSanitizer.sanitizeString(this.logger, strShort);
+                Assert.ok(loggerStub.notCalled);
+                Assert.equal(0, loggerStub.callCount);
+
+                DataSanitizer.sanitizeString(this.logger, strLong);
+                Assert.ok(loggerStub.calledOnce);
+                Assert.equal(1, loggerStub.callCount);
+
+                DataSanitizer.sanitizeString(this.logger, strLong);
+                Assert.ok(loggerStub.calledTwice);
+                Assert.equal(2, loggerStub.callCount);
+
+                loggerStub.restore();
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: strings are fully logged through console',
+            test: () => {
+                const saniStrSpy = this.sandbox.spy(DataSanitizer, "sanitizeString");
+
+                // const define
+                const MAX_STRING_LENGTH = DataSanitizer.MAX_STRING_LENGTH;
+               
+                // use cases
+                const strShort: String = "hi";
+                const strLong = new Array(MAX_STRING_LENGTH + 2).join('a');
+
+                const strShortResult = DataSanitizer.sanitizeString(this.logger, strShort);
+                Assert.ok(saniStrSpy.returned(strShortResult));
+
+                const strLongResult = DataSanitizer.sanitizeString(this.logger, strLong);
+                Assert.ok(saniStrSpy.returned(strLongResult));
+
+                saniStrSpy.restore();
+            }
+        });
+
+        // test cases for sanitizeKey function
+        this.testCase({
+            name: 'DataSanitizerTest: names are well processed',
+            test: () => {
+                // const define
+                const MAX_NAME_LENGTH = DataSanitizer.MAX_NAME_LENGTH;
+               
+                // use cases
+                const nameShort: String = "hi";
+                const nameLong = new Array(MAX_NAME_LENGTH + 2).join('a');
+                
+                // Assert
+                Assert.equal(nameShort.length, DataSanitizer.sanitizeKey(this.logger, nameShort).length);
+                Assert.notEqual(nameLong.length, DataSanitizer.sanitizeKey(this.logger, nameLong).length);
+                Assert.equal(MAX_NAME_LENGTH, DataSanitizer.sanitizeKey(this.logger, nameLong).length);
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: throrwInternal function is called correctly in sanitizeKey function',
+            test: () => {
+                // const define
+                const loggerStub = this.sandbox.stub(this.logger , "throwInternal");
+                const MAX_NAME_LENGTH = DataSanitizer.MAX_NAME_LENGTH;
+                
+                // use cases
+                const nameShort: String = "hi";
+                const nameLong = new Array(MAX_NAME_LENGTH + 2).join('a');
+
+                // Act
+                DataSanitizer.sanitizeKey(this.logger, nameShort);
+                Assert.ok(loggerStub.notCalled);
+                Assert.equal(0, loggerStub.callCount);
+
+                DataSanitizer.sanitizeKey(this.logger, nameLong);
+                Assert.ok(loggerStub.calledOnce);
+                Assert.equal(1, loggerStub.callCount);
+
+                DataSanitizer.sanitizeKey(this.logger, nameLong);
+                Assert.ok(loggerStub.calledTwice);
+                Assert.equal(2, loggerStub.callCount);
+
+                loggerStub.restore();
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: names are fully logged through console',
+            test: () => {
+                const saniStrSpy = this.sandbox.spy(DataSanitizer, "sanitizeKey");
+
+                // const define
+                const MAX_NAME_LENGTH = DataSanitizer.MAX_NAME_LENGTH;
+               
+                // use cases
+                const nameShort: String = "hi";
+                const nameLong = new Array(MAX_NAME_LENGTH + 2).join('a');
+
+                const nameShortResult = DataSanitizer.sanitizeKey(this.logger, nameShort);
+                Assert.ok(saniStrSpy.returned(nameShortResult));
+
+                const nameLongResult = DataSanitizer.sanitizeKey(this.logger, nameLong);
+                Assert.ok(saniStrSpy.returned(nameLongResult));
+
+                saniStrSpy.restore();
+            }
+        });
+
+        // test cases for sanitizeInput function
+        this.testCase({
+            name: 'DataSanitizerTest: inputs are well processed',
+            test: () => {
+                const MAX_INPUT_LENGTH = 1024;
+
+                // use cases
+                const inputShort: String = "hi";
+                const inputLong = new Array(MAX_INPUT_LENGTH + 2).join('a');
+                
+                // Assert
+                Assert.equal(inputShort.length, DataSanitizer.sanitizeInput(this.logger, inputShort, MAX_INPUT_LENGTH, 0).length);
+                Assert.notEqual(inputLong.length, DataSanitizer.sanitizeInput(this.logger, inputLong, MAX_INPUT_LENGTH, 0).length);
+                Assert.equal(MAX_INPUT_LENGTH, DataSanitizer.sanitizeInput(this.logger, inputLong, MAX_INPUT_LENGTH, 0).length);
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: throrwInternal function is called correctly in sanitizeInput function',
+            test: () => {
+                // const define
+                const loggerStub = this.sandbox.stub(this.logger , "throwInternal");
+                const MAX_INPUT_LENGTH = 1024;
+                
+                // use cases
+                const inputShort: String = "hi";
+                const inputLong = new Array(MAX_INPUT_LENGTH + 2).join('a');
+
+                // Act
+                DataSanitizer.sanitizeInput(this.logger, inputShort, MAX_INPUT_LENGTH, 0);
+                Assert.ok(loggerStub.notCalled);
+                Assert.equal(0, loggerStub.callCount);
+
+                DataSanitizer.sanitizeInput(this.logger, inputLong, MAX_INPUT_LENGTH, 0);
+                Assert.ok(loggerStub.calledOnce);
+                Assert.equal(1, loggerStub.callCount);
+
+                DataSanitizer.sanitizeInput(this.logger, inputLong, MAX_INPUT_LENGTH, 0);
+                Assert.ok(loggerStub.calledTwice);
+                Assert.equal(2, loggerStub.callCount);
+
+                loggerStub.restore();
+            }
+        });
+
+        this.testCase({
+            name: 'DataSanitizerTests: inputs are fully logged through console',
+            test: () => {
+                const saniStrSpy = this.sandbox.spy(DataSanitizer, "sanitizeInput");
+
+                // const define
+                const MAX_INPUT_LENGTH = 1024;
+               
+                // use cases
+                const inputShort: String = "hi";
+                const inputLong = new Array(MAX_INPUT_LENGTH + 2).join('a');
+
+                const inputShortResult = DataSanitizer.sanitizeInput(this.logger, inputShort, MAX_INPUT_LENGTH, 0);
+                Assert.ok(saniStrSpy.returned(inputShortResult));
+
+                const inputLongResult = DataSanitizer.sanitizeInput(this.logger, inputLong, MAX_INPUT_LENGTH, 0);
+                Assert.ok(saniStrSpy.returned(inputLongResult));
+
+                saniStrSpy.restore();
+            }
+        });
+    }
+
+}

package/Tests/Unit/src/ConnectionStringParser.tests.ts

@@ -0,0 +1,126 @@
+import { Assert, AITestClass } from "@microsoft/ai-test-framework";
+import { ConnectionStringParser } from "../../../src/ConnectionStringParser";
+import * as Constants from "../../../src/Constants";
+
+const runTest = (options: {
+    connectionString: string,
+    expectedAuthorization?: string,
+    expectedInstrumentationKey?: string,
+    expectedBreezeEndpoint: string,
+}) => {
+    const result = ConnectionStringParser.parse(options.connectionString);
+
+    if (options.expectedAuthorization) {
+        Assert.deepEqual(result.authorization, options.expectedAuthorization);
+    }
+    if (options.expectedInstrumentationKey) {
+        Assert.deepEqual(result.instrumentationkey, options.expectedInstrumentationKey);
+    }
+    Assert.deepEqual(result.ingestionendpoint, options.expectedBreezeEndpoint);
+}
+
+export class ConnectionStringParserTests extends AITestClass {
+
+    public testInitialize() {
+    }
+
+    public testCleanup() {}
+
+    public registerTests() {
+        this.testCase({
+            name: "should parse all valid fields",
+            test: () => {
+                const authorization = "ikey"
+                const instrumentationKey = "instr_key";
+                const ingestionEndpoint = "ingest";
+                const liveEndpoint = "live";
+                const connectionString = `Authorization=${authorization};InstrumentationKey=${instrumentationKey};IngestionEndpoint=${ingestionEndpoint};LiveEndpoint=${liveEndpoint}`;
+
+                const result = ConnectionStringParser.parse(connectionString);
+
+                Assert.deepEqual(result.authorization, authorization);
+                Assert.deepEqual(result.instrumentationkey, instrumentationKey);
+                Assert.deepEqual(result.ingestionendpoint, ingestionEndpoint);
+            }
+        });
+
+        this.testCase({
+            name: "should ignore invalid fields",
+            test: () => {
+                const authorization = "ikey"
+                const instrumentationKey = "ikey";
+                const ingestionEndpoint = "ingest";
+                const liveEndpoint = "live";
+                const connectionString = `Autho.rization=${authorization};Instrume.ntationKey=${instrumentationKey};Ingestion.Endpoint=${ingestionEndpoint};LiveEnd.point=${liveEndpoint}`;
+
+                const result = ConnectionStringParser.parse(connectionString);
+
+                Assert.deepEqual(result.authorization, undefined);
+                Assert.deepEqual(result.instrumentationkey, undefined);
+                Assert.deepEqual(result.ingestionendpoint, Constants.DEFAULT_BREEZE_ENDPOINT);
+            }
+        });
+
+        this.testCase({
+            name: "should use correct default endpoints",
+            test: () => {
+                runTest({
+                    connectionString: "InstrumentationKey=00000000-0000-0000-0000-000000000000",
+                    expectedAuthorization: undefined,
+                    expectedInstrumentationKey: "00000000-0000-0000-0000-000000000000",
+                    expectedBreezeEndpoint: Constants.DEFAULT_BREEZE_ENDPOINT,
+                });
+            }
+        });
+
+        this.testCase({
+            name: "should use correct endpoints when using EndpointSuffix",
+            test: () => {
+                runTest({
+                    connectionString: "InstrumentationKey=00000000-0000-0000-0000-000000000000;EndpointSuffix=ai.contoso.com",
+                    expectedBreezeEndpoint: "https://dc.ai.contoso.com",
+                });
+            }
+        });
+
+        this.testCase({
+            name: "should use correct endpoints when using EndpointSuffix with explicit override",
+            test: () => {
+                runTest({
+                    connectionString: "InstrumentationKey=00000000-0000-0000-0000-000000000000;EndpointSuffix=ai.contoso.com;LiveEndpoint=https://custom.live.contoso.com:444",
+                    expectedBreezeEndpoint: "https://dc.ai.contoso.com",
+                });
+            }
+        });
+
+        this.testCase({
+            name: "should parse EndpointSuffix + Location",
+            test: () => {
+                runTest({
+                    connectionString: "InstrumentationKey=00000000-0000-0000-0000-000000000000;EndpointSuffix=ai.contoso.com;Location=westus2",
+                    expectedBreezeEndpoint: "https://westus2.dc.ai.contoso.com",
+                });
+            }
+        });
+
+        this.testCase({
+            name: "should parse EndpointSuffix + Location + Endpoint Override",
+            test: () => {
+                runTest({
+                    connectionString: "InstrumentationKey=00000000-0000-0000-0000-000000000000;EndpointSuffix=ai.contoso.com;Location=westus2;LiveEndpoint=https://custom.contoso.com:444",
+                    expectedBreezeEndpoint: "https://westus2.dc.ai.contoso.com",
+                });
+            }
+        });
+
+        this.testCase({
+            name: "should parse Endpoint Override",
+            test: () => {
+                runTest({
+                    connectionString: "InstrumentationKey=00000000-0000-0000-0000-000000000000;LiveEndpoint=http://custom.live.endpoint.com:444",
+                    expectedBreezeEndpoint: Constants.DEFAULT_BREEZE_ENDPOINT,
+                });
+            }
+        });
+    }
+}

package/Tests/Unit/src/Exception.tests.ts

@@ -0,0 +1,88 @@
+import { Assert, AITestClass } from "@microsoft/ai-test-framework";
+import { Exception } from "../../../src/applicationinsights-common"
+import { DiagnosticLogger } from "@microsoft/applicationinsights-core-js";
+import { IExceptionInternal, IExceptionDetailsInternal, IExceptionStackFrameInternal } from "../../../src/Interfaces/IExceptionTelemetry";
+import { _ExceptionDetails, _StackFrame } from "../../../src/Telemetry/Exception";
+
+export class ExceptionTests extends AITestClass {
+    logger = new DiagnosticLogger();
+
+    public testInitialize() {
+    }
+
+    public testCleanup() {}
+
+    public registerTests() {
+        this.testCase({
+            name: "Exception: Exception can be exported to interface format",
+            test: () => {
+                const exception = new Exception(this.logger, new Error("test error"));
+                Assert.ok(exception, "Exception is created");
+
+                const exceptionInterface: IExceptionInternal = exception.toInterface();
+                Assert.deepEqual(exception.id, exceptionInterface.id);
+                Assert.deepEqual(exception.problemGroup, exceptionInterface.problemGroup);
+                Assert.deepEqual("4.0", exceptionInterface.ver, "Default format expects CS4.0");
+                Assert.deepEqual(2, exception.ver, "Breeze format expects CS2.0");
+                Assert.deepEqual(exception.isManual, exceptionInterface.isManual);
+                Assert.deepEqual(exception.exceptions.map((exception: any) => exception.toInterface()), exceptionInterface.exceptions);
+                Assert.deepEqual(exception.severityLevel, exceptionInterface.severityLevel);
+                Assert.deepEqual(exception.properties, exceptionInterface.properties);
+                Assert.deepEqual(exception.measurements, exceptionInterface.measurements);
+
+                const exceptionConverted = Exception.CreateFromInterface(this.logger, exceptionInterface);
+                Assert.deepEqual(exception, exceptionConverted);
+            }
+        });
+
+        this.testCase({
+            name: "ExceptionDetails: ExceptionDetails can be exported to interface format",
+            test: () => {
+                try {
+                    const exceptionDetails = new _ExceptionDetails(this.logger, new Error("test error"));
+                    Assert.ok(exceptionDetails, "ExceptionDetails instance is created");
+    
+                    const exceptionDetailsInterface: IExceptionDetailsInternal = exceptionDetails.toInterface();
+                    Assert.deepEqual(exceptionDetails.id, exceptionDetailsInterface.id);
+                    Assert.deepEqual(exceptionDetails.outerId, exceptionDetailsInterface.outerId);
+                    Assert.deepEqual(exceptionDetails.typeName, exceptionDetailsInterface.typeName);
+                    Assert.deepEqual(exceptionDetails.message, exceptionDetailsInterface.message);
+                    Assert.deepEqual(exceptionDetails.hasFullStack, exceptionDetailsInterface.hasFullStack);
+                    Assert.deepEqual(exceptionDetails.stack, exceptionDetailsInterface.stack);
+                    Assert.deepEqual(exceptionDetails.parsedStack && exceptionDetails.parsedStack.map((frame: _StackFrame) => frame.toInterface()), exceptionDetailsInterface.parsedStack);
+    
+                    const exceptionDetailsConverted = _ExceptionDetails.CreateFromInterface(this.logger, exceptionDetailsInterface);
+                    Assert.deepEqual(exceptionDetails, exceptionDetailsConverted);
+                } catch (e) {
+                    console.log(e.stack);
+                    console.log(e.toString());
+                    Assert.ok(false, e.toString());
+                }
+            }
+        });
+
+        this.testCase({
+            name: "StackFrame: StackFrame can be exported to interface format",
+            test: () => {
+                const error = new Error("hello");
+                const stack = error.stack;
+                if (!stack) {
+                    Assert.ok(true);
+                    return;
+                }
+                const stackFrame = new _StackFrame(stack.split("\n")[0], 0);
+                Assert.ok(stackFrame, "StackFrame instance is created");
+
+                const stackFrameInterface: IExceptionStackFrameInternal = stackFrame.toInterface();
+                Assert.deepEqual(stackFrame.level, stackFrameInterface.level);
+                Assert.deepEqual(stackFrame.method, stackFrameInterface.method);
+                Assert.deepEqual(stackFrame.assembly, stackFrameInterface.assembly);
+                Assert.deepEqual(stackFrame.fileName, stackFrameInterface.fileName);
+                Assert.deepEqual(stackFrame.line, stackFrameInterface.line);
+
+                // var stackFrameConverted = _StackFrame.CreateFromInterface(stackFrameInterface);
+                // Assert.deepEqual(stackFrame, stackFrameConverted);
+            }
+        });
+    }
+}