Initial Commit

packages/foundation/bitpacker/bitpacker-validation/src/validation/find-extra-fields.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import { findExtraFields } from "./find-extra-fields.js";
+
+describe("findExtraFields", () => {
+    it("returns empty for null schema", () => {
+        expect(findExtraFields(null, { a: 1 })).toEqual([]);
+    });
+
+    it("returns empty for null data", () => {
+        expect(findExtraFields({ a: 1 }, null)).toEqual([]);
+    });
+
+    it("returns empty for undefined data", () => {
+        expect(findExtraFields({ a: 1 }, undefined)).toEqual([]);
+    });
+
+    it("handles optional wrapper with undefined data", () => {
+        const schema = { _bp: { schema: 255 } };
+        expect(
+            findExtraFields(
+                schema as unknown as import("@suaveplan/types").BitPackerSchema,
+                undefined
+            )
+        ).toEqual([]);
+    });
+
+    it("unwraps optional schema", () => {
+        const schema = { _bp: { schema: { a: 255 } } };
+        const data = { a: 1, b: 2 };
+        const extras = findExtraFields(
+            schema as unknown as import("@suaveplan/types").BitPackerSchema,
+            data
+        );
+        expect(extras.length).toBe(1);
+        expect(extras[0]).toMatchObject({ path: "b", value: 2 });
+    });
+
+    it("returns empty for primitive schemas", () => {
+        expect(findExtraFields(true, false)).toEqual([]);
+        expect(findExtraFields(255, 100)).toEqual([]);
+        expect(findExtraFields("-8", "hello")).toEqual([]);
+    });
+
+    it("finds extra elements in arrays", () => {
+        const schema = [255, 255];
+        const data = [1, 2, 3, 4];
+        const extras = findExtraFields(schema, data);
+        expect(extras.length).toBe(2);
+        expect(extras[0]).toMatchObject({ path: "[2]", value: 3 });
+        expect(extras[1]).toMatchObject({ path: "[3]", value: 4 });
+    });
+
+    it("recursively checks array elements", () => {
+        const schema = [{ a: 255 }];
+        const data = [{ a: 1, b: 2 }];
+        const extras = findExtraFields(schema, data);
+        expect(extras.length).toBe(1);
+        expect(extras[0]).toMatchObject({ path: "[0].b", value: 2 });
+    });
+
+    it("finds extra fields in objects", () => {
+        const schema = { a: 255 };
+        const data = { a: 1, b: 2 };
+        const extras = findExtraFields(schema, data);
+        expect(extras.length).toBe(1);
+        expect(extras[0]).toMatchObject({ path: "b", value: 2 });
+    });
+
+    it("recursively checks nested objects", () => {
+        const schema = { outer: { a: 255 } };
+        const data = { outer: { a: 1, b: 2 } };
+        const extras = findExtraFields(schema, data);
+        expect(extras.length).toBe(1);
+        expect(extras[0]).toMatchObject({ path: "outer.b", value: 2 });
+    });
+
+    it("returns empty when no extra fields", () => {
+        const schema = { a: 255, b: "-8" };
+        const data = { a: 1, b: "hello" };
+        expect(findExtraFields(schema, data)).toEqual([]);
+    });
+
+    it("handles path prefix", () => {
+        const schema = { a: 255 };
+        const data = { a: 1, b: 2 };
+        const extras = findExtraFields(schema, data, "root");
+        expect(extras[0].path).toBe("root.b");
+    });
+
+    it("handles array path prefix", () => {
+        const schema = [255];
+        const data = [1, 2];
+        const extras = findExtraFields(schema, data, "items");
+        expect(extras[0].path).toBe("items[1]");
+    });
+
+    it("skips undefined schema properties", () => {
+        const schema = { a: 255 };
+        const data = { a: 1 };
+        expect(findExtraFields(schema, data)).toEqual([]);
+    });
+
+    it("returns empty for array schema with non-array data", () => {
+        expect(findExtraFields([255], "not array")).toEqual([]);
+    });
+
+    it("returns empty for object schema with non-object data", () => {
+        expect(findExtraFields({ a: 255 }, "not object")).toEqual([]);
+    });
+
+    it("skips inherited properties in data", () => {
+        const schema = { a: 255 };
+        const data = Object.create({ inherited: 1 });
+        data.a = 1;
+        expect(findExtraFields(schema, data)).toEqual([]);
+    });
+
+    it("skips undefined schema property values", () => {
+        const schema: Record<string, unknown> = { a: 255 };
+        schema.b = undefined;
+        const data = { a: 1, b: 2 };
+        const extras = findExtraFields(
+            schema as import("@suaveplan/types").BitPackerSchema,
+            data
+        );
+        // undefined schema properties are skipped, not treated as extra fields
+        expect(extras).toEqual([]);
+    });
+});