@cdktn/hcl2cdk 0.24.0-pre.5 → 0.24.0-pre.51

package/src/__tests__/generation.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { variableTypeToAst } from "../generation";
+import { ProgramScope } from "../types";
+import { astToCode } from "./testHelpers";
+
+describe("variableTypeToAst", () => {
+  async function run(type: string) {
+    return astToCode(
+      await variableTypeToAst(
+        {
+          importables: [],
+        } as unknown as ProgramScope,
+        type,
+      ),
+    );
+  }
+
+  it("should convert a simple type", async () => {
+    expect(await run("${string}")).toMatchInlineSnapshot(
+      `"VariableType.STRING"`,
+    );
+  });
+
+  it("should convert a object type", async () => {
+    expect(
+      await run(
+        "${object({\n          name    = string\n          address = string\n        })}",
+      ),
+    ).toMatchInlineSnapshot(`
+      "VariableType.object({
+        "address": VariableType.STRING,
+        "name": VariableType.STRING
+      })"
+    `);
+  });
+
+  it("should convert a list type", async () => {
+    expect(
+      await run(
+        "${list(object({\n            internal = number\n            external = number\n            protocol = string\n        }))}",
+      ),
+    ).toMatchInlineSnapshot(`
+      "VariableType.list(VariableType.object({
+        "external": VariableType.NUMBER,
+        "internal": VariableType.NUMBER,
+        "protocol": VariableType.STRING
+      }))"
+    `);
+  });
+
+  it("should convert a set type", async () => {
+    expect(await run("${set(string)}")).toMatchInlineSnapshot(
+      `"VariableType.set(VariableType.STRING)"`,
+    );
+  });
+
+  it("should convert a map type", async () => {
+    expect(await run("${map(string)}")).toMatchInlineSnapshot(
+      `"VariableType.map(VariableType.STRING)"`,
+    );
+  });
+
+  it("should convert a tuple type", async () => {
+    expect(await run("${tuple(string, number, bool)}")).toMatchInlineSnapshot(
+      `"VariableType.tuple(VariableType.STRING, VariableType.NUMBER, VariableType.BOOL)"`,
+    );
+  });
+});

package/src/__tests__/jsii-rosetta-workarounds.test.ts

