@cdktn/hcl2cdk 0.24.0-pre.6 → 0.24.0-pre.60

package/test/convertProject.test.ts

@@ -0,0 +1,257 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import {
+  LANGUAGES,
+  TerraformProviderConstraint,
+  ConstructsMakerProviderTarget,
+} from "@cdktn/commons";
+import { readSchema } from "@cdktn/provider-schema";
+import { convertProject, getTerraformConfigFromDir } from "../src";
+import { createTmpHelper } from "./helpers/tmp";
+
+const tmp = createTmpHelper();
+
+const providerRequirements = ["kreuzwerker/docker@ ~>2.15.0"];
+const CDKTF_CLI = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "packages",
+  "cdktn-cli",
+);
+
+const createFiles = (cwd: string, files: [string, string][]) => {
+  files.forEach(([p, content]) => {
+    fs.writeFileSync(path.resolve(cwd, p), content, "utf8");
+  });
+};
+
+const createTSCdkProject = (cwd: string) =>
+  createFiles(cwd, [
+    [
+      "cdktf.json",
+      `{
+"language": "typescript",
+"app": "npm run --silent compile && node main.js",
+"terraformProviders": [],
+"terraformModules": [],
+"context": {}}`,
+    ],
+    [
+      "main.ts",
+      `import { Construct } from "constructs";
+import { App, TerraformStack } from "cdktn";
+
+
+class MyStack extends TerraformStack {
+    constructor(scope: Construct, name: string) {
+    super(scope, name);
+
+    // define resources here
+    }
+}
+
+const app = new App();
+new MyStack(app, "converted");
+app.synth();`,
+    ],
+    [
+      "package.json",
+      `{
+        "name": "converted",
+        "version": "1.0.0",
+        "main": "main.js",
+        "types": "main.ts",
+        "license": "MPL-2.0",
+        "private": true,
+        "scripts": {
+          "get": "cdktn get",
+          "build": "tsc",
+          "synth": "cdktn synth",
+          "compile": "tsc --pretty",
+          "watch": "tsc -w",
+          "test": "echo ok",
+          "upgrade": "npm i cdktn@latest cdktn-cli@latest",
+          "upgrade:next": "npm i cdktn@next cdktn-cli@next"
+        },
+        "engines": {
+          "node": ">=20.9"
+        },
+        "dependencies": {
+          "cdktn": "latest",
+          "constructs": "^10.3.0"
+        },
+        "devDependencies": {
+          "@types/node": "^14.0.26",
+          "typescript": "^5.4.5",
+          "cdktn-cli": "${CDKTF_CLI}"
+        }
+      }`,
+    ],
+    [
+      "tsconfig.json",
+      `{
+        "compilerOptions": {
+          "alwaysStrict": true,
+          "declaration": true,
+          "experimentalDecorators": true,
+          "inlineSourceMap": true,
+          "inlineSources": true,
+          "lib": [
+            "es2018"
+          ],
+          "module": "CommonJS",
+          "noEmitOnError": true,
+          "noFallthroughCasesInSwitch": true,
+          "noImplicitAny": true,
+          "noImplicitReturns": true,
+          "noImplicitThis": true,
+          "noUnusedLocals": true,
+          "noUnusedParameters": true,
+          "resolveJsonModule": true,
+          "strict": true,
+          "strictNullChecks": true,
+          "strictPropertyInitialization": true,
+          "stripInternal": true,
+          "target": "ES2018"
+        },
+        "include": [
+          "**/*.ts"
+        ],
+        "exclude": [
+          "node_modules"
+        ]
+      }`,
+    ],
+  ]);
+
+const terraformProject = (files: [string, string][]) => {
+  const dir = tmp("cdktf-convert.");
+  createFiles(dir, files);
+
+  return {
+    importPath: dir,
+    targetPath: tmp("cdktf-converted."),
+  };
+};
+
+const exec = (command: string, cwd: string) =>
+  execSync(command, {
+    cwd,
+    ...(process.env.VERBOSE === "true" ? { stdio: "inherit" } : {}),
+  });
+
+const getTerraformPlan = (cwd: string) => {
+  exec(`terraform init`, cwd);
+  exec(`terraform plan -out planfile`, cwd);
+  exec(`terraform show -json planfile > plan.json`, cwd);
+
+  return JSON.parse(fs.readFileSync(path.resolve(cwd, "plan.json"), "utf8"));
+};
+
+const getCdkPlan = (cwd: string) => {
+  exec(`npm install`, cwd);
+  exec(`npm run get`, cwd);
+  exec(`npm run synth`, cwd);
+
+  return getTerraformPlan(path.resolve(cwd, "cdktf.out/stacks/converted/"));
+};
+
+function resources(plan: any) {
+  return plan.planned_values.root_module.resources.map((item: any) => ({
+    type: item.type,
+    provider_name: item.provider_name,
+    values: item.values,
+  }));
+}
+
+let cachedProviderSchema: any;
+describe.skip("convertProject", () => {
+  beforeAll(async () => {
+    // Get all the provider schemas
+    const { providerSchema } = await readSchema(
+      providerRequirements.map((spec) =>
+        ConstructsMakerProviderTarget.from(
+          new TerraformProviderConstraint(spec),
+          LANGUAGES[0],
+        ),
+      ),
+    );
+    cachedProviderSchema = providerSchema;
+  });
+  it("has a similar plan", async () => {
+    const { importPath, targetPath } = terraformProject([
+      [
+        "main.tf",
+        `terraform {
+        required_providers {
+          docker = {
+            source  = "kreuzwerker/docker"
+            version = "2.14.0"
+          }
+        }
+      }
+
+      provider "docker" {
+        host = "unix:///var/run/docker.sock"
+      }`,
+      ],
+      [
+        "container.tf",
+        `resource "docker_image" "ubuntu" {
+            name = "ubuntu:latest"
+          }
+
+          resource "docker_container" "foo" {
+            image = docker_image.ubuntu.latest
+            name  = "foo"
+          }`,
+      ],
+      [
+        "cluster.tf",
+        `module "k3s" {
+        source  = "camptocamp/k3s/docker"
+        version = "0.11.0"
+
+        cluster_endpoint = ""
+        cluster_name = "cdktf"
+        network_name = ""
+      }`,
+      ],
+    ]);
+
+    const previousPlan = getTerraformPlan(importPath);
+    createTSCdkProject(targetPath);
+    const mainTs = fs.readFileSync(path.resolve(targetPath, "main.ts"), "utf8");
+
+    const { code, cdktfJson } = await convertProject(
+      getTerraformConfigFromDir(importPath),
+      {
+        language: "typescript",
+        providerSchema: cachedProviderSchema,
+      },
+    );
+
+    fs.writeFileSync(path.resolve(targetPath, "main.ts"), code(mainTs), "utf8");
+    fs.writeFileSync(
+      path.resolve(targetPath, "cdktf.json"),
+      JSON.stringify(
+        cdktfJson(
+          JSON.parse(
+            fs.readFileSync(path.resolve(targetPath, "cdktf.json"), "utf-8"),
+          ),
+        ),
+      ),
+      "utf8",
+    );
+
+    const currentPlan = getCdkPlan(targetPath);
+
+    expect(resources(currentPlan)).toEqual(resources(previousPlan));
+  });
+});

