evolved-monkey 0.1.0

package/tests/integration/submit-flow.spec.ts

@@ -0,0 +1,207 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import type { AddressInfo } from "node:net";
+
+import { runCli } from "../../src/cli.js";
+import { createTempDir } from "../helpers/test-utils.js";
+
+function createTestBackendServer() {
+  const uploadStats = {
+    starterBytes: 0,
+    starterUploads: 0,
+    testsBytes: 0,
+    testsUploads: 0,
+  };
+
+  let server: http.Server | undefined;
+
+  function sendJson(response: http.ServerResponse, statusCode: number, body: unknown): void {
+    response.writeHead(statusCode, { "content-type": "application/json" });
+    response.end(JSON.stringify(body));
+  }
+
+  function readBody(request: http.IncomingMessage): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      request.on("data", (chunk: Buffer) => chunks.push(chunk));
+      request.on("end", () => resolve(Buffer.concat(chunks)));
+      request.on("error", reject);
+    });
+  }
+
+  async function handler(request: http.IncomingMessage, response: http.ServerResponse) {
+    const host = request.headers.host;
+    const baseUrl = `http://${host}`;
+    const pathname = new URL(request.url ?? "/", baseUrl).pathname;
+
+    if (request.method === "POST" && pathname === "/v1/creator/challenges/init") {
+      const bodyBuffer = await readBody(request);
+      const payload = JSON.parse(bodyBuffer.toString("utf8"));
+
+      sendJson(response, 201, {
+        data: {
+          challenge: {
+            id: "challenge-integration-id",
+            slug: payload.slug,
+            title: payload.title,
+            type: "EXPRESS_NODE",
+          },
+        },
+        success: true,
+      });
+      return;
+    }
+
+    const starterUploadMatch = pathname.match(
+      /^\/v1\/creator\/challenges\/([^/]+)\/artifacts\/starter\/upload-url$/,
+    );
+    if (request.method === "POST" && starterUploadMatch) {
+      const slug = decodeURIComponent(starterUploadMatch[1] ?? "");
+
+      sendJson(response, 200, {
+        data: {
+          challengeId: "challenge-integration-id",
+          challengeSlug: slug,
+          upload: {
+            expiresInSeconds: 900,
+            headers: { "content-type": "application/gzip" },
+            key: "challenges/challenge-integration-id/starter/mock.tar.gz",
+            method: "PUT",
+            url: `${baseUrl}/upload/starter`,
+          },
+        },
+        success: true,
+      });
+      return;
+    }
+
+    const testsUploadMatch = pathname.match(
+      /^\/v1\/creator\/challenges\/([^/]+)\/artifacts\/tests\/upload-url$/,
+    );
+    if (request.method === "POST" && testsUploadMatch) {
+      const slug = decodeURIComponent(testsUploadMatch[1] ?? "");
+
+      sendJson(response, 200, {
+        data: {
+          challengeId: "challenge-integration-id",
+          challengeSlug: slug,
+          upload: {
+            expiresInSeconds: 900,
+            headers: { "content-type": "application/gzip" },
+            key: "challenges/challenge-integration-id/tests/mock.tar.gz",
+            method: "PUT",
+            url: `${baseUrl}/upload/tests`,
+          },
+        },
+        success: true,
+      });
+      return;
+    }
+
+    if (request.method === "PUT" && pathname === "/upload/starter") {
+      const bodyBuffer = await readBody(request);
+      uploadStats.starterUploads += 1;
+      uploadStats.starterBytes += bodyBuffer.byteLength;
+      response.writeHead(200);
+      response.end();
+      return;
+    }
+
+    if (request.method === "PUT" && pathname === "/upload/tests") {
+      const bodyBuffer = await readBody(request);
+      uploadStats.testsUploads += 1;
+      uploadStats.testsBytes += bodyBuffer.byteLength;
+      response.writeHead(200);
+      response.end();
+      return;
+    }
+
+    response.writeHead(404);
+    response.end();
+  }
+
+  return {
+    async start() {
+      server = http.createServer((request, response) => {
+        void handler(request, response);
+      });
+
+      await new Promise<void>((resolve) => {
+        server?.listen(0, "127.0.0.1", resolve);
+      });
+
+      const address = server?.address();
+
+      if (!address || typeof address === "string") {
+        throw new Error("Unable to read test server address.");
+      }
+      const info = address as AddressInfo;
+
+      return {
+        baseUrl: `http://127.0.0.1:${info.port}`,
+      };
+    },
+    async stop() {
+      if (!server) {
+        return;
+      }
+
+      await new Promise<void>((resolve) => server?.close(() => resolve()));
+      server = undefined;
+    },
+    uploadStats,
+  };
+}
+
+export async function runSubmitFlowIntegrationTests() {
+  const tempRoot = await createTempDir("em-cli-integration-");
+  const server = createTestBackendServer();
+
+  try {
+    const { baseUrl } = await server.start();
+    const workspaceRelative = "integration-workspace";
+    const workspaceAbsolute = path.join(tempRoot, workspaceRelative);
+
+    await runCli(
+      [
+        "challenge",
+        "init",
+        "--slug",
+        "integration-challenge",
+        "--title",
+        "Integration Challenge",
+        "--description",
+        "Create a deterministic express middleware that validates query params and returns JSON.",
+        "--constraints",
+        "Use only express and built-in Node modules. Keep behavior deterministic and offline.",
+        "--backend",
+        baseUrl,
+        "--dir",
+        workspaceRelative,
+      ],
+      {
+        cwd: tempRoot,
+        log: () => {},
+      },
+    );
+
+    await runCli(
+      ["challenge", "submit", "--backend", baseUrl, "--dir", workspaceAbsolute],
+      {
+        cwd: tempRoot,
+        log: () => {},
+        packageDirectory: async () => Buffer.from("fake-tar-gz-bytes"),
+      },
+    );
+
+    assert.equal(server.uploadStats.starterUploads, 1);
+    assert.equal(server.uploadStats.testsUploads, 1);
+    assert.equal(server.uploadStats.starterBytes > 0, true);
+    assert.equal(server.uploadStats.testsBytes > 0, true);
+  } finally {
+    await server.stop();
+    await fs.rm(tempRoot, { force: true, recursive: true });
+  }
+}

