@shipfox/api-runners 12.1.0 → 12.3.0

package/src/temporal/activities/maintenance-activities.test.ts

@@ -1,18 +1,3 @@
-import {
-  deleteExpiredEphemeralRegistrationTokens,
-  deleteExpiredRunnerReservations,
-  deleteExpiredRunnerSessions,
-  detectAndExpireStuckJobs,
-  reapStaleRunnerInstances,
-} from '#core/maintenance.js';
-import {
-  deleteExpiredEphemeralRegistrationTokensActivity,
-  deleteExpiredReservationsActivity,
-  deleteExpiredRunnerSessionsActivity,
-  detectAndExpireStuckJobsActivity,
-  reapStaleRunnerInstancesActivity,
-} from './maintenance-activities.js';
-
 vi.mock('#core/maintenance.js', () => ({
   deleteExpiredEphemeralRegistrationTokens: vi.fn(),
   deleteExpiredRunnerReservations: vi.fn(),
@@ -21,46 +6,52 @@ vi.mock('#core/maintenance.js', () => ({
   reapStaleRunnerInstances: vi.fn(),
 }));
 
-beforeEach(() => {
+let maintenance: typeof import('#core/maintenance.js');
+let activities: typeof import('./maintenance-activities.js');
+
+beforeEach(async () => {
+  vi.resetModules();
+  maintenance = await import('#core/maintenance.js');
+  activities = await import('./maintenance-activities.js');
   vi.clearAllMocks();
 });
 
 describe('detectAndExpireStuckJobsActivity', () => {
   it('delegates to core maintenance', async () => {
-    vi.mocked(detectAndExpireStuckJobs).mockResolvedValueOnce({expired: 2});
+    vi.mocked(maintenance.detectAndExpireStuckJobs).mockResolvedValueOnce({expired: 2});
 
-    const result = await detectAndExpireStuckJobsActivity({thresholdSeconds: 180});
+    const result = await activities.detectAndExpireStuckJobsActivity({thresholdSeconds: 180});
 
     expect(result).toEqual({expired: 2});
-    expect(detectAndExpireStuckJobs).toHaveBeenCalledWith({thresholdSeconds: 180});
+    expect(maintenance.detectAndExpireStuckJobs).toHaveBeenCalledWith({thresholdSeconds: 180});
   });
 });
 
 describe('deleteExpiredReservationsActivity', () => {
   it('delegates to core maintenance', async () => {
-    vi.mocked(deleteExpiredRunnerReservations).mockResolvedValueOnce({deleted: 3});
+    vi.mocked(maintenance.deleteExpiredRunnerReservations).mockResolvedValueOnce({deleted: 3});
 
-    const result = await deleteExpiredReservationsActivity({limit: 50});
+    const result = await activities.deleteExpiredReservationsActivity({limit: 50});
 
     expect(result).toEqual({deleted: 3});
-    expect(deleteExpiredRunnerReservations).toHaveBeenCalledWith({limit: 50});
+    expect(maintenance.deleteExpiredRunnerReservations).toHaveBeenCalledWith({limit: 50});
   });
 });
 
 describe('reapStaleRunnerInstancesActivity', () => {
   it('delegates to core maintenance', async () => {
-    vi.mocked(reapStaleRunnerInstances).mockResolvedValueOnce({
+    vi.mocked(maintenance.reapStaleRunnerInstances).mockResolvedValueOnce({
       reaped: 4,
       reservationsReleased: 2,
     });
 
-    const result = await reapStaleRunnerInstancesActivity({
+    const result = await activities.reapStaleRunnerInstancesActivity({
       thresholdSeconds: 300,
       limit: 100,
     });
 
     expect(result).toEqual({reaped: 4, reservationsReleased: 2});
-    expect(reapStaleRunnerInstances).toHaveBeenCalledWith({
+    expect(maintenance.reapStaleRunnerInstances).toHaveBeenCalledWith({
       thresholdSeconds: 300,
       limit: 100,
     });
@@ -69,16 +60,16 @@ describe('reapStaleRunnerInstancesActivity', () => {
 
 describe('deleteExpiredRunnerSessionsActivity', () => {
   it('delegates to core maintenance', async () => {
-    vi.mocked(deleteExpiredRunnerSessions).mockResolvedValueOnce({deleted: 4});
+    vi.mocked(maintenance.deleteExpiredRunnerSessions).mockResolvedValueOnce({deleted: 4});
 
-    const result = await deleteExpiredRunnerSessionsActivity({
+    const result = await activities.deleteExpiredRunnerSessionsActivity({
       manualRetentionDays: 30,
       ephemeralRetentionDays: 7,
       limit: 25,
     });
 
     expect(result).toEqual({deleted: 4});
-    expect(deleteExpiredRunnerSessions).toHaveBeenCalledWith({
+    expect(maintenance.deleteExpiredRunnerSessions).toHaveBeenCalledWith({
       manualRetentionDays: 30,
       ephemeralRetentionDays: 7,
       limit: 25,
@@ -88,15 +79,17 @@ describe('deleteExpiredRunnerSessionsActivity', () => {
 
 describe('deleteExpiredEphemeralRegistrationTokensActivity', () => {
   it('delegates to core maintenance', async () => {
-    vi.mocked(deleteExpiredEphemeralRegistrationTokens).mockResolvedValueOnce({deleted: 6});
+    vi.mocked(maintenance.deleteExpiredEphemeralRegistrationTokens).mockResolvedValueOnce({
+      deleted: 6,
+    });
 
-    const result = await deleteExpiredEphemeralRegistrationTokensActivity({
+    const result = await activities.deleteExpiredEphemeralRegistrationTokensActivity({
       retentionDays: 7,
       limit: 25,
     });
 
     expect(result).toEqual({deleted: 6});
-    expect(deleteExpiredEphemeralRegistrationTokens).toHaveBeenCalledWith({
+    expect(maintenance.deleteExpiredEphemeralRegistrationTokens).toHaveBeenCalledWith({
       retentionDays: 7,
       limit: 25,
     });

package/test/env.ts

@@ -4,6 +4,7 @@ process.env.POSTGRES_USERNAME ??= 'shipfox';
 process.env.POSTGRES_PASSWORD ??= 'password';
 process.env.POSTGRES_DATABASE = 'api_test';
 process.env.POSTGRES_MAX_CONNECTIONS ??= '5';
+process.env.RUNNER_RESERVED_LABELS ??= 'shipfox-managed';
 process.env.WORKSPACE_JWT_SECRET = 'test-secret';
 process.env.AUTH_ROOT_KEY = 'MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWY=';
 process.env.TZ = 'UTC';

package/test/fixtures/late-runner-enrollment.ts

@@ -0,0 +1,103 @@
+import {extractDisplayPrefix, generateOpaqueToken, hashOpaqueToken} from '@shipfox/node-tokens';
+import {db} from '#db/db.js';
+import {deleteReservationsByIds} from '#db/reservations.js';
+import {reservations} from '#db/schema/reservations.js';
+import {runnerControlSessions} from '#db/schema/runner-control-sessions.js';
+import {providerRunners} from '#db/schema/runner-instances.js';
+
+export interface LateRunnerEnrollmentArrangement {
+  controlSessionToken: string;
+  provisionerId: string;
+  reservationId: string;
+  runnerInstanceId: string;
+  workspaceId: string;
+}
+
+export async function arrangeExpiredRunnerEnrollment(params: {
+  provisionerId: string;
+  workspaceId: string;
+}): Promise<LateRunnerEnrollmentArrangement> {
+  const reservationId = await insertReservation({
+    ...params,
+    expiresAt: new Date(Date.now() - 1_000),
+  });
+
+  return await createRunnerEnrollmentArrangement({...params, reservationId});
+}
+
+export async function arrangeDeletedRunnerEnrollment(params: {
+  provisionerId: string;
+  workspaceId: string;
+}): Promise<LateRunnerEnrollmentArrangement> {
+  const reservationId = await insertReservation({
+    ...params,
+    expiresAt: new Date(Date.now() + 60_000),
+  });
+  const deleted = await deleteReservationsByIds([reservationId]);
+  if (deleted !== 1) throw new Error('Expected reservation cleanup to delete one row');
+
+  // The provider can still enroll from a launch payload carrying the deleted reservation id.
+  return await createRunnerEnrollmentArrangement({...params, reservationId});
+}
+
+async function insertReservation(params: {
+  expiresAt: Date;
+  provisionerId: string;
+  workspaceId: string;
+}): Promise<string> {
+  const [reservation] = await db()
+    .insert(reservations)
+    .values({
+      workspaceId: params.workspaceId,
+      provisionerId: params.provisionerId,
+      requiredLabels: ['linux'],
+      count: 1,
+      expiresAt: params.expiresAt,
+    })
+    .returning({id: reservations.id});
+  if (!reservation) throw new Error('Expected reservation');
+
+  return reservation.id;
+}
+
+async function createRunnerEnrollmentArrangement(params: {
+  provisionerId: string;
+  reservationId: string;
+  workspaceId: string;
+}): Promise<LateRunnerEnrollmentArrangement> {
+  const providerRunnerId = `late-runner-${crypto.randomUUID()}`;
+  const controlSessionToken = generateOpaqueToken('runnerControlSession');
+  const [runner] = await db()
+    .insert(providerRunners)
+    .values({
+      provisionerId: params.provisionerId,
+      providerRunnerId,
+      intendedReservationId: params.reservationId,
+      templateKey: 'linux',
+      labels: ['linux'],
+      state: 'starting',
+      providerKind: 'docker',
+      protocolVersion: '1',
+      reportedAt: new Date(),
+    })
+    .returning({id: providerRunners.id});
+  if (!runner) throw new Error('Expected runner instance');
+
+  await db()
+    .insert(runnerControlSessions)
+    .values({
+      runnerInstanceId: runner.id,
+      provisionerId: params.provisionerId,
+      hashedToken: hashOpaqueToken(controlSessionToken),
+      prefix: extractDisplayPrefix(controlSessionToken),
+      expiresAt: new Date(Date.now() + 60_000),
+    });
+
+  return {
+    controlSessionToken,
+    provisionerId: params.provisionerId,
+    reservationId: params.reservationId,
+    runnerInstanceId: runner.id,
+    workspaceId: params.workspaceId,
+  };
+}

package/test/index.ts

@@ -23,3 +23,8 @@ export {
   mintRunnerSessionToken,
 } from './fixtures/auth.js';
 export {runnersTestAuthClient} from './fixtures/auth-inter-module.js';
+export {
+  arrangeDeletedRunnerEnrollment,
+  arrangeExpiredRunnerEnrollment,
+  type LateRunnerEnrollmentArrangement,
+} from './fixtures/late-runner-enrollment.js';