@ankhorage/infra 5.1.4 → 5.1.6

package/src/productionServerRuntimeEnvironment.integration.test.ts

@@ -0,0 +1,322 @@
+import type {
+  InfraComputeAdapter,
+  InfraComputeSnapshot,
+  InfraManifest,
+  InfraPlanAction,
+  InfraReconcileResult,
+  InfraResourceStatus,
+  InfraResult,
+} from '@ankhorage/contracts/infra';
+import { infraAdapterDescriptor as hetznerInfraAdapterDescriptor } from '@ankhorage/hetzner';
+import {
+  createInfraAdapter as createK3sInfraAdapter,
+  infraAdapterDescriptor as k3sInfraAdapterDescriptor,
+  type K3sClusterObservation,
+  type K3sClusterSpec,
+  type K3sControlPlane,
+  type K3sNodeAccess,
+} from '@ankhorage/k3s';
+import { expect, test } from 'bun:test';
+
+import { type InfraOrchestrationDependencies, upInfraEnvironmentAsync } from './index.js';
+
+const projectId = 'infra162-server-runtime-environment';
+const serverImage = 'example/server:production';
+
+const manifest = {
+  environments: {
+    local: {
+      deployment: {
+        compute: { provider: 'local' },
+        runtime: { provider: 'docker-compose' },
+      },
+    },
+    preview: {
+      deployment: {
+        compute: { provider: 'hetzner', location: 'fsn1' },
+        runtime: { provider: 'k3s', topology: { servers: 1, agents: 0 } },
+      },
+      workloads: [serverWorkload('development')],
+    },
+    production: {
+      deployment: {
+        compute: { provider: 'hetzner', location: 'fsn1' },
+        runtime: { provider: 'k3s', topology: { servers: 1, agents: 0 } },
+      },
+      workloads: [serverWorkload('production')],
+    },
+  },
+  modules: [],
+} as const satisfies InfraManifest;
+
+test('projects explicit production server environment through the generic k3s workload path', async () => {
+  const fixture = new ProductionServerFixture();
+  const dependencies = createDependencies(fixture);
+
+  const first = requireSuccess(
+    await upInfraEnvironmentAsync({ projectId, manifest, environment: 'production' }, dependencies),
+  );
+  const firstProjection = fixture.kubernetes.serializedResources();
+
+  expect(first.environment).toBe('production');
+  expect(firstProjection).toContain('"name":"NODE_ENV","value":"production"');
+  expect(fixture.k3s.loadedImages).toEqual([serverImage]);
+
+  requireSuccess(
+    await upInfraEnvironmentAsync(
+      {
+        projectId,
+        manifest,
+        environment: 'production',
+        previous: first.ledger,
+      },
+      dependencies,
+    ),
+  );
+
+  expect(fixture.kubernetes.serializedResources()).toBe(firstProjection);
+});
+
+test('preserves an explicitly non-production server environment without rewriting it', async () => {
+  const fixture = new ProductionServerFixture();
+
+  const result = requireSuccess(
+    await upInfraEnvironmentAsync(
+      { projectId, manifest, environment: 'preview' },
+      createDependencies(fixture),
+    ),
+  );
+  const projection = fixture.kubernetes.serializedResources();
+
+  expect(result.environment).toBe('preview');
+  expect(projection).toContain('"name":"NODE_ENV","value":"development"');
+  expect(projection).not.toContain('"name":"NODE_ENV","value":"production"');
+});
+
+function serverWorkload(nodeEnvironment: 'development' | 'production') {
+  return {
+    id: 'server',
+    artifact: { kind: 'image' as const, image: serverImage },
+    environment: {
+      NODE_ENV: { kind: 'literal' as const, value: nodeEnvironment },
+    },
+  };
+}
+
+class ProductionServerFixture {
+  readonly compute = new FakeHetznerComputeAdapter();
+  readonly k3s = new FakeK3sControlPlane();
+  readonly kubernetes = this.k3s.api;
+}
+
+function createDependencies(fixture: ProductionServerFixture): InfraOrchestrationDependencies {
+  return {
+    adapterResolver: {
+      loadAsync: (packageName) => {
+        switch (packageName) {
+          case hetznerInfraAdapterDescriptor.package:
+            return Promise.resolve({
+              infraAdapterDescriptor: hetznerInfraAdapterDescriptor,
+              createInfraAdapter: () => fixture.compute,
+            });
+          case k3sInfraAdapterDescriptor.package:
+            return Promise.resolve({
+              infraAdapterDescriptor: k3sInfraAdapterDescriptor,
+              createInfraAdapter: () => createK3sInfraAdapter({ controlPlane: fixture.k3s }),
+            });
+          default:
+            return Promise.reject(new Error(`Unexpected adapter package: ${packageName}`));
+        }
+      },
+    },
+    credentials: {
+      resolveAsync: () => Promise.resolve(success({ token: 'fixture-token' })),
+    },
+    secrets: {
+      resolveAsync: () =>
+        Promise.resolve({
+          ok: false,
+          diagnostics: [
+            { severity: 'error', code: 'unexpected-secret', message: 'No secret is expected.' },
+          ],
+        }),
+    },
+  };
+}
+
+class FakeHetznerComputeAdapter implements InfraComputeAdapter<'hetzner'> {
+  readonly descriptor = hetznerInfraAdapterDescriptor;
+  readonly snapshot: InfraComputeSnapshot = {
+    targets: [
+      {
+        id: 'server',
+        kind: 'ssh-host',
+        os: 'linux',
+        architecture: 'amd64',
+        host: '203.0.113.162',
+        port: 22,
+        user: 'root',
+        credential: { source: 'control-plane', name: 'SERVER_SSH' },
+        hostKeyFingerprint: 'SHA256:infra162-server',
+      },
+    ],
+    resources: [],
+    outputs: [],
+  };
+
+  validateAsync(): Promise<InfraResult<null>> {
+    return Promise.resolve(success(null));
+  }
+
+  inspectAsync(): Promise<InfraResult<InfraComputeSnapshot>> {
+    return Promise.resolve(success(this.snapshot));
+  }
+
+  planAsync(): Promise<InfraResult<readonly InfraPlanAction[]>> {
+    return Promise.resolve(success([]));
+  }
+
+  ensureAsync(): Promise<InfraResult<InfraComputeSnapshot>> {
+    return Promise.resolve(success(this.snapshot));
+  }
+
+  statusAsync(): Promise<InfraResult<readonly InfraResourceStatus[]>> {
+    return Promise.resolve(success([]));
+  }
+
+  destroyAsync(): Promise<InfraResult<InfraReconcileResult>> {
+    return Promise.resolve(success({ resources: [], outputs: [] }));
+  }
+}
+
+type KubernetesApi = NonNullable<K3sClusterObservation['api']>;
+type KubernetesOwnershipQuery = Parameters<KubernetesApi['listOwnedAsync']>[0];
+type KubernetesResource = Awaited<ReturnType<KubernetesApi['listOwnedAsync']>>[number];
+type KubernetesResourceReference = Parameters<KubernetesApi['deleteAsync']>[0];
+type KubernetesResourceObservation = Awaited<ReturnType<KubernetesApi['observeAsync']>>;
+
+class FakeK3sControlPlane implements K3sControlPlane {
+  readonly api = new FakeKubernetesApi();
+  loadedImages: readonly string[] = [];
+  state: K3sClusterObservation['state'] = 'absent';
+  nodes: K3sClusterObservation['nodes'] = [];
+
+  validateAsync(): Promise<InfraResult<null>> {
+    return Promise.resolve(success(null));
+  }
+
+  inspectAsync(): Promise<InfraResult<K3sClusterObservation>> {
+    return Promise.resolve(success(this.observation()));
+  }
+
+  ensureAsync(spec: K3sClusterSpec): Promise<InfraResult<K3sClusterObservation>> {
+    this.state = 'ready';
+    this.nodes = spec.nodes.map(({ id }) => ({
+      id,
+      state: 'ready',
+      configurationMatches: true,
+    }));
+    return Promise.resolve(success(this.observation()));
+  }
+
+  waitUntilReadyAsync(): Promise<InfraResult<K3sClusterObservation>> {
+    return Promise.resolve(success(this.observation()));
+  }
+
+  loadImagesAsync(
+    _spec: K3sClusterSpec,
+    _access: readonly K3sNodeAccess[],
+    images: readonly string[],
+  ): Promise<InfraResult<null>> {
+    this.loadedImages = [...images];
+    return Promise.resolve(success(null));
+  }
+
+  suspendAsync(): Promise<InfraResult<null>> {
+    this.state = 'stopped';
+    this.nodes = this.nodes.map((node) => ({ ...node, state: 'stopped' }));
+    return Promise.resolve(success(null));
+  }
+
+  destroyAsync(): Promise<InfraResult<null>> {
+    this.state = 'absent';
+    this.nodes = [];
+    return Promise.resolve(success(null));
+  }
+
+  private observation(): K3sClusterObservation {
+    return {
+      state: this.state,
+      configurationMatches: true,
+      nodes: this.nodes,
+      ...(this.state === 'ready' ? { api: this.api } : {}),
+    };
+  }
+}
+
+class FakeKubernetesApi implements KubernetesApi {
+  readonly resources: KubernetesResource[] = [];
+
+  listOwnedAsync(query: KubernetesOwnershipQuery): Promise<readonly KubernetesResource[]> {
+    return Promise.resolve(
+      this.resources.filter(({ metadata }) => includesLabels(metadata.labels, query.labels)),
+    );
+  }
+
+  applyAsync(resource: KubernetesResource): Promise<void> {
+    const index = this.resources.findIndex((candidate) => sameResource(candidate, resource));
+    if (index === -1) this.resources.push(resource);
+    else this.resources.splice(index, 1, resource);
+    return Promise.resolve();
+  }
+
+  deleteAsync(reference: KubernetesResourceReference): Promise<void> {
+    const index = this.resources.findIndex((resource) => sameResource(resource, reference));
+    if (index >= 0) this.resources.splice(index, 1);
+    return Promise.resolve();
+  }
+
+  observeAsync(): Promise<KubernetesResourceObservation> {
+    return Promise.resolve({ state: 'ready' });
+  }
+
+  waitUntilReadyAsync(): Promise<KubernetesResourceObservation> {
+    return Promise.resolve({ state: 'ready' });
+  }
+
+  serializedResources(): string {
+    return JSON.stringify(this.resources);
+  }
+}
+
+function includesLabels(
+  actual: Readonly<Record<string, string>>,
+  expected: Readonly<Record<string, string>>,
+): boolean {
+  return Object.entries(expected).every(([expectedKey, expectedValue]) =>
+    Object.entries(actual).some(
+      ([actualKey, actualValue]) => actualKey === expectedKey && actualValue === expectedValue,
+    ),
+  );
+}
+
+function sameResource(
+  left: KubernetesResource,
+  right: KubernetesResource | KubernetesResourceReference,
+): boolean {
+  return (
+    left.apiVersion === right.apiVersion &&
+    left.kind === right.kind &&
+    left.metadata.name === ('metadata' in right ? right.metadata.name : right.name) &&
+    left.metadata.namespace === ('metadata' in right ? right.metadata.namespace : right.namespace)
+  );
+}
+
+function requireSuccess<T>(result: InfraResult<T>): T {
+  if (!result.ok) throw new Error(result.diagnostics.map(({ message }) => message).join(' '));
+  return result.value;
+}
+
+function success<T>(value: T): InfraResult<T> {
+  return { ok: true, value, diagnostics: [] };
+}

