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

package/build/get/__tests__/generator/provider-functions.test.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const provider_generator_1 = require("../../generator/provider-generator");
+const provider_function_model_1 = require("../../generator/models/provider-function-model");
+const codemaker_1 = require("codemaker");
+const util_1 = require("../util");
+const tmp = (0, util_1.createTmpHelper)();
+test("generate provider functions for the time provider (real terraform 1.15.6 schema fragment)", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("provider-functions.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "provider-functions.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const providerFunctionsOutput = fs.readFileSync(path.join(workdir, "providers/time/provider-functions/index.ts"), "utf-8");
+    expect(providerFunctionsOutput).toMatchSnapshot("time-provider-functions");
+    const providerOutput = fs.readFileSync(path.join(workdir, "providers/time/provider/index.ts"), "utf-8");
+    expect(providerOutput).toMatchSnapshot("time-provider");
+    const providerIndex = fs.readFileSync(path.join(workdir, "providers/time/index.ts"), "utf-8");
+    expect(providerIndex).toMatchSnapshot("provider-index");
+    const providerLazyIndex = fs.readFileSync(path.join(workdir, "providers/time/lazy-index.ts"), "utf-8");
+    expect(providerLazyIndex).toMatchSnapshot("provider-lazy-index");
+});
+describe("generate provider functions covering variadic parameters, primitive/list returns, and a 'default' parameter name", () => {
+    let providerFunctionsOutput;
+    let providerIndex;
+    let providerLazyIndex;
+    beforeAll(async () => {
+        const code = new codemaker_1.CodeMaker();
+        const workdir = tmp("provider-functions-synthetic.test");
+        const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "provider-functions-synthetic.test.fixture.json"), "utf-8"));
+        new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+        await code.save(workdir);
+        providerFunctionsOutput = fs.readFileSync(path.join(workdir, "providers/example/provider-functions/index.ts"), "utf-8");
+        providerIndex = fs.readFileSync(path.join(workdir, "providers/example/index.ts"), "utf-8");
+        providerLazyIndex = fs.readFileSync(path.join(workdir, "providers/example/lazy-index.ts"), "utf-8");
+    });
+    test("matches the snapshot", () => {
+        expect(providerFunctionsOutput).toMatchSnapshot("example-provider-functions");
+        expect(providerIndex).toMatchSnapshot("provider-index");
+        expect(providerLazyIndex).toMatchSnapshot("provider-lazy-index");
+    });
+    test("nested collection docstrings use the compact recursive Array/Set notation", () => {
+        // list(set(string)): notation carries the structure; a plain Terraform
+        // list needs no prose note.
+        expect(providerFunctionsOutput).toContain("@param {Array<Set<string>>} nameGroups");
+        expect(providerFunctionsOutput).toContain("@returns {Array<Set<string>>}");
+        // set(list(string)): Set<...> notation plus the set-semantics prose note
+        // (the jsii type is still an array - the note keeps a reader from
+        // literally passing a JS Set).
+        expect(providerFunctionsOutput).toContain("@param {Set<Array<string>>} nameLists - Terraform set; ordering is not guaranteed and duplicate values are removed.");
+        expect(providerFunctionsOutput).toContain("@returns {Set<Array<string>>} Terraform set; ordering is not guaranteed and duplicate values are removed.");
+    });
+    // This package has no TypeScript-compiling harness
+    // for generated output (no fixture/test anywhere generates a snippet and
+    // feeds it through `tsc`/`ts.transpileModule`, and `cdktn` itself isn't a
+    // dependency of this package to typecheck against), so these are
+    // structural assertions on the emitted declaration text rather than an
+    // actual compile - see also the runtime-level proof in
+    // packages/cdktn/test/provider-functions.test.ts, which exercises the
+    // same union/token mechanics these signatures rely on.
+    describe("composition: a function's return type is directly assignable to another function's parameter of the 'same' Terraform type", () => {
+        test("flagsForSeed()'s set(bool) return type (cdktn.IResolvable) is one of the exact union members flagSet()'s set(bool) parameter declares", () => {
+            expect(providerFunctionsOutput).toContain("public flagsForSeed(seed: string): cdktn.IResolvable {");
+            expect(providerFunctionsOutput).toContain("public flagSet(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {");
+        });
+        test("defaultTags()'s map(string) return type is textually identical to tagMap()'s map(string) parameter type", () => {
+            expect(providerFunctionsOutput).toContain("public defaultTags(prefix: string): { [key: string]: string } {");
+            expect(providerFunctionsOutput).toContain("public tagMap(tags: { [key: string]: string }): string {");
+        });
+    });
+    test("a list(bool) parameter (not just set(bool)) also accepts a whole-collection token", () => {
+        expect(providerFunctionsOutput).toContain("public flagsOrdered(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {");
+    });
+    test("a list(object) parameter widens to any[] | cdktn.IResolvable (whole-collection token accepted)", () => {
+        expect(providerFunctionsOutput).toContain("public describeConfigs(configs: any[] | cdktn.IResolvable): string {");
+    });
+});
+test("buildProviderFunctionsModel throws when two function names collapse to the same generated method name", () => {
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        foo_bar: { return_type: "string", parameters: [] },
+        foo__bar: { return_type: "string", parameters: [] },
+    })).toThrow(/foo_bar/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        foo_bar: { return_type: "string", parameters: [] },
+        foo__bar: { return_type: "string", parameters: [] },
+    })).toThrow(/foo__bar/);
+});
+test("buildProviderFunctionsModel throws when two parameter names collapse within one function", () => {
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        my_function: {
+            return_type: "string",
+            parameters: [
+                { name: "some_value", type: "string" },
+                { name: "some__value", type: "string" },
+            ],
+        },
+    })).toThrow(/some_value/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        my_function: {
+            return_type: "string",
+            parameters: [
+                { name: "some_value", type: "string" },
+                { name: "some__value", type: "string" },
+            ],
+        },
+    })).toThrow(/some__value/);
+});
+// Both of these assert the model-level throw happens before any file is
+// generated: buildProviderFunctionsModel is called directly, with no
+// CodeMaker/generator involved, so there is no emission step to reach.
+test("buildProviderFunctionsModel throws when a function name sanitizes to 'constructor'", () => {
+    // The nested signature literal is cast to `FunctionSignature` (rather than
+    // relying on contextual typing from the surrounding index signature)
+    // because TypeScript special-cases a property literally named
+    // "constructor" - contextually typing it against `Function` (from
+    // `Object.prototype`) instead of the index signature's `FunctionSignature`,
+    // and spuriously flagging `return_type: "string"` as an error. See
+    // https://github.com/microsoft/TypeScript/issues/40776.
+    const signature = {
+        return_type: "string",
+        parameters: [],
+    };
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        constructor: signature,
+    })).toThrow(/constructor/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        constructor: signature,
+    })).toThrow(/example/);
+});
+test("buildProviderFunctionsModel throws when a function name sanitizes to 'providerLocalName'", () => {
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        provider_local_name: { return_type: "string", parameters: [] },
+    })).toThrow(/provider_local_name/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        provider_local_name: { return_type: "string", parameters: [] },
+    })).toThrow(/providerLocalName/);
+});
+test("assertNoFunctionsGetterCollision throws when the provider's own config schema would generate a 'functions' property", () => {
+    expect(() => (0, provider_function_model_1.assertNoFunctionsGetterCollision)("example", ["alias", "functions"])).toThrow(/"functions"/);
+});
+test("assertNoFunctionsGetterCollision does not throw when there is no colliding attribute", () => {
+    expect(() => (0, provider_function_model_1.assertNoFunctionsGetterCollision)("example", ["alias"])).not.toThrow();
+});
+test("generation throws when a provider's config attribute collides with the generated 'functions' getter", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "provider-functions-collision.test.fixture.json"), "utf-8"));
+    expect(() => new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll()).toThrow(/"functions"/);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-functions.test.js","sourceRoot":"","sources":["../../../../src/get/__tests__/generator/provider-functions.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { TerraformProviderGenerator } from \"../../generator/provider-generator\";\nimport {\n  assertNoFunctionsGetterCollision,\n  buildProviderFunctionsModel,\n} from \"../../generator/models/provider-function-model\";\nimport { CodeMaker } from \"codemaker\";\nimport { FunctionSignature } from \"@cdktn/commons\";\nimport { createTmpHelper } from \"../util\";\n\nconst tmp = createTmpHelper();\n\ntest(\"generate provider functions for the time provider (real terraform 1.15.6 schema fragment)\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"provider-functions.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"provider-functions.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const providerFunctionsOutput = fs.readFileSync(\n    path.join(workdir, \"providers/time/provider-functions/index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerFunctionsOutput).toMatchSnapshot(\"time-provider-functions\");\n\n  const providerOutput = fs.readFileSync(\n    path.join(workdir, \"providers/time/provider/index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerOutput).toMatchSnapshot(\"time-provider\");\n\n  const providerIndex = fs.readFileSync(\n    path.join(workdir, \"providers/time/index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerIndex).toMatchSnapshot(\"provider-index\");\n\n  const providerLazyIndex = fs.readFileSync(\n    path.join(workdir, \"providers/time/lazy-index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerLazyIndex).toMatchSnapshot(\"provider-lazy-index\");\n});\n\ndescribe(\"generate provider functions covering variadic parameters, primitive/list returns, and a 'default' parameter name\", () => {\n  let providerFunctionsOutput: string;\n  let providerIndex: string;\n  let providerLazyIndex: string;\n\n  beforeAll(async () => {\n    const code = new CodeMaker();\n    const workdir = tmp(\"provider-functions-synthetic.test\");\n    const spec = JSON.parse(\n      fs.readFileSync(\n        path.join(\n          __dirname,\n          \"fixtures\",\n          \"provider-functions-synthetic.test.fixture.json\",\n        ),\n        \"utf-8\",\n      ),\n    );\n    new TerraformProviderGenerator(code, spec).generateAll();\n    await code.save(workdir);\n\n    providerFunctionsOutput = fs.readFileSync(\n      path.join(workdir, \"providers/example/provider-functions/index.ts\"),\n      \"utf-8\",\n    );\n    providerIndex = fs.readFileSync(\n      path.join(workdir, \"providers/example/index.ts\"),\n      \"utf-8\",\n    );\n    providerLazyIndex = fs.readFileSync(\n      path.join(workdir, \"providers/example/lazy-index.ts\"),\n      \"utf-8\",\n    );\n  });\n\n  test(\"matches the snapshot\", () => {\n    expect(providerFunctionsOutput).toMatchSnapshot(\n      \"example-provider-functions\",\n    );\n    expect(providerIndex).toMatchSnapshot(\"provider-index\");\n    expect(providerLazyIndex).toMatchSnapshot(\"provider-lazy-index\");\n  });\n\n  test(\"nested collection docstrings use the compact recursive Array/Set notation\", () => {\n    // list(set(string)): notation carries the structure; a plain Terraform\n    // list needs no prose note.\n    expect(providerFunctionsOutput).toContain(\n      \"@param {Array<Set<string>>} nameGroups\",\n    );\n    expect(providerFunctionsOutput).toContain(\"@returns {Array<Set<string>>}\");\n    // set(list(string)): Set<...> notation plus the set-semantics prose note\n    // (the jsii type is still an array - the note keeps a reader from\n    // literally passing a JS Set).\n    expect(providerFunctionsOutput).toContain(\n      \"@param {Set<Array<string>>} nameLists - Terraform set; ordering is not guaranteed and duplicate values are removed.\",\n    );\n    expect(providerFunctionsOutput).toContain(\n      \"@returns {Set<Array<string>>} Terraform set; ordering is not guaranteed and duplicate values are removed.\",\n    );\n  });\n\n  // This package has no TypeScript-compiling harness\n  // for generated output (no fixture/test anywhere generates a snippet and\n  // feeds it through `tsc`/`ts.transpileModule`, and `cdktn` itself isn't a\n  // dependency of this package to typecheck against), so these are\n  // structural assertions on the emitted declaration text rather than an\n  // actual compile - see also the runtime-level proof in\n  // packages/cdktn/test/provider-functions.test.ts, which exercises the\n  // same union/token mechanics these signatures rely on.\n  describe(\"composition: a function's return type is directly assignable to another function's parameter of the 'same' Terraform type\", () => {\n    test(\"flagsForSeed()'s set(bool) return type (cdktn.IResolvable) is one of the exact union members flagSet()'s set(bool) parameter declares\", () => {\n      expect(providerFunctionsOutput).toContain(\n        \"public flagsForSeed(seed: string): cdktn.IResolvable {\",\n      );\n      expect(providerFunctionsOutput).toContain(\n        \"public flagSet(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {\",\n      );\n    });\n\n    test(\"defaultTags()'s map(string) return type is textually identical to tagMap()'s map(string) parameter type\", () => {\n      expect(providerFunctionsOutput).toContain(\n        \"public defaultTags(prefix: string): { [key: string]: string } {\",\n      );\n      expect(providerFunctionsOutput).toContain(\n        \"public tagMap(tags: { [key: string]: string }): string {\",\n      );\n    });\n  });\n\n  test(\"a list(bool) parameter (not just set(bool)) also accepts a whole-collection token\", () => {\n    expect(providerFunctionsOutput).toContain(\n      \"public flagsOrdered(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {\",\n    );\n  });\n\n  test(\"a list(object) parameter widens to any[] | cdktn.IResolvable (whole-collection token accepted)\", () => {\n    expect(providerFunctionsOutput).toContain(\n      \"public describeConfigs(configs: any[] | cdktn.IResolvable): string {\",\n    );\n  });\n});\n\ntest(\"buildProviderFunctionsModel throws when two function names collapse to the same generated method name\", () => {\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      foo_bar: { return_type: \"string\", parameters: [] },\n      foo__bar: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/foo_bar/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      foo_bar: { return_type: \"string\", parameters: [] },\n      foo__bar: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/foo__bar/);\n});\n\ntest(\"buildProviderFunctionsModel throws when two parameter names collapse within one function\", () => {\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      my_function: {\n        return_type: \"string\",\n        parameters: [\n          { name: \"some_value\", type: \"string\" },\n          { name: \"some__value\", type: \"string\" },\n        ],\n      },\n    }),\n  ).toThrow(/some_value/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      my_function: {\n        return_type: \"string\",\n        parameters: [\n          { name: \"some_value\", type: \"string\" },\n          { name: \"some__value\", type: \"string\" },\n        ],\n      },\n    }),\n  ).toThrow(/some__value/);\n});\n\n// Both of these assert the model-level throw happens before any file is\n// generated: buildProviderFunctionsModel is called directly, with no\n// CodeMaker/generator involved, so there is no emission step to reach.\ntest(\"buildProviderFunctionsModel throws when a function name sanitizes to 'constructor'\", () => {\n  // The nested signature literal is cast to `FunctionSignature` (rather than\n  // relying on contextual typing from the surrounding index signature)\n  // because TypeScript special-cases a property literally named\n  // \"constructor\" - contextually typing it against `Function` (from\n  // `Object.prototype`) instead of the index signature's `FunctionSignature`,\n  // and spuriously flagging `return_type: \"string\"` as an error. See\n  // https://github.com/microsoft/TypeScript/issues/40776.\n  const signature: FunctionSignature = {\n    return_type: \"string\",\n    parameters: [],\n  };\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      constructor: signature,\n    }),\n  ).toThrow(/constructor/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      constructor: signature,\n    }),\n  ).toThrow(/example/);\n});\n\ntest(\"buildProviderFunctionsModel throws when a function name sanitizes to 'providerLocalName'\", () => {\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      provider_local_name: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/provider_local_name/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      provider_local_name: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/providerLocalName/);\n});\n\ntest(\"assertNoFunctionsGetterCollision throws when the provider's own config schema would generate a 'functions' property\", () => {\n  expect(() =>\n    assertNoFunctionsGetterCollision(\"example\", [\"alias\", \"functions\"]),\n  ).toThrow(/\"functions\"/);\n});\n\ntest(\"assertNoFunctionsGetterCollision does not throw when there is no colliding attribute\", () => {\n  expect(() =>\n    assertNoFunctionsGetterCollision(\"example\", [\"alias\"]),\n  ).not.toThrow();\n});\n\ntest(\"generation throws when a provider's config attribute collides with the generated 'functions' getter\", async () => {\n  const code = new CodeMaker();\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"provider-functions-collision.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  expect(() =>\n    new TerraformProviderGenerator(code, spec).generateAll(),\n  ).toThrow(/\"functions\"/);\n});\n"]}

