@cdktn/provider-generator 0.24.0-pre.9 → 0.24.0-pre.91

package/src/get/__tests__/generator/versions-file.test.ts

@@ -0,0 +1,72 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+import * as path from "path";
+import { Language, TerraformDependencyConstraint } from "@cdktn/commons";
+import { ConstructsMaker, GetOptions } from "../../constructs-maker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+jest.setTimeout(600_000);
+global.setImmediate =
+  global.setImmediate ||
+  ((fn: any, ...args: any[]) => global.setTimeout(fn, 0, ...args));
+
+describe("versions.json file generation", () => {
+  const languages = [Language.TYPESCRIPT, Language.PYTHON];
+
+  const constraints: TerraformDependencyConstraint[] = [
+    {
+      fqn: "hashicorp/aws",
+      name: "aws",
+      source: "hashicorp/aws",
+      version: "4.0.0",
+    },
+    {
+      fqn: "hashicorp/random",
+      name: "random",
+      source: "hashicorp/random",
+      version: "3.1.3",
+    },
+    {
+      fqn: "kreuzwerker/docker",
+      name: "docker",
+      source: "kreuzwerker/docker",
+      version: "2.16.0",
+    },
+  ];
+
+  beforeAll(() => {});
+
+  test.each(languages)(
+    "generates a file for the %s language",
+    async (language) => {
+      const workdir = tmp("versions-file.test");
+
+      const options: GetOptions = {
+        codeMakerOutput: workdir,
+        targetLanguage: language,
+      };
+
+      // Ignore warnings to pop up from the generate function
+      process.env.NODE_OPTIONS = "--max-old-space-size=16384";
+      const constructMaker = new ConstructsMaker(
+        options,
+        process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH,
+      );
+
+      await constructMaker.generate(constraints);
+
+      const output = fs.readFileSync(
+        path.join(workdir, "versions.json"),
+        "utf-8",
+      );
+      expect(Object.keys(JSON.parse(output))).toEqual(
+        expect.arrayContaining(
+          constraints.map((c) => `registry.terraform.io/${c.fqn}`),
+        ),
+      );
+    },
+  );
+});

package/src/get/__tests__/generator/write-only.test.ts

@@ -0,0 +1,71 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate a vault_alicloud_secret_backend resource with a write-only attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("write-only.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "write-only.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/vault/alicloud-secret-backend/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+
+  // The write-only attribute's getter is deprecated ...
+  expect(output).toMatch(
+    /@deprecated Write-only: the provider never returns this value[\s\S]*?public get secretKeyWo\(\)/,
+  );
+  // ... its setter is a plain assignment ...
+  expect(output).toMatch(
+    /public set secretKeyWo\(value: string\) \{\n\s*this\._secretKeyWo = value;\n\s*\}/,
+  );
+  // ... and usage registration happens at resolve time, from inside
+  // synthesizeAttributes()/synthesizeHclAttributes(), by wrapping the
+  // mapped value in markWriteOnlyAttribute() ...
+  expect(output).toMatch(
+    /secret_key_wo: this\.markWriteOnlyAttribute\(cdktn\.stringToTerraform\(this\._secretKeyWo\)\),/,
+  );
+  expect(output).toMatch(
+    /value: this\.markWriteOnlyAttribute\(cdktn\.stringToHclTerraform\(this\._secretKeyWo\)\),/,
+  );
+
+  // The required write-only attribute gets no reset method (required
+  // attributes never do) ...
+  expect(output).not.toMatch(/resetSecretKeyWo\b/);
+  // ... but the OPTIONAL write-only sibling does, exercising the reset ->
+  // clear -> synth-passes path end to end at the generator level.
+  expect(output).toMatch(
+    /public resetSecondarySecretKeyWo\(\) \{\n\s*this\._secondarySecretKeyWo = undefined;\n\s*\}/,
+  );
+  expect(output).toMatch(
+    /secondary_secret_key_wo: this\.markWriteOnlyAttribute\(cdktn\.stringToTerraform\(this\._secondarySecretKeyWo\)\),/,
+  );
+
+  // The non-write-only sibling attribute is untouched: its getter is
+  // emitted directly (no @deprecated JSDoc immediately above), its setter
+  // has no registration call, and its synthesis isn't wrapped.
+  expect(output).toMatch(
+    /private _secretKeyWoVersion\?: number; \n\s*public get secretKeyWoVersion\(\)/,
+  );
+  expect(output).toMatch(
+    /public set secretKeyWoVersion\(value: number\) \{\n\s*this\._secretKeyWoVersion = value;\n\s*\}/,
+  );
+  expect(output).toMatch(
+    /secret_key_wo_version: cdktn\.numberToTerraform\(this\._secretKeyWoVersion\),/,
+  );
+});