package/src/projectLifecycle.test.ts

@@ -18,6 +18,35 @@ afterEach(async () => {
   temporaryPaths.clear();
 });
 
+test('destroy is idempotent without stored ownership state or provider resolution', async () => {
+  const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-project-lifecycle-'));
+  temporaryPaths.add(projectPath);
+  const destroyRequests: InfraDestroyOperationRequest[] = [];
+  const lifecycle = createProjectInfraLifecycle({
+    services: {
+      createDependencies: () => {
+        throw new Error('Provider dependencies must not resolve without stored ownership state.');
+      },
+      operations: createOperations(destroyRequests),
+    },
+  });
+  const request = {
+    projectId: 'sample',
+    projectPath,
+    manifest: { environments: { local: desired }, modules: [] },
+    environment: 'local' as const,
+  };
+
+  const destroyed = await lifecycle.destroyAsync({
+    ...request,
+    confirmation: { projectId: 'sample', environment: 'local' },
+    persistence: { policy: 'retain' },
+  });
+
+  expect(destroyed).toEqual(success({ environment: 'local', ledger: null }));
+  expect(destroyRequests).toEqual([]);
+});
+
 test('runs typed project lifecycle operations with canonical state and artifact ownership', async () => {
   const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-project-lifecycle-'));
   temporaryPaths.add(projectPath);