@topolo/sdk 0.4.7 → 0.4.9

package/src/widgets.test.ts

@@ -2,11 +2,23 @@ import { describe, expect, it } from "vitest";
 import {
   createTopoloWidgetError,
   createTopoloWidgetResponse,
+  defineTopoloChartWidget,
+  defineTopoloNotificationsWidget,
+  defineTopoloQuickActionsWidget,
+  defineTopoloRecentActivityWidget,
+  defineTopoloStatsWidget,
   TOPOLO_WIDGET_ENDPOINT,
   TOPOLO_WIDGET_REFRESH_INTERVAL_MS,
   validateTopoloWidgetResponse,
 } from "./widgets.js";
 
+const BASE = {
+  serviceId: "service_x",
+  serviceName: "X",
+  lastUpdated: "2026-04-25T00:00:00.000Z",
+  snapshot: { summary: "A summary that is long enough to read." },
+};
+
 describe("Topolo widget contract", () => {
   it("exports the platform widget endpoint defaults", () => {
     expect(TOPOLO_WIDGET_ENDPOINT).toBe("/api/widget");
@@ -177,6 +189,210 @@ describe("Topolo widget contract", () => {
     ]);
   });
 
+  it("stamps the literal type onto each define* helper", () => {
+    expect(defineTopoloStatsWidget({ ...BASE, stats: [] }).type).toBe("stats");
+    expect(
+      defineTopoloRecentActivityWidget({ ...BASE, activities: [] }).type,
+    ).toBe("recent-activity");
+    expect(
+      defineTopoloQuickActionsWidget({ ...BASE, actions: [] }).type,
+    ).toBe("quick-actions");
+    expect(
+      defineTopoloNotificationsWidget({ ...BASE, notifications: [], unreadCount: 0 })
+        .type,
+    ).toBe("notifications");
+    expect(
+      defineTopoloChartWidget({
+        ...BASE,
+        chartType: "line",
+        title: "Trend",
+        data: { labels: ["a"], values: [1] },
+      }).type,
+    ).toBe("chart");
+  });
+
+  it("derives lastUpdated from a Date instance passed as now", () => {
+    const response = createTopoloWidgetResponse({
+      serviceId: "service_x",
+      serviceName: "X",
+      now: new Date("2026-05-01T12:00:00.000Z"),
+      widgets: [
+        {
+          type: "stats",
+          snapshot: { summary: "Date branch summary content here." },
+          stats: [],
+        },
+      ],
+    });
+    expect(response.widgets[0]!.lastUpdated).toBe("2026-05-01T12:00:00.000Z");
+  });
+
+  it("generates a current timestamp when now is omitted", () => {
+    const before = Date.now();
+    const response = createTopoloWidgetResponse({
+      serviceId: "service_x",
+      serviceName: "X",
+      widgets: [
+        {
+          type: "stats",
+          snapshot: { summary: "Omitted-now summary content here." },
+          stats: [],
+        },
+      ],
+    });
+    const stamped = Date.parse(response.widgets[0]!.lastUpdated);
+    expect(stamped).toBeGreaterThanOrEqual(before);
+    expect(Number.isNaN(stamped)).toBe(false);
+  });
+
+  it("rejects a non-object response", () => {
+    expect(validateTopoloWidgetResponse(null)).toEqual({
+      ok: false,
+      errors: ["response must be an object"],
+    });
+  });
+
+  it("rejects a non-boolean success and a non-array widgets field", () => {
+    const result = validateTopoloWidgetResponse({ success: "yes", widgets: "nope" });
+    expect(result.ok).toBe(false);
+    expect(result.errors).toContain("success must be a boolean");
+    expect(result.errors).toContain("widgets must be an array");
+  });
+
+  it("flags a non-string error on a failed response", () => {
+    const result = validateTopoloWidgetResponse({
+      success: false,
+      widgets: [],
+      error: 42,
+    });
+    expect(result.errors).toContain("error must be a string when provided");
+  });
+
+  it("flags a chart widget whose data is not an object", () => {
+    const result = validateTopoloWidgetResponse({
+      success: true,
+      widgets: [
+        {
+          ...BASE,
+          type: "chart",
+          chartType: "bar",
+          title: "T",
+          data: "not-an-object",
+        },
+      ],
+    });
+    expect(result.errors).toContain("widgets[0].data must be an object");
+  });
+
+  it("flags non-number unreadCount and missing notifications array", () => {
+    const result = validateTopoloWidgetResponse({
+      success: true,
+      widgets: [
+        {
+          ...BASE,
+          type: "notifications",
+          notifications: "x",
+          unreadCount: "many",
+        },
+      ],
+    });
+    expect(result.errors).toContain("widgets[0].notifications must be an array");
+    expect(result.errors).toContain("widgets[0].unreadCount must be a number");
+  });
+
+  it("flags malformed snapshot metadata arrays and metric entries", () => {
+    const result = validateTopoloWidgetResponse({
+      success: true,
+      widgets: [
+        {
+          ...BASE,
+          snapshot: {
+            summary: "Snapshot with bad metadata arrays present here.",
+            defaultMetricKeys: "not-array",
+            highlights: "not-array",
+            availableMetrics: [{ key: "", label: "", value: "NaN" }],
+          },
+          type: "stats",
+          stats: [],
+        },
+      ],
+    });
+    expect(result.errors).toContain(
+      "widgets[0].snapshot.defaultMetricKeys must be an array when provided",
+    );
+    expect(result.errors).toContain(
+      "widgets[0].snapshot.highlights must be an array when provided",
+    );
+    expect(result.errors).toContain(
+      "widgets[0].snapshot.availableMetrics[0].key must be a non-empty string",
+    );
+    expect(result.errors).toContain(
+      "widgets[0].snapshot.availableMetrics[0].value must be a number",
+    );
+  });
+
+  it("flags availableMetrics when it is present but not an array", () => {
+    const result = validateTopoloWidgetResponse({
+      success: true,
+      widgets: [
+        {
+          ...BASE,
+          snapshot: {
+            summary: "Snapshot summary with bad availableMetrics field.",
+            availableMetrics: "nope",
+          },
+          type: "stats",
+          stats: [],
+        },
+      ],
+    });
+    expect(result.errors).toContain(
+      "widgets[0].snapshot.availableMetrics must be an array when provided",
+    );
+  });
+
+  it("flags a non-object widget entry and a missing snapshot", () => {
+    const result = validateTopoloWidgetResponse({
+      success: true,
+      widgets: [42],
+    });
+    expect(result.errors).toContain("widgets[0] must be an object");
+
+    const result2 = validateTopoloWidgetResponse({
+      success: true,
+      widgets: [
+        {
+          serviceId: "s",
+          serviceName: "n",
+          lastUpdated: "2026-04-25T00:00:00.000Z",
+          type: "stats",
+          stats: [],
+        },
+      ],
+    });
+    expect(result2.errors).toContain("widgets[0].snapshot must be an object");
+  });
+
+  it("flags a non-object availableMetrics entry", () => {
+    const result = validateTopoloWidgetResponse({
+      success: true,
+      widgets: [
+        {
+          ...BASE,
+          snapshot: {
+            summary: "Snapshot with a non-object metric entry here.",
+            availableMetrics: [42],
+          },
+          type: "stats",
+          stats: [],
+        },
+      ],
+    });
+    expect(result.errors).toContain(
+      "widgets[0].snapshot.availableMetrics[0] must be an object",
+    );
+  });
+
   it("reports missing snapshot summaries", () => {
     const result = validateTopoloWidgetResponse({
       success: true,