node-avo-inspector 1.2.0 → 2.0.0-beta.1

package/src/__tests__/TestAvoInspector.ts

@@ -1,376 +0,0 @@
-import { AvoInspector } from "../AvoInspector";
-import { AvoInspectorEnv } from "../AvoInspectorEnv";
-
-import { error, defaultOptions } from "./constants";
-import { AvoNetworkCallsHandler } from "../AvoNetworkCallsHandler";
-
-jest.mock("../AvoNetworkCallsHandler");
-
-describe("Initialization", () => {
-
-  test("Network Handler is initialized on Inspector init", () => {
-    const inspectorVersion = process.env.npm_package_version || "";
-    const { apiKey, env, version, appName } = defaultOptions;
-
-    let inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(true);
-
-    expect(AvoNetworkCallsHandler).toHaveBeenCalledTimes(1);
-    expect(AvoNetworkCallsHandler).toHaveBeenCalledWith(apiKey,
-      env,
-      "my-test-app",
-      version,
-      inspectorVersion,
-      undefined);
-  });
-
-  test("Api Key is set", () => {
-    // Given
-    const apiKey = "api-key-xxx";
-
-    // When
-    let inspector = new AvoInspector({
-      env: AvoInspectorEnv.Prod,
-      version: "0",
-      apiKey,
-    });
-
-    // Then
-    expect(inspector.apiKey).toBe(apiKey);
-  });
-
-  test("Error is thrown when Api Key is not set", () => {
-    // Given
-    // @ts-ignore
-    let apiKey;
-
-    // Then
-    expect(() => {
-      new AvoInspector({
-        env: AvoInspectorEnv.Prod,
-        version: "0",
-        // @ts-ignore
-        apiKey,
-      });
-    }).toThrow(error.API_KEY);
-  });
-
-  test("Error is thrown when whitespace Api Key is used", () => {
-    // Given
-    const apiKey = " ";
-
-    // Then
-    expect(() => {
-      new AvoInspector({
-        env: AvoInspectorEnv.Prod,
-        version: "0",
-        apiKey,
-      });
-    }).toThrow(error.API_KEY);
-  });
-
-  test("Error is thrown when empty string Api Key is used", () => {
-    expect(() => {
-      new AvoInspector({
-        env: AvoInspectorEnv.Prod,
-        version: "0",
-        apiKey: "",
-      });
-    }).toThrow(error.API_KEY);
-  });
-
-  test("Error is thrown when Api Key is set to null", () => {
-    // Given
-    const apiKey = null;
-
-    // Then
-    expect(() => {
-      new AvoInspector({
-        env: AvoInspectorEnv.Prod,
-        version: "0",
-        // @ts-ignore
-        apiKey,
-      });
-    }).toThrow(error.API_KEY);
-  });
-
-  test("Dev environment is used when env is not provided", () => {
-    // Given
-    // @ts-ignore
-    let env;
-
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      version: "0",
-      // @ts-ignore
-      env,
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Dev);
-  });
-
-  test("Dev environment is used when empty string is used", () => {
-    // Given
-    const env = "";
-
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      version: "0",
-      // @ts-ignore
-      env,
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Dev);
-  });
-
-  test("Dev env is set using AvoInspectorEnv", () => {
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Dev,
-      version: "0",
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Dev);
-  });
-
-  test("Dev environment is set using string", () => {
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: "dev",
-      version: "0",
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Dev);
-  });
-
-  test("Staging env is set using AvoInspectorEnv", () => {
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Staging,
-      version: "0",
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Staging);
-  });
-
-  test("Staging environment is set using string", () => {
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: "staging",
-      version: "0",
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Staging);
-  });
-
-  test("Prod env is set using AvoInspectorEnv", () => {
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Prod,
-      version: "0",
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Prod);
-  });
-
-  test("Prod environment is set using string", () => {
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: "prod",
-      version: "0",
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Prod);
-  });
-
-  test("Environment other than Dev, Staging, Prod falls back to Dev", () => {
-    // When
-    const env = "test";
-
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      version: "0",
-      // @ts-ignore
-      env,
-    });
-
-    // Then
-    expect(inspector.environment).toBe(AvoInspectorEnv.Dev);
-  });
-
-  test("Version is set", () => {
-    const version = "1";
-
-    // When
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Prod,
-      version,
-    });
-
-    // Then
-    expect(inspector.version).toBe(version);
-  });
-
-  test("Error is thrown when version is not set", () => {
-    // Given
-    // @ts-ignore
-    let version;
-
-    // Then
-    expect(() => {
-      new AvoInspector({
-        apiKey: "api-key-xxx",
-        env: AvoInspectorEnv.Prod,
-        // @ts-ignore
-        version,
-      });
-    }).toThrow(error.VERSION);
-  });
-
-  test("Error is thrown when version is set to empty string", () => {
-    // Given
-    const version = " ";
-
-    // Then
-    expect(() => {
-      new AvoInspector({
-        apiKey: "api-key-xxx",
-        env: AvoInspectorEnv.Prod,
-        version,
-      });
-    }).toThrow(error.VERSION);
-  });
-
-  test("Error is thrown when version is set to null", () => {
-    // Given
-    const version = null;
-
-    // Then
-    expect(() => {
-      new AvoInspector({
-        apiKey: "api-key-xxx",
-        env: AvoInspectorEnv.Prod,
-        // @ts-ignore
-        version,
-      });
-    }).toThrow(error.VERSION);
-  });
-
-  test("publicEncryptionKey is forwarded to AvoNetworkCallsHandler when provided", () => {
-    const inspectorVersion = process.env.npm_package_version || "";
-
-    (AvoNetworkCallsHandler as unknown as jest.Mock).mockClear();
-
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Dev,
-      version: "1",
-      publicEncryptionKey: "my-public-key-123",
-    });
-
-    expect(AvoNetworkCallsHandler).toHaveBeenCalledWith(
-      "api-key-xxx",
-      AvoInspectorEnv.Dev,
-      "",
-      "1",
-      inspectorVersion,
-      "my-public-key-123"
-    );
-  });
-
-  test("publicEncryptionKey is forwarded as undefined to AvoNetworkCallsHandler when not provided", () => {
-    const inspectorVersion = process.env.npm_package_version || "";
-
-    (AvoNetworkCallsHandler as unknown as jest.Mock).mockClear();
-
-    let inspector = new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Dev,
-      version: "1",
-    });
-
-    expect(AvoNetworkCallsHandler).toHaveBeenCalledWith(
-      "api-key-xxx",
-      AvoInspectorEnv.Dev,
-      "",
-      "1",
-      inspectorVersion,
-      undefined
-    );
-  });
-
-  test("warns when publicEncryptionKey is malformed in dev/staging", () => {
-    const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-
-    new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Dev,
-      version: "1",
-      publicEncryptionKey: "not-valid-hex",
-    });
-
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("publicEncryptionKey does not look like a valid")
-    );
-    consoleWarnSpy.mockRestore();
-  });
-
-  test("does not warn when publicEncryptionKey is a valid 130-char uncompressed hex key in dev/staging", () => {
-    const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-
-    const validKey = "04" + "ab".repeat(64); // 2 + 128 = 130 hex chars
-
-    new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Dev,
-      version: "1",
-      publicEncryptionKey: validKey,
-    });
-
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-    consoleWarnSpy.mockRestore();
-  });
-
-  test("does not warn when publicEncryptionKey is a valid 66-char compressed hex key in dev/staging", () => {
-    const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-
-    const validKey = "02" + "4e".repeat(32); // 2 + 64 = 66 hex chars
-
-    new AvoInspector({
-      apiKey: "api-key-xxx",
-      env: AvoInspectorEnv.Dev,
-      version: "1",
-      publicEncryptionKey: validKey,
-    });
-
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-    consoleWarnSpy.mockRestore();
-  });
-
-  test("constructor works without publicEncryptionKey (backwards compatible)", () => {
-    expect(() => {
-      new AvoInspector({
-        apiKey: "api-key-xxx",
-        env: AvoInspectorEnv.Dev,
-        version: "1",
-      });
-    }).not.toThrow();
-  });
-});

