Bring pipeline-cli and nr-pipeline-ext into nrdk code base (js -> ts) (#84)

* Ported OpenShiftClient.js

* Rename

* src/pipeline-cli/util.ts - indentation

* util.ts + name(), parseName() and isUrl()

* OpenShiftClient.ts +ts conversion

* +OpenShiftResourceSelector.ts

* +OpenShiftStaticSelector.ts

* OpenShiftClient - swap requires for imports

* package.lock + debug, lodash.isstring, lodash.isplainobject and types

* package-lock.json update

* Renames for kebab-case

* Renames for kebab-case

* Cleaned up incomplete JSDoc and self=this

* Source OpenShiftClient from local

* openshift-client-ts +requires from pipeline-cli (still .js format)

* is-openshift-list.ts converted

* package.json + @types/lodash.isempty

* is-openshift-result.ts converted

* constants.ts converted

* Added and converted logger.ts

* logger.ts - revise export structure

* utils.ts + hashString(), hashObject(), execSync()

* transformers.ts converted

* util.ts + export normalizeKind(), getBuildConfigStrategy(), hashDirector(), fullName()

* openshift-client-x.ts converted

* Typing and removing 'use stricts' (handled by tsconfig)

* openshift-resource-selector.ts converted

* package-lock.json + @types/lodash.isempty

* Switch remaining pipeline-cli references to local

* basic-java-application-clean.ts copied and converted

* basic-functional-tester.ts copied and converted

* Switch nr-pipeline-ext references to local

* index.ts - replace one, remove four from @bcgov/nr-pipeline-ex imports

* custom-error.ts copied and converted

* constants.ts copied and converted

* util-functions copied and converted

* git-operation copied and converted

* constants.ts + CONST export (instead of default)

* Clean up remaining imports, general cleanup

* src/pipeline-cli/index.ts + exports

* +test/pipeline-cli/index.test.ts - checks against index

* +test/nr-pipeline-ext/index.test.ts and src/.../index.ts

* +openshift-client.test.ts - copied and converted, but only partially working

* Finish polishing fns for copied openshift-client.test.ts

* test/pipeline-cli/util.test.ts copied and converted

* test/pipeline-cli/lib.test.ts copied and converted

* src/pipeline-cli/util.ts +fns: isArray, isPlainObject, isString, parseArgumentsFromArray

* +test/pipeline-cli/resources - consumed by tests

* lib.test.ts - fixed bug emptying params

* +openshift-client.e2e.test.ts (stuck pending)

* +openshift-client-x.e2e.test.ts (stuck pending)

* +openshift-client-x.test.ts (stuck on stubs/fakes)

* Minor adjustments

* openshift-client-x.ts fix null checks

* test/nr-pipeline-ext - first pass for tests - copy, change to .ts and eslint --fix

* unicorn-case renames

* basic-java-application-clean.test.ts - finished up

* test/tsconfig.json + include - fixes under-linting in test folders

* util-functions.test.ts - finish up

* Remove unnecessary or incomplete tests

* util-functions.test.ts - fixed .skip

* +test/nr-pipeline-ext/index.test.ts

* pipeline-cli/openshift-client-x.test.ts rolled in lib.test.ts

* tests/ - cleanup and skips

* src/pipeline-cli/openshift-client-x.ts - cleanup

* test/commands/on/jira.issue.tests.ts - remove imrt @gov/nr-pipeline-ext

* Use src/error.ts instead of src/nr-pipeline-ext/custom-error.ts

* Replaced nr-pipeline-ext/util-functions with util/util-functions

* test/tsconfig.json - reverted changes

* Remove unfinished pipeline-cli e2e tests

* src/pipeline-cli/openshift-client.ts - clean up after js-ts conversion

* src/pipeline-cli/openshift-client-result.ts - revise case

* src/pipeline-cli/util.ts - clean up after js-ts conversion

* src/pipeline-cli/openshift-client-x.ts - clean up after js-ts conversion

* test/pipeline-cli/openshift-client-x.test.ts - small fixes, reenable/unskip last 3 tests

* package.json - remove link script and dependencies

* package.json, package-lock.json + lodash.isempty

* Post-rebase cleanup

* Update merge conflict

Author: DerekRoberts

package-lock.json

@@ -19,19 +19,22 @@
     "@aws-sdk/credential-provider-node": "^3.11.0",
     "@aws-sdk/protocol-http": "^3.10.0",
     "@aws-sdk/signature-v4": "^3.10.0",
-    "@bcgov/nr-pipeline-ext": "0.1.0-rc.13",
-    "@bcgov/pipeline-cli": "^1.0.1-2",
     "@oclif/command": "^1.8.0",
     "@oclif/plugin-help": "^3.2.0",
+    "@types/lodash.isplainobject": "^4.0.6",
     "axios": "^0.21.1",
     "chalk": "^4.1.0",
     "cli-ux": "^5.5.0",
+    "debug": "^4.2.0",
     "form-data": "^3.0.0",
     "inquirer": "^7.3.3",
     "isomorphic-git": "^1.7.8",
     "jira-connector": "^3.1.0",
     "jira.js": "^1.7.3",
     "keycloak-admin": "^1.14.10",
+    "lodash.isempty": "^4.4.0",
+    "lodash.isplainobject": "^4.0.6",
+    "lodash.isstring": "^4.0.1",
     "lodash.merge": "^4.6.2",
     "rsync": "^0.6.1",
     "safe-buffer": "^5.2.1",
@@ -45,7 +48,10 @@
     "@oclif/dev-cli": "^1",
     "@oclif/test": "^1",
     "@types/chai": "^4.2.12",
+    "@types/debug": "^4.1.5",
     "@types/inquirer": "^7.3.1",
+    "@types/lodash.isempty": "^4.4.6",
+    "@types/lodash.isstring": "^4.0.6",
     "@types/lodash.merge": "^4.6.6",
     "@types/mocha": "^8.0.3",
     "@types/node": "^12.19.1",
@@ -126,7 +132,6 @@
     "mocha": "mocha --timeout 9999999",
     "version": "oclif-dev readme && git add README.md",
     "oclif": "oclif",
-    "link": "npm link @bcgov/nr-pipeline-ext && npm link @bcgov/pipeline-cli",
     "publish:latest": "npm --no-git-tag-version version prerelease && npm publish --tag latest",
     "publish:alpha": "npm --no-git-tag-version version prerelease && npm publish --tag alpha"
   },

