tests: migrate tests for x590 (#62)

Signed-off-by: Carlos Feria <[email protected]>

Author: carlosthe19916

client/src/app/pages/RekorSearch/Template/x509/decode.test.ts

@@ -0,0 +1,86 @@
+import { vi, type Mock } from "vitest";
+
+import { decodex509 } from "./decode";
+import { X509Certificate } from "@peculiar/x509";
+import { toRelativeDateString } from "../../utils/date";
+import { EXTENSIONS_CONFIG } from "./extensions";
+
+vi.mock("@peculiar/x509", () => ({
+  X509Certificate: vi.fn(),
+}));
+
+vi.mock("../../utils/date", () => ({
+  toRelativeDateString: vi.fn(),
+}));
+
+vi.mock("./extensions", () => ({
+  EXTENSIONS_CONFIG: {
+    "1.2.3.4.5": {
+      name: "Mock Extension",
+      toJSON: vi.fn().mockReturnValue({ mockKey: "mockValue" }),
+    },
+  },
+}));
+
+describe("decodex509", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    (toRelativeDateString as Mock).mockImplementation((date) => `Relative date for ${date}`);
+    (X509Certificate as unknown as Mock).mockImplementation(() => ({
+      serialNumber: "123456",
+      issuer: "Issuer Name",
+      notBefore: new Date("2020-01-01"),
+      notAfter: new Date("2022-01-01"),
+      publicKey: {
+        algorithm: "rsaEncryption",
+      },
+      subjectName: "Subject Name",
+      extensions: [
+        {
+          type: "1.2.3.4.5",
+          critical: false,
+          value: new ArrayBuffer(8),
+        },
+      ],
+    }));
+  });
+
+  it("should decode a raw X.509 certificate", () => {
+    const rawCertificate = "rawCertificateString";
+    const decoded = decodex509(rawCertificate);
+    expect(decoded).toBeDefined();
+    expect(decoded.Signature.Issuer).toBe("Issuer Name");
+  });
+
+  // simulate an extension not found
+  // @ts-expect-error allowed
+  EXTENSIONS_CONFIG.unknownExtensionType = undefined;
+
+  it("converts ArrayBuffer to hex string for unknown extension types", () => {
+    (X509Certificate as unknown as Mock).mockImplementation(() => ({
+      // mock certificate fields as above, adjusting for this specific test
+      serialNumber: "654321",
+      issuer: "New Issuer",
+      notBefore: new Date("2021-01-01"),
+      notAfter: new Date("2023-01-01"),
+      publicKey: {
+        algorithm: "ecdsa",
+      },
+      subjectName: "New Subject",
+      extensions: [
+        {
+          type: "unknownExtensionType",
+          critical: true,
+          value: new Uint8Array([1, 2, 3, 4]).buffer, // tests bufferToHex
+        },
+      ],
+    }));
+
+    const rawCertificate = "anotherRawCertificateString";
+    const decoded = decodex509(rawCertificate);
+
+    // asserts the hex string format of the ArrayBuffer
+    expect(decoded["X509v3 extensions"]["unknownExtensionType (critical)"]).toBe("01:02:03:04");
+  });
+});

client/src/app/pages/RekorSearch/Template/x509/extensions.test.ts

