@ibm-cloud/cd-tools 1.2.3 → 1.2.5

package/README.md

@@ -48,7 +48,7 @@ The tools are provided as an [npx](https://docs.npmjs.com/cli/commands/npx) comm
 
 ```shell-session
 $ npx @ibm-cloud/cd-tools
-Usage: npx @ibm-cloud/cd-tools [options] [command]
+Usage: @ibm-cloud/cd-tools [options] [command]
 
 Tools for migrating Toolchains, Delivery Pipelines, and Git Repos and Issue Tracking projects.
 

package/cmd/copy-toolchain.js

@@ -237,7 +237,7 @@ async function main(options) {
 			}, 5000);
 
 			await initProviderFile(sourceRegion, TEMP_DIR);
-			await runTerraformInit(TEMP_DIR);
+			await runTerraformInit(TEMP_DIR, verbosity);
 
 			nonSecretRefs = await importTerraform(bearer, apiKey, sourceRegion, sourceToolchainId, targetToolchainName, policyIds, TEMP_DIR, isCompact, verbosity);
 		};
@@ -303,7 +303,8 @@ async function main(options) {
 				'Running terraform init...',
 				'Terraform successfully initialized',
 				LOG_STAGES.tf,
-				outputDir
+				outputDir,
+				verbosity
 			);
 
 			logger.info(`DRY_RUN: ${dryRun}, running terraform apply...`, LOG_STAGES.tf);

package/cmd/utils/requests.js

@@ -10,8 +10,11 @@
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
 
+import mocks from '../../test/data/mocks.js'
 import { logger, LOG_STAGES } from './logger.js';
 
+const MOCK_ALL_REQUESTS = process.env.MOCK_ALL_REQUESTS === 'true' || 'false';
+
 axiosRetry(axios, {
     retries: 3,
     retryDelay: axiosRetry.exponentialDelay,
@@ -142,6 +145,10 @@ async function getToolchainsByName(bearer, accountId, toolchainName) {
 }
 
 async function getCdInstanceByRegion(bearer, accountId, region) {
+    if (MOCK_ALL_REQUESTS && process.env.MOCK_GET_CD_INSTANCE_BY_REGION_SCENARIO) {
+        return mocks.getCdInstanceByRegionResponses[process.env.MOCK_GET_CD_INSTANCE_BY_REGION_SCENARIO].data.items.length > 0;
+    }
+
     const apiBaseUrl = 'https://api.global-search-tagging.cloud.ibm.com/v3';
     const options = {
         url: apiBaseUrl + '/resources/search',
@@ -403,7 +410,7 @@ async function deleteToolchain(bearer, toolchainId, region) {
     };
     const response = await axios(options);
     switch (response.status) {
-        case 200:
+        case 204:
             return toolchainId;
         default:
             throw Error(response.statusText);

package/cmd/utils/terraform.js

@@ -15,7 +15,7 @@ import { parse as tfToJson } from '@cdktf/hcl2json'
 import { jsonToTf } from 'json-to-tf';
 
 import { validateToolchainId, validateGritUrl } from './validate.js';
-import { logger } from './logger.js';
+import { logger, LOG_STAGES } from './logger.js';
 import { getRandChars, promptUserInput, replaceUrlRegion } from './utils.js';
 
 // promisify
@@ -300,12 +300,16 @@ async function setupTerraformFiles({ token, srcRegion, targetRegion, targetTag,
     return Promise.all(promises);
 }
 
-async function runTerraformPlanGenerate(dir, fileName) {
-    return await execPromise(`terraform plan -generate-config-out="${fileName}"`, { cwd: dir });
+async function runTerraformInit(dir, verbosity) {
+    logger.log('Running command \'terraform init\'', LOG_STAGES.tf);
+    const out = await execPromise('terraform init', { cwd: dir });
+    if (verbosity >= 2) logger.print(out, '\n');
+    logger.log('Command \'terraform init\' completed', LOG_STAGES.tf);
+    return out;
 }
 
-async function runTerraformInit(dir) {
-    return await execPromise('terraform init', { cwd: dir });
+async function runTerraformPlanGenerate(dir, fileName) {
+    return await execPromise(`terraform plan -generate-config-out="${fileName}"`, { cwd: dir });
 }
 
 // primarily used to get number of resources to be used

package/config.js

@@ -126,90 +126,90 @@ Format:
 	{ 
 		key: str, // tool parameter key
 		tfKey?: str, // terraform-equivalent key
-		prereq?: { key: string, values: [string] }, // proceed only if tool parameter "prereq.key" is one of "values"
+		prereq?: { key: string, values: [string] }, // proceed only if tool parameter 'prereq.key' is one of 'values'
 		required?: bool // is this key required for terraform?
 	}
 	... which represents a secret/sensitive value
 */
 const SECRET_KEYS_MAP = {
-	"artifactory": [
-		{ key: "token", tfKey: "token" }
+	'artifactory': [
+		{ key: 'token', tfKey: 'token' }
 	],
-	"cloudobjectstorage": [
-		{ key: "cos_api_key", tfKey: "cos_api_key", prereq: { key: "auth_type", values: ["apikey"] } },
-		{ key: "hmac_access_key_id", tfKey: "hmac_access_key_id", prereq: { key: "auth_type", values: ["hmac"] } },
-		{ key: "hmac_secret_access_key", tfKey: "hmac_secret_access_key", prereq: { key: "auth_type", values: ["hmac"] } },
+	'cloudobjectstorage': [
+		{ key: 'cos_api_key', tfKey: 'cos_api_key', prereq: { key: 'auth_type', values: ['apikey'] } },
+		{ key: 'hmac_access_key_id', tfKey: 'hmac_access_key_id', prereq: { key: 'auth_type', values: ['hmac'] } },
+		{ key: 'hmac_secret_access_key', tfKey: 'hmac_secret_access_key', prereq: { key: 'auth_type', values: ['hmac'] } },
 	],
-	"github_integrated": [
-		{ key: "api_token" } // no terraform equivalent
+	'github_integrated': [
+		{ key: 'api_token' } // no terraform equivalent
 	],
-	"githubconsolidated": [
-		{ key: "api_token", tfKey: "api_token", prereq: { key: "auth_type", values: ["pat"] } },
+	'githubconsolidated': [
+		{ key: 'api_token', tfKey: 'api_token', prereq: { key: 'auth_type', values: ['pat'] } },
 	],
-	"gitlab": [
-		{ key: "api_token", tfKey: "api_token", prereq: { key: "auth_type", values: ["pat"] } },
+	'gitlab': [
+		{ key: 'api_token', tfKey: 'api_token', prereq: { key: 'auth_type', values: ['pat'] } },
 	],
-	"hashicorpvault": [
-		{ key: "token", tfKey: "token", prereq: { key: "authentication_method", values: ["github", "token"] } },
-		{ key: "role_id", tfKey: "role_id", prereq: { key: "authentication_method", values: ["approle"] } },
-		{ key: "secret_id", tfKey: "secret_id", prereq: { key: "authentication_method", values: ["approle"] } },
-		{ key: "password", tfKey: "password", prereq: { key: "authentication_method", values: ["userpass"] } },
+	'hashicorpvault': [
+		{ key: 'token', tfKey: 'token', prereq: { key: 'authentication_method', values: ['github', 'token'] } },
+		{ key: 'role_id', tfKey: 'role_id', prereq: { key: 'authentication_method', values: ['approle'] } },
+		{ key: 'secret_id', tfKey: 'secret_id', prereq: { key: 'authentication_method', values: ['approle'] } },
+		{ key: 'password', tfKey: 'password', prereq: { key: 'authentication_method', values: ['userpass'] } },
 	],
-	"hostedgit": [
-		{ key: "api_token", tfKey: "api_token", prereq: { key: "auth_type", values: ["pat"] } },
+	'hostedgit': [
+		{ key: 'api_token', tfKey: 'api_token', prereq: { key: 'auth_type', values: ['pat'] } },
 	],
-	"jenkins": [
-		{ key: "api_token", tfKey: "api_token" },
+	'jenkins': [
+		{ key: 'api_token', tfKey: 'api_token' },
 	],
-	"jira": [
-		{ key: "password", tfKey: "api_token" },
+	'jira': [
+		{ key: 'password', tfKey: 'api_token' },
 	],
-	"nexus": [
-		{ key: "token", tfKey: "token" },
+	'nexus': [
+		{ key: 'token', tfKey: 'token' },
 	],
-	"pagerduty": [
-		{ key: "service_key", tfKey: "service_key", required: true },
+	'pagerduty': [
+		{ key: 'service_key', tfKey: 'service_key', required: true },
 	],
-	"private_worker": [
-		{ key: "workerQueueCredentials", tfKey: "worker_queue_credentials", required: true },
+	'private_worker': [
+		{ key: 'workerQueueCredentials', tfKey: 'worker_queue_credentials', required: true },
 	],
-	"saucelabs": [
-		{ key: "key", tfKey: "access_key", required: true },
+	'saucelabs': [
+		{ key: 'key', tfKey: 'access_key', required: true },
 	],
-	"security_compliance": [
-		{ key: "scc_api_key", tfKey: "scc_api_key", prereq: { key: "use_profile_attachment", values: ["enabled"] } },
+	'security_compliance': [
+		{ key: 'scc_api_key', tfKey: 'scc_api_key', prereq: { key: 'use_profile_attachment', values: ['enabled'] } },
 	],
-	"slack": [
-		{ key: "api_token", tfKey: "webhook", required: true },
+	'slack': [
+		{ key: 'api_token', tfKey: 'webhook', required: true },
 	],
-	"sonarqube": [
-		{ key: "user_password", tfKey: "user_password" },
+	'sonarqube': [
+		{ key: 'user_password', tfKey: 'user_password' },
 	]
 };
 
 // maps tool parameter tool_type_id to terraform resource type
 const SUPPORTED_TOOLS_MAP = {
-	"appconfig": "ibm_cd_toolchain_tool_appconfig",
-	"artifactory": "ibm_cd_toolchain_tool_artifactory",
-	"bitbucketgit": "ibm_cd_toolchain_tool_bitbucketgit",
-	"private_worker": "ibm_cd_toolchain_tool_privateworker",
-	"draservicebroker": "ibm_cd_toolchain_tool_devopsinsights",
-	"eventnotifications": "ibm_cd_toolchain_tool_eventnotifications",
-	"hostedgit": "ibm_cd_toolchain_tool_hostedgit",
-	"githubconsolidated": "ibm_cd_toolchain_tool_githubconsolidated",
-	"gitlab": "ibm_cd_toolchain_tool_gitlab",
-	"hashicorpvault": "ibm_cd_toolchain_tool_hashicorpvault",
-	"jenkins": "ibm_cd_toolchain_tool_jenkins",
-	"jira": "ibm_cd_toolchain_tool_jira",
-	"keyprotect": "ibm_cd_toolchain_tool_keyprotect",
-	"nexus": "ibm_cd_toolchain_tool_nexus",
-	"customtool": "ibm_cd_toolchain_tool_custom",
-	"saucelabs": "ibm_cd_toolchain_tool_saucelabs",
-	"secretsmanager": "ibm_cd_toolchain_tool_secretsmanager",
-	"security_compliance": "ibm_cd_toolchain_tool_securitycompliance",
-	"slack": "ibm_cd_toolchain_tool_slack",
-	"sonarqube": "ibm_cd_toolchain_tool_sonarqube",
-	"pipeline": "ibm_cd_toolchain_tool_pipeline"
+	'appconfig': 'ibm_cd_toolchain_tool_appconfig',
+	'artifactory': 'ibm_cd_toolchain_tool_artifactory',
+	'bitbucketgit': 'ibm_cd_toolchain_tool_bitbucketgit',
+	'private_worker': 'ibm_cd_toolchain_tool_privateworker',
+	'draservicebroker': 'ibm_cd_toolchain_tool_devopsinsights',
+	'eventnotifications': 'ibm_cd_toolchain_tool_eventnotifications',
+	'hostedgit': 'ibm_cd_toolchain_tool_hostedgit',
+	'githubconsolidated': 'ibm_cd_toolchain_tool_githubconsolidated',
+	'gitlab': 'ibm_cd_toolchain_tool_gitlab',
+	'hashicorpvault': 'ibm_cd_toolchain_tool_hashicorpvault',
+	'jenkins': 'ibm_cd_toolchain_tool_jenkins',
+	'jira': 'ibm_cd_toolchain_tool_jira',
+	'keyprotect': 'ibm_cd_toolchain_tool_keyprotect',
+	'nexus': 'ibm_cd_toolchain_tool_nexus',
+	'customtool': 'ibm_cd_toolchain_tool_custom',
+	'saucelabs': 'ibm_cd_toolchain_tool_saucelabs',
+	'secretsmanager': 'ibm_cd_toolchain_tool_secretsmanager',
+	'security_compliance': 'ibm_cd_toolchain_tool_securitycompliance',
+	'slack': 'ibm_cd_toolchain_tool_slack',
+	'sonarqube': 'ibm_cd_toolchain_tool_sonarqube',
+	'pipeline': 'ibm_cd_toolchain_tool_pipeline'
 };
 
 const VAULT_REGEX = [

package/index.js

@@ -10,11 +10,12 @@
 
 import { program } from 'commander';
 import * as commands from './cmd/index.js'
+import packageJson from './package.json' with { type: "json" };
 
 program
-  .name('index.js')
+  .name(packageJson.name)
   .description('Tools and utilities for the IBM Cloud Continuous Delivery service and resources.')
-  .version('0.0.1')
+  .version(packageJson.version)
   .showHelpAfterError();
 
 for (let i in commands) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ibm-cloud/cd-tools",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Tools and utilities for the IBM Cloud Continuous Delivery service and resources",
   "repository": {
     "type": "git",
@@ -15,7 +15,7 @@
   "author": "IBM Corp.",
   "license": "Apache-2.0",
   "scripts": {
-    "test": "mocha --require \"test/setup.js\" \"test/copy-toolchain/*.test.js\""
+    "test": "mocha --require \"test/setup.js\" --retries 3 --parallel \"test/copy-toolchain/*.test.js\""
   },
   "dependencies": {
     "@cdktf/hcl2json": "^0.21.0",

package/test/README.md

@@ -30,11 +30,12 @@ Before running tests, ensure that you have completed the setup steps in the main
 ### Test Configuration
 You can customize the behavior of the tests by defining configuration properties in the `test/config/local.json` file.
 
-| Property           | Type      | Default      | Description                                                                                                                  |
-| ------------------ | --------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------- |
-| `TEST_DEBUG_MODE`  | `boolean` | `false`      | When set to `true`, files generated by test cases in `TEST_TEMP_DIR` and log files generated in `TEST_LOG_DIR` are preserved |
-| `TEST_TEMP_DIR`    | `string`  | `test/.tmp`  | The directory to store temporary files generated by test cases                                                               |
-| `TEST_LOG_DIR`     | `string`  | `test/.logs` | The directory to store test run log files                                                                                    |
-| `IBMCLOUD_API_KEY` | `string`  | `null`       | The IBM Cloud API Key used to run the tests                                                                                  |
-| `LOG_DUMP`         | `boolean` | `false`      | When set to `true`, individual test case's process's log file generation is enabled                                          |
-| `DISABLE_SPINNER`  | `boolean` | `true`       | When set to `true`, visual spinner is disabled across all test cases' processes                                              |
+| Property           | Type      | Default           | Description                                                                                                                  |
+| ------------------ | --------- | ------------------| ---------------------------------------------------------------------------------------------------------------------------- |
+| `TEST_DEBUG_MODE`  | `boolean` | `false`           | When set to `true`, files generated by test cases in `TEST_TEMP_DIR` and log files generated in `TEST_LOG_DIR` are preserved |
+| `TEST_TEMP_DIR`    | `string`  | `test/.tmp`       | The directory to store temporary files generated by test cases                                                               |
+| `TEST_LOG_DIR`     | `string`  | `test/.test-logs` | The directory to store test run log files                                                                                    |
+| `IBMCLOUD_API_KEY` | `string`  | `null`            | The IBM Cloud API Key used to run the tests                                                                                  |
+| `LOG_DUMP`         | `boolean` | `false`           | When set to `true`, individual test case's process's log file generation is enabled                                          |
+| `DISABLE_SPINNER`  | `boolean` | `true`            | When set to `true`, visual spinner is disabled across all test cases' processes                                              |
+| `VERBOSE_MODE`     | `boolean` | `false`           |  When set to `true`, each test case's log output increases                                                                   |

package/test/config/local.template.json

@@ -4,5 +4,6 @@
     "TEST_LOG_DIR": "test/.logs",
     "IBMCLOUD_API_KEY": "<YOUR IBMCLOUD API KEY>",
     "LOG_DUMP": true,
-    "DISABLE_SPINNER": true
+    "DISABLE_SPINNER": true,
+    "VERBOSE_MODE": false
 }

package/test/copy-toolchain/functionalities.test.js

@@ -0,0 +1,198 @@
+/**
+ * Licensed Materials - Property of IBM
+ * (c) Copyright IBM Corporation 2025. All Rights Reserved.
+ *
+ * Note to U.S. Government Users Restricted Rights:
+ * Use, duplication or disclosure restricted by GSA ADP Schedule
+ * Contract with IBM Corp.
+ */
+
+import path from 'node:path';
+import nconf from 'nconf';
+import fs from 'node:fs';
+
+import * as chai from 'chai';
+chai.config.truncateThreshold = 0;
+import { expect, assert } from 'chai';
+
+import { assertPtyOutput, assertExecError, areFilesInDir, deleteCreatedToolchains, parseTcIdAndRegion } from '../utils/testUtils.js';
+import { getBearerToken, getToolchain } from '../../cmd/utils/requests.js';
+import { TEST_TOOLCHAINS, DEFAULT_RG_ID, R2R_CLI_RG_ID } from '../data/test-toolchains.js';
+import { TARGET_REGIONS } from '../../config.js';
+
+nconf.env('__');
+nconf.file('local', 'test/config/local.json');
+
+const TEMP_DIR = nconf.get('TEST_TEMP_DIR');
+const VERBOSE_MODE = nconf.get('VERBOSE_MODE');
+const IBMCLOUD_API_KEY = nconf.get('IBMCLOUD_API_KEY');
+
+const CLI_PATH = path.resolve('index.js');
+const COMMAND = 'copy-toolchain';
+
+const toolchainsToDelete = new Map();
+after(async () => await deleteCreatedToolchains(toolchainsToDelete));
+
+describe('copy-toolchain: Test functionalities', function () {
+    this.timeout('300s');
+    this.command = COMMAND;
+    const testCases = [
+        {
+            name: 'Terraform Version Verification',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TARGET_REGIONS[0]],
+            expected: /✔ Terraform Version:/,
+            options: {
+                exitCondition: '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):',
+                timeout: 10000
+            }
+        },
+        {
+            name: 'Check if CD instance exists in target region',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TARGET_REGIONS[0]],
+            expected: new RegExp(`Could not find a Continuous Delivery instance in the target region '${TARGET_REGIONS[0]}', please create one before proceeding.`),
+            options: {
+                exitCondition: `Could not find a Continuous Delivery instance in the target region '${TARGET_REGIONS[0]}', please create one before proceeding.`,
+                timeout: 10000,
+                env: { ...process.env, MOCK_ALL_REQUESTS: 'true', MOCK_GET_CD_INSTANCE_BY_REGION_SCENARIO: 'NOT_FOUND' }
+            }
+        },
+        {
+            name: 'Log file is created successfully',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TARGET_REGIONS[0]],
+            expected: null,
+            options: {
+                exitCondition: '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):',
+                timeout: 10000,
+                cwd: TEMP_DIR + '/' + 'log-file-is-created-successfully'
+            },
+            assertionFunc: () => areFilesInDir(TEMP_DIR + '/' + 'log-file-is-created-successfully', ['.log'])
+        },
+        {
+            name: 'Force Flag bypasses all user prompts',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TEST_TOOLCHAINS['empty'].region, '-f'],
+            expected: null,
+            options: {
+                timeout: 120000,
+            },
+            assertionFunc: async (output) => {
+                // Should bypass everything and clone the toolchain
+                output.match(/See cloned toolchain:/);
+                const { toolchainId, region } = parseTcIdAndRegion(output);
+                const token = await getBearerToken(IBMCLOUD_API_KEY);
+                const toolchainData = await getToolchain(token, toolchainId, region);
+                assert.isTrue(toolchainData.id === toolchainId, 'Was toolchain created successfully without any confirmations?');
+            }
+        },
+        {
+            name: 'Prompt User when toolchain name already exists in resource group',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TARGET_REGIONS[0]],
+            expected: new RegExp(`Warning! A toolchain named \'${TEST_TOOLCHAINS['empty'].name}\' already exists in:[\\s\\S]*?Resource Group:[\\s\\S]*?${R2R_CLI_RG_ID}`),
+            options: {
+                exitCondition: '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):',
+                timeout: 10000
+            }
+        },
+        {
+            name: 'Prompt User when toolchain name already exists in region',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TEST_TOOLCHAINS['empty'].region, '-g', DEFAULT_RG_ID],
+            expected: new RegExp(`Warning! A toolchain named \'${TEST_TOOLCHAINS['empty'].name}\' already exists in:[\\s\\S]*?Region: ${TEST_TOOLCHAINS['empty'].region}`),
+            options: {
+                exitCondition: '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):',
+                timeout: 10000
+            }
+        },
+        {
+            name: 'Dry Run Flag does not clone a toolchain',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TEST_TOOLCHAINS['empty'].region, '-D'],
+            expected: null,
+            options: {
+                timeout: 100000,
+                questionAnswerMap: {
+                    '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': '',
+                    [`(Recommended) Edit the cloned toolchain's name [default: ${TEST_TOOLCHAINS['empty'].name}] (Ctrl-C to abort):`]: '',
+                },
+                cwd: TEMP_DIR + '/' + 'dry-run-flag-does-not-clone-a-toolchain'
+            },
+            assertionFunc: (output) => {
+                expect(output).to.match(/DRY_RUN: true, skipping terraform apply/);
+                assert.isTrue(areFilesInDir(TEMP_DIR + '/' + 'dry-run-flag-does-not-clone-a-toolchain', ['cd_toolchain.tf', 'output.tf']));
+            }
+        },
+        {
+            name: 'Silent flag suppresses info, debug and log messages',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TEST_TOOLCHAINS['empty'].region, '-s'],
+            expected: null,
+            options: {
+                timeout: 100000,
+                questionAnswerMap: {
+                    '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': '',
+                    [`(Recommended) Edit the cloned toolchain's name [default: ${TEST_TOOLCHAINS['empty'].name}] (Ctrl-C to abort):`]: '',
+                },
+            },
+            assertionFunc: (output) => {
+                // finds any [INFO] level logs that matches '[INFO] ...' but not '[INFO] See cloned toolchain...' 
+                expect(output).to.not.match(/^(?!.*\[INFO\]\s+See cloned toolchain).*\[INFO\].*$/m);
+
+                expect(output).to.not.match(/\[DEBUG\]/);
+                expect(output).to.not.match(/\[LOG\]/);
+            }
+        },
+        {
+            name: 'Compact flag only generates one terraform file',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['single-pl'].crn, '-r', TEST_TOOLCHAINS['single-pl'].region, '-D', '-f', '-C'],
+            expected: null,
+            options: {
+                timeout: 100000,
+                cwd: TEMP_DIR + '/' + 'compact-flag-only-generates-one-tf-file'
+            },
+            assertionFunc: () => {
+                // check only resources.tf is created
+                assert.isFalse(
+                    areFilesInDir(TEMP_DIR + '/' + 'compact-flag-only-generates-one-tf-file', [
+                        'cd_toolchain.tf',
+                        'cd_toolchain_tool_pipeline.tf',
+                        'cd_tekton_pipeline.tf',
+                    ])
+                );
+                assert.isTrue(areFilesInDir(TEMP_DIR + '/' + 'compact-flag-only-generates-one-tf-file', ['resources.tf']));
+            }
+        },
+        {
+            name: 'Prompt user when OAuth does not exist for Git tool in target region',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['single-pl'].crn, '-r', TEST_TOOLCHAINS['single-pl'].region, '-D'],
+            expected: /Warning! The following git tool integration\(s\) are not authorized in the target region/,
+            options: {
+                timeout: 60000,
+                questionAnswerMap: {
+                    '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': '',
+                    [`(Recommended) Edit the cloned toolchain's name [default: ${TEST_TOOLCHAINS['single-pl'].name}] (Ctrl-C to abort):`]: '',
+                    'Only \'yes\' will be accepted to proceed. (Ctrl-C to abort)': 'yes'
+                },
+            }
+        }
+    ];
+
+    for (const { name, cmd, expected, options, assertionFunc } of testCases) {
+        if (VERBOSE_MODE) cmd.push('-v');
+        it(`${name}`, async () => {
+            const res = await assertPtyOutput(cmd, expected, options, assertionFunc);
+            if (res) toolchainsToDelete.set(res.toolchainId, res.region);
+        });
+    }
+
+    it('Check for existing .tf files in output directory', async () => {
+        const testDir = path.resolve(TEMP_DIR, 'check-for-existing-tf-files-in-out-dir');
+        const tfFilePath = path.resolve(testDir, 'empty.tf');
+        if (!fs.existsSync(testDir)) fs.mkdirSync(testDir, { recursive: true });
+        fs.writeFileSync(tfFilePath, '');
+
+        const cmd = [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TARGET_REGIONS[0], '-d', testDir];
+        if (VERBOSE_MODE) cmd.push('-v');
+
+        await assertExecError(
+            cmd,
+            /Output directory already has 1 '.tf' files, please specify a different output directory/,
+            { cwd: testDir }
+        );
+    });
+});

