pepr 0.38.0-rc → 0.38.1

package/src/lib/controller/store.test.ts

@@ -1,131 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
-
-import { expect, test, describe, afterEach } from "@jest/globals";
-import * as fc from "fast-check";
-import { redactedStore, redactedPatch } from "./store";
-import { AddOperation } from "fast-json-patch";
-
-const redactedValue = "**redacted**";
-const peprStoreFuzz = fc.record({
-  kind: fc.constant("PeprStore"),
-  apiVersion: fc.constant("v1"),
-  metadata: fc.record({
-    name: fc.string(),
-    namespace: fc.string(),
-  }),
-  data: fc.dictionary(
-    fc.string().filter(str => str !== "__proto__"),
-    fc.string().filter(str => str !== "__proto__"),
-  ),
-});
-describe("Fuzzing redactedStore", () => {
-  afterEach(() => {
-    delete process.env.PEPR_STORE_REDACT_VALUES;
-  });
-
-  test("should redact values if PEPR_STORE_REDACT_VALUES is true", () => {
-    fc.assert(
-      fc.property(peprStoreFuzz, store => {
-        process.env.PEPR_STORE_REDACT_VALUES = "true";
-        const result = redactedStore(store);
-
-        Object.values(result.data).forEach(value => {
-          expect(value).toBe(redactedValue);
-        });
-      }),
-    );
-  });
-
-  test("should not redact values if PEPR_STORE_REDACT_VALUES is not true", () => {
-    fc.assert(
-      fc.property(peprStoreFuzz, store => {
-        process.env.PEPR_STORE_REDACT_VALUES = "false";
-        const result = redactedStore(store);
-        expect(result.data).toEqual(store.data);
-      }),
-    );
-  });
-
-  test("should maintain other properties of the store", () => {
-    fc.assert(
-      fc.property(peprStoreFuzz, store => {
-        const redactionEnabled = fc.boolean();
-        process.env.PEPR_STORE_REDACT_VALUES = redactionEnabled ? "true" : "false";
-
-        const result = redactedStore(store);
-
-        expect(result.kind).toBe(store.kind);
-        expect(result.apiVersion).toBe(store.apiVersion);
-        expect(result.metadata).toEqual(store.metadata);
-      }),
-    );
-  });
-});
-
-const addOperationKeys = [
-  "add:/data/hello-pepr-a:secret",
-  "add:/data/hello-pepr-v2-b:secret",
-  "add:/data/hello-pepr-v2-c:secret",
-  "add:/data/hello-pepr-v2-d:secret",
-  "add:/data/hello-pepr-v2-e:secret",
-  "add:/data/hello-pepr-v2-f:secret",
-];
-const addOperationValues: AddOperation<string>[] = [
-  {
-    op: "add",
-    path: "add:/data/hello-pepr-a",
-    value: "secret",
-  },
-  {
-    op: "add",
-    path: "add:/data/hello-pepr-v2-b",
-    value: "secret",
-  },
-  {
-    op: "add",
-    path: "add:/data/hello-pepr-v2-c",
-    value: "secret",
-  },
-  {
-    op: "add",
-    path: "add:/data/hello-pepr-v2-d",
-    value: "secret",
-  },
-  {
-    op: "add",
-    path: "add:/data/hello-pepr-v2-e",
-    value: "secret",
-  },
-  {
-    op: "add",
-    path: "add:/data/hello-pepr-v2-f",
-    value: "secret",
-  },
-];
-
-describe("redactedPatch", () => {
-  afterEach(() => {
-    delete process.env.PEPR_STORE_REDACT_VALUES;
-  });
-
-  test("should redact keys and values if PEPR_STORE_REDACT_VALUES is true", () => {
-    process.env.PEPR_STORE_REDACT_VALUES = "true";
-    addOperationKeys.forEach((key, i) => {
-      const redactedResult = redactedPatch({ [key]: addOperationValues[i] });
-      for (const [k, v] of Object.entries(redactedResult)) {
-        expect(k).toContain(`:${redactedValue}`);
-        expect(v).toEqual(expect.objectContaining({ value: redactedValue }));
-      }
-    });
-  });
-  test("should not redact keys and values if PEPR_STORE_REDACT_VALUES is not true", () => {
-    addOperationKeys.forEach((key, i) => {
-      const redactedResult = redactedPatch({ [key]: addOperationValues[i] });
-      for (const [k, v] of Object.entries(redactedResult)) {
-        expect(k).not.toContain(`:${redactedValue}`);
-        expect(v).not.toEqual(expect.objectContaining({ value: redactedValue }));
-      }
-    });
-  });
-});

package/src/lib/errors.test.ts

@@ -1,85 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
-
-import { expect, test, describe } from "@jest/globals";
-import * as fc from "fast-check";
-import { Errors, ErrorList, ValidateError } from "./errors";
-
-describe("ValidateError Fuzz Testing", () => {
-  test("should only accept predefined error values", () => {
-    fc.assert(
-      fc.property(fc.string(), error => {
-        if (ErrorList.includes(error)) {
-          expect(() => ValidateError(error)).not.toThrow();
-        } else {
-          expect(() => ValidateError(error)).toThrow(
-            `Invalid error: ${error}. Must be one of: ${ErrorList.join(", ")}`,
-          );
-        }
-      }),
-      { verbose: true },
-    );
-  });
-});
-describe("ValidateError Fake Data Testing", () => {
-  test("should correctly handle typical fake error data", () => {
-    const fakeErrors = ["error", "failure", "null", "undefined", "exception"];
-    fakeErrors.forEach(fakeError => {
-      if (ErrorList.includes(fakeError)) {
-        expect(() => ValidateError(fakeError)).not.toThrow();
-      } else {
-        expect(() => ValidateError(fakeError)).toThrow(
-          `Invalid error: ${fakeError}. Must be one of: ${ErrorList.join(", ")}`,
-        );
-      }
-    });
-  });
-});
-describe("ValidateError Property-Based Testing", () => {
-  test("should only validate errors that are part of the ErrorList", () => {
-    fc.assert(
-      fc.property(fc.constantFrom(...ErrorList), validError => {
-        expect(() => ValidateError(validError)).not.toThrow();
-      }),
-      { verbose: true },
-    );
-
-    fc.assert(
-      fc.property(
-        fc.string().filter(e => !ErrorList.includes(e)),
-        invalidError => {
-          expect(() => ValidateError(invalidError)).toThrow(
-            `Invalid error: ${invalidError}. Must be one of: ${ErrorList.join(", ")}`,
-          );
-        },
-      ),
-      { verbose: true },
-    );
-  });
-});
-
-test("Errors object should have correct properties", () => {
-  expect(Errors).toEqual({
-    audit: "audit",
-    ignore: "ignore",
-    reject: "reject",
-  });
-});
-
-test("ErrorList should contain correct values", () => {
-  expect(ErrorList).toEqual(["audit", "ignore", "reject"]);
-});
-
-test("ValidateError should not throw an error for valid errors", () => {
-  expect(() => {
-    ValidateError("audit");
-    ValidateError("ignore");
-    ValidateError("reject");
-  }).not.toThrow();
-});
-
-test("ValidateError should throw an error for invalid errors", () => {
-  expect(() => ValidateError("invalidError")).toThrowError({
-    message: "Invalid error: invalidError. Must be one of: audit, ignore, reject",
-  });
-});