package.json

@@ -22,7 +22,7 @@ export default class Clean extends BaseCommand {
     const {flags} = this.parse(Clean)
     await applyFlagDefaults(flags)
     const settings = loadConfigScript(flags)
-    const {BasicJavaApplicationClean} = require('@bcgov/nr-pipeline-ext')
+    const {BasicJavaApplicationClean} = await import('../nr-pipeline-ext/basic-java-application-clean')
     new BasicJavaApplicationClean(settings).clean()
     // const task = loadScript(flags, FlagNames.CLEAN_SCRIPT)
     // task(Object.assign(settings, {phase: settings.options.env}))

src/commands/clean.ts

@@ -31,7 +31,7 @@ export default class FunctionalTest extends BaseCommand {
     const {flags} = this.parse(FunctionalTest)
     await applyFlagDefaults(flags)
     const settings = loadConfigScript(flags)
-    const {BasicFunctionalTester} = require('@bcgov/nr-pipeline-ext')
+    const {BasicFunctionalTester} = await import('../nr-pipeline-ext/basic-functional-tester')
     new BasicFunctionalTester(settings).runFunctionalTests()
   }
 }

src/commands/functionaltest.ts

@@ -1,29 +1,20 @@
-import {
-  BasicJavaApplicationBuilder,
-  BasicFunctionalTester,
-  InputDeployerVerify,
-  Liquibase,
-  Jira,
-  GitOperation,
-  CONST,
-} from '@bcgov/nr-pipeline-ext'
-import {OpenShiftClient, OpenShiftClientX} from '@bcgov/pipeline-cli'
-import {BasicJavaApplicationDeployer} from './util/basic-java-application-deployer'
-import {SecretManager} from './api/service/secret-manager'
 import {BasicBuilder} from './util/basic-builder'
 import {BasicDeployer} from './util/basic-deployer'
