@oneuptime/common 11.7.3 → 12.0.0

package/Tests/Types/DateUserTimezone.test.ts

@@ -139,6 +139,58 @@ describe("OneUptimeDate user timezone", () => {
       expect(formatted).toContain("EDT");
     });
 
+    it("names the abbreviation in effect on the formatted date, not today's", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      /*
+       * The abbreviation used to be looked up for "now", so all summer every
+       * winter timestamp read "EDT" — and 13:00 EDT is a different instant
+       * than the 13:00 EST that was actually stored.
+       */
+      const winter: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-01-15T18:00:00Z"),
+      );
+      const summer: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-07-15T18:00:00Z"),
+      );
+
+      expect(winter).toContain("13:00");
+      expect(winter).toContain("EST");
+      expect(winter).not.toContain("EDT");
+
+      expect(summer).toContain("14:00");
+      expect(summer).toContain("EDT");
+    });
+
+    it("labels each pass of a folded fall-back hour with its own abbreviation", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // 01:30 local happens twice on 2026-11-01 — once EDT, once EST.
+      const firstPass: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-11-01T05:30:00Z"),
+      );
+      const secondPass: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-11-01T06:30:00Z"),
+      );
+
+      expect(firstPass).toContain("01:30");
+      expect(secondPass).toContain("01:30");
+      // Identical wall clocks; the abbreviation is what tells them apart.
+      expect(firstPass).toContain("EDT");
+      expect(secondPass).toContain("EST");
+    });
+
+    it("still omits the abbreviation when only the date is shown", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const dateOnly: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-01-15T18:00:00Z"),
+        true,
+      );
+
+      expect(dateOnly).toBe("Jan 15, 2026");
+    });
+
     it("reads the hour and minute of an instant in the user timezone", () => {
       OneUptimeDate.setUserTimezone(KOLKATA);
 

package/Tests/Types/Day/DayOfWeek.test.ts

@@ -0,0 +1,46 @@
+import DayOfWeek, { DayOfWeekUtil } from "../../../Types/Day/DayOfWeek";
+import { describe, expect, test } from "@jest/globals";
+
+describe("DayOfWeekUtil.getNumberOfDayOfWeek", () => {
+  test("maps each day to its JS Date index (Sunday=0 … Saturday=6)", () => {
+    expect(DayOfWeekUtil.getNumberOfDayOfWeek(DayOfWeek.Sunday)).toBe(0);
+    expect(DayOfWeekUtil.getNumberOfDayOfWeek(DayOfWeek.Monday)).toBe(1);
+    expect(DayOfWeekUtil.getNumberOfDayOfWeek(DayOfWeek.Tuesday)).toBe(2);
+    expect(DayOfWeekUtil.getNumberOfDayOfWeek(DayOfWeek.Wednesday)).toBe(3);
+    expect(DayOfWeekUtil.getNumberOfDayOfWeek(DayOfWeek.Thursday)).toBe(4);
+    expect(DayOfWeekUtil.getNumberOfDayOfWeek(DayOfWeek.Friday)).toBe(5);
+    expect(DayOfWeekUtil.getNumberOfDayOfWeek(DayOfWeek.Saturday)).toBe(6);
+  });
+
+  test("agrees with the native Date.getDay() for a known week", () => {
+    // 2024-01-07 is a Sunday; the following seven days walk the whole week.
+    const days: Array<DayOfWeek> = [
+      DayOfWeek.Sunday,
+      DayOfWeek.Monday,
+      DayOfWeek.Tuesday,
+      DayOfWeek.Wednesday,
+      DayOfWeek.Thursday,
+      DayOfWeek.Friday,
+      DayOfWeek.Saturday,
+    ];
+
+    days.forEach((day: DayOfWeek, index: number) => {
+      const date: Date = new Date(Date.UTC(2024, 0, 7 + index));
+      expect(DayOfWeekUtil.getNumberOfDayOfWeek(day)).toBe(date.getUTCDay());
+    });
+  });
+
+  test("returns unique indices for all seven days", () => {
+    const allDays: Array<DayOfWeek> = Object.values(DayOfWeek);
+    const indices: Array<number> = allDays.map((day: DayOfWeek) => {
+      return DayOfWeekUtil.getNumberOfDayOfWeek(day);
+    });
+
+    expect(new Set(indices).size).toBe(7);
+    expect(
+      indices.sort((a: number, b: number) => {
+        return a - b;
+      }),
+    ).toEqual([0, 1, 2, 3, 4, 5, 6]);
+  });
+});

package/Tests/Types/Docker/DockerInventoryExtractor.test.ts

@@ -0,0 +1,249 @@
+import { ParsedDockerResource } from "../../../Server/Services/DockerResourceService";
+import {
+  INVENTORIED_DOCKER_KINDS,
+  INVENTORY_KIND_ATTRIBUTE,
+  canonicalDockerKind,
+  extractDockerInventoryResource,
+  isInventoriedDockerKind,
+} from "../../../Types/Docker/DockerInventoryExtractor";
+import { describe, expect, it } from "@jest/globals";
+
+const lastSeenAt: Date = new Date("2026-07-31T12:00:00.000Z");
+
+type ExtractFunction = (
+  kind: string,
+  body: unknown,
+) => ParsedDockerResource | null;
+
+// Convenience: JSON-encode the body the way an inventory log line arrives.
+const extract: ExtractFunction = (
+  kind: string,
+  body: unknown,
+): ParsedDockerResource | null => {
+  const result: { resource: ParsedDockerResource } | null =
+    extractDockerInventoryResource({
+      kind,
+      logBody: typeof body === "string" ? body : JSON.stringify(body),
+      lastSeenAt,
+    });
+  return result ? result.resource : null;
+};
+
+describe("DockerInventoryExtractor constants", () => {
+  it("exposes the kind attribute key the agent stamps", () => {
+    expect(INVENTORY_KIND_ATTRIBUTE).toBe("oneuptime.docker.kind");
+  });
+
+  it("models exactly the four docker resource kinds", () => {
+    expect([...INVENTORIED_DOCKER_KINDS]).toEqual([
+      "Container",
+      "Image",
+      "Network",
+      "Volume",
+    ]);
+  });
+});
+
+describe("isInventoriedDockerKind", () => {
+  it("accepts canonical kinds case-insensitively", () => {
+    expect(isInventoriedDockerKind("Container")).toBe(true);
+    expect(isInventoriedDockerKind("container")).toBe(true);
+    expect(isInventoriedDockerKind("VOLUME")).toBe(true);
+  });
+
+  it("rejects kinds that are not modeled", () => {
+    expect(isInventoriedDockerKind("Secret")).toBe(false);
+    expect(isInventoriedDockerKind("")).toBe(false);
+  });
+});
+
+describe("canonicalDockerKind", () => {
+  it("maps singular, plural and mixed case to canonical PascalCase", () => {
+    expect(canonicalDockerKind("container")).toBe("Container");
+    expect(canonicalDockerKind("Containers")).toBe("Container");
+    expect(canonicalDockerKind("  IMAGES  ")).toBe("Image");
+    expect(canonicalDockerKind("network")).toBe("Network");
+    expect(canonicalDockerKind("Volumes")).toBe("Volume");
+  });
+
+  it("returns null for empty, whitespace and unknown kinds", () => {
+    expect(canonicalDockerKind("")).toBeNull();
+    expect(canonicalDockerKind("   ")).toBeNull();
+    expect(canonicalDockerKind("pod")).toBeNull();
+  });
+});
+
+describe("extractDockerInventoryResource - guard cases", () => {
+  it("returns null for an unmodeled kind", () => {
+    expect(extract("Secret", { Name: "x" })).toBeNull();
+  });
+
+  it("returns null for malformed JSON in the log body", () => {
+    expect(extract("Container", "{not json")).toBeNull();
+  });
+
+  it("returns null when the body is a JSON array, not an object", () => {
+    expect(extract("Container", [1, 2, 3])).toBeNull();
+  });
+
+  it("returns null when the body is a JSON primitive", () => {
+    expect(extract("Container", "42")).toBeNull();
+  });
+});
+
+describe("extractDockerInventoryResource - Container", () => {
+  it("parses a docker CLI container envelope", () => {
+    const resource: ParsedDockerResource | null = extract("Container", {
+      kind: "Container",
+      data: {
+        Id: "abcdef0123456789deadbeef",
+        Names: "/web,/web-1",
+        Image: "nginx:latest",
+        State: "RUNNING",
+        CreatedAt: "2026-07-30T10:00:00.000Z",
+        Labels: { app: "web" },
+      },
+    });
+
+    expect(resource).not.toBeNull();
+    expect(resource!.kind).toBe("Container");
+    // Leading slash stripped, first name only.
+    expect(resource!.name).toBe("web");
+    // Container id truncated to the short 12-char form.
+    expect(resource!.containerId).toBe("abcdef012345");
+    expect(resource!.imageName).toBe("nginx:latest");
+    // State is lowercased.
+    expect(resource!.state).toBe("running");
+    expect(resource!.labels).toEqual({ app: "web" });
+    expect(resource!.lastSeenAt).toBe(lastSeenAt);
+    expect(resource!.resourceCreationTimestamp).not.toBeNull();
+    expect(resource!.resourceCreationTimestamp!.getTime()).toBe(
+      new Date("2026-07-30T10:00:00.000Z").getTime(),
+    );
+  });
+
+  it("accepts a raw payload without the { kind, data } envelope", () => {
+    const resource: ParsedDockerResource | null = extract("container", {
+      Id: "0123456789ab",
+      Names: "api",
+    });
+
+    expect(resource).not.toBeNull();
+    expect(resource!.name).toBe("api");
+    expect(resource!.containerId).toBe("0123456789ab");
+  });
+
+  it("falls back to the Name field when Names is absent", () => {
+    const resource: ParsedDockerResource | null = extract("Container", {
+      Name: "/solo",
+    });
+    expect(resource!.name).toBe("solo");
+  });
+
+  it("returns null when a container has no usable name", () => {
+    expect(extract("Container", { Id: "abc", Names: " , ," })).toBeNull();
+  });
+
+  it("leaves optional fields null when absent", () => {
+    const resource: ParsedDockerResource | null = extract("Container", {
+      Names: "bare",
+    });
+    expect(resource!.containerId).toBeNull();
+    expect(resource!.imageName).toBeNull();
+    expect(resource!.state).toBeNull();
+    expect(resource!.labels).toBeNull();
+    expect(resource!.resourceCreationTimestamp).toBeNull();
+  });
+
+  it("treats an unparseable CreatedAt as no timestamp", () => {
+    const resource: ParsedDockerResource | null = extract("Container", {
+      Names: "web",
+      CreatedAt: "not-a-timestamp",
+    });
+    expect(resource!.resourceCreationTimestamp).toBeNull();
+  });
+});
+
+describe("extractDockerInventoryResource - Image", () => {
+  it("builds the name from Repository and Tag", () => {
+    const resource: ParsedDockerResource | null = extract("Image", {
+      ID: "sha256:abcdef0123456789",
+      Repository: "nginx",
+      Tag: "1.25",
+    });
+    expect(resource!.name).toBe("nginx:1.25");
+    // sha256: prefix stripped, then truncated to 12.
+    expect(resource!.containerId).toBe("abcdef012345");
+    expect(resource!.imageName).toBeNull();
+  });
+
+  it("uses only the repository when the tag is <none>", () => {
+    const resource: ParsedDockerResource | null = extract("Image", {
+      Repository: "nginx",
+      Tag: "<none>",
+    });
+    expect(resource!.name).toBe("nginx");
+  });
+
+  it("skips a dangling image whose repository is <none>", () => {
+    expect(
+      extract("Image", { Repository: "<none>", Tag: "<none>" }),
+    ).toBeNull();
+  });
+
+  it("prefers an explicit Name field when provided", () => {
+    const resource: ParsedDockerResource | null = extract("Image", {
+      Name: "custom/image:v2",
+      Repository: "ignored",
+      Tag: "ignored",
+    });
+    expect(resource!.name).toBe("custom/image:v2");
+  });
+});
+
+describe("extractDockerInventoryResource - Network", () => {
+  it("encodes driver and scope into the state column", () => {
+    const resource: ParsedDockerResource | null = extract("Network", {
+      ID: "netid00000011112222",
+      Name: "bridge",
+      Driver: "bridge",
+      Scope: "local",
+    });
+    expect(resource!.kind).toBe("Network");
+    expect(resource!.name).toBe("bridge");
+    expect(resource!.state).toBe("bridge/local");
+    expect(resource!.containerId).toBe("netid0000001");
+  });
+
+  it("returns null for a network without a name", () => {
+    expect(extract("Network", { Driver: "bridge" })).toBeNull();
+  });
+
+  it("leaves state null when neither driver nor scope is present", () => {
+    const resource: ParsedDockerResource | null = extract("Network", {
+      Name: "isolated",
+    });
+    expect(resource!.state).toBeNull();
+  });
+});
+
+describe("extractDockerInventoryResource - Volume", () => {
+  it("parses a volume and never sets a containerId", () => {
+    const resource: ParsedDockerResource | null = extract("Volume", {
+      Name: "data",
+      Driver: "local",
+      Scope: "local",
+      Labels: { backup: "true" },
+    });
+    expect(resource!.kind).toBe("Volume");
+    expect(resource!.name).toBe("data");
+    expect(resource!.state).toBe("local/local");
+    expect(resource!.containerId).toBeNull();
+    expect(resource!.imageName).toBeNull();
+    expect(resource!.labels).toEqual({ backup: "true" });
+  });
+
+  it("returns null for a volume without a name", () => {
+    expect(extract("Volume", { Driver: "local" })).toBeNull();
+  });
+});

package/Tests/Types/Kubernetes/KubernetesInventoryExtractor.test.ts

@@ -0,0 +1,231 @@
+import {
+  INVENTORIED_RESOURCE_TYPES,
+  ParsedKubernetesContainerRow,
+  extractContainersFromPod,
+  extractInventoryResource,
+  kindFromResourceType,
+} from "../../../Types/Kubernetes/KubernetesInventoryExtractor";
+import { KubernetesPodObject } from "../../../Types/Kubernetes/KubernetesObjectParser";
+import { describe, expect, test } from "@jest/globals";
+
+const lastSeenAt: Date = new Date("2026-07-31T12:00:00.000Z");
+
+// Build a minimally-typed Pod object; only the fields the extractor reads.
+const makePod: (input: unknown) => KubernetesPodObject = (
+  input: unknown,
+): KubernetesPodObject => {
+  return input as KubernetesPodObject;
+};
+
+describe("kindFromResourceType", () => {
+  test("maps every inventoried plural resource type to its PascalCase Kind", () => {
+    expect(kindFromResourceType("pods")).toBe("Pod");
+    expect(kindFromResourceType("nodes")).toBe("Node");
+    expect(kindFromResourceType("namespaces")).toBe("Namespace");
+    expect(kindFromResourceType("deployments")).toBe("Deployment");
+    expect(kindFromResourceType("statefulsets")).toBe("StatefulSet");
+    expect(kindFromResourceType("daemonsets")).toBe("DaemonSet");
+    expect(kindFromResourceType("jobs")).toBe("Job");
+    expect(kindFromResourceType("cronjobs")).toBe("CronJob");
+    expect(kindFromResourceType("persistentvolumeclaims")).toBe(
+      "PersistentVolumeClaim",
+    );
+    expect(kindFromResourceType("persistentvolumes")).toBe("PersistentVolume");
+    expect(kindFromResourceType("horizontalpodautoscalers")).toBe(
+      "HorizontalPodAutoscaler",
+    );
+    expect(kindFromResourceType("verticalpodautoscalers")).toBe(
+      "VerticalPodAutoscaler",
+    );
+  });
+
+  test("is case-insensitive on the resource type", () => {
+    expect(kindFromResourceType("Pods")).toBe("Pod");
+    expect(kindFromResourceType("CRONJOBS")).toBe("CronJob");
+  });
+
+  test("returns null for unrecognized resource types", () => {
+    expect(kindFromResourceType("secrets")).toBeNull();
+    expect(kindFromResourceType("")).toBeNull();
+    expect(kindFromResourceType("configmaps")).toBeNull();
+  });
+
+  test("INVENTORIED_RESOURCE_TYPES only contains recognized types", () => {
+    for (const resourceType of INVENTORIED_RESOURCE_TYPES) {
+      expect(kindFromResourceType(resourceType)).not.toBeNull();
+    }
+    expect(INVENTORIED_RESOURCE_TYPES).toContain("pods");
+    expect(INVENTORIED_RESOURCE_TYPES.length).toBe(12);
+  });
+});
+
+describe("extractContainersFromPod", () => {
+  test("returns one row per spec container, merging status by name", () => {
+    const pod: KubernetesPodObject = makePod({
+      metadata: { name: "web-abc", namespace: "prod" },
+      spec: {
+        containers: [
+          {
+            name: "app",
+            image: "nginx:1.25",
+            resources: { limits: { memory: "256Mi" } },
+          },
+          { name: "sidecar", image: "envoy:1.29" },
+        ],
+      },
+      status: {
+        containerStatuses: [
+          {
+            name: "app",
+            state: "running",
+            reason: "",
+            ready: true,
+            restartCount: 2,
+          },
+        ],
+      },
+    });
+
+    const rows: Array<ParsedKubernetesContainerRow> = extractContainersFromPod({
+      parsedPod: pod,
+      lastSeenAt,
+    });
+
+    expect(rows.length).toBe(2);
+
+    const appRow: ParsedKubernetesContainerRow = rows[0]!;
+    expect(appRow.podName).toBe("web-abc");
+    expect(appRow.podNamespaceKey).toBe("prod");
+    expect(appRow.name).toBe("app");
+    expect(appRow.image).toBe("nginx:1.25");
+    expect(appRow.state).toBe("running");
+    expect(appRow.isReady).toBe(true);
+    expect(appRow.restartCount).toBe(2);
+    expect(appRow.memoryLimitBytes).toBe(256 * 1024 * 1024);
+    expect(appRow.lastSeenAt).toBe(lastSeenAt);
+
+    // No status for the sidecar -> status-derived fields stay null.
+    const sidecarRow: ParsedKubernetesContainerRow = rows[1]!;
+    expect(sidecarRow.name).toBe("sidecar");
+    expect(sidecarRow.image).toBe("envoy:1.29");
+    expect(sidecarRow.state).toBeNull();
+    expect(sidecarRow.isReady).toBeNull();
+    expect(sidecarRow.restartCount).toBeNull();
+    expect(sidecarRow.memoryLimitBytes).toBeNull();
+  });
+
+  test("parses binary and decimal memory units to bytes", () => {
+    const expectations: Array<[string, number]> = [
+      ["512Ki", 512 * 1024],
+      ["1Gi", 1024 * 1024 * 1024],
+      ["2Ti", 2 * 1024 * 1024 * 1024 * 1024],
+      ["512M", 512 * 1000 * 1000],
+      ["1G", 1000 * 1000 * 1000],
+      ["2048", 2048],
+    ];
+
+    for (const [raw, expected] of expectations) {
+      const rows: Array<ParsedKubernetesContainerRow> =
+        extractContainersFromPod({
+          parsedPod: makePod({
+            metadata: { name: "p", namespace: "n" },
+            spec: {
+              containers: [
+                { name: "c", resources: { limits: { memory: raw } } },
+              ],
+            },
+          }),
+          lastSeenAt,
+        });
+      expect(rows[0]!.memoryLimitBytes).toBe(expected);
+    }
+  });
+
+  test("leaves memoryLimitBytes null for an unparseable memory string", () => {
+    const rows: Array<ParsedKubernetesContainerRow> = extractContainersFromPod({
+      parsedPod: makePod({
+        metadata: { name: "p", namespace: "n" },
+        spec: {
+          containers: [
+            { name: "c", resources: { limits: { memory: "not-a-size" } } },
+          ],
+        },
+      }),
+      lastSeenAt,
+    });
+    expect(rows[0]!.memoryLimitBytes).toBeNull();
+  });
+
+  test("falls back to the status image when the spec image is empty", () => {
+    const rows: Array<ParsedKubernetesContainerRow> = extractContainersFromPod({
+      parsedPod: makePod({
+        metadata: { name: "p", namespace: "n" },
+        spec: { containers: [{ name: "c", image: "" }] },
+        status: {
+          containerStatuses: [
+            { name: "c", image: "resolved@sha256:abc", ready: false },
+          ],
+        },
+      }),
+      lastSeenAt,
+    });
+    expect(rows[0]!.image).toBe("resolved@sha256:abc");
+    expect(rows[0]!.isReady).toBe(false);
+  });
+
+  test("skips containers with no name and pods with no metadata name", () => {
+    const skippedUnnamed: Array<ParsedKubernetesContainerRow> =
+      extractContainersFromPod({
+        parsedPod: makePod({
+          metadata: { name: "p", namespace: "n" },
+          spec: { containers: [{ name: "" }, { name: "real" }] },
+        }),
+        lastSeenAt,
+      });
+    expect(
+      skippedUnnamed.map((r: ParsedKubernetesContainerRow) => {
+        return r.name;
+      }),
+    ).toEqual(["real"]);
+
+    const noPodName: Array<ParsedKubernetesContainerRow> =
+      extractContainersFromPod({
+        parsedPod: makePod({ metadata: {}, spec: { containers: [] } }),
+        lastSeenAt,
+      });
+    expect(noPodName).toEqual([]);
+  });
+
+  test("defaults the namespace key to empty string when absent", () => {
+    const rows: Array<ParsedKubernetesContainerRow> = extractContainersFromPod({
+      parsedPod: makePod({
+        metadata: { name: "cluster-pod" },
+        spec: { containers: [{ name: "c" }] },
+      }),
+      lastSeenAt,
+    });
+    expect(rows[0]!.podNamespaceKey).toBe("");
+  });
+});
+
+describe("extractInventoryResource", () => {
+  test("returns null for an unrecognized resource type", () => {
+    expect(
+      extractInventoryResource({
+        resourceType: "secrets",
+        logBody: "{}",
+        lastSeenAt,
+      }),
+    ).toBeNull();
+  });
+
+  test("returns null when the log body cannot be parsed into an object", () => {
+    expect(
+      extractInventoryResource({
+        resourceType: "pods",
+        logBody: "this is not a k8s object",
+        lastSeenAt,
+      }),
+    ).toBeNull();
+  });
+});