@shipfox/api-runners 2.0.0

package/test/factories/provisioned-runner.ts

@@ -0,0 +1,78 @@
+import {Factory} from 'fishery';
+import type {ProvisionedRunner} from '#core/entities/provisioned-runner.js';
+import {db} from '#db/db.js';
+import {provisionedRunners} from '#db/schema/provisioned-runners.js';
+
+export const provisionedRunnerFactory = Factory.define<ProvisionedRunner>(({onCreate}) => {
+  onCreate(async (provisionedRunner) => {
+    const [row] = await db()
+      .insert(provisionedRunners)
+      .values({
+        workspaceId: provisionedRunner.workspaceId,
+        provisionerId: provisionedRunner.provisionerId,
+        provisionedRunnerId: provisionedRunner.provisionedRunnerId,
+        reservationId: provisionedRunner.reservationId,
+        templateKey: provisionedRunner.templateKey,
+        labels: provisionedRunner.labels,
+        state: provisionedRunner.state,
+        reason: provisionedRunner.reason,
+        runnerSessionId: provisionedRunner.runnerSessionId,
+        providerKind: provisionedRunner.providerKind,
+        reportedAt: provisionedRunner.reportedAt,
+        startedAt: provisionedRunner.startedAt,
+        stoppingAt: provisionedRunner.stoppingAt,
+        stoppedAt: provisionedRunner.stoppedAt,
+        failedAt: provisionedRunner.failedAt,
+        terminatedAt: provisionedRunner.terminatedAt,
+        reservationReleasedAt: provisionedRunner.reservationReleasedAt,
+      })
+      .returning();
+
+    if (!row) throw new Error('Insert returned no rows');
+    return {
+      id: row.id,
+      workspaceId: row.workspaceId,
+      provisionerId: row.provisionerId,
+      provisionedRunnerId: row.provisionedRunnerId,
+      reservationId: row.reservationId,
+      templateKey: row.templateKey,
+      labels: row.labels,
+      state: row.state,
+      reason: row.reason,
+      runnerSessionId: row.runnerSessionId,
+      providerKind: row.providerKind,
+      reportedAt: row.reportedAt,
+      startedAt: row.startedAt,
+      stoppingAt: row.stoppingAt,
+      stoppedAt: row.stoppedAt,
+      failedAt: row.failedAt,
+      terminatedAt: row.terminatedAt,
+      reservationReleasedAt: row.reservationReleasedAt,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  });
+
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    provisionerId: crypto.randomUUID(),
+    provisionedRunnerId: crypto.randomUUID(),
+    reservationId: null,
+    templateKey: 'linux',
+    labels: ['linux'],
+    state: 'running',
+    reason: null,
+    runnerSessionId: null,
+    providerKind: 'docker',
+    reportedAt: new Date(),
+    startedAt: null,
+    stoppingAt: null,
+    stoppedAt: null,
+    failedAt: null,
+    terminatedAt: null,
+    reservationReleasedAt: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+});

package/test/factories/provisioner-token.ts

@@ -0,0 +1,41 @@
+import {extractDisplayPrefix, generateOpaqueToken, hashOpaqueToken} from '@shipfox/node-tokens';
+import {Factory} from 'fishery';
+import type {ProvisionerToken} from '#core/entities/provisioner-token.js';
+import {createProvisionerToken} from '#db/provisioner-tokens.js';
+
+export interface ProvisionerTokenFactoryTransientParams {
+  rawToken?: string;
+}
+
+export const provisionerTokenFactory = Factory.define<
+  ProvisionerToken,
+  ProvisionerTokenFactoryTransientParams
+>(({onCreate, transientParams}) => {
+  const rawToken = transientParams.rawToken ?? generateOpaqueToken('provisionerToken');
+
+  onCreate((token) => {
+    return createProvisionerToken({
+      workspaceId: token.workspaceId,
+      hashedToken: token.hashedToken,
+      prefix: token.prefix,
+      name: token.name ?? undefined,
+      createdByUserId: token.createdByUserId,
+      expiresAt: token.expiresAt ?? undefined,
+    });
+  });
+
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    hashedToken: hashOpaqueToken(rawToken),
+    prefix: extractDisplayPrefix(rawToken),
+    name: 'test provisioner',
+    createdByUserId: crypto.randomUUID(),
+    revokedByUserId: null,
+    expiresAt: null,
+    revokedAt: null,
+    lastSeenAt: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+});

package/test/factories/reservation.ts

@@ -0,0 +1,33 @@
+import {Factory} from 'fishery';
+import {db} from '#db/db.js';
+import {reservations} from '#db/schema/reservations.js';
+
+interface ReservationAttrs {
+  workspaceId: string;
+  provisionerId: string;
+  requiredLabels: string[];
+  count: number;
+  expiresAt: Date;
+}
+
+export const reservationFactory = Factory.define<ReservationAttrs>(({onCreate}) => {
+  onCreate(async (attrs) => {
+    const [row] = await db().insert(reservations).values(attrs).returning();
+    if (!row) throw new Error('Insert returned no rows');
+    return {
+      workspaceId: row.workspaceId,
+      provisionerId: row.provisionerId,
+      requiredLabels: row.requiredLabels,
+      count: row.count,
+      expiresAt: row.expiresAt,
+    };
+  });
+
+  return {
+    workspaceId: crypto.randomUUID(),
+    provisionerId: crypto.randomUUID(),
+    requiredLabels: ['linux'],
+    count: 1,
+    expiresAt: new Date(Date.now() + 60_000),
+  };
+});

package/test/factories/runner-session.ts

@@ -0,0 +1,32 @@
+import {Factory} from 'fishery';
+import type {RunnerSession} from '#core/entities/runner-session.js';
+import {createRunnerSession} from '#db/runner-sessions.js';
+
+export const runnerSessionFactory = Factory.define<RunnerSession>(({onCreate}) => {
+  onCreate((session) => {
+    return createRunnerSession({
+      workspaceId: session.workspaceId,
+      scope: session.scope,
+      registrationTokenId: session.registrationTokenId,
+      labels: session.labels,
+      toolCapabilities: session.toolCapabilities,
+    });
+  });
+
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    scope: 'workspace',
+    registrationTokenId: crypto.randomUUID(),
+    registrationTokenKind: 'manual',
+    provisionerId: null,
+    provisionedRunnerId: null,
+    labels: ['linux', 'x64'],
+    toolCapabilities: null,
+    toolCapabilitiesReportedAt: null,
+    maxClaims: null,
+    claimsUsed: 0,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+});

package/test/globalSetup.ts

@@ -0,0 +1,23 @@
+import './env.js';
+import {runMigrations} from '@shipfox/node-drizzle';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {sql} from 'drizzle-orm';
+import {closeDb, db, migrationsPath} from '#db/index.js';
+
+export async function setup() {
+  createPostgresClient();
+
+  await runMigrations(db(), migrationsPath, '__drizzle_migrations_runners');
+  await db().execute(sql`TRUNCATE runners_provisioned_runners, runners_reservations CASCADE`);
+  await db().execute(sql`TRUNCATE runners_provisioner_tokens CASCADE`);
+  await db().execute(sql`TRUNCATE runners_ephemeral_registration_tokens CASCADE`);
+  await db().execute(sql`TRUNCATE runners_runner_sessions CASCADE`);
+  await db().execute(sql`TRUNCATE runners_rate_limits CASCADE`);
+  await db().execute(sql`TRUNCATE runners_manual_registration_tokens CASCADE`);
+  await db().execute(sql`TRUNCATE runners_pending_jobs CASCADE`);
+  await db().execute(sql`TRUNCATE runners_running_jobs CASCADE`);
+  await db().execute(sql`TRUNCATE runners_outbox CASCADE`);
+
+  closeDb();
+  await closePostgresClient();
+}

package/test/index.ts

@@ -0,0 +1,16 @@
+export {
+  type EphemeralRegistrationTokenFactoryTransientParams,
+  ephemeralRegistrationTokenFactory,
+} from './factories/ephemeral-registration-token.js';
+export {
+  type ManualRegistrationTokenFactoryTransientParams,
+  manualRegistrationTokenFactory,
+} from './factories/manual-registration-token.js';
+export {pendingJobFactory} from './factories/pending-job.js';
+export {provisionedRunnerFactory} from './factories/provisioned-runner.js';
+export {
+  type ProvisionerTokenFactoryTransientParams,
+  provisionerTokenFactory,
+} from './factories/provisioner-token.js';
+export {reservationFactory} from './factories/reservation.js';
+export {runnerSessionFactory} from './factories/runner-session.js';

package/test/setup.ts

@@ -0,0 +1,17 @@
+import './env.js';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {afterAll, afterEach, beforeAll, vi} from '@shipfox/vitest/vi';
+import {closeDb} from '#db/index.js';
+
+beforeAll(() => {
+  createPostgresClient();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+afterAll(async () => {
+  closeDb();
+  await closePostgresClient();
+});

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@shipfox/ts-config/node",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.tsx", "**/*.test.ts"]
+}