package/test/copy-toolchain/{validation.test.js → input-validation.test.js}

@@ -9,31 +9,32 @@
 
 import path from 'node:path';
 import nconf from 'nconf';
+import fs from 'node:fs';
 
 import * as chai from 'chai';
+import { expect } from 'chai';
 chai.config.truncateThreshold = 0;
 
 import mocks from '../data/mocks.js';
-import { testSuiteCleanup, expectExecError, expectPtyOutputToMatch } from '../utils/testUtils.js';
+import { assertExecError, assertPtyOutput } from '../utils/testUtils.js';
 import { TEST_TOOLCHAINS } from '../data/test-toolchains.js';
 import { TARGET_REGIONS } from '../../config.js';
 
 nconf.env('__');
 nconf.file('local', 'test/config/local.json');
 
+const VERBOSE_MODE = nconf.get('VERBOSE_MODE');
+const TEMP_DIR = nconf.get('TEST_TEMP_DIR');
+
 const CLI_PATH = path.resolve('index.js');
 const COMMAND = 'copy-toolchain';
 
-const toolchainsToDelete = new Map();
-
-after(async () => await testSuiteCleanup(toolchainsToDelete));
 
 describe('copy-toolchain: Test user input handling', function () {
-    this.timeout('60s');
-    this.command = 'copy-toolchain';
+    this.timeout('120s');
+    this.command = COMMAND;
 
     const validCrn = TEST_TOOLCHAINS['empty'].crn;
-
     const invalidArgsCases = [
         {
             name: 'Toolchain CRN not specified',
@@ -87,23 +88,51 @@ describe('copy-toolchain: Test user input handling', function () {
             cmd: [CLI_PATH, COMMAND, '-c', validCrn, '-r', TARGET_REGIONS[0], '-g', mocks.invalidRgId],
             expected: /The resource group with provided ID or name was not found or is not accessible/,
         },
+        {
+            name: 'Non-existent GRIT mapping file provided',
+            cmd: [CLI_PATH, COMMAND, '-c', validCrn, '-r', TARGET_REGIONS[0], '-G', 'non-existent.json'],
+            expected: /ENOENT: no such file or directory/
+        }
     ];
 
-    for (const { name, cmd, expected, options } of invalidArgsCases) {
+    for (const { name, cmd, expected, options, assertionFn } of invalidArgsCases) {
+        if (VERBOSE_MODE) cmd.push('-v');
         it(`Invalid args: ${name}`, async () => {
-            await expectExecError(cmd, expected, options);
+            await assertExecError(cmd, expected, options, assertionFn);
         });
     }
 
+    it('Invalid GRIT URL mapping provided in file', async () => {
+
+        const gritTestDir = path.resolve(TEMP_DIR, 'invalid-grit-mapping-provided-in-file');
+        const gritMappingFilePath = path.resolve(gritTestDir, mocks.invalidGritFileName);
+
+        if (!fs.existsSync(gritTestDir)) fs.mkdirSync(gritTestDir, { recursive: true });
+        fs.writeFileSync(gritMappingFilePath, JSON.stringify(mocks.invalidGritMapping, null, 2));
+
+        const cmd = [CLI_PATH, COMMAND, '-c', validCrn, '-r', TARGET_REGIONS[0], '-G', mocks.invalidGritFileName];
+        if (VERBOSE_MODE) cmd.push('-v');
+
+        await assertExecError(
+            cmd,
+            null,
+            { cwd: gritTestDir },
+            (err) => {
+                expect(err).to.match(/Error: Provided full GRIT url is not valid/);
+                expect(err).to.match(/One or more invalid entries in GRIT mapping file, error count: 2/);
+            }
+        );
+    });
+
     const invalidUserInputCases = [
         {
             name: 'Invalid Toolchain tag is provided',
             cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TARGET_REGIONS[0]],
             expected: /Provided tag is invalid/,
             options: {
-                questionAnswerMap: { '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):' : mocks.invalidTag },
+                questionAnswerMap: { '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': mocks.invalidTag },
                 exitCondition: 'Validation failed',
-                timeout: 5000
+                timeout: 10000
             }
         },
         {
@@ -111,16 +140,17 @@ describe('copy-toolchain: Test user input handling', function () {
             cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['empty'].crn, '-r', TEST_TOOLCHAINS['empty'].region],
             expected: /Provided toolchain name is invalid/,
             options: {
-                questionAnswerMap: { [`(Recommended) Edit the cloned toolchain's name [default: ${TEST_TOOLCHAINS['empty'].name}] (Ctrl-C to abort):`] : mocks.invalidTcName },
+                questionAnswerMap: { [`(Recommended) Edit the cloned toolchain's name [default: ${TEST_TOOLCHAINS['empty'].name}] (Ctrl-C to abort):`]: mocks.invalidTcName },
                 exitCondition: 'Validation failed',
-                timeout: 5000
+                timeout: 10000
             }
-        },
+        }
     ];
 
     for (const { name, cmd, expected, options } of invalidUserInputCases) {
+        if (VERBOSE_MODE) cmd.push('-v');
         it(`Invalid user input in prompts: ${name}`, async () => {
-            await expectPtyOutputToMatch(cmd, expected, options);
+            await assertPtyOutput(cmd, expected, options);
         });
     }
 });

package/test/copy-toolchain/tf-import.test.js

@@ -0,0 +1,117 @@
+/**
+ * Licensed Materials - Property of IBM
+ * (c) Copyright IBM Corporation 2025. All Rights Reserved.
+ *
+ * Note to U.S. Government Users Restricted Rights:
+ * Use, duplication or disclosure restricted by GSA ADP Schedule
+ * Contract with IBM Corp.
+ */
+
+import path from 'node:path';
+import nconf from 'nconf';
+
+import * as chai from 'chai';
+chai.config.truncateThreshold = 0;
+
+import { assertTfResourcesInDir, assertPtyOutput } from '../utils/testUtils.js';
+import { TEST_TOOLCHAINS } from '../data/test-toolchains.js';
+
+nconf.env('__');
+nconf.file('local', 'test/config/local.json');
+
+const TEMP_DIR = nconf.get('TEST_TEMP_DIR');
+const VERBOSE_MODE = nconf.get('VERBOSE_MODE');
+
+const CLI_PATH = path.resolve('index.js');
+const COMMAND = 'copy-toolchain';
+
+describe('copy-toolchain: Test import-terraform output', function () {
+    this.timeout('300s');
+    this.command = COMMAND;
+
+    const testCases = [
+        {
+            name: 'Import 1PL-GHE-CC Toolchain',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['1pl-ghe-cc'].crn, '-r', TEST_TOOLCHAINS['1pl-ghe-cc'].region, '-D', '-f'],
+            expected: null,
+            options: {
+                timeout: 100000,
+                cwd: TEMP_DIR + '/' + 'import-1pl-ghe-cc-toolchain'
+            },
+            assertionFunc: async () => {
+                await assertTfResourcesInDir(TEMP_DIR + '/' + 'import-1pl-ghe-cc-toolchain', {
+                    ibm_cd_tekton_pipeline: 1,
+                    ibm_cd_tekton_pipeline_definition: 1,
+                    ibm_cd_tekton_pipeline_property: 1,
+                    ibm_cd_tekton_pipeline_trigger: 1,
+                    ibm_cd_tekton_pipeline_trigger_property: 1,
+                    ibm_cd_toolchain: 1,
+                    ibm_cd_toolchain_tool_custom: 1,
+                    ibm_cd_toolchain_tool_githubconsolidated: 1,
+                    ibm_cd_toolchain_tool_pipeline: 1,
+                    ibm_cd_toolchain_tool_secretsmanager: 1,
+                    ibm_cd_toolchain_tool_slack: 1,
+                    ibm_iam_authorization_policy: 1
+                });
+            }
+        },
+        {
+            name: 'Import 1PL-GHE-CD Toolchain',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['1pl-ghe-cd'].crn, '-r', TEST_TOOLCHAINS['1pl-ghe-cd'].region, '-D', '-f'],
+            expected: null,
+            options: {
+                timeout: 100000,
+                cwd: TEMP_DIR + '/' + 'import-1pl-ghe-cd-toolchain'
+            },
+            assertionFunc: async () => {
+                await assertTfResourcesInDir(TEMP_DIR + '/' + 'import-1pl-ghe-cd-toolchain', {
+                    ibm_cd_tekton_pipeline: 1,
+                    ibm_cd_tekton_pipeline_definition: 1,
+                    ibm_cd_tekton_pipeline_property: 1,
+                    ibm_cd_tekton_pipeline_trigger: 1,
+                    ibm_cd_tekton_pipeline_trigger_property: 1,
+                    ibm_cd_toolchain: 1,
+                    ibm_cd_toolchain_tool_custom: 1,
+                    ibm_cd_toolchain_tool_githubconsolidated: 1,
+                    ibm_cd_toolchain_tool_pipeline: 1,
+                    ibm_cd_toolchain_tool_secretsmanager: 1,
+                    ibm_cd_toolchain_tool_slack: 1,
+                    ibm_iam_authorization_policy: 1
+                });
+            }
+        },
+        {
+            name: 'Import DevSecOps-GRIT-CI Toolchain',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['devsecops-grit-ci'].crn, '-r', TEST_TOOLCHAINS['devsecops-grit-ci'].region, '-D', '-f'],
+            expected: null,
+            options: {
+                timeout: 100000,
+                cwd: TEMP_DIR + '/' + 'import-devsecops-grit-ci-toolchain'
+            },
+            assertionFunc: async () => {
+                await assertTfResourcesInDir(TEMP_DIR + '/' + 'import-devsecops-grit-ci-toolchain', {
+                    ibm_cd_tekton_pipeline: 1,
+                    ibm_cd_tekton_pipeline_definition: 1,
+                    ibm_cd_tekton_pipeline_property: 1,
+                    ibm_cd_tekton_pipeline_trigger: 1,
+                    ibm_cd_tekton_pipeline_trigger_property: 1,
+                    ibm_cd_toolchain: 1,
+                    ibm_cd_toolchain_tool_custom: 1,
+                    ibm_cd_toolchain_tool_devopsinsights: 1,
+                    ibm_cd_toolchain_tool_hostedgit: 1,
+                    ibm_cd_toolchain_tool_pipeline: 1,
+                    ibm_cd_toolchain_tool_secretsmanager: 1,
+                    ibm_cd_toolchain_tool_slack: 1,
+                    ibm_iam_authorization_policy: 1
+                })
+            }
+        },
+    ];
+
+    for (const { name, cmd, expected, options, assertionFunc } of testCases) {
+        if (VERBOSE_MODE) cmd.push('-v');
+        it(`${name}`, async () => {
+            await assertPtyOutput(cmd, expected, options, assertionFunc);
+        });
+    }
+});