@@ -0,0 +1,145 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+
+import {
+  replaceCsharpImports,
+  replaceGoImports,
+  replaceJavaImports,
+  replacePythonImports,
+} from "../jsii-rosetta-workarounds";
+
+describe("jsii-rosetta-workarounds", () => {
+  describe("replacePythonImports", () => {
+    it("normal imports", () => {
+      const code = `
+import constructs as constructs
+# Provider bindings are generated by running cdktn get.
+# See https://cdktn.io/docs/concepts/providers#import-providers for more details.
+import ...gen.providers.scaleway as scaleway
+class MyConvertedCode(constructs.Construct):
+    def __init__(self, scope, name):
+        super().__init__(scope, name)
+        scaleway.provider.ScalewayProvider(self, "scaleway",
+            region="fr-par",
+            zone="fr-par-1"
+        )`;
+
+      expect(replacePythonImports(code)).toEqual(
+        expect.stringContaining("import imports.scaleway as scaleway"),
+      );
+    });
+
+    it("granular imports", () => {
+      const code = `from ...gen.providers.aws.lib.rdsCluster import RdsCluster`;
+
+      expect(replacePythonImports(code)).toEqual(
+        "from imports.aws.rdsCluster import RdsCluster",
+      );
+
+      const withoutLibCode = `from ...gen.providers.azurerm.resource_group import ResourceGroup`;
+      expect(replacePythonImports(withoutLibCode)).toEqual(
+        "from imports.azurerm.resource_group import ResourceGroup",
+      );
+    });
+
+    it("resource imports", () => {
+      const code = `import ...gen.providers.aws.lib.rdsCluster as RdsCluster`;
+
+      expect(replacePythonImports(code)).toEqual(
+        "import imports.aws.rdsCluster as RdsCluster",
+      );
+    });
+
+    it("fixes module imports", () => {
+      const code = `import ...gen.modules.hello_module as HelloModule`;
+
+      expect(replacePythonImports(code)).toEqual(
+        "import imports.hello_module as HelloModule",
+      );
+    });
+  });
+
+  describe("replaceCsharpImports", () => {
+    it("normal imports", () => {
+      const code = `using Gen.Providers.Aws.Lib.RdsCluster;`;
+
+      expect(replaceCsharpImports(code)).toEqual("using aws.RdsCluster;");
+    });
+
+    it("fixes module imports", () => {
+      const code = `using Gen.Modules.HelloModule`;
+
+      expect(replaceCsharpImports(code)).toEqual("using HelloModule");
+
+      const anotherCode = `using Gen.Modules.Hello.Module`;
+
+      expect(replaceCsharpImports(anotherCode)).toEqual("using Hello.Module");
+    });
+  });
+
+  describe("replaceJavaImports", () => {
+    it("normal imports", () => {
+      const code = `import gen.providers.scaleway.objectResource.*;`;
+
+      expect(replaceJavaImports(code)).toEqual(
+        "import imports.scaleway.objectResource.*;",
+      );
+    });
+
+    it("precise imports", () => {
+      const code = `import gen.providers.aws.lib.s3Bucket.S3Bucket;`;
+
+      expect(replaceJavaImports(code)).toEqual(
+        "import imports.aws.s3Bucket.S3Bucket;",
+      );
+
+      const withoutLibImport = `import gen.providers.aws.s3Bucket.S3Bucket;`;
+
+      expect(replaceJavaImports(withoutLibImport)).toEqual(
+        "import imports.aws.s3Bucket.S3Bucket;",
+      );
+    });
+
+    it("fixes module imports", () => {
+      const code = `import gen.modules.hello.module.*;`;
+
+      expect(replaceJavaImports(code)).toEqual(
+        "import imports.hello.module.*;",
+      );
+
+      const anotherCode = `import gen.modules.helloModule.*;`;
+
+      expect(replaceJavaImports(anotherCode)).toEqual(
+        "import imports.helloModule.*;",
+      );
+    });
+  });
+
+  describe("replaceGoImports", () => {
+    it("normal imports", () => {
+      const code = `import "github.com/aws-samples/dummy/gen/providers/scaleway/objectBucket"`;
+
+      expect(replaceGoImports(code)).toEqual(
+        `import "cdk.tf/go/stack/generated/scaleway/objectBucket"`,
+      );
+    });
+
+    it("precise imports", () => {
+      const code = `import "github.com/aws-samples/dummy/gen/providers/aws/lib/dbInstance"`;
+
+      expect(replaceGoImports(code)).toEqual(
+        `import "cdk.tf/go/stack/generated/aws/dbInstance"`,
+      );
+    });
+
+    it("fixes module imports", () => {
+      const code = `import helloModule "github.com/aws-samples/dummy/gen/modules/hello_module"`;
+
+      expect(replaceGoImports(code)).toEqual(
+        // TODO: Set up cdktn.io/ static redirect?
+        // "github.com/open-constructs/cdk-terrain/examples/go/documentation/generated/terraform-aws-modules/aws/vpc"
+        `import helloModule "cdk.tf/go/stack/generated/hello_module"`,
+      );
+    });
+  });
+});

package/src/__tests__/partialCode.test.ts

