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

package/dist/__tests__/TestAvoEventSpecFetcher.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoEventSpecFetcher_1 = require("../eventSpec/AvoEventSpecFetcher");
-const https = require("https");
-const events_1 = require("events");
-jest.mock("https");
-const mockedHttps = https;
-class MockIncomingMessage extends events_1.EventEmitter {
-    constructor(statusCode) {
-        super();
-        this.statusCode = statusCode;
-    }
-}
-class MockClientRequest extends events_1.EventEmitter {
-    constructor() {
-        super(...arguments);
-        this.end = jest.fn();
-        this.destroy = jest.fn();
-        this.setTimeout = jest.fn();
-    }
-}
-/** Build a wire-format response body matching the /trackingPlan/eventSpec API */
-function wireResponse(eventName, properties, metadata) {
-    const p = {};
-    for (const [name, constraint] of Object.entries(properties)) {
-        p[name] = { t: constraint.t, r: true };
-    }
-    return {
-        events: [{ b: metadata.branchId, id: "evt1", vids: [], p }],
-        metadata,
-    };
-}
-function setupMockRequest(responseStatusCode, responseBody) {
-    const mockReq = new MockClientRequest();
-    const mockRes = new MockIncomingMessage(responseStatusCode);
-    mockedHttps.request.mockImplementation((_options, callback) => {
-        callback(mockRes);
-        const data = JSON.stringify(responseBody);
-        mockRes.emit("data", Buffer.from(data));
-        mockRes.emit("end");
-        return mockReq;
-    });
-    return mockReq;
-}
-function setupMockRequestError() {
-    const mockReq = new MockClientRequest();
-    mockedHttps.request.mockImplementation((_options, _callback) => {
-        process.nextTick(() => mockReq.emit("error", new Error("network failure")));
-        return mockReq;
-    });
-    return mockReq;
-}
-describe("AvoEventSpecFetcher", () => {
-    let fetcher;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        fetcher = new AvoEventSpecFetcher_1.AvoEventSpecFetcher("test-api-key");
-    });
-    afterEach(() => {
-        fetcher.destroy();
-    });
-    test("fetches event spec via HTTPS GET", (done) => {
-        const metadata = { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" };
-        const wire = wireResponse("click", { target: { t: "string" } }, metadata);
-        const expectedParsed = {
-            eventSpec: {
-                eventName: "click",
-                properties: [{ propertyName: "target", propertyType: "string" }],
-            },
-            metadata,
-        };
-        setupMockRequest(200, wire);
-        fetcher.fetch("click", "stream1", (result) => {
-            expect(result).toEqual(expectedParsed);
-            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
-            const callArgs = mockedHttps.request.mock.calls[0][0];
-            expect(callArgs.method).toBe("GET");
-            expect(callArgs.hostname).toBe("api.avo.app");
-            done();
-        });
-    });
-    test("in-flight dedup: exactly ONE https.request for concurrent same-key events", (done) => {
-        const metadata = { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" };
-        const wire = wireResponse("purchase", {}, metadata);
-        const expectedParsed = {
-            eventSpec: { eventName: "purchase", properties: [] },
-            metadata,
-        };
-        // Delay the response so both calls are in-flight
-        const mockReq = new MockClientRequest();
-        const mockRes = new MockIncomingMessage(200);
-        mockedHttps.request.mockImplementation((_options, callback) => {
-            // Defer the response
-            setTimeout(() => {
-                callback(mockRes);
-                const data = JSON.stringify(wire);
-                mockRes.emit("data", Buffer.from(data));
-                mockRes.emit("end");
-            }, 10);
-            return mockReq;
-        });
-        let callCount = 0;
-        const checkDone = (result) => {
-            callCount++;
-            expect(result).toEqual(expectedParsed);
-            if (callCount === 2) {
-                // Only ONE actual https.request
-                expect(mockedHttps.request).toHaveBeenCalledTimes(1);
-                done();
-            }
-        };
-        fetcher.fetch("purchase", "stream1", checkDone);
-        fetcher.fetch("purchase", "stream1", checkDone);
-    });
-    test("in-flight failure: all queued callbacks resolved with null", (done) => {
-        setupMockRequestError();
-        let callCount = 0;
-        const checkDone = (result) => {
-            callCount++;
-            expect(result).toBeNull();
-            if (callCount === 2) {
-                expect(mockedHttps.request).toHaveBeenCalledTimes(1);
-                done();
-            }
-        };
-        fetcher.fetch("fail-event", "stream1", checkDone);
-        fetcher.fetch("fail-event", "stream1", checkDone);
-    });
-    test("non-200 status code resolves callback with null", (done) => {
-        setupMockRequest(500, { error: "Internal Server Error" });
-        fetcher.fetch("click", "stream1", (result) => {
-            expect(result).toBeNull();
-            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
-            done();
-        });
-    });
-    test("malformed JSON body resolves callback with null", (done) => {
-        const mockReq = new MockClientRequest();
-        const mockRes = new MockIncomingMessage(200);
-        mockedHttps.request.mockImplementation((_options, callback) => {
-            callback(mockRes);
-            mockRes.emit("data", Buffer.from("not valid json {{{"));
-            mockRes.emit("end");
-            return mockReq;
-        });
-        fetcher.fetch("click", "stream1", (result) => {
-            expect(result).toBeNull();
-            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
-            done();
-        });
-    });
-    test("timeout resolves callback with null", (done) => {
-        const mockReq = new MockClientRequest();
-        mockedHttps.request.mockImplementation((_options, _callback) => {
-            // Simulate timeout: never call the response callback,
-            // instead emit "timeout" on next tick
-            process.nextTick(() => mockReq.emit("timeout"));
-            return mockReq;
-        });
-        fetcher.fetch("click", "stream1", (result) => {
-            expect(result).toBeNull();
-            expect(mockReq.destroy).toHaveBeenCalled();
-            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
-            done();
-        });
-    });
-    test("separate keys make separate requests", (done) => {
-        const metadata = { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" };
-        const wire = wireResponse("click", {}, metadata);
-        const expectedParsed = {
-            eventSpec: { eventName: "click", properties: [] },
-            metadata,
-        };
-        setupMockRequest(200, wire);
-        let callCount = 0;
-        const checkDone = () => {
-            callCount++;
-            if (callCount === 2) {
-                expect(mockedHttps.request).toHaveBeenCalledTimes(2);
-                done();
-            }
-        };
-        fetcher.fetch("click", "stream1", (result) => {
-            expect(result).toEqual(expectedParsed);
-            checkDone();
-        });
-        fetcher.fetch("purchase", "stream1", (result) => {
-            // Both resolve with the same mock but that's fine for this test
-            checkDone();
-        });
-    });
-    test("parseWireResponse transforms wire format correctly", () => {
-        const wire = {
-            events: [{
-                    b: "main",
-                    id: "evt1",
-                    vids: [],
-                    p: {
-                        "Cli Action": { t: "string", r: true, v: { '["Status","Pull"]': ["evt1"] } },
-                        "Client": { t: "string", r: true },
-                    },
-                }],
-            metadata: { schemaId: "s1", branchId: "main", latestActionId: "a1", sourceId: "src1" },
-        };
-        const result = AvoEventSpecFetcher_1.AvoEventSpecFetcher.parseWireResponse(wire, "Cli Invoked");
-        expect(result.metadata).toEqual({ schemaId: "s1", branchId: "main", latestActionId: "a1", sourceId: "src1" });
-        expect(result.eventSpec).not.toBeNull();
-        expect(result.eventSpec.eventName).toBe("Cli Invoked");
-        expect(result.eventSpec.properties).toEqual([
-            { propertyName: "Cli Action", propertyType: "string" },
-            { propertyName: "Client", propertyType: "string" },
-        ]);
-    });
-    test("parseWireResponse returns null eventSpec for empty events array", () => {
-        const wire = { events: [], metadata: { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" } };
-        const result = AvoEventSpecFetcher_1.AvoEventSpecFetcher.parseWireResponse(wire, "test");
-        expect(result.eventSpec).toBeNull();
-    });
-});

package/dist/__tests__/TestAvoInspector.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/TestAvoInspector.js

@@ -1,291 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoInspector_1 = require("../AvoInspector");
-const AvoInspectorEnv_1 = require("../AvoInspectorEnv");
-const constants_1 = require("./constants");
-const AvoNetworkCallsHandler_1 = require("../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 } = constants_1.defaultOptions;
-        let inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(true);
-        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledTimes(1);
-        expect(AvoNetworkCallsHandler_1.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_1.AvoInspector({
-            env: AvoInspectorEnv_1.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_1.AvoInspector({
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-                version: "0",
-                // @ts-ignore
-                apiKey,
-            });
-        }).toThrow(constants_1.error.API_KEY);
-    });
-    test("Error is thrown when whitespace Api Key is used", () => {
-        // Given
-        const apiKey = " ";
-        // Then
-        expect(() => {
-            new AvoInspector_1.AvoInspector({
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-                version: "0",
-                apiKey,
-            });
-        }).toThrow(constants_1.error.API_KEY);
-    });
-    test("Error is thrown when empty string Api Key is used", () => {
-        expect(() => {
-            new AvoInspector_1.AvoInspector({
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-                version: "0",
-                apiKey: "",
-            });
-        }).toThrow(constants_1.error.API_KEY);
-    });
-    test("Error is thrown when Api Key is set to null", () => {
-        // Given
-        const apiKey = null;
-        // Then
-        expect(() => {
-            new AvoInspector_1.AvoInspector({
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-                version: "0",
-                // @ts-ignore
-                apiKey,
-            });
-        }).toThrow(constants_1.error.API_KEY);
-    });
-    test("Dev environment is used when env is not provided", () => {
-        // Given
-        // @ts-ignore
-        let env;
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            version: "0",
-            // @ts-ignore
-            env,
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Dev);
-    });
-    test("Dev environment is used when empty string is used", () => {
-        // Given
-        const env = "";
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            version: "0",
-            // @ts-ignore
-            env,
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Dev);
-    });
-    test("Dev env is set using AvoInspectorEnv", () => {
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
-            version: "0",
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Dev);
-    });
-    test("Dev environment is set using string", () => {
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: "dev",
-            version: "0",
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Dev);
-    });
-    test("Staging env is set using AvoInspectorEnv", () => {
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.AvoInspectorEnv.Staging,
-            version: "0",
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Staging);
-    });
-    test("Staging environment is set using string", () => {
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: "staging",
-            version: "0",
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Staging);
-    });
-    test("Prod env is set using AvoInspectorEnv", () => {
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-            version: "0",
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Prod);
-    });
-    test("Prod environment is set using string", () => {
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: "prod",
-            version: "0",
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Prod);
-    });
-    test("Environment other than Dev, Staging, Prod falls back to Dev", () => {
-        // When
-        const env = "test";
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            version: "0",
-            // @ts-ignore
-            env,
-        });
-        // Then
-        expect(inspector.environment).toBe(AvoInspectorEnv_1.AvoInspectorEnv.Dev);
-    });
-    test("Version is set", () => {
-        const version = "1";
-        // When
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.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_1.AvoInspector({
-                apiKey: "api-key-xxx",
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-                // @ts-ignore
-                version,
-            });
-        }).toThrow(constants_1.error.VERSION);
-    });
-    test("Error is thrown when version is set to empty string", () => {
-        // Given
-        const version = " ";
-        // Then
-        expect(() => {
-            new AvoInspector_1.AvoInspector({
-                apiKey: "api-key-xxx",
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-                version,
-            });
-        }).toThrow(constants_1.error.VERSION);
-    });
-    test("Error is thrown when version is set to null", () => {
-        // Given
-        const version = null;
-        // Then
-        expect(() => {
-            new AvoInspector_1.AvoInspector({
-                apiKey: "api-key-xxx",
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
-                // @ts-ignore
-                version,
-            });
-        }).toThrow(constants_1.error.VERSION);
-    });
-    test("publicEncryptionKey is forwarded to AvoNetworkCallsHandler when provided", () => {
-        const inspectorVersion = process.env.npm_package_version || "";
-        AvoNetworkCallsHandler_1.AvoNetworkCallsHandler.mockClear();
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
-            version: "1",
-            publicEncryptionKey: "my-public-key-123",
-        });
-        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledWith("api-key-xxx", AvoInspectorEnv_1.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_1.AvoNetworkCallsHandler.mockClear();
-        let inspector = new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
-            version: "1",
-        });
-        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledWith("api-key-xxx", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "", "1", inspectorVersion, undefined);
-    });
-    test("warns when publicEncryptionKey is malformed in dev/staging", () => {
-        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
-        new AvoInspector_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.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_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.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_1.AvoInspector({
-            apiKey: "api-key-xxx",
-            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
-            version: "1",
-            publicEncryptionKey: validKey,
-        });
-        expect(consoleWarnSpy).not.toHaveBeenCalled();
-        consoleWarnSpy.mockRestore();
-    });
-    test("constructor works without publicEncryptionKey (backwards compatible)", () => {
-        expect(() => {
-            new AvoInspector_1.AvoInspector({
-                apiKey: "api-key-xxx",
-                env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
-                version: "1",
-            });
-        }).not.toThrow();
-    });
-});

