@ibm-cloud/cd-tools 1.2.2 → 1.2.4

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';