@@ -0,0 +1,115 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument */
+
+import { EXTENSIONS_CONFIG } from "./extensions";
+
+vi.mock("@peculiar/asn1-schema", () => ({
+  AsnUtf8StringConverter: {
+    fromASN: vi.fn().mockReturnValue("mockedString"),
+  },
+  AsnAnyConverter: {
+    toASN: vi.fn().mockReturnValue(new ArrayBuffer(0)),
+  },
+}));
+
+vi.mock("@peculiar/x509", () => ({
+  AuthorityKeyIdentifierExtension: vi.fn().mockImplementation(() => ({
+    keyId: "01020304",
+    certId: undefined,
+  })),
+  BasicConstraintsExtension: vi.fn().mockImplementation(() => ({
+    ca: false,
+  })),
+  ExtendedKeyUsageExtension: vi.fn().mockImplementation(() => ({
+    usages: ["1.3.6.1.5.5.7.3.3"],
+  })),
+  KeyUsagesExtension: vi.fn().mockImplementation(() => ({
+    usages: 3,
+  })),
+  SubjectAlternativeNameExtension: vi.fn().mockImplementation(() => ({
+    names: [],
+  })),
+  SubjectKeyIdentifierExtension: vi.fn().mockImplementation(() => ({
+    keyId: "01020304",
+  })),
+}));
+
+vi.mock("./constants", () => ({
+  KEY_USAGE_NAMES: {
+    1: "Digital Signature",
+    2: "Non Repudiation",
+    4: "Key Encipherment",
+    8: "Data Encipherment",
+  },
+}));
+
+describe("EXTENSIONS_CONFIG", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should map '2.5.29.14' to Subject Key Identifier", () => {
+    const rawExtension = {
+      rawData: new Uint8Array([1, 2, 3, 4]),
+      value: new Uint8Array([5, 6, 7, 8]),
+    };
+    const result = EXTENSIONS_CONFIG["2.5.29.14"].toJSON(rawExtension as any);
+    expect(result).toEqual(["01:02:03:04"]);
+  });
+
+  it("should map '2.5.29.15' to Key Usage", () => {
+    const rawExtension = {
+      rawData: new Uint8Array([1, 2, 3, 4]),
+      value: new Uint8Array([5, 6, 7, 8]),
+    };
+    const result = EXTENSIONS_CONFIG["2.5.29.15"].toJSON(rawExtension as any);
+    expect(result).toEqual(["Digital Signature", "Non Repudiation"]);
+  });
+
+  it.skip("should map '2.5.29.17' to Subject Alternative Name", () => {
+    const rawExtension = {
+      rawData: new Uint8Array([1, 2, 3, 4]),
+      value: new Uint8Array([5, 6, 7, 8]),
+    };
+    const result = EXTENSIONS_CONFIG["2.5.29.17"].toJSON(rawExtension as any);
+    expect(result).toEqual({ names: [] });
+  });
+
+  it("should map '2.5.29.19' to Basic Constraints", () => {
+    const rawExtension = {
+      rawData: new Uint8Array([1, 2, 3, 4]),
+      value: new Uint8Array([5, 6, 7, 8]),
+    };
+    const result = EXTENSIONS_CONFIG["2.5.29.19"].toJSON(rawExtension as any);
+    expect(result).toEqual({ CA: false });
+  });
+
+  it("should map '2.5.29.35' to Authority Key Identifier", () => {
+    const rawExtension = {
+      rawData: new Uint8Array([1, 2, 3, 4]),
+      value: new Uint8Array([5, 6, 7, 8]),
+    };
+    const result = EXTENSIONS_CONFIG["2.5.29.35"].toJSON(rawExtension as any);
+    expect(result).toEqual({ keyid: "01:02:03:04", certid: undefined });
+  });
+
+  it("should map '2.5.29.37' to Extended Key Usage", () => {
+    const rawExtension = {
+      rawData: new Uint8Array([1, 2, 3, 4]),
+      value: new Uint8Array([5, 6, 7, 8]),
+    };
+    const result = EXTENSIONS_CONFIG["2.5.29.37"].toJSON(rawExtension as any);
+    expect(result).toEqual(["Code Signing"]);
+  });
+
+  it("should decode text using textDecoder", () => {
+    const rawExtension = { value: new TextEncoder().encode("test") };
+    const result = EXTENSIONS_CONFIG["1.3.6.1.4.1.57264.1.1"].toJSON(rawExtension as any);
+    expect(result).toBe("test");
+  });
+
+  it("should decode UTF-8 string using utf8StringDecoder", () => {
+    const rawExtension = { value: new TextEncoder().encode("test") };
+    const result = EXTENSIONS_CONFIG["1.3.6.1.4.1.57264.1.8"].toJSON(rawExtension as any);
+    expect(result).toBe("mockedString");
+  });
+});