package/src/__tests__/TestAvoStreamId.ts

@@ -1,72 +0,0 @@
-import { AvoStreamId } from "../AvoStreamId";
-
-describe("AvoStreamId", () => {
-  let consoleWarnSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  test("streamId getter returns empty string by default", () => {
-    const avoStreamId = new AvoStreamId();
-    expect(avoStreamId.streamId).toBe("");
-  });
-
-  test("streamId getter returns the value passed to constructor", () => {
-    const avoStreamId = new AvoStreamId("my-stream-id");
-    expect(avoStreamId.streamId).toBe("my-stream-id");
-  });
-
-  test("streamId containing ':' logs a warning", () => {
-    const avoStreamId = new AvoStreamId("invalid:stream:id");
-    const id = avoStreamId.streamId;
-
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "[Avo Inspector] Warning: streamId contains ':' which is not supported"
-    );
-    expect(id).toBe("invalid:stream:id");
-  });
-
-  test("streamId without ':' does not log a warning", () => {
-    const avoStreamId = new AvoStreamId("valid-stream-id");
-    const id = avoStreamId.streamId;
-
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-    expect(id).toBe("valid-stream-id");
-  });
-
-  test("empty streamId does not log a warning", () => {
-    const avoStreamId = new AvoStreamId("");
-    const id = avoStreamId.streamId;
-
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-    expect(id).toBe("");
-  });
-
-  test("explicit undefined arg returns empty string and does not warn", () => {
-    const avoStreamId = new AvoStreamId(undefined);
-    const id = avoStreamId.streamId;
-
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-    expect(id).toBe("");
-  });
-
-  test("warning is only logged once per instance, not on every .streamId access", () => {
-    const avoStreamId = new AvoStreamId("bad:id");
-
-    // The warning is logged in the constructor, so it's already been called once
-    expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
-
-    // Access streamId multiple times
-    avoStreamId.streamId;
-    avoStreamId.streamId;
-    avoStreamId.streamId;
-
-    // Should still be only one warning total
-    expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
-  });
-});