package/src/get/__tests__/target-versions.test.ts

@@ -0,0 +1,206 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+import * as path from "path";
+import {
+  Language,
+  TerraformDependencyConstraint,
+  TerraformTargetVersions,
+} from "@cdktn/commons";
+import { createTmpHelper } from "./util";
+
+const mockReadSchema = jest.fn();
+jest.mock("@cdktn/provider-schema", () => ({
+  readSchema: (...args: unknown[]) => mockReadSchema(...args),
+}));
+
+// Imported after the mock so ConstructsMaker picks up the mocked readSchema.
+import { ConstructsMaker, GetOptions } from "../constructs-maker";
+
+const tmp = createTmpHelper();
+
+const constraint: TerraformDependencyConstraint = {
+  fqn: "hashicorp/random",
+  name: "random",
+  source: "hashicorp/random",
+  version: "3.1.3",
+};
+
+// Minimal schema - no resources/data sources - so generation stays within
+// pure TypeScript emission (no jsii-pacmak invocation), mirroring the
+// "empty-provider-resources" fixture used elsewhere in this package.
+const fakeSchema = {
+  providerSchema: {
+    format_version: "0.2" as const,
+    provider_schemas: {
+      "registry.terraform.io/hashicorp/random": {
+        resource_schemas: null,
+        data_source_schemas: null,
+      },
+    },
+    provider_versions: {
+      "registry.terraform.io/hashicorp/random": "3.1.3",
+    },
+    cli_name: "terraform",
+    cli_version: "1.7.5",
+  },
+};
+
+describe("targetVersions threading through 'cdktn get'", () => {
+  beforeEach(() => {
+    mockReadSchema.mockReset();
+    mockReadSchema.mockResolvedValue(fakeSchema);
+  });
+
+  it("passes GetOptions.targetVersions through to readSchema", async () => {
+    const workdir = tmp("target-versions-thread.test");
+    const targetVersions: TerraformTargetVersions = { terraform: ">=1.5.7" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options, "/some/cache/path");
+    await maker.generate([constraint]);
+
+    expect(mockReadSchema).toHaveBeenCalledWith(
+      [constraint],
+      "/some/cache/path",
+      targetVersions,
+    );
+  });
+
+  it("omits targetVersions from the readSchema call when not configured", async () => {
+    const workdir = tmp("target-versions-absent.test");
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    expect(mockReadSchema).toHaveBeenCalledWith(
+      [constraint],
+      undefined,
+      undefined,
+    );
+  });
+
+  it("stamps constraints.json with targetVersions + cli identity, and older constraints.json files without those fields are still treated as fresh (no forced regeneration)", async () => {
+    const workdir = tmp("target-versions-stamp.test");
+    const targetVersions: TerraformTargetVersions = { terraform: ">=1.5.7" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    const constraintsFile = JSON.parse(
+      await fs.readFile(path.join(workdir, "constraints.json"), "utf8"),
+    );
+    expect(constraintsFile.targetVersions).toEqual(targetVersions);
+    expect(constraintsFile.cli).toEqual({
+      name: "terraform",
+      version: "1.7.5",
+    });
+
+    // Rewrite constraints.json as it would have looked before this feature
+    // landed (no targetVersions/cli fields), keeping the rest identical -
+    // this simulates re-running `cdktn get` against an output directory
+    // generated by an older cdktn version.
+    const {
+      targetVersions: _tv,
+      cli: _cli,
+      ...legacyConstraints
+    } = constraintsFile;
+    await fs.writeFile(
+      path.join(workdir, "constraints.json"),
+      JSON.stringify(legacyConstraints, null, 2),
+    );
+
+    const maker2 = new ConstructsMaker(options);
+    const toGenerate = await maker2.filterAlreadyGenerated([constraint]);
+    expect(toGenerate).toEqual([]);
+  });
+
+  it("threads a partial targetVersions (single product) through unchanged and stamps it verbatim", async () => {
+    const workdir = tmp("target-versions-partial.test");
+    const targetVersions: TerraformTargetVersions = { opentofu: ">=1.11.0" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    expect(mockReadSchema).toHaveBeenCalledWith(
+      [constraint],
+      undefined,
+      targetVersions,
+    );
+
+    // The stamp records exactly what the project declared - no terraform
+    // default is injected at get-time (defaulting for the undeclared
+    // product happens only at synth-time, in resolveTargetVersions).
+    const constraintsFile = JSON.parse(
+      await fs.readFile(path.join(workdir, "constraints.json"), "utf8"),
+    );
+    expect(constraintsFile.targetVersions).toEqual({ opentofu: ">=1.11.0" });
+  });
+
+  it("omits the cli stamp when the fetched schema carries no CLI version metadata", async () => {
+    const workdir = tmp("target-versions-no-cli.test");
+    const {
+      cli_name: _cliName,
+      cli_version: _cliVersion,
+      ...schemaWithoutCli
+    } = fakeSchema.providerSchema;
+    mockReadSchema.mockResolvedValue({ providerSchema: schemaWithoutCli });
+
+    const targetVersions: TerraformTargetVersions = { terraform: ">=1.5.7" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    const constraintsFile = JSON.parse(
+      await fs.readFile(path.join(workdir, "constraints.json"), "utf8"),
+    );
+    expect(constraintsFile.cli).toBeUndefined();
+    expect(constraintsFile.targetVersions).toEqual(targetVersions);
+  });
+
+  it("does not force regeneration when targetVersions change between runs", async () => {
+    // The stamp is diagnostic-only: per the GetOptions.targetVersions doc,
+    // targetVersions never filters codegen (the full schema surface is
+    // always generated), so freshness only compares the providers map and
+    // the cdktf version.
+    const workdir = tmp("target-versions-change.test");
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions: { terraform: ">=1.5.7" },
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    const maker2 = new ConstructsMaker({
+      ...options,
+      targetVersions: { terraform: ">=1.11.0" },
+    });
+    const toGenerate = await maker2.filterAlreadyGenerated([constraint]);
+    expect(toGenerate).toEqual([]);
+  });
+});

package/src/get/__tests__/util.ts

@@ -0,0 +1,75 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as os from "os";
+import {
+  Language,
+  TerraformModuleConstraint,
+  withTempDir,
+} from "@cdktn/commons";
+import { ConstructsMaker } from "../constructs-maker";
+import * as path from "path";
+
+/**
+ * Creates a per-test-file temp-dir helper.
+ *
+ * Returns a `tmp(prefix)` function that creates a uniquely-named directory
+ * under `os.tmpdir()` and tracks it. An `afterAll` hook is registered on
+ * the calling test file's scope; when the file finishes running, every
+ * tracked directory is removed (recursively, force).
+ */
+export function createTmpHelper(): (prefix: string) => string {
+  const dirs: string[] = [];
+  afterAll(() => {
+    for (const d of dirs) fs.rmSync(d, { recursive: true, force: true });
+  });
+  return (prefix: string) => {
+    const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    dirs.push(d);
+    return d;
+  };
+}
+
+export function expectModuleToMatchSnapshot(
+  testName: string,
+  testCategory: string,
+  fixtureNames: string[],
+) {
+  test(testName, async () => {
+    await withTempDir(`${testName.replace(/\s*/, "-")}.test`, async () => {
+      const curdir = process.cwd();
+      fs.mkdirSync("module");
+
+      fixtureNames.forEach((fixtureName) => {
+        fs.copyFileSync(
+          path.join(__dirname, testCategory, "fixtures", fixtureName),
+          path.join(curdir, "module", fixtureName),
+        );
+      });
+
+      const constraint = new TerraformModuleConstraint({
+        source: "./module",
+        name: "module",
+        fqn: "module",
+      });
+
+      fs.mkdirSync("work");
+      const workdir = path.join(curdir, "work");
+
+      const maker = new ConstructsMaker(
+        {
+          codeMakerOutput: workdir,
+          targetLanguage: Language.TYPESCRIPT,
+        },
+        process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH,
+      );
+      await maker.generate([constraint]);
+
+      const output = fs.readFileSync(
+        path.join(workdir, "modules/module.ts"),
+        "utf-8",
+      );
+      expect(output).toMatchSnapshot();
+    });
+  });
+}