package/test/externals.test.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { testCase, Synth, binding, Snapshot } from "./helpers/convert";
+
+describe("externals", () => {
+  testCase.test(
+    "handle simple external data",
+    `
+    provider "external" {
+    }
+
+    variable "fargate_region" {
+      type    = string
+      default = "us-east-1"
+    }
+
+    data "external" "thumbprint" {
+      program    = ["\${path.module}/oidc_thumbprint.sh", var.fargate_region]
+    }
+
+    output "foo" {
+      value = data.external.thumbprint.result.thumbprint
+    }
+      `,
+    [binding.external],
+    Snapshot.yes,
+    Synth.yes,
+    {
+      dataSources: ["external"],
+    },
+  );
+});

package/test/globalSetup.ts

@@ -0,0 +1,224 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import execa from "execa";
+import { readSchema } from "@cdktn/provider-schema";
+import {
+  TerraformProviderConstraint,
+  TerraformModuleConstraint,
+} from "@cdktn/commons";
+
+const cdktnBin = path.join(__dirname, "../../../cdktn-cli/bin/cdktn");
+const cdktnDist = path.join(__dirname, "../../../../dist");
+
+const includeSynthTests = Boolean(process.env.CI);
+
+enum ProviderType {
+  provider,
+  module,
+}
+
+type ProviderDefinition = {
+  fqn: string;
+  type: ProviderType;
+  path: string;
+};
+
+const bindings: Record<string, ProviderDefinition> = {
+  aws: {
+    fqn: "hashicorp/aws@=5.11.0",
+    type: ProviderType.provider,
+    path: "providers/aws",
+  },
+  docker: {
+    fqn: "kreuzwerker/docker@=3.0.1",
+    type: ProviderType.provider,
+    path: "providers/docker",
+  },
+  null: {
+    fqn: "hashicorp/null@=3.2.1",
+    type: ProviderType.provider,
+    path: "providers/null",
+  },
+  google: {
+    fqn: "hashicorp/google@=4.55.0",
+    type: ProviderType.provider,
+    path: "providers/google",
+  },
+  azuread: {
+    fqn: "hashicorp/azuread@=2.36.0",
+    type: ProviderType.provider,
+    path: "providers/azuread",
+  },
+  local: {
+    fqn: "hashicorp/local@=2.3.0",
+    type: ProviderType.provider,
+    path: "providers/local",
+  },
+  auth0: {
+    fqn: "alexkappa/auth0@=0.26.2",
+    type: ProviderType.provider,
+    path: "providers/auth0",
+  },
+  datadog: {
+    fqn: "DataDog/datadog@=3.21.0",
+    type: ProviderType.provider,
+    path: "providers/datadog",
+  },
+  kubernetes: {
+    fqn: "hashicorp/kubernetes@=2.18.0",
+    type: ProviderType.provider,
+    path: "providers/kubernetes",
+  },
+  scaleway: {
+    fqn: "scaleway/scaleway@ ~>2.10.0",
+    type: ProviderType.provider,
+    path: "providers/scaleway",
+  },
+  external: {
+    fqn: "hashicorp/external@=2.3.1",
+    type: ProviderType.provider,
+    path: "providers/external",
+  },
+  awsVpc: {
+    fqn: "terraform-aws-modules/vpc/aws@=3.19.0",
+    type: ProviderType.module,
+    path: "modules/terraform-aws-modules/aws",
+  },
+};
+
+/**
+ * Generates TypeScript bindings for one provider or module by running `cdktn get` in a fresh temp dir under
+ * `parentDir`, and returns the absolute path to the generated `.gen/<binding.path>` subtree. The temp dir lives under
+ * `parentDir` (the fixtures root) so `globalTeardown` reclaims it along with the rest of the fixtures.
+ *
+ * @param binding The provider or module to generate bindings for (fqn, type, path inside `.gen`).
+ * @param parentDir Parent directory under which the per-binding temp dir is created — pass `fixturesDir` so cleanup
+ *   happens via `globalTeardown`.
+ * @returns Absolute path to the generated binding root (i.e. `<tempDir>/.gen/<binding.path>`).
+ */
+async function generateBinding(
+  binding: ProviderDefinition,
+  parentDir: string,
+): Promise<string> {
+  const tempDir = await fs.mkdtemp(path.join(parentDir, "cdktf-provider-"));
+  await fs.writeFile(
+    path.resolve(tempDir, "cdktf.json"),
+    JSON.stringify({
+      language: "typescript",
+      app: "npx ts-node main.ts",
+      terraformProviders:
+        binding.type === ProviderType.provider ? [binding.fqn] : [],
+      terraformModules:
+        binding.type === ProviderType.module ? [binding.fqn] : [],
+    }),
+  );
+  await execa(cdktnBin, ["get"], { cwd: tempDir });
+
+  return path.resolve(tempDir, ".gen", binding.path);
+}
+
+/**
+ * Initialises a fresh CDKTN project for the given language by running `cdktn init --local --template=<language>` in a
+ * new temp dir under `parentDir`, and returns the absolute path to that project. The project is treated as a read-only
+ * base — each test gets its own provisioned copy via `copyBaseProject` (which symlinks the heavy `node_modules`).
+ *
+ * @param language Template to initialise (e.g. `typescript`, `python`, `csharp`).
+ * @param parentDir Parent directory under which the per-language temp project dir is created — pass `fixturesDir` so
+ *   cleanup happens via `globalTeardown`.
+ * @returns Absolute path to the initialised base project.
+ */
+async function prepareBaseProject(
+  language: string,
+  parentDir: string,
+): Promise<string> {
+  const projectDir = await fs.mkdtemp(
+    path.join(parentDir, "cdktf-convert-base-"),
+  );
+  await execa(
+    cdktnBin,
+    [
+      "init",
+      "--local",
+      `--dist=${cdktnDist}`,
+      "--project-name='hello'",
+      "--project-description='world'",
+      `--template=${language}`,
+      "--enable-crash-reporting=false",
+    ],
+    {
+      cwd: projectDir,
+    },
+  );
+  return projectDir;
+}
+
+export interface FixturesManifest {
+  providerBindings: Record<string, string>; // fqn -> absolute path to generated binding dir
+  baseProjects: Record<string, string>; // language -> absolute path to base project dir
+  schemaCacheDir: string; // absolute path to pre-populated provider schema cache
+}
+
+module.exports = async function globalSetup() {
+  const fixturesDir = await fs.mkdtemp(
+    path.join(os.tmpdir(), "hcl2cdk-fixtures-"),
+  );
+
+  console.log("[globalSetup] Generating provider bindings...");
+  const bindingEntries = Object.values(bindings);
+  const bindingResults = await Promise.all(
+    bindingEntries.map(async (b) => {
+      const absolutePath = await generateBinding(b, fixturesDir);
+      return [b.fqn, absolutePath] as [string, string];
+    }),
+  );
+  const providerBindings = Object.fromEntries(bindingResults);
+
+  const requiredLanguages = includeSynthTests
+    ? ["typescript", "python", "csharp"]
+    : ["typescript"];
+
+  console.log(
+    `[globalSetup] Initializing base projects for: ${requiredLanguages.join(", ")}...`,
+  );
+  const baseProjectEntries = await Promise.all(
+    requiredLanguages.map(async (lang) => {
+      const projectDir = await prepareBaseProject(lang, fixturesDir);
+      return [lang, projectDir] as [string, string];
+    }),
+  );
+  const baseProjects = Object.fromEntries(baseProjectEntries);
+
+  // Pre-cache provider schemas so test workers never need to run terraform
+  const schemaCacheDir = path.join(fixturesDir, "schema-cache");
+  await fs.mkdirp(schemaCacheDir);
+
+  console.log("[globalSetup] Pre-caching provider schemas...");
+  await Promise.all(
+    bindingEntries.map(async (entry) => {
+      const constraint =
+        entry.type === ProviderType.provider
+          ? new TerraformProviderConstraint(entry.fqn)
+          : new TerraformModuleConstraint(entry.fqn);
+      await readSchema([constraint], schemaCacheDir);
+    }),
+  );
+
+  const manifest: FixturesManifest = {
+    providerBindings,
+    baseProjects,
+    schemaCacheDir,
+  };
+  const manifestPath = path.join(fixturesDir, "manifest.json");
+  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+
+  // Pass to test workers via environment variables
+  // (Jest 29 propagates parent env to forked workers)
+  process.env.HCL2CDK_FIXTURES_MANIFEST = manifestPath;
+  process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH = schemaCacheDir;
+  process.env.HCL2CDK_FIXTURES_DIR = fixturesDir;
+
+  console.log(`[globalSetup] Fixtures manifest written to ${manifestPath}`);
+};