package/test/copy-toolchain/tool-validation.test.js

@@ -0,0 +1,107 @@
+/**
+ * Licensed Materials - Property of IBM
+ * (c) Copyright IBM Corporation 2025. All Rights Reserved.
+ *
+ * Note to U.S. Government Users Restricted Rights:
+ * Use, duplication or disclosure restricted by GSA ADP Schedule
+ * Contract with IBM Corp.
+ */
+
+import path from 'node:path';
+import nconf from 'nconf';
+
+import * as chai from 'chai';
+chai.config.truncateThreshold = 0;
+import { expect } from 'chai';
+
+import { assertPtyOutput, deleteCreatedToolchains } from '../utils/testUtils.js';
+import { TEST_TOOLCHAINS } from '../data/test-toolchains.js';
+import { TARGET_REGIONS } from '../../config.js';
+
+nconf.env('__');
+nconf.file('local', 'test/config/local.json');
+
+const VERBOSE_MODE = nconf.get('VERBOSE_MODE');
+
+const CLI_PATH = path.resolve('index.js');
+const COMMAND = 'copy-toolchain';
+
+const toolchainsToDelete = new Map();
+after(async () => await deleteCreatedToolchains(toolchainsToDelete));
+
+describe('copy-toolchain: Test tool validation', function () {
+    this.timeout('300s');
+    this.command = COMMAND;
+    const testCases = [
+        {
+            name: 'Misconfigured tool identified',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['1pl-ghe-cd'].crn, '-r', TARGET_REGIONS[10]],
+            expected: /slack[\s\S]*?misconfigured/,
+            options: {
+                exitCondition: 'Caution: The above tool(s) will not be properly configured post migration. Do you want to proceed?',
+                questionAnswerMap: {
+                    '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': '',
+                },
+                timeout: 30000
+            }
+        },
+        {
+            name: 'Tools with plain text secrets identified',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['1pl-ghe-cd'].crn, '-r', TARGET_REGIONS[10]],
+            expected: null,
+            options: {
+                exitCondition: 'Caution: The above tool(s) will not be properly configured post migration. Do you want to proceed?',
+                questionAnswerMap: {
+                    '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': '',
+                },
+                timeout: 30000
+            },
+            assertionFunc: (output) => {
+                expect(output).to.match(/Warning! The following tools contain secrets that cannot be migrated/);
+                expect(output).to.match(/cloudobjectstorage[\s\S]*?cos_api_key/);
+                expect(output).to.match(/slack[\s\S]*?api_token/);
+                expect(output).to.match(/pipeline[\s\S]*?properties.doi-ibmcloud-api-key/);
+            }
+        },
+        {
+            name: 'Classic pipelines are identified',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['misconfigured'].crn, '-r', TARGET_REGIONS[10]],
+            expected: /Warning! Classic pipelines are currently not supported in migration/,
+            options: {
+                exitCondition: 'Caution: The above tool(s) will not be properly configured post migration. Do you want to proceed?',
+                questionAnswerMap: {
+                    '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': '',
+                },
+                timeout: 30000
+            }
+        },
+        {
+            name: 'Git tools using PAT are identified',
+            cmd: [CLI_PATH, COMMAND, '-c', TEST_TOOLCHAINS['misconfigured'].crn, '-r', TARGET_REGIONS[10]],
+            expected: null,
+            options: {
+                exitCondition: 'Caution: The above tool(s) will not be properly configured post migration. Do you want to proceed?',
+                questionAnswerMap: {
+                    '(Recommended) Add a tag to the cloned toolchain (Ctrl-C to abort):': '',
+                },
+                timeout: 30000
+            },
+            assertionFunc: (output) => {
+                expect(output).to.match(/Warning! The following GRIT integration\(s\) are using auth_type "pat", please switch to auth_type "oauth" before proceeding/);
+                expect(output).to.match(/hostedgit/);
+                expect(output).to.match(/Warning! The following tools contain secrets that cannot be migrated/);
+                expect(output).to.match(/githubconsolidated[\s\S]*?api_token/);
+                expect(output).to.match(/github_integrated[\s\S]*?api_token/);
+                expect(output).to.match(/gitlab[\s\S]*?api_token/);
+            }
+        },
+    ];
+
+    for (const { name, cmd, expected, options, assertionFunc } of testCases) {
+        if (VERBOSE_MODE) cmd.push('-v');
+        it(`${name}`, async () => {
+            const res = await assertPtyOutput(cmd, expected, options, assertionFunc);
+            if (res) toolchainsToDelete.set(res.toolchainId, res.region);
+        });
+    }
+});