+import {BasicFunctionalTester} from './nr-pipeline-ext/basic-functional-tester'
+import {BasicJavaApplicationDeployer} from './util/basic-java-application-deployer'
+import {CONST} from './nr-pipeline-ext/constants'
 import {GeneralError as GenericError} from './error'
+import {GitOperation} from './nr-pipeline-ext/git-operation'
+import {OpenShiftClientX} from './pipeline-cli/openshift-client-x'
+import {OpenShiftClient} from './pipeline-cli/openshift-client'
+import {SecretManager} from './api/service/secret-manager'
 export {
   OpenShiftClient,
   OpenShiftClientX,
   BasicBuilder,
   BasicDeployer,
-  BasicJavaApplicationBuilder,
   BasicJavaApplicationDeployer,
   BasicFunctionalTester,
-  InputDeployerVerify,
-  Liquibase,
-  Jira,
   GitOperation,
   CONST,
   SecretManager,

src/index.ts

@@ -0,0 +1,107 @@
+/* eslint-disable no-console */
+/**
+ * Calling the script would expect to contain arguments of:
+ *  --env=[target environment],
+ *  --pr=[the pr number]
+ *
+ * Script assumes:
+ *  'srcFolderName' =  "functional-testing" to be the folder to contain source code for testing using "NodeJs".
+ *  'runCommand': default running command for Node using npm to run
+ * The two above can be configured from project's config.js file.
+ *
+ * Environment variables:
+ *  - TARGET_TESTING_URL: will be internally constructed from query route object to Openshift namespace, and
+ *                        is exposed to test environment before running tests.
+ *  - TARGET_ENV: will also be exposed to test environment as specified from --env argument
+ *  - UITEST_SKIP: can be used to skip tests
+ */
+
+import {OpenShiftClientX} from '../pipeline-cli/openshift-client-x'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as util from 'util'
+const exec = util.promisify(require('child_process').exec)
+
+export class BasicFunctionalTester {
+  settings: any
+
+  constructor(settings: any) {
+    this.settings = settings
+  }
+
+  async runFunctionalTests() {
+    const options = this.settings.options
+    const targetEnv = options.env
+    console.log(`Working under directory: ${process.cwd()}`)
+    console.log(`Target environment: ${targetEnv}`)
+    console.log('User arguments:', options)
+
+    const currentPhase = this.settings.phases[targetEnv]
+    const oc = new OpenShiftClientX(Object.assign({namespace: currentPhase.namespace}, options))
+    const routeSpce = oc.get('route', {
+      selector: `app=${currentPhase.instance},env-id=${currentPhase.changeId},github-owner=${oc.git.owner}`,
+      namespace: currentPhase.namespace,
+    })[0].spec
+    const targetUrl = ''.concat(
+      routeSpce.tls.termination === 'edge' ? 'https' : 'http',
+      '://',
+      routeSpce.host,
+      routeSpce.path
+    )
+    console.log(`Targeted URL for testing is retrived as: '${targetUrl}' for environment: ${targetEnv}`)
+
+    // current phase settings
+    const uitestConfig = {
+      srcFolderName: 'functional-testing', // default test folder name, relative to project folder
+      skip: 'false', // default
+      runCommand: 'npm ci && npm run headless-chrome-tests', // sample command
+      env: Object.assign(
+        {},
+        {PATH: process.env.PATH, HOME: process.env.HOME},
+        {TARGET_ENV: targetEnv, TARGET_TESTING_URL: targetUrl},
+        {APPDATA: process.env.APPDATA}
+      ),
+    }
+    if (currentPhase.uitest !== undefined) {
+      const userConfig = currentPhase.uitest
+      uitestConfig.srcFolderName =
+                userConfig.srcFolderName && userConfig.srcFolderName.trim() !== '' ?
+                  userConfig.srcFolderName :
+                  uitestConfig.srcFolderName
+      uitestConfig.skip = process.env.UITEST_SKIP ? process.env.UITEST_SKIP : uitestConfig.skip
+      uitestConfig.runCommand =
+                userConfig.runCommand && userConfig.runCommand.trim() !== '' ?
+                  userConfig.runCommand :
+                  uitestConfig.runCommand
+      userConfig.env ?
+        Object.assign(uitestConfig.env, userConfig.env) :
+        Object.assign(uitestConfig.env)
+    }
+
+    if (uitestConfig.skip && uitestConfig.skip.trim() === 'true') {
+      console.log('User UITEST_SKIP is set. Skipping functional tests.')
+    } else {
+      const testFolderDir = path.resolve(process.cwd(), `./${uitestConfig.srcFolderName}/`)
+      console.log('Resolved Testing Folder Dir:', testFolderDir)
+      fs.access(testFolderDir, function (error) {
+        if (error) {
+          console.error('Directory does not exist or no permission', error)
+          throw error
+        }
+      })
+
+      console.log('Process environments: ', uitestConfig.env)
+      console.log('Run Command: ', uitestConfig.runCommand)
+      try {
+        const {stdout} = await exec(`${uitestConfig.runCommand}`, {
+          cwd: `${testFolderDir}`,
+          env: uitestConfig.env,
+        })
+        console.log('Finished running test: \n', stdout)
+      } catch (error) {
+        console.error('Error: Command execution failed: ', error)
+        throw error
+      }
+    }
+  } // end of runFunctionalTests method
+}

src/main.ts

@@ -0,0 +1,89 @@
+import {OpenShiftClientX} from '../pipeline-cli/openshift-client-x'
+
+export class BasicJavaApplicationClean {
+  settings: any
+
+  constructor(settings: any) {
+    this.settings = settings
+  }
+
+  clean(): void {
+    const settings = this.settings
+    const env = settings.options.env.toLowerCase()
+    const phases = settings.phases
+    const options = settings.options
+    const oc = new OpenShiftClientX(Object.assign({namespace: phases.build.namespace}, options))
+    const targetPhase = this.getTargetPhases(env)
+
+    for (const t of targetPhase) {
+      const phase = phases[t]
+      const buildConfigs = oc.get('bc', {
+        selector: `app=${phase.instance},env-id=${phase.changeId},!shared,github-repo=${oc.git.repository},github-owner=${oc.git.owner}`,
+        namespace: phase.namespace,
+      })
+      if (buildConfigs) {
+        buildConfigs.forEach((bc: any) => {
+          if (bc.spec.output.to.kind === 'ImageStreamTag') {
+            oc.delete([`ImageStreamTag/${bc.spec.output.to.name}`], {
+              'ignore-not-found': 'true',
+              wait: 'true',
+              namespace: phase.namespace,
+            })
+          }
+        })
+      }
+
+      const deploymentConfigs = oc.get('dc', {
+        selector: `app=${phase.instance},env-id=${phase.changeId},env-name=${t},!shared,github-repo=${oc.git.repository},github-owner=${oc.git.owner}`,
+        namespace: phase.namespace,
+      })
+      if (deploymentConfigs) {
+        deploymentConfigs.forEach((dc: any) => {
+          dc.spec.triggers.forEach((trigger: any) => {
+            if (
+              trigger.type === 'ImageChange' &&
+                            trigger.imageChangeParams.from.kind === 'ImageStreamTag'
+            ) {
+              oc.delete([`ImageStreamTag/${trigger.imageChangeParams.from.name}`], {
+                'ignore-not-found': 'true',
+                wait: 'true',
+                namespace: phase.namespace,
+              })
+            }
+          })
+        })
+      }
+
+      oc.raw('delete', ['all'], {
+        selector: `app=${phase.instance},env-id=${phase.changeId},!shared,github-repo=${oc.git.repository},github-owner=${oc.git.owner}`,
+        wait: 'true',
+        namespace: phase.namespace,
+      })
+      oc.raw('delete', ['pvc,Secret,configmap,endpoints,RoleBinding,role,ServiceAccount,Endpoints'], {
+        selector: `app=${phase.instance},env-id=${phase.changeId},!shared,github-repo=${oc.git.repository},github-owner=${oc.git.owner}`,
+        wait: 'true',
+        namespace: phase.namespace,
+      })
+    }
+  } // end clean()
+
+  // /**
+  //    * Obtaining the target (phases) to clean up based on passed user argument 'env'.
+  //    * @param {string} env user passed argument for environment(s) to be cleaned.
+  //    * @returns Array(string) of targeted environments.
+  //    */
+  getTargetPhases(env: string): string[] {
+    const targetPhase = []
+    const phases = this.settings.phases
+    for (const phase in phases) {
+      if (env.match(/^(all|transient)$/) && phases[phase].transient) {
+        targetPhase.push(phase)
+      } else if (env === phase) {
+        targetPhase.push(phase)
+        break
+      }
+    }
+
+    return targetPhase
+  } // end getTargetPhases()
+} // end class

src/nr-pipeline-ext/basic-functional-tester.ts

@@ -0,0 +1,39 @@
+export const ISSUE_TYPE_CODE = Object.freeze({RFD: 'RFD', RFD_SUBTASK: 'RFD-subtask'})
+
+export const ISSUE_LINK_TYPE_NAME = Object.freeze({RFC_FRD: 'RFC-RFD'})
+
+export const ENV = Object.freeze({BUILD: 'build', DEV: 'dev', DLVR: 'dlvr', TEST: 'test', PROD: 'prod'})
+
+export const JIRA_TARGET_ENV = Object.freeze({DLVR: 'DLVR', TEST: 'TEST', PROD: 'PROD'})
+
+export const JIRA_ENV_REVIEWER = Object.freeze([
+  Object.freeze({ENV: JIRA_TARGET_ENV.DLVR, REVIEWER: 'Developer'}),
+  Object.freeze({ENV: JIRA_TARGET_ENV.TEST, REVIEWER: 'IIT'}),
+  Object.freeze({ENV: JIRA_TARGET_ENV.PROD, REVIEWER: 'Business'}),
+])
+
+export const DB_ACTION = Object.freeze({BACKUP: 'backup', RECOVERY: 'recovery'})
+
+export const VERIFY_STATUS = Object.freeze({READY: 'Ready', NOT_READY: 'Not Ready'})
+
+export const REASON = Object.freeze({
+  REASON_CODE_RFD_BLOCKED: 'RFD_BLOCKED',
+  REASON_DESC_RFD_BLOCKED: 'RFD(s) are blocked',
+  REASON_CODE_RFD_NOT_APPROVED: 'RFD_NOT_APPROVED',
+  REASON_DESC_RFD_NOT_APPROVED: 'RFD(s) are not approved',
+  REASON_CODE_PREVIOUS_RFD_NOT_CLOSED: 'PREVIOUS_RFD_NOT_CLOSED',
+  REASON_DESC_PREVIOUS_RFD_NOT_CLOSED: 'Previous stage RFD(s) are not closed',
+  REASON_CODE_RFC_NOT_AUTHORIZED: 'RFC_NOT_AUTHORIZED',
+  REASON_DESC_RFC_NOT_AUTHORIZED: 'RFC is not authorized to target environment',
+})
+
+export const CONST = {
+  ISSUE_TYPE_CODE: ISSUE_TYPE_CODE,
+  ISSUE_LINK_TYPE_NAME: ISSUE_LINK_TYPE_NAME,
+  ENV: ENV,
+  JIRA_TARGET_ENV: JIRA_TARGET_ENV,
+  JIRA_ENV_REVIEWER: JIRA_ENV_REVIEWER,
+  DB_ACTION: DB_ACTION,
+  VERIFY_STATUS: VERIFY_STATUS,
+  REASON: REASON,
+}