package/src/__tests__/TestDeduplicator.ts

@@ -1,191 +0,0 @@
-import { AvoDeduplicator } from "../AvoDeduplicator";
-import { deepEquals } from "../utils";
-import { AvoInspector } from "../AvoInspector";
-import { defaultOptions } from "./constants";
-
-jest
-  .useFakeTimers()
-  .setSystemTime(new Date('2020-01-01'));
-
-describe("Deduplicator", () => {
-  const deduplicator = new AvoDeduplicator();
-
-  const testObject = {
-    "0": "some string",
-    "1": [1, 2, 3],
-    2: [["str", true]],
-    3: { avo: [1.1, 2.2, 3.3] },
-  };
-
-  test(`AvoDeduplicator.deepEqual tests`, () => {
-    const secondObject = {
-      "0": "some string",
-      "1": [1, 2, 3],
-      2: [["str", true]],
-      3: { avo: [1.1, 2.2, 3.3] },
-    };
-
-    expect(deepEquals(testObject, secondObject)).toBe(true);
-
-    expect(deepEquals(testObject, { ...secondObject, "4": "4" })).toBe(false);
-
-    expect(
-      deepEquals(testObject, {
-        ...secondObject,
-        3: { ...secondObject[3], avo: [1.1] },
-      })
-    ).toBe(false);
-
-    expect(deepEquals(testObject, { ...secondObject, 0: "other string" })).toBe(
-      false
-    );
-  });
-
-  test(`Detects duplications when track in avo and then manually`, () => {
-    const shouldRegisterFromAvo = deduplicator.shouldRegisterEvent(
-      "Test",
-      testObject,
-      true
-    );
-    const shouldRegisterManual = deduplicator.shouldRegisterEvent(
-      "Test",
-      testObject,
-      false
-    );
-
-    expect(shouldRegisterFromAvo).toBe(true);
-    expect(shouldRegisterManual).toBe(false);
-  });
-
-  test(`Detects duplications when track manually and then in avo`, () => {
-    const shouldRegisterManual = deduplicator.shouldRegisterEvent(
-      "Test",
-      testObject,
-      false
-    );
-    const shouldRegisterFromAvo = deduplicator.shouldRegisterEvent(
-      "Test",
-      testObject,
-      true
-    );
-
-    expect(shouldRegisterManual).toBe(true);
-    expect(shouldRegisterFromAvo).toBe(false);
-  });
-
-  test(`Inspector deduplicates only one event when track manually, in avo and then manually again`, async () => {
-    const inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(false);
-
-    const manuallyTrackedSchema = await inspector.trackSchemaFromEvent(
-      "test",
-      testObject
-    );
-    // @ts-ignore
-    const avoTrackedSchema = await inspector._avoFunctionTrackSchemaFromEvent(
-      "test",
-      testObject,
-      "eventId",
-      "eventhash"
-    );
-    const manuallyTrackedSchemaAgain = await inspector.trackSchemaFromEvent(
-      "test",
-      testObject
-    );
-
-    expect(manuallyTrackedSchema.length).toBe(4);
-    expect(manuallyTrackedSchema.length + avoTrackedSchema.length + manuallyTrackedSchemaAgain.length).toBe(8);
-  });
-
-  test(`Inspector deduplicates only one event when track in avo, manually and then in avo again`, async () => {
-    const inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(false);
-
-    // @ts-ignore
-    const avoTrackedSchema = await inspector._avoFunctionTrackSchemaFromEvent(
-      "test",
-      testObject,
-      "eventId",
-      "eventhash"
-    );
-    const manuallyTrackedSchema = await inspector.trackSchemaFromEvent(
-      "test",
-      testObject
-    );
-    // @ts-ignore
-    const avoTrackedSchemaAgain = await inspector._avoFunctionTrackSchemaFromEvent(
-      "test",
-      testObject,
-      "eventId",
-      "eventhash"
-    );
-
-    expect(avoTrackedSchema.length).toBe(4);
-    expect(manuallyTrackedSchema.length).toBe(0);
-    expect(avoTrackedSchemaAgain.length).toBe(4);
-  });
-
-  test(`Allows two same manual events in a row`, async () => {
-    const inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(false);
-
-    const manuallyTrackedSchema = await inspector.trackSchemaFromEvent(
-      "test",
-      testObject
-    );
-    const manuallyTrackedSchemaAgain = await inspector.trackSchemaFromEvent(
-      "test",
-      testObject
-    );
-
-    expect(manuallyTrackedSchema.length).toBe(4);
-    expect(manuallyTrackedSchemaAgain.length).toBe(4);
-  });
-
-  test(`Allows two same avo events in a row`, async () => {
-    const inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(false);
-
-    // @ts-ignore
-    const avoTrackedSchema = await inspector._avoFunctionTrackSchemaFromEvent(
-      "test",
-      testObject,
-      "eventId",
-      "eventhash"
-    );
-    // @ts-ignore
-    const avoTrackedSchemaAgain = await inspector._avoFunctionTrackSchemaFromEvent(
-      "test",
-      testObject,
-      "eventId",
-      "eventhash"
-    );
-
-    expect(avoTrackedSchema.length).toBe(4);
-    expect(avoTrackedSchemaAgain.length).toBe(4);
-  });
-
-  test(`Does not deduplicate if more than 500ms pass`, () => {
-    const shouldRegisterFromAvo = deduplicator.shouldRegisterEvent(
-      "Test",
-      testObject,
-      true
-    );
-    const now = new Date();
-    const dateNowSpy = jest
-      .spyOn(Date, "now")
-      .mockImplementation(() =>
-        now.setMilliseconds(now.getMilliseconds() + 501)
-      );
-    const shouldRegisterManual = deduplicator.shouldRegisterEvent(
-      "Test",
-      testObject,
-      false
-    );
-
-    expect(shouldRegisterFromAvo).toBe(true);
-    expect(shouldRegisterManual).toBe(true);
-
-    dateNowSpy.mockRestore();
-  });
-});