@wopr-network/platform-core 1.34.0 → 1.35.1

package/src/fleet/init-fleet-updater.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Tests the profile-filtering + onManualTenantsSkipped logic used inside initFleetUpdater.
+ *
+ * We can't import initFleetUpdater directly because it constructs ImagePoller,
+ * ContainerUpdater, etc. which pull in heavy dependencies that cause hangs.
+ * Instead, we replicate the getUpdatableProfiles closure from initFleetUpdater
+ * and test it in isolation via a RolloutOrchestrator with mock deps.
+ */
+import { describe, expect, it, vi } from "vitest";
+import type { IBotProfileRepository } from "./bot-profile-repository.js";
+import { RolloutOrchestrator } from "./rollout-orchestrator.js";
+import type { IRolloutStrategy } from "./rollout-strategy.js";
+import type { ITenantUpdateConfigRepository } from "./tenant-update-config-repository.js";
+import type { BotProfile } from "./types.js";
+import type { ContainerUpdater } from "./updater.js";
+import type { VolumeSnapshotManager } from "./volume-snapshot-manager.js";
+
+vi.mock("../config/logger.js", () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeProfileWithFields(fields: { id: string; tenantId: string; updatePolicy: "auto" | "manual" }): BotProfile {
+  return {
+    ...fields,
+    image: "ghcr.io/org/img:latest",
+  } as unknown as BotProfile;
+}
+
+function makeProfileRepo(profiles: BotProfile[]): IBotProfileRepository {
+  return {
+    list: vi.fn().mockResolvedValue(profiles),
+    get: vi
+      .fn()
+      .mockImplementation((id: string) =>
+        Promise.resolve(profiles.find((p) => (p as unknown as { id: string }).id === id) ?? null),
+      ),
+    save: vi.fn().mockResolvedValue(undefined),
+    delete: vi.fn().mockResolvedValue(false),
+  } as unknown as IBotProfileRepository;
+}
+
+function makeConfigRepo(
+  configs: Record<string, { mode: "auto" | "manual"; preferredHourUtc: number }> = {},
+): ITenantUpdateConfigRepository {
+  return {
+    get: vi.fn().mockImplementation((tenantId: string) => {
+      const cfg = configs[tenantId];
+      return Promise.resolve(cfg ? { tenantId, ...cfg, updatedAt: Date.now() } : null);
+    }),
+    upsert: vi.fn().mockResolvedValue(undefined),
+    listAutoEnabled: vi.fn().mockResolvedValue([]),
+  };
+}
+
+function makeMockUpdater(): ContainerUpdater {
+  return {
+    updateBot: vi.fn().mockResolvedValue({
+      botId: "",
+      success: true,
+      previousImage: "",
+      newImage: "",
+      previousDigest: null,
+      newDigest: null,
+      rolledBack: false,
+    }),
+  } as unknown as ContainerUpdater;
+}
+
+function makeMockSnapshotManager(): VolumeSnapshotManager {
+  return {
+    snapshot: vi.fn(),
+    restore: vi.fn(),
+    delete: vi.fn(),
+  } as unknown as VolumeSnapshotManager;
+}
+
+function makeMockStrategy(): IRolloutStrategy {
+  return {
+    nextBatch: vi.fn().mockImplementation((remaining: BotProfile[]) => remaining),
+    pauseDuration: vi.fn().mockReturnValue(0),
+    onBotFailure: vi.fn().mockReturnValue("skip" as const),
+    maxRetries: vi.fn().mockReturnValue(0),
+    healthCheckTimeout: vi.fn().mockReturnValue(0),
+  };
+}
+
+/**
+ * Builds the same getUpdatableProfiles closure that initFleetUpdater creates,
+ * so we can test the filtering + callback logic without importing the heavy module.
+ */
+function buildGetUpdatableProfiles(
+  profileRepo: IBotProfileRepository,
+  configRepo: ITenantUpdateConfigRepository | undefined,
+  onManualTenantsSkipped: ((tenantIds: string[], imageTag: string) => void) | undefined,
+  imageTag = "v1.2.3",
+): () => Promise<BotProfile[]> {
+  return async () => {
+    const profiles = await profileRepo.list();
+
+    const manualPolicyIds: string[] = [];
+    const nonManualPolicy = profiles.filter((p) => {
+      if (p.updatePolicy === "manual") {
+        manualPolicyIds.push(p.tenantId);
+        return false;
+      }
+      return true;
+    });
+
+    if (!configRepo) {
+      if (manualPolicyIds.length > 0 && onManualTenantsSkipped) {
+        onManualTenantsSkipped([...new Set(manualPolicyIds)], imageTag);
+      }
+      return nonManualPolicy;
+    }
+
+    const configManualIds: string[] = [];
+    const results = await Promise.all(
+      nonManualPolicy.map(async (p) => {
+        const tenantCfg = await configRepo.get(p.tenantId);
+        if (tenantCfg && tenantCfg.mode === "manual") {
+          configManualIds.push(p.tenantId);
+          return null;
+        }
+        return p;
+      }),
+    );
+
+    const allManualIds = [...manualPolicyIds, ...configManualIds];
+    if (allManualIds.length > 0 && onManualTenantsSkipped) {
+      onManualTenantsSkipped([...new Set(allManualIds)], imageTag);
+    }
+
+    return results.filter((p): p is BotProfile => p !== null);
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("initFleetUpdater — onManualTenantsSkipped", () => {
+  it("callback fires with tenant IDs of manual-mode tenants (policy-based)", async () => {
+    const profiles = [
+      makeProfileWithFields({ id: "b1", tenantId: "t-manual", updatePolicy: "manual" }),
+      makeProfileWithFields({ id: "b2", tenantId: "t-auto", updatePolicy: "auto" }),
+    ];
+    const profileRepo = makeProfileRepo(profiles);
+    const onManualTenantsSkipped = vi.fn();
+
+    const orchestrator = new RolloutOrchestrator({
+      updater: makeMockUpdater(),
+      snapshotManager: makeMockSnapshotManager(),
+      strategy: makeMockStrategy(),
+      getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, undefined, onManualTenantsSkipped),
+    });
+
+    await orchestrator.rollout();
+
+    expect(onManualTenantsSkipped).toHaveBeenCalledWith(["t-manual"], "v1.2.3");
+  });
+
+  it("callback deduplicates tenant IDs", async () => {
+    const profiles = [
+      makeProfileWithFields({ id: "b1", tenantId: "t-dup", updatePolicy: "manual" }),
+      makeProfileWithFields({ id: "b2", tenantId: "t-dup", updatePolicy: "manual" }),
+      makeProfileWithFields({ id: "b3", tenantId: "t-auto", updatePolicy: "auto" }),
+    ];
+    const profileRepo = makeProfileRepo(profiles);
+    const onManualTenantsSkipped = vi.fn();
+
+    const orchestrator = new RolloutOrchestrator({
+      updater: makeMockUpdater(),
+      snapshotManager: makeMockSnapshotManager(),
+      strategy: makeMockStrategy(),
+      getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, undefined, onManualTenantsSkipped),
+    });
+
+    await orchestrator.rollout();
+
+    expect(onManualTenantsSkipped).toHaveBeenCalledWith(["t-dup"], "v1.2.3");
+  });
+
+  it("callback not called when no manual tenants exist", async () => {
+    const profiles = [
+      makeProfileWithFields({ id: "b1", tenantId: "t1", updatePolicy: "auto" }),
+      makeProfileWithFields({ id: "b2", tenantId: "t2", updatePolicy: "auto" }),
+    ];
+    const profileRepo = makeProfileRepo(profiles);
+    const onManualTenantsSkipped = vi.fn();
+
+    const orchestrator = new RolloutOrchestrator({
+      updater: makeMockUpdater(),
+      snapshotManager: makeMockSnapshotManager(),
+      strategy: makeMockStrategy(),
+      getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, undefined, onManualTenantsSkipped),
+    });
+
+    await orchestrator.rollout();
+
+    expect(onManualTenantsSkipped).not.toHaveBeenCalled();
+  });
+
+  it("callback fires with config-repo manual tenants when configRepo is provided", async () => {
+    const profiles = [
+      makeProfileWithFields({ id: "b1", tenantId: "t-cfg-manual", updatePolicy: "auto" }),
+      makeProfileWithFields({ id: "b2", tenantId: "t-cfg-auto", updatePolicy: "auto" }),
+    ];
+    const profileRepo = makeProfileRepo(profiles);
+    const configRepo = makeConfigRepo({
+      "t-cfg-manual": { mode: "manual", preferredHourUtc: 3 },
+    });
+    const onManualTenantsSkipped = vi.fn();
+
+    const orchestrator = new RolloutOrchestrator({
+      updater: makeMockUpdater(),
+      snapshotManager: makeMockSnapshotManager(),
+      strategy: makeMockStrategy(),
+      getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, configRepo, onManualTenantsSkipped),
+    });
+
+    await orchestrator.rollout();
+
+    expect(onManualTenantsSkipped).toHaveBeenCalledWith(["t-cfg-manual"], "v1.2.3");
+  });
+});