@@ -0,0 +1,432 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { fillWithConfigAccessors } from "../partialCode";
+import { ProgramScope } from "../types";
+
+const getScope = () =>
+  ({
+    providerSchema: {
+      format_version: "0.1",
+      provider_schemas: {
+        aws: {
+          data_source_schemas: {},
+          provider: {
+            block: {
+              attributes: {},
+              block_types: {},
+            },
+            version: 0,
+          },
+          resource_schemas: {
+            aws_image: {
+              version: 0,
+              block: {
+                block_types: {
+                  c: {
+                    nesting_mode: "single",
+                    block: {
+                      attributes: {
+                        d: {
+                          type: "string",
+                          description_kind: "plain",
+                          optional: true,
+                          required: true,
+                        },
+                      },
+                      block_types: {},
+                    },
+                  },
+                  d: {
+                    nesting_mode: "list",
+                    block: {
+                      attributes: {
+                        e: {
+                          type: "string",
+                          description_kind: "plain",
+                          optional: true,
+                          required: true,
+                        },
+                      },
+                      block_types: {},
+                    },
+                    min_items: 1,
+                  },
+                  timeouts: {
+                    nesting_mode: "single",
+                    block: {
+                      attributes: {
+                        read: {
+                          type: "string",
+                          description_kind: "plain",
+                          optional: true,
+                        },
+                      },
+                      block_types: {},
+                      description_kind: "plain",
+                    },
+                  },
+                },
+                attributes: {
+                  a: {
+                    type: "string",
+                    required: true,
+                  },
+                  b: {
+                    type: "string",
+                    required: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    constructs: new Set(),
+    hasTokenBasedTypeCoercion: false,
+    nodeIds: [],
+    providerGenerator: {},
+    variables: {},
+    importables: [],
+
+    // This should be mutated
+    topLevelConfig: {},
+  }) as ProgramScope;
+
+describe("fillWithConfigAccessors", () => {
+  it("adds a missing required attributes", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        c: {
+          d: "d",
+        },
+        timeouts: {
+          read: "20m",
+        },
+        d: [{ e: "e" }],
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig.b).toEqual("aws.image.b");
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": {
+          "computed": false,
+          "object": {
+            "name": "config",
+            "type": "Identifier",
+          },
+          "optional": null,
+          "property": {
+            "name": "b",
+            "type": "Identifier",
+          },
+          "type": "MemberExpression",
+        },
+        "c": {
+          "d": "d",
+        },
+        "d": [
+          {
+            "e": "e",
+          },
+        ],
+        "timeouts": {
+          "read": "20m",
+        },
+      }
+    `);
+  });
+
+  it("ignores missing unrequired set block types", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        b: "b",
+        c: {
+          d: "d",
+        },
+        d: [{ e: "e" }],
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig).toEqual({});
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "b",
+        "c": {
+          "d": "d",
+        },
+        "d": [
+          {
+            "e": "e",
+          },
+        ],
+      }
+    `);
+  });
+
+  it("fills within a single block type", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        b: "b",
+        c: {},
+        d: [{ e: "e" }],
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig).toEqual({
+      d: "aws.image.c.d",
+    });
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "b",
+        "c": {
+          "d": {
+            "computed": false,
+            "object": {
+              "name": "config",
+              "type": "Identifier",
+            },
+            "optional": null,
+            "property": {
+              "name": "d",
+              "type": "Identifier",
+            },
+            "type": "MemberExpression",
+          },
+        },
+        "d": [
+          {
+            "e": "e",
+          },
+        ],
+      }
+    `);
+  });
+
+  it("fills an entire single block type", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        b: "b",
+        d: [{ e: "e" }],
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig).toEqual({
+      c: "aws.image.c",
+    });
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "b",
+        "c": {
+          "computed": false,
+          "object": {
+            "name": "config",
+            "type": "Identifier",
+          },
+          "optional": null,
+          "property": {
+            "name": "c",
+            "type": "Identifier",
+          },
+          "type": "MemberExpression",
+        },
+        "d": [
+          {
+            "e": "e",
+          },
+        ],
+      }
+    `);
+  });
+
+  it("fills within a list block type", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        b: "b",
+        c: { d: "d" },
+        d: [{}],
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig).toEqual({
+      e: "aws.image.d.[].e",
+    });
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "b",
+        "c": {
+          "d": "d",
+        },
+        "d": [
+          {
+            "e": {
+              "computed": false,
+              "object": {
+                "name": "config",
+                "type": "Identifier",
+              },
+              "optional": null,
+              "property": {
+                "name": "e",
+                "type": "Identifier",
+              },
+              "type": "MemberExpression",
+            },
+          },
+        ],
+      }
+    `);
+  });
+
+  it("fills an entire list block type", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        b: "b",
+        c: { d: "d" },
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig).toEqual({
+      d: "aws.image.d",
+    });
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "b",
+        "c": {
+          "d": "d",
+        },
+        "d": {
+          "computed": false,
+          "object": {
+            "name": "config",
+            "type": "Identifier",
+          },
+          "optional": null,
+          "property": {
+            "name": "d",
+            "type": "Identifier",
+          },
+          "type": "MemberExpression",
+        },
+      }
+    `);
+  });
+
+  it("can handle multiple fills with the same name", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        b: "b",
+        c: {},
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig).toEqual({
+      d: "aws.image.c.d",
+      d1: "aws.image.d",
+    });
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "b",
+        "c": {
+          "d": {
+            "computed": false,
+            "object": {
+              "name": "config",
+              "type": "Identifier",
+            },
+            "optional": null,
+            "property": {
+              "name": "d",
+              "type": "Identifier",
+            },
+            "type": "MemberExpression",
+          },
+        },
+        "d": {
+          "computed": false,
+          "object": {
+            "name": "config",
+            "type": "Identifier",
+          },
+          "optional": null,
+          "property": {
+            "name": "d1",
+            "type": "Identifier",
+          },
+          "type": "MemberExpression",
+        },
+      }
+    `);
+  });
+
+  it("fills lists with min_items > 0", () => {
+    const scope = getScope();
+    const result = fillWithConfigAccessors(
+      scope,
+      {
+        a: "a",
+        b: "b",
+        c: { d: "d" },
+        d: [],
+      },
+      "aws.image",
+    );
+    expect(scope.topLevelConfig).toEqual({
+      d: "aws.image.d",
+    });
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "b",
+        "c": {
+          "d": "d",
+        },
+        "d": {
+          "computed": false,
+          "object": {
+            "name": "config",
+            "type": "Identifier",
+          },
+          "optional": null,
+          "property": {
+            "name": "d",
+            "type": "Identifier",
+          },
+          "type": "MemberExpression",
+        },
+      }
+    `);
+  });
+});