package/test/data/mocks.js

@@ -19,11 +19,31 @@ const invalidRgId = 'invalid#RgId';
 
 const invalidRgName = 'invalid#Rg@Name';
 
+const invalidGritMapping = {
+    'ca-tor.git.cloud.ibm.com/fake-user/fake-repo': 'eu-gb.git.cloud.ibm.com/fake-user/fake-repo',
+    'ibm.com/fake-user/fake-repo': 'ibm.com/fake-user/fake-repo'
+};
+
+const invalidGritFileName = 'invalid-mapping.json';
+
+const getCdInstanceByRegionResponses = {
+    'NOT_FOUND': {
+        status: 200,
+        data: {
+            items: [],
+            limit: 10
+        }
+    }
+};
+
 export default {
     invalidCrn,
     invalidRegion,
     invalidTcName,
     invalidTag,
     invalidRgId,
-    invalidRgName
+    invalidRgName,
+    invalidGritMapping,
+    invalidGritFileName,
+    getCdInstanceByRegionResponses
 };

package/test/data/test-toolchains.js

@@ -9,13 +9,51 @@
 
 export const TEST_TOOLCHAINS = {
     'empty': {
-        'name': 'empty-toolchain',
-        'crn': 'crn:v1:bluemix:public:toolchain:ca-tor:a/9e8559fac61ee9fc74d3e595fa75d147:a3d4a26a-b447-490e-af84-356bbe63dd1c::',
-        'region': 'ca-tor'
+        name: 'KEEP-EMPTY-TOOLCHAIN',
+        crn: 'crn:v1:bluemix:public:toolchain:ca-tor:a/9e8559fac61ee9fc74d3e595fa75d147:0100aa9f-1e57-41d8-b4c7-5d84178d59bb::',
+        region: 'ca-tor',
     },
     'misconfigured': {
-        'name': 'misconfigured-toolchain',
-        'crn': 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:0ccfaa70-ca90-47db-8246-f4ecfc6ad8f3::',
-        'region': 'eu-es'
+        name: 'KEEP-MISCONFIGURED-TOOLCHAIN',
+        crn: 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:0ccfaa70-ca90-47db-8246-f4ecfc6ad8f3::',
+        region: 'eu-es'
+    },
+    '1pl-ghe-cc': {
+        name: 'KEEP-1PL-GHE-CC',
+        crn: 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:9d51bb6b-f659-4ab7-9bc4-2eae1d61f4e7::',
+        region: 'eu-es'
+    },
+    '1pl-ghe-cd': {
+        name: 'KEEP-1PL-GHE-CD',
+        crn: 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:6a70313f-a927-4b0e-8471-70f17330998d::',
+        region: 'eu-es'
+    },
+    '1pl-ghe-ci': {
+        name: 'KEEP-1PL-GHE-CI',
+        crn: 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:6b8e27ae-5924-4a38-8819-f405366cb900::',
+        region: 'eu-es'
+    },
+    'devsecops-grit-cc': {
+        name: 'KEEP-DevSecOps-GRIT-CC',
+        crn: 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:920f6a94-4c1b-412b-b95c-baf823958744::',
+        region: 'eu-es'
+    },
+    'devsecops-grit-cd': {
+        name: 'KEEP-DevSecOps-GRIT-CD',
+        crn: 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:8618565f-08fa-4cac-9250-029cac7b41ba::',
+        region: 'eu-es'
+    },
+    'devsecops-grit-ci': {
+        name: 'KEEP-DevSecOps-GRIT-CI',
+        crn: 'crn:v1:bluemix:public:toolchain:eu-es:a/9e8559fac61ee9fc74d3e595fa75d147:cdc271bc-cc07-4a85-beb2-895e033319b0::',
+        region: 'eu-es'
+    },
+    'single-pl': {
+        name: 'KEEP-SINGLE-PIPELINE-TOOLCHAIN',
+        crn: 'crn:v1:bluemix:public:toolchain:us-east:a/9e8559fac61ee9fc74d3e595fa75d147:5ef88780-1e0f-4cda-94c7-f78909cc1140::',
+        region: 'us-east'
     }
 };