package/src/fleet/init-fleet-updater.ts

@@ -40,7 +40,7 @@ export interface FleetUpdaterConfig {
   /** Optional fleet event emitter. When provided, bot.updated / bot.update_failed events are emitted. */
   eventEmitter?: FleetEventEmitter;
   /** Called with manual-mode tenant IDs when a new image is available but they are excluded from rollout. */
-  onManualTenantsSkipped?: (tenantIds: string[]) => void;
+  onManualTenantsSkipped?: (tenantIds: string[], imageTag: string) => void;
 }
 
 export interface FleetUpdaterHandle {
@@ -91,6 +91,11 @@ export function initFleetUpdater(
   const snapshotManager = new VolumeSnapshotManager(docker, snapshotDir);
   const strategy = createRolloutStrategy(strategyType, strategyOptions);
 
+  // Captured by the onUpdateAvailable handler and read by getUpdatableProfiles.
+  // Set before each orchestrator.rollout() call so the callback receives the
+  // image tag that triggered this rollout rather than a stale "latest" placeholder.
+  let currentImageTag = "latest";
+
   const orchestrator = new RolloutOrchestrator({
     updater,
     snapshotManager,
@@ -110,7 +115,7 @@ export function initFleetUpdater(
 
       if (!configRepo) {
         if (manualPolicyIds.length > 0 && onManualTenantsSkipped) {
-          onManualTenantsSkipped([...new Set(manualPolicyIds)]);
+          onManualTenantsSkipped([...new Set(manualPolicyIds)], currentImageTag);
         }
         return nonManualPolicy;
       }
@@ -131,7 +136,7 @@ export function initFleetUpdater(
 
       const allManualIds = [...manualPolicyIds, ...configManualIds];
       if (allManualIds.length > 0 && onManualTenantsSkipped) {
-        onManualTenantsSkipped([...new Set(allManualIds)]);
+        onManualTenantsSkipped([...new Set(allManualIds)], currentImageTag);
       }
 
       return results.filter((p) => p !== null);
@@ -169,11 +174,24 @@ export function initFleetUpdater(
   // Wire the detection → orchestration pipeline.
   // Any digest change triggers a fleet-wide rollout because the managed image
   // is shared across all tenants — one new digest means all bots need updating.
-  poller.onUpdateAvailable = async (_botId: string, _newDigest: string) => {
+  poller.onUpdateAvailable = async (botId: string, _newDigest: string) => {
     if (orchestrator.isRolling) {
       logger.debug("Skipping update trigger — rollout already in progress");
       return;
     }
+
+    // Resolve the image tag from the bot that triggered the update so that
+    // onManualTenantsSkipped receives the real version instead of "latest".
+    try {
+      const triggeringProfile = await profileStore.get(botId);
+      if (triggeringProfile) {
+        const img = triggeringProfile.image;
+        currentImageTag = img.includes(":") ? (img.split(":").pop() ?? "latest") : "latest";
+      }
+    } catch {
+      // Best-effort — currentImageTag stays at previous value
+    }
+
     logger.info("New image digest detected — starting fleet-wide rollout");
     await orchestrator.rollout().catch((err) => {
       logger.error("Rollout failed", { err });

package/src/trpc/admin-fleet-update-router.test.ts

@@ -0,0 +1,201 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { RolloutOrchestrator } from "../fleet/rollout-orchestrator.js";
+import type { ITenantUpdateConfigRepository, TenantUpdateConfig } from "../fleet/tenant-update-config-repository.js";
+import type { IOrgMemberRepository } from "../tenancy/org-member-repository.js";
+import { createAdminFleetUpdateRouter } from "./admin-fleet-update-router.js";
+import { createCallerFactory, router, setTrpcOrgMemberRepo } from "./init.js";
+
+vi.mock("../config/logger.js", () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMockOrgRepo(): IOrgMemberRepository {
+  return {
+    listMembers: vi.fn().mockResolvedValue([]),
+    addMember: vi.fn().mockResolvedValue(undefined),
+    updateMemberRole: vi.fn().mockResolvedValue(undefined),
+    removeMember: vi.fn().mockResolvedValue(undefined),
+    findMember: vi.fn().mockResolvedValue(null),
+    countAdminsAndOwners: vi.fn().mockResolvedValue(0),
+    listInvites: vi.fn().mockResolvedValue([]),
+    createInvite: vi.fn().mockResolvedValue(undefined),
+    findInviteById: vi.fn().mockResolvedValue(null),
+    findInviteByToken: vi.fn().mockResolvedValue(null),
+    deleteInvite: vi.fn().mockResolvedValue(undefined),
+    deleteAllMembers: vi.fn().mockResolvedValue(undefined),
+    deleteAllInvites: vi.fn().mockResolvedValue(undefined),
+    listOrgsByUser: vi.fn().mockResolvedValue([]),
+    markInviteAccepted: vi.fn().mockResolvedValue(undefined),
+  } as unknown as IOrgMemberRepository;
+}
+
+function makeOrchestrator(overrides: Partial<RolloutOrchestrator> = {}): RolloutOrchestrator {
+  return {
+    isRolling: false,
+    rollout: vi.fn().mockResolvedValue({
+      totalBots: 0,
+      succeeded: 0,
+      failed: 0,
+      skipped: 0,
+      aborted: false,
+      alreadyRunning: false,
+      results: [],
+    }),
+    ...overrides,
+  } as unknown as RolloutOrchestrator;
+}
+
+function makeConfigRepo(configs: Record<string, TenantUpdateConfig> = {}): ITenantUpdateConfigRepository {
+  return {
+    get: vi.fn().mockImplementation((tenantId: string) => Promise.resolve(configs[tenantId] ?? null)),
+    upsert: vi.fn().mockResolvedValue(undefined),
+    listAutoEnabled: vi.fn().mockResolvedValue(Object.values(configs)),
+  };
+}
+
+const adminCtx = {
+  user: { id: "admin-1", roles: ["platform_admin"] },
+  tenantId: undefined,
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("createAdminFleetUpdateRouter", () => {
+  let orchestrator: RolloutOrchestrator;
+  let configRepo: ITenantUpdateConfigRepository;
+
+  beforeEach(() => {
+    setTrpcOrgMemberRepo(makeMockOrgRepo());
+    orchestrator = makeOrchestrator();
+    configRepo = makeConfigRepo();
+  });
+
+  function makeCaller() {
+    const fleetRouter = createAdminFleetUpdateRouter(
+      () => orchestrator,
+      () => configRepo,
+    );
+    const appRouter = router({ fleet: fleetRouter });
+    const createCaller = createCallerFactory(appRouter);
+    return createCaller(adminCtx);
+  }
+
+  describe("rolloutStatus", () => {
+    it("returns isRolling from orchestrator (false)", async () => {
+      const caller = makeCaller();
+      const status = await caller.fleet.rolloutStatus();
+      expect(status).toEqual({ isRolling: false });
+    });
+
+    it("returns isRolling from orchestrator (true)", async () => {
+      orchestrator = makeOrchestrator({ isRolling: true } as Partial<RolloutOrchestrator>);
+      const caller = makeCaller();
+      const status = await caller.fleet.rolloutStatus();
+      expect(status).toEqual({ isRolling: true });
+    });
+  });
+
+  describe("forceRollout", () => {
+    it("calls orchestrator.rollout()", async () => {
+      const caller = makeCaller();
+      const result = await caller.fleet.forceRollout();
+
+      expect(result).toEqual({ triggered: true });
+      expect(orchestrator.rollout).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("listTenantConfigs", () => {
+    it("delegates to repo.listAutoEnabled()", async () => {
+      const configs: TenantUpdateConfig[] = [
+        { tenantId: "t1", mode: "auto", preferredHourUtc: 3, updatedAt: Date.now() },
+        { tenantId: "t2", mode: "auto", preferredHourUtc: 12, updatedAt: Date.now() },
+      ];
+      vi.mocked(configRepo.listAutoEnabled).mockResolvedValue(configs);
+
+      const caller = makeCaller();
+      const result = await caller.fleet.listTenantConfigs();
+
+      expect(configRepo.listAutoEnabled).toHaveBeenCalledOnce();
+      expect(result).toEqual(configs);
+    });
+  });
+
+  describe("setTenantConfig", () => {
+    it("preserves existing preferredHourUtc when not provided", async () => {
+      const existing: TenantUpdateConfig = {
+        tenantId: "t1",
+        mode: "auto",
+        preferredHourUtc: 17,
+        updatedAt: Date.now(),
+      };
+      vi.mocked(configRepo.get).mockResolvedValue(existing);
+
+      const caller = makeCaller();
+      await caller.fleet.setTenantConfig({ tenantId: "t1", mode: "manual" });
+
+      expect(configRepo.get).toHaveBeenCalledWith("t1");
+      expect(configRepo.upsert).toHaveBeenCalledWith("t1", {
+        mode: "manual",
+        preferredHourUtc: 17, // preserved from existing
+      });
+    });
+
+    it("uses provided preferredHourUtc when given", async () => {
+      const existing: TenantUpdateConfig = {
+        tenantId: "t1",
+        mode: "auto",
+        preferredHourUtc: 17,
+        updatedAt: Date.now(),
+      };
+      vi.mocked(configRepo.get).mockResolvedValue(existing);
+
+      const caller = makeCaller();
+      await caller.fleet.setTenantConfig({
+        tenantId: "t1",
+        mode: "auto",
+        preferredHourUtc: 9,
+      });
+
+      expect(configRepo.upsert).toHaveBeenCalledWith("t1", {
+        mode: "auto",
+        preferredHourUtc: 9,
+      });
+    });
+
+    it("defaults to 3 when no existing config and preferredHourUtc not provided", async () => {
+      vi.mocked(configRepo.get).mockResolvedValue(null);
+
+      const caller = makeCaller();
+      await caller.fleet.setTenantConfig({ tenantId: "t-new", mode: "auto" });
+
+      expect(configRepo.upsert).toHaveBeenCalledWith("t-new", {
+        mode: "auto",
+        preferredHourUtc: 3, // default
+      });
+    });
+  });
+
+  it("rejects non-admin users", async () => {
+    const fleetRouter = createAdminFleetUpdateRouter(
+      () => orchestrator,
+      () => configRepo,
+    );
+    const appRouter = router({ fleet: fleetRouter });
+    const createCaller = createCallerFactory(appRouter);
+    const caller = createCaller({ user: { id: "u1", roles: ["user"] }, tenantId: undefined });
+
+    await expect(caller.fleet.rolloutStatus()).rejects.toThrow("Platform admin role required");
+  });
+});