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

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

@@ -0,0 +1,686 @@
+// 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);
+  }
+});
+
+test("deeply nested (unsupported) collection attribute types", async () => {
+  // Regression test for https://github.com/open-constructs/cdk-terrain/issues/11:
+  // computed attributes whose type nests list/set/map more than two levels deep (e.g.
+  // map(map(list(string)))) must not generate a reference to a "cdktn.*" stored class
+  // that doesn't exist (e.g. "StringListMapMap"). Instead of falling straight back to a
+  // plain, untyped getter, the generator collapses these into the nearest typed
+  // "Any"-wrapper that does exist (e.g. "AnyMapMap"), preserving typed navigation for the
+  // outer layers. Only shapes with no available stored class at all fall back to a plain
+  // getter.
+  const code = new CodeMaker();
+  const workdir = tmp("deeply-nested-collections.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "deeply-nested-collections.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/data-deeply-nested-collections/index.ts",
+    ),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+
+  // None of the unsupported nested attributes should reference a non-existent "cdktn.*"
+  // wrapper class.
+  expect(output).not.toContain("StringListMapMap");
+  expect(output).not.toContain("StringMapMapList");
+  expect(output).not.toContain("NumberListMapList");
+  expect(output).not.toContain("StringListMapMapMap");
+
+  // Unsupported triple nestings collapse to the nearest typed "Any"-wrapper instead of
+  // falling back to a plain getter.
+  expect(output).toContain('new cdktn.AnyMapMap(this, "map_map_list_string")');
+  expect(output).toContain(
+    'new cdktn.AnyMapList(this, "list_map_map_string", false)',
+  );
+  expect(output).toContain(
+    'new cdktn.AnyMapList(this, "set_map_list_number", true)',
+  );
+  expect(output).toContain(
+    'new cdktn.AnyMapMap(this, "map_map_map_list_string")',
+  );
+
+  // A supported double nesting (map(list(string))) must still emit its stored class.
+  expect(output).toContain('new cdktn.StringListMap(this, "map_list_string")');
+
+  // map(map(number)) / map(map(bool)) are now directly supported by new core classes.
+  expect(output).toContain('new cdktn.NumberMapMap(this, "map_map_number")');
+  expect(output).toContain('new cdktn.BooleanMapMap(this, "map_map_bool")');
+
+  // map(map(string)) is pre-existing, unchanged support.
+  expect(output).toContain('new cdktn.StringMapMap(this, "map_map_string")');
+
+  // Collapsed getters get a JSDoc documenting the Terraform type and the collapse
+  // boundary.
+  expect(output).toContain("Terraform type: `map(map(list(string)))`");
+  expect(output).toContain(
+    "it is exposed as `AnyMapMap` and values below that boundary are untyped tokens",
+  );
+
+  // Supported, non-collapsed attributes must NOT get this JSDoc (avoids snapshot churn).
+  expect(output).not.toContain("Terraform type: `map(list(string))`");
+  expect(output).not.toContain("Terraform type: `map(map(string))`");
+});