package/tests/run-tests.ts

@@ -0,0 +1,42 @@
+import { runSubmitFlowIntegrationTests } from "./integration/submit-flow.spec.js";
+import { runCliCommandsUnitTests } from "./unit/cli-commands.spec.js";
+
+type TestEntry = {
+  name: string;
+  run: () => Promise<void>;
+};
+
+const tests: TestEntry[] = [
+  {
+    name: "unit: cli-commands",
+    run: runCliCommandsUnitTests,
+  },
+  {
+    name: "integration: submit-flow",
+    run: runSubmitFlowIntegrationTests,
+  },
+];
+
+async function main() {
+  let failed = 0;
+
+  for (const test of tests) {
+    try {
+      await test.run();
+      console.log(`[PASS] ${test.name}`);
+    } catch (error: unknown) {
+      failed += 1;
+      console.error(`[FAIL] ${test.name}`);
+      console.error(error);
+    }
+  }
+
+  if (failed > 0) {
+    process.exit(1);
+    return;
+  }
+
+  console.log(`All tests passed (${tests.length}).`);
+}
+
+void main();

package/tests/snapshots/init-result.json

@@ -0,0 +1,5 @@
+{
+  "challengeId": "challenge-snapshot-id",
+  "slug": "snapshot-challenge",
+  "workspaceDir": "<workspace>"
+}

package/tests/unit/cli-commands.spec.ts

@@ -0,0 +1,105 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { runChallengeInit } from "../../src/commands/challenge-init.js";
+import { runChallengeValidate } from "../../src/commands/challenge-validate.js";
+import { readJsonFile } from "../../src/lib/fs-utils.js";
+import type {
+  ArtifactUploadResponse,
+  BackendClientContract,
+  ChallengeDraftPayload,
+} from "../../src/types.js";
+import {
+  copyDir,
+  createTempDir,
+  resolveFixturePath,
+  resolveSnapshotPath,
+} from "../helpers/test-utils.js";
+
+class FakeBackendClient implements BackendClientContract {
+  public async createChallengeDraft(input: ChallengeDraftPayload) {
+    return {
+      id: "challenge-snapshot-id",
+      slug: input.slug,
+      title: input.title,
+      type: "EXPRESS_NODE" as const,
+    };
+  }
+
+  public async requestStarterUpload(_slug: string): Promise<ArtifactUploadResponse> {
+    throw new Error("Not used in this unit test.");
+  }
+
+  public async requestTestsUpload(_slug: string): Promise<ArtifactUploadResponse> {
+    throw new Error("Not used in this unit test.");
+  }
+
+  public async uploadArtifact(_upload: ArtifactUploadResponse["upload"], _fileBuffer: Buffer) {
+    throw new Error("Not used in this unit test.");
+  }
+}
+
+export async function runCliCommandsUnitTests() {
+  const tempRoot = await createTempDir("em-cli-unit-");
+
+  try {
+    const initResult = await runChallengeInit({
+      backendClient: new FakeBackendClient(),
+      cwd: tempRoot,
+      flags: {
+        constraints:
+          "Use only express and built-in APIs. Keep runtime deterministic and avoid external services.",
+        description:
+          "Build a middleware that validates incoming headers and returns clear JSON error responses.",
+        slug: "snapshot-challenge",
+        title: "Snapshot Challenge",
+      },
+      log: () => {},
+    });
+
+    const normalizedInitResult = {
+      ...initResult,
+      workspaceDir: "<workspace>",
+    };
+    const snapshotPath = resolveSnapshotPath("init-result.json");
+    const expectedSnapshot = JSON.parse(await fs.readFile(snapshotPath, "utf8")) as {
+      challengeId: string;
+      slug: string;
+      workspaceDir: string;
+    };
+
+    assert.deepEqual(normalizedInitResult, expectedSnapshot);
+
+    const configPath = path.join(initResult.workspaceDir, "challenge.config.json");
+    const config = await readJsonFile<{
+      slug: string;
+      type: string;
+    }>(configPath);
+    assert.equal(config.slug, "snapshot-challenge");
+    assert.equal(config.type, "EXPRESS_NODE");
+
+    const validResult = await runChallengeValidate({
+      cwd: initResult.workspaceDir,
+      flags: {},
+      log: () => {},
+    });
+
+    assert.equal(validResult.ok, true);
+
+    const invalidFixtureSource = resolveFixturePath("invalid-workspace");
+    const invalidFixtureTarget = path.join(tempRoot, "invalid-workspace");
+    await copyDir(invalidFixtureSource, invalidFixtureTarget);
+
+    const invalidResult = await runChallengeValidate({
+      cwd: invalidFixtureTarget,
+      flags: {},
+      log: () => {},
+    });
+
+    assert.equal(invalidResult.ok, false);
+    assert.equal(invalidResult.errors.length > 0, true);
+  } finally {
+    await fs.rm(tempRoot, { force: true, recursive: true });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM"],
+    "types": ["node"],
+    "rootDir": ".",
+    "outDir": "./dist",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "strict": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}