package/build/get/__tests__/generator/provider-source-matching.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provider-source-matching.test.d.ts.map

package/build/get/__tests__/generator/provider-source-matching.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const commons_1 = require("@cdktn/commons");
+const codemaker_1 = require("codemaker");
+const provider_generator_1 = require("../../generator/provider-generator");
+// Builds a minimal provider schema keyed by a single FQPN. The provider body is
+// intentionally empty (like the empty-provider-resources fixture) since these
+// tests only exercise the schema-key <-> target-source matching logic.
+const schemaWithKey = (fqpn) => ({
+    provider_schemas: {
+        [fqpn]: { resource_schemas: null },
+    },
+    provider_versions: {
+        [fqpn]: "1.84.0",
+    },
+});
+const targetForSource = (source) => new commons_1.ConstructsMakerProviderTarget(new commons_1.TerraformProviderConstraint(`${source}@1.84.0`), commons_1.Language.TYPESCRIPT);
+const generateFor = (schemaKey, source) => {
+    const generator = new provider_generator_1.TerraformProviderGenerator(new codemaker_1.CodeMaker(), schemaWithKey(schemaKey));
+    generator.generate(targetForSource(source));
+    return generator;
+};
+describe("provider source matching against schema keys", () => {
+    it("matches a shorthand source against an OpenTofu registry schema key", () => {
+        // Regression test for #216: `tofu providers schema` returns keys under
+        // registry.opentofu.org, so a shorthand source must not assume
+        // registry.terraform.io.
+        const generator = generateFor("registry.opentofu.org/hashicorp/awscc", "hashicorp/awscc");
+        expect(Object.keys(generator.versions)).toContain("registry.opentofu.org/hashicorp/awscc");
+    });
+    it("matches a shorthand source against a Terraform registry schema key", () => {
+        const generator = generateFor("registry.terraform.io/hashicorp/awscc", "hashicorp/awscc");
+        expect(Object.keys(generator.versions)).toContain("registry.terraform.io/hashicorp/awscc");
+    });
+    it("keeps an explicit hostname strict and does not cross registries", () => {
+        expect(() => generateFor("registry.opentofu.org/hashicorp/awscc", "registry.terraform.io/hashicorp/awscc")).toThrow(/Could not find provider with constraint/);
+    });
+    it("matches an explicit hostname when it agrees with the schema key", () => {
+        const generator = generateFor("registry.opentofu.org/hashicorp/awscc", "registry.opentofu.org/hashicorp/awscc");
+        expect(Object.keys(generator.versions)).toContain("registry.opentofu.org/hashicorp/awscc");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/get/__tests__/generator/provider.test.js

@@ -39,6 +39,10 @@ test("generate provider", async () => {
     await code.save(workdir);
     const output = fs.readFileSync(path.join(workdir, "providers/aws/provider/index.ts"), "utf-8");
     expect(output).toMatchSnapshot();
+    // aws has no provider-defined functions in this fixture - no getter, no
+    // cross-directory import should be emitted.
+    expect(output).not.toContain("public get functions()");
+    expect(output).not.toContain("provider-functions");
 });
 test("generate provider with only block_types", async () => {
     const code = new codemaker_1.CodeMaker();
@@ -48,5 +52,9 @@ test("generate provider with only block_types", async () => {
     await code.save(workdir);
     const output = fs.readFileSync(path.join(workdir, "providers/elasticstack/provider/index.ts"), "utf-8");
     expect(output).toMatchSnapshot();
+    // elasticstack has no provider-defined functions in this fixture - no
+    // getter, no cross-directory import should be emitted.
+    expect(output).not.toContain("public get functions()");
+    expect(output).not.toContain("provider-functions");
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/get/__tests__/generator/supported-stored-classes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=supported-stored-classes.test.d.ts.map

package/build/get/__tests__/generator/supported-stored-classes.test.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const commons_1 = require("@cdktn/commons");
+const supported_stored_classes_1 = require("../../generator/models/supported-stored-classes");
+const models_1 = require("../../generator/models");
+describe("resolveStoredClassName", () => {
+    test("own composed name resolves as-is when supported (not collapsed)", () => {
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("stringListMap", "list")).toEqual({
+            name: "StringListMap",
+            collapsed: false,
+        });
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("stringMapMap", "map")).toEqual({
+            name: "StringMapMap",
+            collapsed: false,
+        });
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("numberMapMap", "map")).toEqual({
+            name: "NumberMapMap",
+            collapsed: false,
+        });
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("booleanMapMap", "map")).toEqual({
+            name: "BooleanMapMap",
+            collapsed: false,
+        });
+    });
+    test("unsupported own composed name collapses to nearest Any-wrapper", () => {
+        // map(map(list(string))) - own "stringListMapMap" unsupported, element is a map
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("stringListMapMap", "map")).toEqual({
+            name: "AnyMapMap",
+            collapsed: true,
+        });
+        // list(map(map(string))) - own "stringMapMapList" unsupported, element is a map
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("stringMapMapList", "map")).toEqual({
+            name: "AnyMapList",
+            collapsed: true,
+        });
+        // set(map(list(number))) - own "numberListMapList" unsupported, element is a map
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("numberListMapList", "map")).toEqual({
+            name: "AnyMapList",
+            collapsed: true,
+        });
+        // map(map(map(list(string)))) - own "stringListMapMapMap" unsupported, element is a map
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("stringListMapMapMap", "map")).toEqual({
+            name: "AnyMapMap",
+            collapsed: true,
+        });
+    });
+    test("returns undefined when neither the own name nor a collapsed Any-wrapper exists", () => {
+        // Own name doesn't end in List/Map at all.
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("somethingWeird", "map")).toBeUndefined();
+        // Own name ends in Map, but the element isn't itself a list/set/map, so there is no
+        // "AnyXMap" candidate to fall back to.
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("weirdMap", "struct")).toBeUndefined();
+        expect((0, supported_stored_classes_1.resolveStoredClassName)("weirdMap", "simple")).toBeUndefined();
+    });
+});
+// A minimal stand-in for a non-complex, non-collection AttributeTypeModel whose
+// typeModelType is neither "list", "set", "map", nor "simple"/"struct" - i.e. a shape the
+// generator's collapse logic has no candidate class name for. Used to exercise the
+// defensive plain-getter fallback in AttributeModel.getterType without needing a real
+// (currently nonexistent) unsupported shape.
+class UnresolvableStubTypeModel {
+    get struct() {
+        return undefined;
+    }
+    get isComplex() {
+        return false;
+    }
+    getStoredClassInitializer(_name) {
+        return "";
+    }
+    get storedClassType() {
+        return "unresolvable";
+    }
+    get inputTypeDefinition() {
+        return "any";
+    }
+    getAttributeAccessFunction(name) {
+        return `this.interpolationForAttribute('${name}')`;
+    }
+    get toTerraformFunction() {
+        return "cdktn.anyToTerraform";
+    }
+    get toHclTerraformFunction() {
+        return "cdktn.anyToHclTerraform";
+    }
+    get typeModelType() {
+        return "unresolvable-shape";
+    }
+    get hasReferenceClass() {
+        return false;
+    }
+    get isTokenizable() {
+        return false;
+    }
+    get isStoredClassUnavailable() {
+        return false;
+    }
+}
+describe("AttributeModel.getterType loud fallback", () => {
+    test("falls back to a plain getter and logs a debug breadcrumb when no stored class (not even a collapsed Any-wrapper) is available", () => {
+        const debugSpy = jest.spyOn(commons_1.logger, "debug").mockImplementation();
+        try {
+            // A map whose element is itself an unrecognized shape: own composed name
+            // ("unresolvableMap") isn't in the supported set, and the element's typeModelType
+            // isn't "list"/"set"/"map", so there is no "AnyXMap" candidate either.
+            const type = new models_1.MapAttributeTypeModel(new UnresolvableStubTypeModel());
+            expect(type.isStoredClassUnavailable).toBe(true);
+            const attribute = new models_1.AttributeModel({
+                storageName: "_weirdAttribute",
+                name: "weirdAttribute",
+                type,
+                optional: false,
+                computed: true,
+                terraformName: "weird_attribute",
+                terraformFullName: "test_resource.weird_attribute",
+                provider: false,
+                required: false,
+            });
+            expect(attribute.getterType).toEqual({ _type: "plain" });
+            expect(attribute.storedClassBoundaryKind).toEqual("fallback");
+            expect(debugSpy).toHaveBeenCalledTimes(1);
+            const [message] = debugSpy.mock.calls[0];
+            expect(message).toContain("test_resource.weird_attribute");
+            expect(message).toContain("unresolvableMap");
+            // Repeated access must not spam the logger.
+            void attribute.getterType;
+            void attribute.getterType;
+            expect(debugSpy).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            debugSpy.mockRestore();
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"supported-stored-classes.test.js","sourceRoot":"","sources":["../../../../src/get/__tests__/generator/supported-stored-classes.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { logger } from \"@cdktn/commons\";\nimport { resolveStoredClassName } from \"../../generator/models/supported-stored-classes\";\nimport {\n  AttributeModel,\n  AttributeTypeModel,\n  MapAttributeTypeModel,\n} from \"../../generator/models\";\n\ndescribe(\"resolveStoredClassName\", () => {\n  test(\"own composed name resolves as-is when supported (not collapsed)\", () => {\n    expect(resolveStoredClassName(\"stringListMap\", \"list\")).toEqual({\n      name: \"StringListMap\",\n      collapsed: false,\n    });\n    expect(resolveStoredClassName(\"stringMapMap\", \"map\")).toEqual({\n      name: \"StringMapMap\",\n      collapsed: false,\n    });\n    expect(resolveStoredClassName(\"numberMapMap\", \"map\")).toEqual({\n      name: \"NumberMapMap\",\n      collapsed: false,\n    });\n    expect(resolveStoredClassName(\"booleanMapMap\", \"map\")).toEqual({\n      name: \"BooleanMapMap\",\n      collapsed: false,\n    });\n  });\n\n  test(\"unsupported own composed name collapses to nearest Any-wrapper\", () => {\n    // map(map(list(string))) - own \"stringListMapMap\" unsupported, element is a map\n    expect(resolveStoredClassName(\"stringListMapMap\", \"map\")).toEqual({\n      name: \"AnyMapMap\",\n      collapsed: true,\n    });\n    // list(map(map(string))) - own \"stringMapMapList\" unsupported, element is a map\n    expect(resolveStoredClassName(\"stringMapMapList\", \"map\")).toEqual({\n      name: \"AnyMapList\",\n      collapsed: true,\n    });\n    // set(map(list(number))) - own \"numberListMapList\" unsupported, element is a map\n    expect(resolveStoredClassName(\"numberListMapList\", \"map\")).toEqual({\n      name: \"AnyMapList\",\n      collapsed: true,\n    });\n    // map(map(map(list(string)))) - own \"stringListMapMapMap\" unsupported, element is a map\n    expect(resolveStoredClassName(\"stringListMapMapMap\", \"map\")).toEqual({\n      name: \"AnyMapMap\",\n      collapsed: true,\n    });\n  });\n\n  test(\"returns undefined when neither the own name nor a collapsed Any-wrapper exists\", () => {\n    // Own name doesn't end in List/Map at all.\n    expect(resolveStoredClassName(\"somethingWeird\", \"map\")).toBeUndefined();\n    // Own name ends in Map, but the element isn't itself a list/set/map, so there is no\n    // \"AnyXMap\" candidate to fall back to.\n    expect(resolveStoredClassName(\"weirdMap\", \"struct\")).toBeUndefined();\n    expect(resolveStoredClassName(\"weirdMap\", \"simple\")).toBeUndefined();\n  });\n});\n\n// A minimal stand-in for a non-complex, non-collection AttributeTypeModel whose\n// typeModelType is neither \"list\", \"set\", \"map\", nor \"simple\"/\"struct\" - i.e. a shape the\n// generator's collapse logic has no candidate class name for. Used to exercise the\n// defensive plain-getter fallback in AttributeModel.getterType without needing a real\n// (currently nonexistent) unsupported shape.\nclass UnresolvableStubTypeModel implements AttributeTypeModel {\n  get struct() {\n    return undefined;\n  }\n  get isComplex() {\n    return false;\n  }\n  getStoredClassInitializer(_name: string) {\n    return \"\";\n  }\n  get storedClassType() {\n    return \"unresolvable\";\n  }\n  get inputTypeDefinition() {\n    return \"any\";\n  }\n  getAttributeAccessFunction(name: string) {\n    return `this.interpolationForAttribute('${name}')`;\n  }\n  get toTerraformFunction() {\n    return \"cdktn.anyToTerraform\";\n  }\n  get toHclTerraformFunction() {\n    return \"cdktn.anyToHclTerraform\";\n  }\n  get typeModelType() {\n    return \"unresolvable-shape\";\n  }\n  get hasReferenceClass() {\n    return false;\n  }\n  get isTokenizable() {\n    return false;\n  }\n  get isStoredClassUnavailable() {\n    return false;\n  }\n}\n\ndescribe(\"AttributeModel.getterType loud fallback\", () => {\n  test(\"falls back to a plain getter and logs a debug breadcrumb when no stored class (not even a collapsed Any-wrapper) is available\", () => {\n    const debugSpy = jest.spyOn(logger, \"debug\").mockImplementation();\n\n    try {\n      // A map whose element is itself an unrecognized shape: own composed name\n      // (\"unresolvableMap\") isn't in the supported set, and the element's typeModelType\n      // isn't \"list\"/\"set\"/\"map\", so there is no \"AnyXMap\" candidate either.\n      const type = new MapAttributeTypeModel(new UnresolvableStubTypeModel());\n      expect(type.isStoredClassUnavailable).toBe(true);\n\n      const attribute = new AttributeModel({\n        storageName: \"_weirdAttribute\",\n        name: \"weirdAttribute\",\n        type,\n        optional: false,\n        computed: true,\n        terraformName: \"weird_attribute\",\n        terraformFullName: \"test_resource.weird_attribute\",\n        provider: false,\n        required: false,\n      });\n\n      expect(attribute.getterType).toEqual({ _type: \"plain\" });\n      expect(attribute.storedClassBoundaryKind).toEqual(\"fallback\");\n\n      expect(debugSpy).toHaveBeenCalledTimes(1);\n      const [message] = debugSpy.mock.calls[0];\n      expect(message).toContain(\"test_resource.weird_attribute\");\n      expect(message).toContain(\"unresolvableMap\");\n\n      // Repeated access must not spam the logger.\n      void attribute.getterType;\n      void attribute.getterType;\n      expect(debugSpy).toHaveBeenCalledTimes(1);\n    } finally {\n      debugSpy.mockRestore();\n    }\n  });\n});\n"]}