@cdktn/provider-generator 0.24.0-pre.5 → 0.24.0-pre.50

package/src/get/__tests__/generator/types.test.ts

@@ -0,0 +1,611 @@
+// 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("computed optional complex attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("computed-complex-option.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "computed-optional-complex.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/computed-optional-complex/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("computed complex attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("computed-complex.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "computed-complex.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/computed-complex/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("computed complex nested attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("computed-complex-nested.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "computed-complex-nested.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/computed-complex-nested/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("string list attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("string-list.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "string-list.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/string-list/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("number list attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("number-list.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "number-list.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/number-list/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("boolean list attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("boolean-list.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "boolean-list.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/boolean-list/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("string map attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("string-map.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "string-map.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/string-map/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("number map attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("number-map.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "number-map.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/number-map/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("boolean map attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("boolean-map.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "boolean-map.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/boolean-map/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("deeply nested block types", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("block-types.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "deeply-nested-block-types.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/deeply-nested-block-types/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("single block type", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("single-block-type.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "single-block-type.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/single-block-type/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("set / list block type", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("set-list-block.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "block-type-set-list.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/block-type-set-list/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("computed nested complex list block type", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("nested-computed-list-block.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "block-type-nested-computed-list.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/aws/block-type-nested-computed-list/index.ts",
+    ),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("primitive string", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("primitive-string.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "primitive-string.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/primitive-string/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("primitive number", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("primitive-number.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "primitive-number.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/primitive-number/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("primitive boolean", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("primitive-boolean.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "primitive-boolean.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/primitive-boolean/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("primitive dynamic", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("primitive-dynamic.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "primitive-dynamic.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/primitive-dynamic/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("ignored attributes", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("ignored-attributes.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "ignored-attributes.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/ignored-attributes/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("incompatible attribute names", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("incompatible-attribute-names.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "incompatible-attribute-names.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/incompatible-attribute-names/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("incompatible resource names", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("incompatible-resource-names.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "incompatible-resource-names.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const files = fs.readdirSync(path.join(workdir, "providers/test"));
+  const topLevelFiles = ["index.ts", "lazy-index.ts"];
+  expect(files).toMatchInlineSnapshot(`
+    [
+      "function-resource",
+      "index.ts",
+      "lazy-index.ts",
+      "license-resource",
+      "object-resource",
+      "provider-resource",
+      "static-resource",
+      "string-resource",
+      "version-resource",
+    ]
+  `);
+
+  for (const file of files) {
+    const output = fs.readFileSync(
+      path.join(
+        workdir,
+        "providers/test/",
+        file,
+        topLevelFiles.includes(file) ? "" : "index.ts",
+      ),
+      "utf-8",
+    );
+    expect(output).toMatchSnapshot(file); // use filename as snapshot indicator to not depend on order of files (e.g. if new file appears)
+  }
+});
+
+test("list of string map attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("list-of-string-map.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "list-of-string-map.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/list-of-string-map/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("map of string list attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("map-of-string-list.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "map-of-string-list.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/map-of-string-list/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("reset and input name conflicts", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("name-conflict.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "name-conflict.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/name-conflict/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("list of list attributes", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("list-list-object.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "list-list-object.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/test/complex/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("list of list of strings", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("list-list-string.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "list-list-string.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  // const resourceOutput = fs.readFileSync(
+  //   path.join(workdir, "providers/test/airbyte-connection/index.ts"),
+  //   "utf-8"
+  // );
+  // expect(resourceOutput).toMatchSnapshot();
+
+  const datasourceOutput = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/data-airbyte-source-schema-catalog/index.ts",
+    ),
+    "utf-8",
+  );
+  expect(datasourceOutput).toMatchSnapshot();
+});
+
+test("map of map of string attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("map-of-map-of-string.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "map-of-map-of-string.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/map-of-map-of-string/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("case-insensitive base name collision", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("case-insensitive-base-name-collision.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "case-insensitive-base-name-collision.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const files = fs.readdirSync(path.join(workdir, "providers/oci"));
+  const topLevelFiles = ["index.ts", "lazy-index.ts"];
+
+  // Verify that colliding base names are disambiguated with a "-a" suffix.
+  expect(files).toContain("load-balancer-backend-set");
+  expect(files).toContain("load-balancer-backendset-a");
+
+  expect(files).toContain("data-oci-load-balancer-backend-sets");
+  expect(files).toContain("data-oci-load-balancer-backendsets-a");
+
+  // No two directories should collide case-insensitively
+  const lowercaseFiles = files.map((f) => f.toLowerCase());
+  const uniqueLowercaseFiles = [...new Set(lowercaseFiles)];
+  expect(lowercaseFiles).toEqual(uniqueLowercaseFiles);
+
+  for (const file of files) {
+    const output = fs.readFileSync(
+      path.join(
+        workdir,
+        "providers/oci/",
+        file,
+        topLevelFiles.includes(file) ? "" : "index.ts",
+      ),
+      "utf-8",
+    );
+    expect(output).toMatchSnapshot(file);
+  }
+});

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}`),
+        ),
+      );
+    },
+  );
+});