rastack 0.0.33 → 0.0.34

package/test/deploy.spec.ts

@@ -0,0 +1,355 @@
+import yaml from "js-yaml";
+import {
+  DeployConfig,
+  buildSteps,
+  checkSteps,
+  ciPlan,
+  deployStackCommand,
+  deploySteps,
+  lambdaEnv,
+  mergeConfig,
+  normalizeConfig,
+  parseGitHubRemote,
+  repoVariables,
+  scaffoldFiles,
+  stackParameters,
+  templateUrl,
+  validateConfig,
+  renderCiWorkflow,
+  renderDeployWorkflow,
+  CI_WORKFLOW_PATH,
+  CONFIG_PATH,
+  DEPLOY_WORKFLOW_PATH,
+} from "../src/deploy";
+
+/** A complete, valid config to build variations off. */
+function base(overrides: Partial<DeployConfig> = {}): DeployConfig {
+  return normalizeConfig({
+    app: "airline",
+    github: {
+      owner: "theserverkid",
+      repo: "reactapistack-demo",
+      branch: "master",
+    },
+    ...overrides,
+  });
+}
+
+describe("deploy config — normalize", () => {
+  it("fills defaults and derives the stack name from prefix + app", () => {
+    const cfg = base();
+    expect(cfg.namePrefix).toBe("rastack");
+    expect(cfg.region).toBe("af-south-1");
+    expect(cfg.stackName).toBe("rastack-airline");
+    expect(cfg.namespace).toBe("production");
+    expect(cfg.lambda).toEqual({
+      bin: "bootstrap",
+      arch: "arm64",
+      features: "lambda",
+    });
+    expect(cfg.resourcesDir).toBe("resources");
+    expect(cfg.outDir).toBe(".rastack");
+    expect(cfg.tokenUse).toBe("access");
+  });
+
+  it("honours an explicit stack name and prefix", () => {
+    const cfg = base({ namePrefix: "acme", stackName: "custom-stack" });
+    expect(cfg.stackName).toBe("custom-stack");
+  });
+
+  it("re-derives the stack name off a custom prefix when none is given", () => {
+    const cfg = normalizeConfig({
+      app: "airline",
+      namePrefix: "acme",
+      github: { owner: "o", repo: "r" },
+    });
+    expect(cfg.stackName).toBe("acme-airline");
+    expect(cfg.github.branch).toBe("master"); // branch default
+  });
+
+  it("drops empty optional buckets to undefined", () => {
+    const cfg = normalizeConfig({
+      app: "a",
+      templatesBucket: "  ",
+      github: {},
+    });
+    expect(cfg.templatesBucket).toBeUndefined();
+    expect(cfg.artifactsBucket).toBeUndefined();
+  });
+});
+
+describe("deploy config — merge", () => {
+  it("deep-merges nested github/lambda without dropping siblings", () => {
+    const cfg = mergeConfig(base(), {
+      github: { branch: "dev" },
+      lambda: { arch: "x86_64" },
+    });
+    expect(cfg.github.owner).toBe("theserverkid");
+    expect(cfg.github.branch).toBe("dev");
+    expect(cfg.lambda.arch).toBe("x86_64");
+    expect(cfg.lambda.bin).toBe("bootstrap");
+  });
+
+  it("merges stack outputs", () => {
+    const cfg = mergeConfig(base(), { outputs: { functionName: "fn-1" } });
+    const cfg2 = mergeConfig(cfg, { outputs: { apiUrl: "https://x" } });
+    expect(cfg2.outputs).toEqual({ functionName: "fn-1", apiUrl: "https://x" });
+  });
+});
+
+describe("deploy config — validate", () => {
+  it("passes a well-formed config", () => {
+    expect(validateConfig(base())).toEqual([]);
+  });
+
+  it("rejects a bad app slug (Cognito [a-z0-9] rule)", () => {
+    expect(validateConfig(base({ app: "My-App" })).join("\n")).toMatch(
+      /app "My-App"/,
+    );
+    expect(validateConfig(base({ app: "" })).join("\n")).toMatch(
+      /app is required/,
+    );
+  });
+
+  it("rejects a malformed region", () => {
+    expect(validateConfig(base({ region: "not-a-region" })).join()).toMatch(
+      /region/,
+    );
+  });
+
+  it("requires github owner + repo", () => {
+    const errs = validateConfig(normalizeConfig({ app: "a", github: {} }));
+    expect(errs.join("\n")).toMatch(/github.owner is required/);
+    expect(errs.join("\n")).toMatch(/github.repo is required/);
+  });
+
+  it("rejects an unknown lambda arch", () => {
+    const cfg = {
+      ...base(),
+      lambda: { ...base().lambda, arch: "riscv" as never },
+    };
+    expect(validateConfig(cfg).join()).toMatch(/lambda.arch/);
+  });
+});
+
+describe("parseGitHubRemote", () => {
+  it("parses ssh, https, and https+.git forms", () => {
+    expect(
+      parseGitHubRemote("git@github.com:theserverkid/reactapistack.git"),
+    ).toEqual({
+      owner: "theserverkid",
+      repo: "reactapistack",
+    });
+    expect(
+      parseGitHubRemote("https://github.com/theserverkid/reactapistack"),
+    ).toEqual({
+      owner: "theserverkid",
+      repo: "reactapistack",
+    });
+    expect(
+      parseGitHubRemote("https://github.com/theserverkid/reactapistack.git/"),
+    ).toEqual({
+      owner: "theserverkid",
+      repo: "reactapistack",
+    });
+  });
+
+  it("returns null for non-GitHub remotes", () => {
+    expect(parseGitHubRemote("git@gitlab.com:o/r.git")).toBeNull();
+    expect(parseGitHubRemote("not a url")).toBeNull();
+  });
+});
+
+describe("stack parameters + launch command", () => {
+  it("emits the app.yaml parameters in template order", () => {
+    const params = stackParameters(base({ artifactsBucket: "art-bucket" }));
+    expect(params.map((p) => p.key)).toEqual([
+      "AppName",
+      "NamePrefix",
+      "GitHubOwner",
+      "GitHubRepo",
+      "GitHubBranch",
+      "IcebergNamespace",
+      "ArtifactsBucket",
+    ]);
+  });
+
+  it("omits ArtifactsBucket when unset (it has no template default)", () => {
+    expect(stackParameters(base()).map((p) => p.key)).not.toContain(
+      "ArtifactsBucket",
+    );
+  });
+
+  it("builds the template URL only when the templates bucket is known", () => {
+    expect(templateUrl(base())).toBeNull();
+    expect(templateUrl(base({ templatesBucket: "tpl" }))).toBe(
+      "https://tpl.s3.af-south-1.amazonaws.com/app.yaml",
+    );
+  });
+
+  it("launches by URL when hosted, else from the in-repo template", () => {
+    const hosted = deployStackCommand(
+      base({ templatesBucket: "tpl", artifactsBucket: "art" }),
+    );
+    expect(hosted).toContain(
+      "--template-url https://tpl.s3.af-south-1.amazonaws.com/app.yaml",
+    );
+    expect(hosted).toContain("--stack-name rastack-airline");
+    expect(hosted).toContain("ArtifactsBucket=art");
+
+    const local = deployStackCommand(base());
+    expect(local).toContain("--template-file deploy/cloudformation/app.yaml");
+  });
+});
+
+describe("repo variables + lambda env", () => {
+  it("resolves repo Variables from stack outputs when present", () => {
+    const cfg = base({ outputs: { deployRoleArn: "arn:aws:iam::1:role/x" } });
+    const vars = repoVariables(cfg);
+    expect(vars.find((v) => v.name === "AWS_DEPLOY_ROLE_ARN")!.value).toBe(
+      "arn:aws:iam::1:role/x",
+    );
+    expect(vars.find((v) => v.name === "AWS_REGION")!.value).toBe("af-south-1");
+  });
+
+  it("fills the RASTACK_* env, using outputs where available", () => {
+    const cfg = base({
+      outputs: {
+        warehouseBucket: "wh-bucket",
+        userPoolId: "eu_x",
+        userPoolClientId: "cli",
+      },
+    });
+    const env = Object.fromEntries(lambdaEnv(cfg).map((e) => [e.key, e.value]));
+    expect(env.RASTACK_WAREHOUSE).toBe("s3://wh-bucket/warehouse");
+    expect(env.RASTACK_ISSUER).toBe(
+      "https://cognito-idp.af-south-1.amazonaws.com/eu_x",
+    );
+    expect(env.RASTACK_AUDIENCE).toBe("cli");
+    expect(env.RASTACK_TOKEN_USE).toBe("access");
+  });
+});
+
+describe("ci plan — check", () => {
+  it("validates then compiles, honouring the resources dir + bin", () => {
+    const steps = checkSteps(base({ resourcesDir: "res" }), "npx rastack");
+    expect(steps.map((s) => s.run)).toEqual([
+      "npx rastack check res",
+      "npx rastack compile res .rastack",
+    ]);
+    expect(ciPlan("check", base(), { bin: "rastack" })).toEqual(
+      checkSteps(base(), "rastack"),
+    );
+  });
+});
+
+describe("ci plan — build", () => {
+  it("uses --arm64 and bakes the JWKS from the stack output when unresolved", () => {
+    const steps = buildSteps(base());
+    const cross = steps.find((s) => s.name.startsWith("Cross-build"))!;
+    expect(cross.run).toContain("--arm64");
+    expect(cross.cwd).toBe("rust");
+    const bake = steps.find((s) => s.name.startsWith("Bake"))!;
+    expect(bake.run).toContain("describe-stacks");
+    expect(bake.run).toContain("OutputKey=='JwksUrl'");
+  });
+
+  it("uses --x86-64 for an x86 build and a literal JWKS when wired", () => {
+    const cfg = base({
+      lambda: { ...base().lambda, arch: "x86_64" },
+      outputs: { jwksUrl: "https://jwks" },
+    });
+    const steps = buildSteps(cfg);
+    expect(steps.find((s) => s.name.startsWith("Cross-build"))!.run).toContain(
+      "--x86-64",
+    );
+    const bake = steps.find((s) => s.name.startsWith("Bake"))!;
+    expect(bake.run).toContain('"https://jwks"');
+    expect(bake.run).not.toContain("describe-stacks");
+  });
+
+  it("stages the compiled manifest + openapi next to the binary", () => {
+    const steps = buildSteps(base());
+    const zip = steps.find((s) => s.name.startsWith("Assemble"))!;
+    expect(zip.run).toContain("rust/target/lambda/bootstrap/bootstrap.zip");
+    expect(zip.run).toContain("schema.rastack.json");
+    expect(zip.run).toContain("openapi.json");
+    expect(zip.run).toContain("jwks.json");
+  });
+});
+
+describe("ci plan — deploy", () => {
+  it("builds then ships, resolving the function name live when unwired", () => {
+    const steps = deploySteps(base());
+    const ship = steps.find((s) => s.name.startsWith("Ship"))!;
+    expect(ship.run).toContain("aws lambda update-function-code");
+    expect(ship.run).toContain("OutputKey=='FunctionName'");
+    expect(ship.run).toContain(
+      "fileb://rust/target/lambda/bootstrap/bootstrap.zip",
+    );
+    // build steps are included
+    expect(steps.some((s) => s.name.startsWith("Cross-build"))).toBe(true);
+  });
+
+  it("skips the build with skipBuild and uses the wired function name", () => {
+    const cfg = base({ outputs: { functionName: "airline-api" } });
+    const steps = deploySteps(cfg, { skipBuild: true });
+    expect(steps.some((s) => s.name.startsWith("Cross-build"))).toBe(false);
+    const ship = steps.find((s) => s.name.startsWith("Ship"))!;
+    expect(ship.run).toContain("--function-name airline-api");
+    expect(ship.run).not.toContain("describe-stacks");
+  });
+
+  it("ciPlan dispatches each phase", () => {
+    expect(ciPlan("build", base())).toEqual(buildSteps(base()));
+    expect(ciPlan("deploy", base())).toEqual(deploySteps(base()));
+  });
+});
+
+describe("workflow templates", () => {
+  it("renders valid YAML that pins the deploy branch", () => {
+    const ci = renderCiWorkflow(
+      base({ github: { owner: "o", repo: "r", branch: "main" } }),
+    );
+    const doc = yaml.load(ci) as any;
+    expect(doc.name).toBe("CI");
+    // `on:` parses to the boolean-ish key `true` in YAML 1.1 — assert via the raw text.
+    expect(ci).toContain("branches: [main]");
+    expect(ci).toContain("run: rastack ci check");
+  });
+
+  it("deploy workflow keeps the GitHub expressions intact and runs one line", () => {
+    const wf = renderDeployWorkflow(base());
+    const doc = yaml.load(wf) as any;
+    expect(doc.permissions["id-token"]).toBe("write");
+    expect(wf).toContain("${{ vars.AWS_DEPLOY_ROLE_ARN }}");
+    expect(wf).toContain("aws-actions/configure-aws-credentials@v4");
+    expect(wf).toContain("run: rastack ci deploy");
+  });
+
+  it("names the deploy job after the target architecture", () => {
+    expect(renderDeployWorkflow(base())).toContain("(arm64)");
+    expect(
+      renderDeployWorkflow(
+        base({ lambda: { ...base().lambda, arch: "x86_64" } }),
+      ),
+    ).toContain("(x86_64)");
+  });
+});
+
+describe("scaffold", () => {
+  it("writes the config + both workflows by default", () => {
+    const files = scaffoldFiles(base());
+    expect(files.map((f) => f.path).sort()).toEqual(
+      [CONFIG_PATH, CI_WORKFLOW_PATH, DEPLOY_WORKFLOW_PATH].sort(),
+    );
+    // the config file round-trips through normalize
+    const cfgFile = files.find((f) => f.path === CONFIG_PATH)!;
+    expect(normalizeConfig(JSON.parse(cfgFile.content))).toEqual(base());
+  });
+
+  it("omits the workflows with noWorkflows", () => {
+    const files = scaffoldFiles(base(), { noWorkflows: true });
+    expect(files.map((f) => f.path)).toEqual([CONFIG_PATH]);
+  });
+});