@hearthkit/cli 0.1.0

package/src/run-hearthkit-cli-dev-infra-bucket.test.ts

@@ -0,0 +1,254 @@
+import { afterAll, describe, expect, it } from 'vitest'
+import { expectCliSuccess, runHearthkitCliGate } from '../test-fixtures/cli-run-expectations.ts'
+import {
+  gateContainerExists,
+  gateContainerIsRunning,
+  removeGateComposeNetworks,
+  removeGateContainer,
+} from '../test-fixtures/docker-gate-containers.ts'
+import {
+  remapGeneratedMinioHostPorts,
+  removeGateComposeProject,
+  reserveFreeHostPort,
+} from '../test-fixtures/gate-compose-project-runs.ts'
+import {
+  createGateDirectory,
+  gateEnvironment,
+  removeGateDirectory,
+  uniqueGateProjectName,
+  writeGateComposeFile,
+  writeGateProjectManifest,
+} from '../test-fixtures/gate-project-directories.ts'
+import { loadHearthkitCliBucketExports } from '../test-fixtures/hearthkit-cli-bucket-exports.ts'
+import { loadHearthkitCliEntry } from '../test-fixtures/hearthkit-cli-entry.ts'
+import {
+  getMinioObjectWithSignedUrl,
+  putMinioObjectWithSignedUrl,
+  waitForMinioS3Endpoint,
+} from '../test-fixtures/minio-s3-gate-requests.ts'
+import {
+  generateLocalInfraComposeOptionsSchema,
+  hearthkitProjectNameSchema,
+} from './cli-contract.ts'
+
+/** Pulling images, waiting for a MinIO healthcheck and tearing the stack down again is far past the file-wide timeout. */
+const dockerGateTimeoutMilliseconds = 300_000
+
+const directoriesToRemove: string[] = []
+const composeFilePathsToRemove: string[] = []
+const containersToRemove: string[] = []
+const composeProjectNamesToClean: string[] = []
+
+/** Everything one gate needs to drive and probe its own throwaway MinIO stack. */
+type BucketGateStack = {
+  directoryPath: string
+  composeFilePath: string
+  hearthkitProjectName: string
+  minioContainerName: string
+  bucketInitContainerName: string
+  s3HostPort: number
+}
+
+/**
+ * Writes the real generated compose file into a throwaway project directory and hands back the
+ * names and the port a gate needs to observe it. Two things are deliberate. The file is written
+ * before the CLI runs, because resolveLocalInfraComposeFile never overwrites an existing
+ * docker-compose.yml, so `dev infra up` runs exactly these generated bytes. And the published minio
+ * ports are moved onto reserved free ports, because the contract fixes them at 9000 and 9001, which
+ * the repo's own MinIO and a developer's running stack both hold.
+ */
+async function prepareBucketGateStack(purpose: string): Promise<BucketGateStack> {
+  const { generateLocalInfraCompose } = await loadHearthkitCliEntry()
+  const { localStorageBucketInitServiceName } = await loadHearthkitCliBucketExports()
+
+  const directoryPath = await createGateDirectory(purpose)
+  directoriesToRemove.push(directoryPath)
+  const hearthkitProjectName = uniqueGateProjectName(purpose)
+  composeProjectNamesToClean.push(hearthkitProjectName)
+
+  const generatedComposeFileContent = generateLocalInfraCompose(
+    generateLocalInfraComposeOptionsSchema.parse({
+      hearthkitProjectName,
+      infraServices: ['minio'],
+    }),
+  )
+  const [s3HostPort, consoleHostPort] = await Promise.all([
+    reserveFreeHostPort(),
+    reserveFreeHostPort(),
+  ])
+  if (s3HostPort === consoleHostPort) {
+    throw new Error('gate reserved the same host port twice for one MinIO stack')
+  }
+
+  const composeFilePath = await writeGateComposeFile(
+    directoryPath,
+    remapGeneratedMinioHostPorts({
+      composeFileContent: generatedComposeFileContent,
+      s3HostPort,
+      consoleHostPort,
+    }),
+  )
+  composeFilePathsToRemove.push(composeFilePath)
+  // What a project that installed @hearthkit/storage really carries. The compose file is already
+  // there, so the CLI never reads it; it is written so the directory is the situation being gated.
+  await writeGateProjectManifest({
+    directoryPath,
+    manifestName: hearthkitProjectName,
+    hearthkitDependencies: ['@hearthkit/storage'],
+  })
+
+  const minioContainerName = `${hearthkitProjectName}-minio`
+  const bucketInitContainerName = `${hearthkitProjectName}-${localStorageBucketInitServiceName}`
+  containersToRemove.push(minioContainerName, bucketInitContainerName)
+
+  return {
+    directoryPath,
+    composeFilePath,
+    hearthkitProjectName,
+    minioContainerName,
+    bucketInitContainerName,
+    s3HostPort,
+  }
+}
+
+afterAll(async () => {
+  for (const composeFilePath of composeFilePathsToRemove) {
+    await removeGateComposeProject(composeFilePath)
+  }
+  for (const containerName of containersToRemove) {
+    await removeGateContainer(containerName)
+  }
+  await removeGateComposeNetworks(composeProjectNamesToClean)
+  for (const directoryPath of directoriesToRemove) {
+    await removeGateDirectory(directoryPath)
+  }
+})
+
+describe('hearthkit dev infra with a local storage bucket', () => {
+  it(
+    'starts the generated minio and bucket init containers with dev infra up succeeding on a fresh run and again on a repeat run',
+    async () => {
+      const stack = await prepareBucketGateStack('bucket-up')
+
+      try {
+        const freshRun = await runHearthkitCliGate({
+          argv: ['dev', 'infra', 'up'],
+          cwd: stack.directoryPath,
+          env: gateEnvironment(),
+        })
+
+        const freshSuccess = expectCliSuccess(freshRun, 'dev-infra-up-succeeded', 0)
+        // The init container is not a LocalInfraServiceName, so compose starting it never widens
+        // the reported list.
+        expect(freshSuccess.startedInfraServices).toEqual(['minio'])
+        expect(await gateContainerIsRunning(stack.minioContainerName)).toBe(true)
+        // The container that created the bucket is still running, and it has to be. dev infra up
+        // passes --wait unconditionally, and docker compose up --wait exits 1 when any service it
+        // started has exited, whatever the exit code — so an init container that did its work and
+        // exited 0 would have made the run above report infra-compose-failed instead.
+        expect(await gateContainerIsRunning(stack.bucketInitContainerName)).toBe(true)
+
+        const repeatRun = await runHearthkitCliGate({
+          argv: ['dev', 'infra', 'up'],
+          cwd: stack.directoryPath,
+          env: gateEnvironment(),
+        })
+
+        // mc mb --ignore-existing is what makes the second run a no-op rather than a failure on a
+        // bucket that is already there.
+        const repeatSuccess = expectCliSuccess(repeatRun, 'dev-infra-up-succeeded', 0)
+        expect(repeatSuccess.startedInfraServices).toEqual(['minio'])
+        expect(await gateContainerIsRunning(stack.minioContainerName)).toBe(true)
+        expect(await gateContainerIsRunning(stack.bucketInitContainerName)).toBe(true)
+      } finally {
+        await removeGateComposeProject(stack.composeFilePath)
+      }
+    },
+    dockerGateTimeoutMilliseconds,
+  )
+
+  it(
+    'leaves a bucket in MinIO that a real signed S3 request can upload to and read back',
+    async () => {
+      const stack = await prepareBucketGateStack('bucket-s3')
+      const { deriveLocalStorageBucketName } = await loadHearthkitCliBucketExports()
+      const localStorageBucketName = deriveLocalStorageBucketName(
+        hearthkitProjectNameSchema.parse(stack.hearthkitProjectName),
+      )
+
+      try {
+        expectCliSuccess(
+          await runHearthkitCliGate({
+            argv: ['dev', 'infra', 'up'],
+            cwd: stack.directoryPath,
+            env: gateEnvironment(),
+          }),
+          'dev-infra-up-succeeded',
+          0,
+        )
+        await waitForMinioS3Endpoint({ s3HostPort: stack.s3HostPort })
+
+        const objectKey = 'hearthkit-gate-upload.txt'
+        const objectBody = `hearthkit gate body for ${stack.hearthkitProjectName}`
+        const upload = await putMinioObjectWithSignedUrl({
+          s3HostPort: stack.s3HostPort,
+          bucketName: localStorageBucketName,
+          objectKey,
+          objectBody,
+        })
+
+        // A signed request is the first thing that can see a missing bucket: signing never contacts
+        // the server, so a MinIO with no bucket answers the upload with 404 NoSuchBucket. Checking
+        // the bucket exists is not the same claim as checking it is usable over the S3 API.
+        expect(upload.status).toBe(200)
+
+        const download = await getMinioObjectWithSignedUrl({
+          s3HostPort: stack.s3HostPort,
+          bucketName: localStorageBucketName,
+          objectKey,
+        })
+        expect(download.status).toBe(200)
+        expect(download.body).toBe(objectBody)
+      } finally {
+        await removeGateComposeProject(stack.composeFilePath)
+      }
+    },
+    dockerGateTimeoutMilliseconds,
+  )
+
+  it(
+    'removes the still-running bucket init container along with minio when dev infra down runs',
+    async () => {
+      const stack = await prepareBucketGateStack('bucket-down')
+
+      try {
+        expectCliSuccess(
+          await runHearthkitCliGate({
+            argv: ['dev', 'infra', 'up'],
+            cwd: stack.directoryPath,
+            env: gateEnvironment(),
+          }),
+          'dev-infra-up-succeeded',
+          0,
+        )
+        expect(await gateContainerIsRunning(stack.minioContainerName)).toBe(true)
+        expect(await gateContainerIsRunning(stack.bucketInitContainerName)).toBe(true)
+
+        const downRun = await runHearthkitCliGate({
+          argv: ['dev', 'infra', 'down'],
+          cwd: stack.directoryPath,
+          env: gateEnvironment(),
+        })
+
+        // dev infra down is unchanged by the amendment: docker compose down removes every container
+        // the file defines, the idle init container included.
+        expectCliSuccess(downRun, 'dev-infra-down-succeeded', 0)
+        expect(await gateContainerExists(stack.minioContainerName)).toBe(false)
+        expect(await gateContainerExists(stack.bucketInitContainerName)).toBe(false)
+      } finally {
+        await removeGateComposeProject(stack.composeFilePath)
+      }
+    },
+    dockerGateTimeoutMilliseconds,
+  )
+})