@oneuptime/common 12.0.25 → 12.0.26

package/Tests/Server/Services/ResourceFeedServices.test.ts

@@ -0,0 +1,269 @@
+import fs from "fs";
+import path from "path";
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * PasswordHash carries a pre-existing TS5.9 diagnostic that fails any suite
+ * whose runtime require graph reaches it, and DatabaseService - the base class
+ * of every service below - imports it.
+ */
+jest.mock("../../../Server/Utils/PasswordHash", () => {
+  return {
+    __esModule: true,
+    default: {
+      hash: jest.fn(),
+      verify: jest.fn(),
+      generateSalt: jest.fn(),
+      needsUpgrade: jest.fn(),
+      applyPepper: jest.fn(),
+    },
+  };
+});
+
+import KubernetesClusterFeedService from "../../../Server/Services/KubernetesClusterFeedService";
+import KubernetesClusterFeed, {
+  KubernetesClusterFeedEventType,
+} from "../../../Models/DatabaseModels/KubernetesClusterFeed";
+import { Blue500, Green500 } from "../../../Types/BrandColors";
+import ObjectID from "../../../Types/ObjectID";
+
+const SERVICES_DIRECTORY: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "Server",
+  "Services",
+);
+
+const SERVICES_INDEX: string = fs.readFileSync(
+  path.join(SERVICES_DIRECTORY, "Index.ts"),
+  "utf8",
+);
+
+const BASE_API_INDEX: string = fs.readFileSync(
+  path.join(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "..",
+    "App",
+    "FeatureSet",
+    "BaseAPI",
+    "Index.ts",
+  ),
+  "utf8",
+);
+
+/*
+ * The nine resources that gained an activity feed. Written out rather than
+ * globbed so that adding a tenth is a deliberate edit here as well as a new
+ * file - the wiring below is exactly what gets forgotten when a family is
+ * added by copying another one.
+ */
+const FEED_SERVICE_NAMES: Array<string> = [
+  "KubernetesClusterFeedService",
+  "DockerHostFeedService",
+  "DockerSwarmClusterFeedService",
+  "CephClusterFeedService",
+  "PodmanHostFeedService",
+  "ProxmoxClusterFeedService",
+  "HostFeedService",
+  "CloudResourceFeedService",
+  "ServiceFeedService",
+];
+
+function readService(serviceName: string): string {
+  return fs.readFileSync(
+    path.join(SERVICES_DIRECTORY, `${serviceName}.ts`),
+    "utf8",
+  );
+}
+
+describe("Resource feed service wiring", () => {
+  test.each(FEED_SERVICE_NAMES)("%s exists on disk", (serviceName: string) => {
+    expect(
+      fs.existsSync(path.join(SERVICES_DIRECTORY, `${serviceName}.ts`)),
+    ).toBe(true);
+  });
+
+  test.each(FEED_SERVICE_NAMES)(
+    "%s is registered in Server/Services/Index.ts",
+    (serviceName: string) => {
+      /*
+       * That array is what boot-time createTables() and the hard-delete job
+       * iterate. An unregistered service has no table and its retention window
+       * is dead configuration - see FeedRetentionConsistency.test.ts, written
+       * after exactly that happened to OnCallDutyPolicyFeedService.
+       */
+      expect(SERVICES_INDEX).toContain(
+        `import ${serviceName} from "./${serviceName}";`,
+      );
+      expect(SERVICES_INDEX).toMatch(
+        new RegExp(`^\\s{2}${serviceName},$`, "m"),
+      );
+    },
+  );
+
+  test.each(FEED_SERVICE_NAMES)(
+    "%s declares the common three year retention window",
+    (serviceName: string) => {
+      expect(readService(serviceName)).toContain(
+        'this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);',
+      );
+    },
+  );
+
+  test.each(FEED_SERVICE_NAMES)(
+    "%s is served over the API",
+    (serviceName: string) => {
+      /*
+       * The feed page reads through ModelAPI, so a model and service with no
+       * BaseAPI router renders an empty feed and a 404 in the console rather
+       * than failing anywhere a test would normally look.
+       */
+      const modelName: string = serviceName.replace(/Service$/, "");
+      expect(BASE_API_INDEX).toContain(
+        `import ${serviceName}, {\n  Service as ${serviceName}Type,\n} from "Common/Server/Services/${serviceName}";`,
+      );
+      expect(BASE_API_INDEX).toContain(
+        `new BaseAPI<${modelName}, ${serviceName}Type>(`,
+      );
+    },
+  );
+});
+
+describe("KubernetesClusterFeedService.createKubernetesClusterFeedItem", () => {
+  const CLUSTER_ID: ObjectID = ObjectID.generate();
+  const PROJECT_ID: ObjectID = ObjectID.generate();
+  const USER_ID: ObjectID = ObjectID.generate();
+
+  let created: Array<KubernetesClusterFeed> = [];
+
+  beforeEach(() => {
+    created = [];
+    jest
+      .spyOn(KubernetesClusterFeedService, "create")
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockImplementation((data: any): Promise<KubernetesClusterFeed> => {
+        created.push(data.data as KubernetesClusterFeed);
+        return Promise.resolve(data.data as KubernetesClusterFeed);
+      });
+  });
+
+  test("writes the item with the event, colour and acting user", async () => {
+    await KubernetesClusterFeedService.createKubernetesClusterFeedItem({
+      kubernetesClusterId: CLUSTER_ID,
+      projectId: PROJECT_ID,
+      kubernetesClusterFeedEventType:
+        KubernetesClusterFeedEventType.KubernetesClusterCreated,
+      displayColor: Green500,
+      feedInfoInMarkdown: "cluster created",
+      moreInformationInMarkdown: "more",
+      userId: USER_ID,
+    });
+
+    expect(created.length).toBe(1);
+    const item: KubernetesClusterFeed = created[0]!;
+    expect(item.kubernetesClusterId).toBe(CLUSTER_ID);
+    expect(item.projectId).toBe(PROJECT_ID);
+    expect(item.kubernetesClusterFeedEventType).toBe(
+      KubernetesClusterFeedEventType.KubernetesClusterCreated,
+    );
+    expect(item.feedInfoInMarkdown).toBe("cluster created");
+    expect(item.moreInformationInMarkdown).toBe("more");
+    expect(item.userId).toBe(USER_ID);
+    expect(item.displayColor).toBe(Green500);
+  });
+
+  test("stamps postedAt so the feed can be ordered by it", async () => {
+    /*
+     * The feed page sorts on postedAt, and the detail-page index is
+     * (clusterId, postedAt). A row with a null postedAt sorts unpredictably
+     * and can vanish from the middle of the timeline.
+     */
+    await KubernetesClusterFeedService.createKubernetesClusterFeedItem({
+      kubernetesClusterId: CLUSTER_ID,
+      projectId: PROJECT_ID,
+      kubernetesClusterFeedEventType:
+        KubernetesClusterFeedEventType.OwnerUserAdded,
+      feedInfoInMarkdown: "owner added",
+    });
+
+    expect(created[0]!.postedAt).toBeInstanceOf(Date);
+  });
+
+  test("honours an explicit postedAt", async () => {
+    const postedAt: Date = new Date("2024-01-15T10:30:00.000Z");
+
+    await KubernetesClusterFeedService.createKubernetesClusterFeedItem({
+      kubernetesClusterId: CLUSTER_ID,
+      projectId: PROJECT_ID,
+      kubernetesClusterFeedEventType:
+        KubernetesClusterFeedEventType.OwnerUserAdded,
+      feedInfoInMarkdown: "owner added",
+      postedAt: postedAt,
+    });
+
+    expect(created[0]!.postedAt).toBe(postedAt);
+  });
+
+  test("defaults the colour so the timeline never renders a colourless dot", async () => {
+    await KubernetesClusterFeedService.createKubernetesClusterFeedItem({
+      kubernetesClusterId: CLUSTER_ID,
+      projectId: PROJECT_ID,
+      kubernetesClusterFeedEventType:
+        KubernetesClusterFeedEventType.OwnerUserAdded,
+      feedInfoInMarkdown: "owner added",
+    });
+
+    expect(created[0]!.displayColor).toBe(Blue500);
+  });
+
+  test.each([
+    ["kubernetesClusterId", { kubernetesClusterId: undefined }],
+    ["projectId", { projectId: undefined }],
+    ["feedInfoInMarkdown", { feedInfoInMarkdown: "" }],
+  ])(
+    "writes nothing, and does not throw, when %s is missing",
+    async (_name: string, override: Record<string, unknown>) => {
+      /*
+       * Every caller is a side effect of a write that already succeeded - an
+       * owner being added, a cluster being created. Throwing here would roll
+       * back or fail the thing the feed is merely describing.
+       */
+      await expect(
+        KubernetesClusterFeedService.createKubernetesClusterFeedItem({
+          kubernetesClusterId: CLUSTER_ID,
+          projectId: PROJECT_ID,
+          kubernetesClusterFeedEventType:
+            KubernetesClusterFeedEventType.OwnerUserAdded,
+          feedInfoInMarkdown: "owner added",
+          ...override,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } as any),
+      ).resolves.toBeUndefined();
+
+      expect(created.length).toBe(0);
+    },
+  );
+
+  test("swallows a failing write rather than failing its caller", async () => {
+    jest
+      .spyOn(KubernetesClusterFeedService, "create")
+      .mockImplementation((): Promise<KubernetesClusterFeed> => {
+        return Promise.reject(new Error("postgres is down"));
+      });
+
+    await expect(
+      KubernetesClusterFeedService.createKubernetesClusterFeedItem({
+        kubernetesClusterId: CLUSTER_ID,
+        projectId: PROJECT_ID,
+        kubernetesClusterFeedEventType:
+          KubernetesClusterFeedEventType.OwnerUserAdded,
+        feedInfoInMarkdown: "owner added",
+      }),
+    ).resolves.toBeUndefined();
+  });
+});