package/test/globalTeardown.ts

@@ -0,0 +1,11 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+
+module.exports = async function globalTeardown() {
+  const fixturesDir = process.env.HCL2CDK_FIXTURES_DIR;
+  if (fixturesDir) {
+    console.log(`[globalTeardown] Cleaning up fixtures at ${fixturesDir}`);
+    await fs.remove(fixturesDir);
+  }
+};

package/test/granular-imports.test.ts

@@ -0,0 +1,161 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { testCase, Synth, binding, Snapshot } from "./helpers/convert";
+
+describe("granular-imports", () => {
+  testCase.test(
+    "nested sub-structs",
+    `
+    provider "kubernetes" {
+    }
+    resource "kubernetes_deployment" "example" {
+      metadata {
+        name = "terraform-example"
+        labels = {
+          test = "MyExampleApp"
+        }
+      }
+
+      spec {
+        replicas = 3
+
+        selector {
+          match_labels = {
+            test = "MyExampleApp"
+          }
+        }
+
+        template {
+          metadata {
+            labels = {
+              test = "MyExampleApp"
+            }
+          }
+
+          spec {
+            container {
+              image = "nginx:1.21.6"
+              name  = "example"
+
+              resources {
+                limits = {
+                  cpu    = "0.5"
+                  memory = "512Mi"
+                }
+                requests = {
+                  cpu    = "250m"
+                  memory = "50Mi"
+                }
+              }
+
+              liveness_probe {
+                http_get {
+                  path = "/"
+                  port = 80
+
+                  http_header {
+                    name  = "X-Custom-Header"
+                    value = "Awesome"
+                  }
+                }
+
+                initial_delay_seconds = 3
+                period_seconds        = 3
+              }
+            }
+          }
+        }
+      }
+    }
+`,
+    [binding.kubernetes],
+    Snapshot.yes,
+    Synth.yes_but_only_typescript_right_now_because_it_breaks,
+    {
+      resources: ["kubernetes_deployment"],
+    },
+  );
+
+  testCase.test(
+    "should handle most cdktf and provider constructs for granular imports",
+    `
+    terraform {
+      backend "remote" {
+        organization = "example_corp"
+
+        workspaces {
+          name = "my-app-prod"
+        }
+      }
+    }
+
+    provider "google" {
+      project = "my-project"
+      region  = "us-central1"
+    }
+
+    provider "local" {}
+
+    resource "google_compute_autoscaler" "example" {
+      name   = "example-autoscaler"
+      zone   = "us-east1-b"
+      target = "target-for-example-autoscaler"
+      count = 2
+
+      autoscaling_policy = {
+        max_replicas    = 8
+        min_replicas    = 2
+        cooldown_period = 60
+
+        cpu_utilization = {
+          target = 0.5
+        }
+      }
+    }
+
+    resource "google_compute_instance_group_manager" "default" {
+      name = "my-igm"
+      zone = "us-central1-f"
+
+      version {
+        instance_template = 1
+        name              = "primary"
+      }
+
+      target_pools       = []
+      base_instance_name = "autoscaler-sample"
+    }
+
+    resource "google_compute_autoscaler" "default" {
+      name   = "my-autoscaler"
+      zone   = "us-central1-f"
+      target = google_compute_instance_group_manager.default.id
+
+      autoscaling_policy {
+        max_replicas    = 5 + 2
+        min_replicas    = 1
+        cooldown_period = 60
+      }
+    }
+
+    variable "image_id" {
+      type = string
+    }
+
+    output "image_id" {
+      value = var.image_id
+    }
+
+    data "local_file" "foo" {
+      filename = "./\${var.image_id}.img"
+    }
+
+    `,
+    [binding.google, binding.local],
+    Snapshot.yes,
+    Synth.yes,
+    {
+      resources: ["google_compute_autoscaler", "local_file"],
+    },
+  );
+});