node-avo-inspector 1.1.0 → 1.2.0-alpha.1

package/src/__tests__/TestAvoStreamId.ts

@@ -0,0 +1,72 @@
+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

@@ -3,6 +3,10 @@ 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();
 

package/src/__tests__/TestEventValidator.ts

@@ -0,0 +1,231 @@
+import { EventValidator } from "../eventSpec/EventValidator";
+import { EventSpec, PropertyConstraint, PropertyValidationResult } from "../eventSpec/AvoEventSpecFetchTypes";
+
+// We need to mock safe-regex2 for some tests
+jest.mock("safe-regex2", () => {
+  const actual = jest.requireActual("safe-regex2");
+  return {
+    __esModule: true,
+    default: actual.default || actual,
+    _mockable: true,
+  };
+});
+
+describe("EventValidator", () => {
+  let validator: EventValidator;
+
+  beforeEach(() => {
+    validator = new EventValidator();
+    jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("type validation", () => {
+    test("passes when property types match spec", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [
+          { propertyName: "target", propertyType: "string" },
+          { propertyName: "count", propertyType: "int" },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "target", propertyType: "string" },
+        { propertyName: "count", propertyType: "int" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-1");
+      // All properties passed type check, so failedEventIds should be empty
+      expect(results.every((r: PropertyValidationResult) => r.failedEventIds.length === 0)).toBe(true);
+      // Bandwidth optimization: passedEventIds cleared because passed >= failed for each property
+      expect(results.every((r: PropertyValidationResult) => r.passedEventIds.length === 0)).toBe(true);
+    });
+
+    test("fails when property type does not match spec", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [{ propertyName: "count", propertyType: "int" }],
+      };
+      const eventProperties = [
+        { propertyName: "count", propertyType: "string" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-2");
+      const countResult = results.find((r: PropertyValidationResult) => r.propertyName === "count");
+      expect(countResult?.failedEventIds).toContain("evt-2");
+      expect(countResult?.passedEventIds).not.toContain("evt-2");
+    });
+
+    test("fails for missing required properties", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [
+          { propertyName: "target", propertyType: "string" },
+          { propertyName: "count", propertyType: "int" },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "target", propertyType: "string" },
+        // count is missing
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-3");
+      const countResult = results.find((r: PropertyValidationResult) => r.propertyName === "count");
+      expect(countResult?.failedEventIds).toContain("evt-3");
+    });
+  });
+
+  describe("regex validation", () => {
+    test("passes when value matches safe regex pattern (type match)", () => {
+      const spec: EventSpec = {
+        eventName: "navigate",
+        properties: [
+          {
+            propertyName: "url",
+            propertyType: "string",
+            regex: "^https://",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "url", propertyType: "string", propertyValue: "https://example.com" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-4");
+      const urlResult = results.find((r: PropertyValidationResult) => r.propertyName === "url");
+      // Type matches and regex matches, property passed. Bandwidth optimization: passedEventIds cleared
+      // because passed count (1) >= failed count (0)
+      expect(urlResult?.failedEventIds).toEqual([]);
+    });
+
+    test("fails when value does not match safe regex pattern", () => {
+      const spec: EventSpec = {
+        eventName: "navigate",
+        properties: [
+          {
+            propertyName: "url",
+            propertyType: "string",
+            regex: "^https://",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "url", propertyType: "string", propertyValue: "http://example.com" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-regex-fail");
+      const urlResult = results.find((r: PropertyValidationResult) => r.propertyName === "url");
+      expect(urlResult?.failedEventIds).toContain("evt-regex-fail");
+      expect(urlResult?.passedEventIds).not.toContain("evt-regex-fail");
+    });
+
+    test("logs warning and passes type check when regex syntax is invalid", () => {
+      const spec: EventSpec = {
+        eventName: "filter",
+        properties: [
+          {
+            propertyName: "pattern",
+            propertyType: "string",
+            regex: "[invalid",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "pattern", propertyType: "string", propertyValue: "anything" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-bad-regex");
+      const patternResult = results.find((r: PropertyValidationResult) => r.propertyName === "pattern");
+      // Invalid regex is caught, property still passes type check
+      expect(patternResult?.failedEventIds).toEqual([]);
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining("[Avo Inspector] Warning")
+      );
+    });
+
+    test("skips unsafe regex patterns with warning", () => {
+      const spec: EventSpec = {
+        eventName: "search",
+        properties: [
+          {
+            propertyName: "query",
+            propertyType: "string",
+            // Catastrophic backtracking pattern
+            regex: "(a+)+$",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "query", propertyType: "string", propertyValue: "aaa" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-5");
+      // Unsafe regex should be skipped, property still passes type check
+      const queryResult = results.find((r: PropertyValidationResult) => r.propertyName === "query");
+      // Bandwidth optimization: passedEventIds cleared because passed count >= failed count
+      expect(queryResult?.failedEventIds).toEqual([]);
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining("[Avo Inspector] Warning")
+      );
+    });
+  });
+
+  describe("extra/unexpected properties", () => {
+    test("ignores properties present in event but not in the spec", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [
+          { propertyName: "target", propertyType: "string" },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "target", propertyType: "string" },
+        { propertyName: "extraProp", propertyType: "int" },
+        { propertyName: "anotherExtra", propertyType: "boolean" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-extra");
+      // Only spec properties get results — extra properties are not reported
+      expect(results).toHaveLength(1);
+      expect(results[0].propertyName).toBe("target");
+      expect(results.find((r: PropertyValidationResult) => r.propertyName === "extraProp")).toBeUndefined();
+      expect(results.find((r: PropertyValidationResult) => r.propertyName === "anotherExtra")).toBeUndefined();
+    });
+  });
+
+  describe("bandwidth optimization", () => {
+    test("returns passedEventIds only when strictly smaller than failedEventIds", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [{ propertyName: "target", propertyType: "string" }],
+      };
+
+      // Single pass
+      const passResults = validator.validate(
+        spec,
+        [{ propertyName: "target", propertyType: "string" }],
+        "evt-pass"
+      );
+      const passResult = passResults.find((r: PropertyValidationResult) => r.propertyName === "target");
+
+      // When there's only passed and no failed, passedEventIds count (1) > failedEventIds count (0)
+      // So passedEventIds is NOT strictly smaller - it should be returned
+      // But the optimization says: return passedEventIds ONLY when strictly smaller than failedEventIds
+      // So when passedEventIds.length >= failedEventIds.length, we clear passedEventIds
+      expect(passResult?.passedEventIds).toEqual([]);
+
+      // Single fail
+      const failResults = validator.validate(
+        spec,
+        [{ propertyName: "target", propertyType: "int" }],
+        "evt-fail"
+      );
+      const failResult = failResults.find((r: PropertyValidationResult) => r.propertyName === "target");
+      // failedEventIds has 1, passedEventIds has 0 -> passedEventIds is strictly smaller, return it
+      expect(failResult?.failedEventIds).toContain("evt-fail");
+    });
+  });
+});

package/src/__tests__/TestNetworkCallsHandler.ts

@@ -15,7 +15,6 @@ describe("NetworkCallsHandler", () => {
   let networkHandler: AvoNetworkCallsHandler;
   let baseBody: BaseBody;
 
-  const customCallback = jest.fn();
   const now = new Date();
 
   beforeAll(() => {
@@ -43,8 +42,9 @@ describe("NetworkCallsHandler", () => {
       libPlatform: "node",
       messageId: mockedReturns.GUID,
       trackingId: "",
+      sessionId: "",
+      anonymousId: "",
       createdAt: new Date().toISOString(),
-      sessionId: mockedReturns.SESSION_ID,
       samplingRate: 1.0,
     };
   });
@@ -53,23 +53,12 @@ describe("NetworkCallsHandler", () => {
     jest.clearAllMocks();
   });
 
-  test("bodyForSessionStartedCall returns base body + session started body used for session started", () => {
-    const body = networkHandler.bodyForSessionStartedCall(
-      mockedReturns.SESSION_ID
-    );
-
-    expect(body).toEqual({
-      ...baseBody,
-      type: "sessionStarted",
-    });
-  });
-
   test("bodyForEventSchemaCall returns base body + event schema used for event sending from non Codegen", () => {
     const eventName = "event name";
     const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
 
     const body = networkHandler.bodyForEventSchemaCall(
-      mockedReturns.SESSION_ID,
+      "",
       eventName,
       eventProperties,
       null,
@@ -78,6 +67,7 @@ describe("NetworkCallsHandler", () => {
 
     expect(body).toEqual({
       ...baseBody,
+      anonymousId: "",
       type: "event",
       eventName,
       eventProperties,
@@ -94,7 +84,7 @@ describe("NetworkCallsHandler", () => {
     const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
 
     const body = networkHandler.bodyForEventSchemaCall(
-      mockedReturns.SESSION_ID,
+      "",
       eventName,
       eventProperties,
       eventId,
@@ -103,6 +93,7 @@ describe("NetworkCallsHandler", () => {
 
     expect(body).toEqual({
       ...baseBody,
+      anonymousId: "",
       type: "event",
       eventName,
       eventProperties,
@@ -111,4 +102,80 @@ describe("NetworkCallsHandler", () => {
       eventHash,
     });
   });
+
+  test("bodyForEventSchemaCall uses streamId as anonymousId", () => {
+    const eventName = "event name";
+    const streamId = "user-123";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+
+    const body = networkHandler.bodyForEventSchemaCall(
+      streamId,
+      eventName,
+      eventProperties,
+      null,
+      null
+    );
+
+    expect(body.anonymousId).toBe("user-123");
+  });
+
+  test("bodyForEventSchemaCall with rawEventProperties passes them through (no encryption in dev without key)", () => {
+    const eventName = "event name";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+    const rawEventProperties = { prop0: "hello" };
+
+    const body = networkHandler.bodyForEventSchemaCall(
+      "",
+      eventName,
+      eventProperties,
+      null,
+      null,
+      rawEventProperties
+    );
+
+    // Without a publicEncryptionKey, encryption is not triggered,
+    // so eventProperties should be the plain schema (not encrypted)
+    expect(body.eventProperties).toEqual(eventProperties);
+    expect(body.type).toBe("event");
+    expect(body.eventName).toBe(eventName);
+  });
+
+  test("base body includes publicEncryptionKey when handler is constructed with one", () => {
+    const handlerWithKey = new AvoNetworkCallsHandler(
+      apiKey,
+      env,
+      "",
+      version,
+      inspectorVersion,
+      "test-public-key-abc"
+    );
+
+    const eventName = "event name";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+
+    const body = handlerWithKey.bodyForEventSchemaCall(
+      "",
+      eventName,
+      eventProperties,
+      null,
+      null
+    );
+
+    expect(body.publicEncryptionKey).toBe("test-public-key-abc");
+  });
+
+  test("base body does not include publicEncryptionKey when handler is constructed without one", () => {
+    const eventName = "event name";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+
+    const body = networkHandler.bodyForEventSchemaCall(
+      "",
+      eventName,
+      eventProperties,
+      null,
+      null
+    );
+
+    expect(body.publicEncryptionKey).toBeUndefined();
+  });
 });