+
+export const DEFAULT_RG_ID = '63b47433992f4295bc490852cbf1cb55';
+export const R2R_CLI_RG_ID = 'f64e5eb8cfee406a983803bd79aa6c93';

package/test/setup.js

@@ -23,10 +23,23 @@ const TEMP_DIR = resolve(nconf.get('TEST_TEMP_DIR'));
 const LOG_DIR = resolve(nconf.get('TEST_LOG_DIR'));
 const DEBUG_MODE = nconf.get('TEST_DEBUG_MODE');
 
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+
 export const mochaHooks = {
-    beforeAll() {
-        if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
-        if (fs.existsSync(LOG_DIR)) fs.rmSync(LOG_DIR, { recursive: true });
+    async beforeAll() {
+        for (let i = 0; i < 3; i++) {
+            try {
+                fs.rmSync(TEMP_DIR, { recursive: true, force: true });
+                fs.rmSync(LOG_DIR, { recursive: true, force: true });
+            } catch {}
+            if (!fs.existsSync(TEMP_DIR) && !fs.existsSync(LOG_DIR)) break;
+            await sleep(1000);
+        }
+        fs.mkdirSync(TEMP_DIR, { recursive: true });
     },
     beforeEach() {
         if (DEBUG_MODE === true && LOG_DIR) {
@@ -35,10 +48,14 @@ export const mochaHooks = {
                 resolve(LOG_DIR, this.currentTest.parent.command, testTitle + '.log') :
                 resolve(LOG_DIR, testTitle + '.log');
             logger.createLogStream(logFile);
+            // Adding logging for log stream creation and closing, because there's cases of missing test log files when running tests in parallel, most likely because of the singleton logger, 
+            // causing some sort of race condition happening
+            // console.info(`Created test log stream for test case '${this.currentTest.title}'`);
         }
     },
-    afterEach() {
-        logger.close();
+    async afterEach() {
+        await logger.close();
+        // console.info(`Closed test log stream for test case '${this.currentTest.title}'`);
     },
     afterAll() {
         if (fs.existsSync(TEMP_DIR) && DEBUG_MODE === false) fs.rmSync(TEMP_DIR, { recursive: true });

package/test/utils/testUtils.js

@@ -8,11 +8,14 @@
  */
 
 import { promisify } from 'util';
+import fs from 'fs';
+import path from 'path';
 import child_process from 'child_process';
 import stripAnsi from 'strip-ansi';
 import pty from 'node-pty';
+import { parse as tfToJson } from '@cdktf/hcl2json'
 import nconf from 'nconf';
-import { expect } from 'chai';
+import { expect, assert } from 'chai';
 
 import { getBearerToken, deleteToolchain } from '../../cmd/utils/requests.js';
 import { logger } from '../../cmd/utils/logger.js';
@@ -20,15 +23,53 @@ import { logger } from '../../cmd/utils/logger.js';
 nconf.env('__');
 nconf.file('local', 'test/config/local.json');
 
+const TEMP_DIR = nconf.get('TEST_TEMP_DIR');
 const IBMCLOUD_API_KEY = nconf.get('IBMCLOUD_API_KEY');
 
 function cleanOutput(data) {
     if (typeof data === 'string') return stripAnsi(data).replace(/\r/g, '').trim();
 }
 
+function searchDirectory(currentPath) {
+    const foundFiles = [];
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+            foundFiles.push(...searchDirectory(fullPath));
+        } else {
+            foundFiles.push(path.join(currentPath, entry.name));
+        }
+    }
+    return foundFiles;
+}
+
+export function parseTcIdAndRegion(output) {
+    const pattern = /See cloned toolchain: https:\/\/cloud\.ibm\.com\/devops\/toolchains\/([a-zA-Z0-9-]+)\?env_id=ibm\:yp\:([a-zA-Z0-9-]+)/;
+    const match = output.match(pattern);
+
+    if (match) {
+        const toolchainId = match[1];
+        const region = match[2];
+        return { toolchainId, region };
+    } else {
+        return null;
+    }
+}
+
 export async function execCommand(fullCommand, options) {
     const commandStr = `node ${fullCommand.join(' ')}`;
     const execPromise = promisify(child_process.exec);
+
+    if (!options) {
+        options = { cwd: TEMP_DIR }
+    } else {
+        options.cwd ??= TEMP_DIR;
+        if (!fs.existsSync(options.cwd)) {
+            fs.mkdirSync(options.cwd, { recursive: true });
+        }
+    }
+
     try {
         const { stdout, stderr } = await execPromise(commandStr, options);
         if (stderr) {
@@ -51,12 +92,14 @@ export async function execCommand(fullCommand, options) {
 export function runPtyProcess(fullCommand, options) {
     const {
         timeout = 0,
-        cwd = process.cwd(),
+        cwd = TEMP_DIR,
         env = process.env,
         questionAnswerMap = {},
         exitCondition = '',
     } = options;
 
+    if (!fs.existsSync(cwd)) fs.mkdirSync(cwd, { recursive: true });
+
     return new Promise((resolve, reject) => {
         try {
             const ptyProcess = pty.spawn('node', fullCommand, {
@@ -106,7 +149,7 @@ export function runPtyProcess(fullCommand, options) {
     });
 }
 
-export async function testSuiteCleanup(toolchainsToDelete) {
+export async function deleteCreatedToolchains(toolchainsToDelete) {
     if (toolchainsToDelete && typeof toolchainsToDelete === 'object' && toolchainsToDelete.size > 0) {
         const token = await getBearerToken(IBMCLOUD_API_KEY);
         const deletePromises = [...toolchainsToDelete.entries()].map(([id, region]) => deleteToolchain(token, id, region));
@@ -114,24 +157,83 @@ export async function testSuiteCleanup(toolchainsToDelete) {
     }
 }
 
-export async function expectExecError(fullCommand, expectedMessage, options) {
+export async function assertExecError(fullCommand, expectedMessage, options, assertionFn) {
     try {
         const output = await execCommand(fullCommand, options);
         logger.dump(output);
         throw new Error('Expected command to fail but it succeeded');
     } catch (e) {
         logger.dump(e.message);
-        expect(e.message).to.match(expectedMessage);
+        if (assertionFn) {
+            const res = assertionFn(e.message);
+            if (res instanceof Promise) await res;
+        } else if (expectedMessage) {
+            expect(e.message).to.match(expectedMessage);
+        } else {
+            assert.fail('No assertion function or expected message provided.');
+        }
     }
 }
 
-export async function expectPtyOutputToMatch(fullCommand, expectedMessage, options) {
+export async function assertPtyOutput(fullCommand, expectedMessage, options, assertionFn) {
     try {
         const output = await runPtyProcess(fullCommand, options);
         logger.dump(output);
-        expect(output).to.match(expectedMessage);
+        if (assertionFn) {
+            const res = assertionFn(output);
+            if (res instanceof Promise) await res;
+        } else if (expectedMessage) {
+            expect(output).to.match(expectedMessage);
+        } else {
+            assert.fail('No assertion function or expected message provided.');
+        }
+        return parseTcIdAndRegion(output);
     } catch (e) {
         logger.dump(e.message);
         throw (e);
     }
 }
+
+export function areFilesInDir(dirPath, filePatterns) {
+    const foundFiles = searchDirectory(dirPath);
+    for (const pattern of filePatterns) {
+        const regex = new RegExp(pattern);
+        if (!foundFiles.some(file => regex.test(file))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export async function assertTfResourcesInDir(dirPath, expectedResourcesMap) {
+    const resourceCounter = {};
+
+    const foundFiles = searchDirectory(dirPath);
+    const allResources = [];
+    for (const file of foundFiles) {
+        if (!file.endsWith('.tf')) continue;
+        const fileName = path.basename(file);
+        const tfFile = fs.readFileSync(file, 'utf8');
+        const tfFileObject = await tfToJson(fileName, tfFile);
+        if (tfFileObject.resource) allResources.push(tfFileObject.resource);
+    }
+
+    for (const resourceMap of allResources) {
+        for (const resourceType of Object.keys(resourceMap)) {
+            resourceCounter[resourceType] = (resourceCounter[resourceType] || 0) + 1;
+        }
+    }
+    // Check if all expected resources are present
+    for (const [resourceType, expectedCount] of Object.entries(expectedResourcesMap)) {
+        if (resourceCounter[resourceType] !== expectedCount) {
+            assert.fail(`Expected ${expectedCount} ${resourceType} resource(s) but found ${resourceCounter[resourceType] || 0}`);
+        }
+    }
+    // Check if there are unexpected resources
+    for (const [resourceType, count] of Object.entries(resourceCounter)) {
+        if (!(resourceType in expectedResourcesMap)) {
+            assert.fail(`Unexpected ${resourceType} resource found. (Count: ${count})`);
+        }
+    }
+    assert.ok(true, 'Directory contains all expected resources');
+}

package/test/copy-toolchain/import.test.js

@@ -1,11 +0,0 @@
-/**
- * Licensed Materials - Property of IBM
- * (c) Copyright IBM Corporation 2025. All Rights Reserved.
- *
- * Note to U.S. Government Users Restricted Rights:
- * Use, duplication or disclosure restricted by GSA ADP Schedule
- * Contract with IBM Corp.
- */
-
-describe('copy-toolchain: Test import-terraform output', function () {
-});

package/test/copy-toolchain/terraform.test.js

@@ -1,11 +0,0 @@
-/**
- * Licensed Materials - Property of IBM
- * (c) Copyright IBM Corporation 2025. All Rights Reserved.
- *
- * Note to U.S. Government Users Restricted Rights:
- * Use, duplication or disclosure restricted by GSA ADP Schedule
- * Contract with IBM Corp.
- */
-
-describe('copy-toolchain: Test Terraform output', function () {
-});