package/Tests/Server/Services/ResourceOwnerFeedWrites.test.ts

@@ -0,0 +1,245 @@
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * PasswordHash carries a pre-existing TS5.9 diagnostic that fails any suite
+ * whose runtime require graph reaches it, and DatabaseService imports it.
+ */
+jest.mock("../../../Server/Utils/PasswordHash", () => {
+  return {
+    __esModule: true,
+    default: {
+      hash: jest.fn(),
+      verify: jest.fn(),
+      generateSalt: jest.fn(),
+      needsUpgrade: jest.fn(),
+      applyPepper: jest.fn(),
+    },
+  };
+});
+
+import KubernetesClusterOwnerUserService from "../../../Server/Services/KubernetesClusterOwnerUserService";
+import KubernetesClusterOwnerTeamService from "../../../Server/Services/KubernetesClusterOwnerTeamService";
+import KubernetesClusterFeedService from "../../../Server/Services/KubernetesClusterFeedService";
+import KubernetesClusterService from "../../../Server/Services/KubernetesClusterService";
+import UserService from "../../../Server/Services/UserService";
+import TeamService from "../../../Server/Services/TeamService";
+import KubernetesClusterOwnerUser from "../../../Models/DatabaseModels/KubernetesClusterOwnerUser";
+import KubernetesClusterOwnerTeam from "../../../Models/DatabaseModels/KubernetesClusterOwnerTeam";
+import { KubernetesClusterFeedEventType } from "../../../Models/DatabaseModels/KubernetesClusterFeed";
+import Team from "../../../Models/DatabaseModels/Team";
+import User from "../../../Models/DatabaseModels/User";
+import Name from "../../../Types/Name";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * Owners are the part of a resource's history people actually get paged about,
+ * and until now nothing recorded when one changed: a Kubernetes cluster's
+ * owner list showed who is on the hook today with no way to see who used to be
+ * or who put them there. These four hooks are what write that history, and all
+ * four are easy to lose - the delete pair in particular, because the rows are
+ * already gone by the time onDeleteSuccess runs, so the ids have to be carried
+ * forward from onBeforeDelete or the feed item silently never happens.
+ */
+
+const CLUSTER_ID: ObjectID = ObjectID.generate();
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const USER_ID: ObjectID = ObjectID.generate();
+const TEAM_ID: ObjectID = ObjectID.generate();
+const ACTING_USER_ID: ObjectID = ObjectID.generate();
+
+interface FeedCall {
+  kubernetesClusterId: ObjectID;
+  projectId: ObjectID;
+  kubernetesClusterFeedEventType: KubernetesClusterFeedEventType;
+  feedInfoInMarkdown: string;
+  userId?: ObjectID | undefined;
+}
+
+let feedCalls: Array<FeedCall> = [];
+
+beforeEach(() => {
+  feedCalls = [];
+
+  jest
+    .spyOn(KubernetesClusterFeedService, "createKubernetesClusterFeedItem")
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .mockImplementation((data: any): Promise<void> => {
+      feedCalls.push(data as FeedCall);
+      return Promise.resolve();
+    });
+
+  jest
+    .spyOn(KubernetesClusterService, "getKubernetesClusterMarkdownLink")
+    .mockImplementation((): Promise<string> => {
+      return Promise.resolve(
+        "[Kubernetes Cluster prod](https://example.com/cluster)",
+      );
+    });
+
+  jest
+    .spyOn(UserService, "getUserMarkdownString")
+    .mockImplementation((): Promise<string> => {
+      return Promise.resolve("Jane Doe (jane@example.com)");
+    });
+});
+
+describe("KubernetesClusterOwnerUserService feed writes", () => {
+  test("records the owner and who added them", async () => {
+    const createdItem: KubernetesClusterOwnerUser =
+      new KubernetesClusterOwnerUser();
+    createdItem.kubernetesClusterId = CLUSTER_ID;
+    createdItem.projectId = PROJECT_ID;
+    createdItem.userId = USER_ID;
+
+    await KubernetesClusterOwnerUserService.onCreateSuccess(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { createBy: { props: { userId: ACTING_USER_ID } } } as any,
+      createdItem,
+    );
+
+    expect(feedCalls.length).toBe(1);
+    expect(feedCalls[0]!.kubernetesClusterFeedEventType).toBe(
+      KubernetesClusterFeedEventType.OwnerUserAdded,
+    );
+    expect(feedCalls[0]!.kubernetesClusterId).toBe(CLUSTER_ID);
+    expect(feedCalls[0]!.feedInfoInMarkdown).toContain("Jane Doe");
+    expect(feedCalls[0]!.feedInfoInMarkdown).toContain(
+      "[Kubernetes Cluster prod](https://example.com/cluster)",
+    );
+    // Who did the adding, not who was added.
+    expect(feedCalls[0]!.userId).toBe(ACTING_USER_ID);
+  });
+
+  test("writes nothing when the row is missing its cluster or user", async () => {
+    const createdItem: KubernetesClusterOwnerUser =
+      new KubernetesClusterOwnerUser();
+    createdItem.projectId = PROJECT_ID;
+
+    await KubernetesClusterOwnerUserService.onCreateSuccess(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { createBy: { props: {} } } as any,
+      createdItem,
+    );
+
+    expect(feedCalls.length).toBe(0);
+  });
+
+  test("carries the deleted row forward so the removal can be described", async () => {
+    /*
+     * onDeleteSuccess runs after the rows are gone. Reading them in
+     * onBeforeDelete is the only chance to learn which cluster and which user
+     * the removal was about.
+     */
+    const doomed: KubernetesClusterOwnerUser = new KubernetesClusterOwnerUser();
+    doomed.kubernetesClusterId = CLUSTER_ID;
+    doomed.projectId = PROJECT_ID;
+    doomed.userId = USER_ID;
+
+    jest
+      .spyOn(KubernetesClusterOwnerUserService, "findBy")
+      .mockImplementation((): Promise<Array<KubernetesClusterOwnerUser>> => {
+        return Promise.resolve([doomed]);
+      });
+
+    const user: User = new User(USER_ID);
+    user.name = new Name("Jane Doe");
+
+    jest
+      .spyOn(UserService, "findOneById")
+      .mockImplementation((): Promise<User | null> => {
+        return Promise.resolve(user);
+      });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const service: any = KubernetesClusterOwnerUserService as any;
+
+    const onDelete: unknown = await service.onBeforeDelete({
+      query: {},
+      props: { userId: ACTING_USER_ID },
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((onDelete as any).carryForward.itemsToDelete).toEqual([doomed]);
+
+    await service.onDeleteSuccess(
+      {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        deleteBy: (onDelete as any).deleteBy,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        carryForward: (onDelete as any).carryForward,
+      },
+      [],
+    );
+
+    expect(feedCalls.length).toBe(1);
+    expect(feedCalls[0]!.kubernetesClusterFeedEventType).toBe(
+      KubernetesClusterFeedEventType.OwnerUserRemoved,
+    );
+    expect(feedCalls[0]!.feedInfoInMarkdown).toContain("Jane Doe");
+    expect(feedCalls[0]!.userId).toBe(ACTING_USER_ID);
+  });
+});
+
+describe("KubernetesClusterOwnerTeamService feed writes", () => {
+  test("records the team that was added", async () => {
+    const team: Team = new Team(TEAM_ID);
+    team.name = "Platform";
+
+    jest
+      .spyOn(TeamService, "findOneById")
+      .mockImplementation((): Promise<Team | null> => {
+        return Promise.resolve(team);
+      });
+
+    const createdItem: KubernetesClusterOwnerTeam =
+      new KubernetesClusterOwnerTeam();
+    createdItem.kubernetesClusterId = CLUSTER_ID;
+    createdItem.projectId = PROJECT_ID;
+    createdItem.teamId = TEAM_ID;
+
+    await KubernetesClusterOwnerTeamService.onCreateSuccess(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { createBy: { props: { userId: ACTING_USER_ID } } } as any,
+      createdItem,
+    );
+
+    expect(feedCalls.length).toBe(1);
+    expect(feedCalls[0]!.kubernetesClusterFeedEventType).toBe(
+      KubernetesClusterFeedEventType.OwnerTeamAdded,
+    );
+    expect(feedCalls[0]!.feedInfoInMarkdown).toContain("Platform");
+  });
+
+  test("records the team that was removed", async () => {
+    const team: Team = new Team(TEAM_ID);
+    team.name = "Platform";
+
+    jest
+      .spyOn(TeamService, "findOneById")
+      .mockImplementation((): Promise<Team | null> => {
+        return Promise.resolve(team);
+      });
+
+    const doomed: KubernetesClusterOwnerTeam = new KubernetesClusterOwnerTeam();
+    doomed.kubernetesClusterId = CLUSTER_ID;
+    doomed.projectId = PROJECT_ID;
+    doomed.teamId = TEAM_ID;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const service: any = KubernetesClusterOwnerTeamService as any;
+
+    await service.onDeleteSuccess(
+      {
+        deleteBy: { props: { userId: ACTING_USER_ID } },
+        carryForward: { itemsToDelete: [doomed] },
+      },
+      [],
+    );
+
+    expect(feedCalls.length).toBe(1);
+    expect(feedCalls[0]!.kubernetesClusterFeedEventType).toBe(
+      KubernetesClusterFeedEventType.OwnerTeamRemoved,
+    );
+    expect(feedCalls[0]!.feedInfoInMarkdown).toContain("Platform");
+  });
+});