@cdktn/hcl2cdk 0.23.0-pre.4 → 0.23.0-pre.40

package/ambient.d.ts

@@ -11,4 +11,3 @@ declare module 'child_process' {
 
 declare module 'tunnel-agent';
 declare module 'deep-equal';
-declare module "archiver";

package/build/__tests__/coerceType.test.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const coerceType_1 = require("../coerceType");
+const template_1 = __importDefault(require("@babel/template"));
+const generator_1 = __importDefault(require("@babel/generator"));
+function expressionify(code) {
+    return template_1.default.ast(code).expression;
+}
+function generateCode(ast) {
+    return (0, generator_1.default)(ast).code;
+}
+const scope = {
+    importables: [],
+    variables: {
+        a_user_defined_variable: {
+            resource: "var",
+            variableName: "aUserDefinedVariable",
+        },
+        a_user_defined_local: {
+            resource: "var",
+            variableName: "aUserDefinedTerraformLocal",
+        },
+    },
+};
+describe("coerceType", () => {
+    it.each([
+        { code: `"hello-world"`, type: "string", targetType: undefined },
+        { code: `"hello-world"`, type: "string", targetType: "string" },
+    ])("should change nothing for %p ", ({ code, type, targetType }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(code);
+    });
+    it.each([
+        {
+            code: `"300"`,
+            type: "string",
+            targetType: "number",
+            expectedCode: `Token.asNumber("300")`,
+        },
+        {
+            code: `300`,
+            type: "number",
+            targetType: "string",
+            expectedCode: `Token.asString(300)`,
+        },
+        {
+            code: `"['foo', 'bar']"`,
+            type: "string",
+            targetType: ["list", "string"],
+            expectedCode: `Token.asList("['foo', 'bar']")`,
+        },
+        {
+            code: `"[1,2,3]"`,
+            type: "string",
+            targetType: ["list", "number"],
+            expectedCode: `Token.asNumberList("[1,2,3]")`,
+        },
+        {
+            code: `"['foo', 'bar']"`,
+            type: "string",
+            targetType: ["set", "string"],
+            expectedCode: `Token.asList("['foo', 'bar']")`,
+        },
+        {
+            code: `"[1,2,3]"`,
+            type: "string",
+            targetType: ["set", "number"],
+            expectedCode: `Token.asNumberList("[1,2,3]")`,
+        },
+        // We don't have a token function for boolean lists, so we need to take an asAny
+        {
+            code: `"[true,false,true]"`,
+            type: "string",
+            targetType: ["list", "bool"],
+            expectedCode: `Token.asAny("[true,false,true]")`,
+        },
+        {
+            code: `"{ foo: 'bar' }"`,
+            type: "string",
+            targetType: ["map", "string"],
+            expectedCode: `Token.asStringMap("{ foo: 'bar' }")`,
+        },
+        {
+            code: `"{ foo: 1 }"`,
+            type: "string",
+            targetType: ["map", "number"],
+            expectedCode: `Token.asNumberMap("{ foo: 1 }")`,
+        },
+        {
+            code: `"{ foo: true }"`,
+            type: "string",
+            targetType: ["map", "bool"],
+            expectedCode: `Token.asBooleanMap("{ foo: true }")`,
+        },
+        {
+            code: `"{ foo: {bar: true} }"`,
+            type: "string",
+            targetType: ["map", ["map", "boolean"]],
+            expectedCode: `Token.asAnyMap("{ foo: {bar: true} }")`,
+        },
+    ])("should use Token functions %p", ({ code, type, targetType, expectedCode }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(expectedCode);
+    });
+    it.each([
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: "string",
+            expectedCode: `aUserDefinedVariable.stringValue`,
+        },
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: "number",
+            expectedCode: `aUserDefinedVariable.numberValue`,
+        },
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: ["list", "string"],
+            expectedCode: `aUserDefinedVariable.listValue`,
+        },
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: "bool",
+            expectedCode: `aUserDefinedVariable.booleanValue`,
+        },
+    ])("should use TerraformVariables accessors %p", ({ code, type, targetType, expectedCode }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(expectedCode);
+    });
+    it.each([
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: "string",
+            expectedCode: `aUserDefinedTerraformLocal.stringValue`,
+        },
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: "number",
+            expectedCode: `aUserDefinedTerraformLocal.numberValue`,
+        },
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: ["list", "string"],
+            expectedCode: `aUserDefinedTerraformLocal.listValue`,
+        },
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: "bool",
+            expectedCode: `aUserDefinedTerraformLocal.booleanValue`,
+        },
+    ])("should use TerraformLocal accessors %p", ({ code, type, targetType, expectedCode }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(expectedCode);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coerceType.test.js","sourceRoot":"","sources":["../../src/__tests__/coerceType.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { coerceType } from \"../coerceType\";\nimport template from \"@babel/template\";\nimport generate from \"@babel/generator\";\n\nfunction expressionify(code: string) {\n  return (template.ast(code) as any).expression;\n}\nfunction generateCode(ast: any) {\n  return generate(ast).code;\n}\n\nconst scope: any = {\n  importables: [],\n  variables: {\n    a_user_defined_variable: {\n      resource: \"var\",\n      variableName: \"aUserDefinedVariable\",\n    },\n    a_user_defined_local: {\n      resource: \"var\",\n      variableName: \"aUserDefinedTerraformLocal\",\n    },\n  },\n};\n\ndescribe(\"coerceType\", () => {\n  it.each([\n    { code: `\"hello-world\"`, type: \"string\", targetType: undefined },\n    { code: `\"hello-world\"`, type: \"string\", targetType: \"string\" },\n  ])(\"should change nothing for %p \", ({ code, type, targetType }) => {\n    expect(\n      generateCode(\n        coerceType(scope, expressionify(code), type as any, targetType as any),\n      ),\n    ).toEqual(code);\n  });\n\n  it.each([\n    {\n      code: `\"300\"`,\n      type: \"string\",\n      targetType: \"number\",\n      expectedCode: `Token.asNumber(\"300\")`,\n    },\n    {\n      code: `300`,\n      type: \"number\",\n      targetType: \"string\",\n      expectedCode: `Token.asString(300)`,\n    },\n    {\n      code: `\"['foo', 'bar']\"`,\n      type: \"string\",\n      targetType: [\"list\", \"string\"],\n      expectedCode: `Token.asList(\"['foo', 'bar']\")`,\n    },\n    {\n      code: `\"[1,2,3]\"`,\n      type: \"string\",\n      targetType: [\"list\", \"number\"],\n      expectedCode: `Token.asNumberList(\"[1,2,3]\")`,\n    },\n    {\n      code: `\"['foo', 'bar']\"`,\n      type: \"string\",\n      targetType: [\"set\", \"string\"],\n      expectedCode: `Token.asList(\"['foo', 'bar']\")`,\n    },\n    {\n      code: `\"[1,2,3]\"`,\n      type: \"string\",\n      targetType: [\"set\", \"number\"],\n      expectedCode: `Token.asNumberList(\"[1,2,3]\")`,\n    },\n    // We don't have a token function for boolean lists, so we need to take an asAny\n    {\n      code: `\"[true,false,true]\"`,\n      type: \"string\",\n      targetType: [\"list\", \"bool\"],\n      expectedCode: `Token.asAny(\"[true,false,true]\")`,\n    },\n    {\n      code: `\"{ foo: 'bar' }\"`,\n      type: \"string\",\n      targetType: [\"map\", \"string\"],\n      expectedCode: `Token.asStringMap(\"{ foo: 'bar' }\")`,\n    },\n    {\n      code: `\"{ foo: 1 }\"`,\n      type: \"string\",\n      targetType: [\"map\", \"number\"],\n      expectedCode: `Token.asNumberMap(\"{ foo: 1 }\")`,\n    },\n\n    {\n      code: `\"{ foo: true }\"`,\n      type: \"string\",\n      targetType: [\"map\", \"bool\"],\n      expectedCode: `Token.asBooleanMap(\"{ foo: true }\")`,\n    },\n\n    {\n      code: `\"{ foo: {bar: true} }\"`,\n      type: \"string\",\n      targetType: [\"map\", [\"map\", \"boolean\"]],\n      expectedCode: `Token.asAnyMap(\"{ foo: {bar: true} }\")`,\n    },\n  ])(\n    \"should use Token functions %p\",\n    ({ code, type, targetType, expectedCode }) => {\n      expect(\n        generateCode(\n          coerceType(\n            scope,\n            expressionify(code),\n            type as any,\n            targetType as any,\n          ),\n        ),\n      ).toEqual(expectedCode);\n    },\n  );\n\n  it.each([\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: \"string\",\n      expectedCode: `aUserDefinedVariable.stringValue`,\n    },\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: \"number\",\n      expectedCode: `aUserDefinedVariable.numberValue`,\n    },\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: [\"list\", \"string\"],\n      expectedCode: `aUserDefinedVariable.listValue`,\n    },\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: \"bool\",\n      expectedCode: `aUserDefinedVariable.booleanValue`,\n    },\n  ])(\n    \"should use TerraformVariables accessors %p\",\n    ({ code, type, targetType, expectedCode }) => {\n      expect(\n        generateCode(\n          coerceType(\n            scope,\n            expressionify(code),\n            type as any,\n            targetType as any,\n          ),\n        ),\n      ).toEqual(expectedCode);\n    },\n  );\n\n  it.each([\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: \"string\",\n      expectedCode: `aUserDefinedTerraformLocal.stringValue`,\n    },\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: \"number\",\n      expectedCode: `aUserDefinedTerraformLocal.numberValue`,\n    },\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: [\"list\", \"string\"],\n      expectedCode: `aUserDefinedTerraformLocal.listValue`,\n    },\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: \"bool\",\n      expectedCode: `aUserDefinedTerraformLocal.booleanValue`,\n    },\n  ])(\n    \"should use TerraformLocal accessors %p\",\n    ({ code, type, targetType, expectedCode }) => {\n      expect(\n        generateCode(\n          coerceType(\n            scope,\n            expressionify(code),\n            type as any,\n            targetType as any,\n          ),\n        ),\n      ).toEqual(expectedCode);\n    },\n  );\n});\n"]}