package/dist/__tests__/TestAvoStreamId.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/TestAvoStreamId.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoStreamId_1 = require("../AvoStreamId");
-describe("AvoStreamId", () => {
-    let consoleWarnSpy;
-    beforeEach(() => {
-        consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    test("streamId getter returns empty string by default", () => {
-        const avoStreamId = new AvoStreamId_1.AvoStreamId();
-        expect(avoStreamId.streamId).toBe("");
-    });
-    test("streamId getter returns the value passed to constructor", () => {
-        const avoStreamId = new AvoStreamId_1.AvoStreamId("my-stream-id");
-        expect(avoStreamId.streamId).toBe("my-stream-id");
-    });
-    test("streamId containing ':' logs a warning", () => {
-        const avoStreamId = new AvoStreamId_1.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_1.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_1.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_1.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_1.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/dist/__tests__/TestDeduplicator.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/TestDeduplicator.js

@@ -1,102 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoDeduplicator_1 = require("../AvoDeduplicator");
-const utils_1 = require("../utils");
-const AvoInspector_1 = require("../AvoInspector");
-const constants_1 = require("./constants");
-jest
-    .useFakeTimers()
-    .setSystemTime(new Date('2020-01-01'));
-describe("Deduplicator", () => {
-    const deduplicator = new AvoDeduplicator_1.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((0, utils_1.deepEquals)(testObject, secondObject)).toBe(true);
-        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { "4": "4" }))).toBe(false);
-        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { 3: Object.assign(Object.assign({}, secondObject[3]), { avo: [1.1] }) }))).toBe(false);
-        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, 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`, () => __awaiter(void 0, void 0, void 0, function* () {
-        const inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
-        const manuallyTrackedSchema = yield inspector.trackSchemaFromEvent("test", testObject);
-        // @ts-ignore
-        const avoTrackedSchema = yield inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash");
-        const manuallyTrackedSchemaAgain = yield 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`, () => __awaiter(void 0, void 0, void 0, function* () {
-        const inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
-        // @ts-ignore
-        const avoTrackedSchema = yield inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash");
-        const manuallyTrackedSchema = yield inspector.trackSchemaFromEvent("test", testObject);
-        // @ts-ignore
-        const avoTrackedSchemaAgain = yield 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`, () => __awaiter(void 0, void 0, void 0, function* () {
-        const inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
-        const manuallyTrackedSchema = yield inspector.trackSchemaFromEvent("test", testObject);
-        const manuallyTrackedSchemaAgain = yield inspector.trackSchemaFromEvent("test", testObject);
-        expect(manuallyTrackedSchema.length).toBe(4);
-        expect(manuallyTrackedSchemaAgain.length).toBe(4);
-    }));
-    test(`Allows two same avo events in a row`, () => __awaiter(void 0, void 0, void 0, function* () {
-        const inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
-        // @ts-ignore
-        const avoTrackedSchema = yield inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash");
-        // @ts-ignore
-        const avoTrackedSchemaAgain = yield 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();
-    });
-});

package/dist/__tests__/TestEventValidator.d.ts

@@ -1 +0,0 @@
-export {};