@eclipse-che/che-e2e 7.74.0-dev-41d1364 → 7.74.0-dev-aace77a

package/utils/KubernetesCommandLineToolsExecutor.ts

@@ -14,76 +14,100 @@ import * as path from 'path';
 import { API_TEST_CONSTANTS, KubernetesCommandLineTool } from '../constants/API_TEST_CONSTANTS';
 import { BASE_TEST_CONSTANTS } from '../constants/BASE_TEST_CONSTANTS';
 import { OAUTH_CONSTANTS } from '../constants/OAUTH_CONSTANTS';
+import { IKubernetesCommandLineToolsExecutor } from './IKubernetesCommandLineToolsExecutor';
+import { inject, injectable } from 'inversify';
+import { CLASSES } from '../configs/inversify.types';
 
-export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
+@injectable()
+export class KubernetesCommandLineToolsExecutor implements IKubernetesCommandLineToolsExecutor {
 	private static container: string;
 	private static pod: string;
-	private readonly namespace: string;
-	private readonly workspaceName: string | undefined;
-	private readonly KUBERNETES_COMMAND_LINE_TOOL: string = API_TEST_CONSTANTS.TS_API_TEST_KUBERNETES_COMMAND_LINE_TOOL;
+	private readonly kubernetesCommandLineTool: string;
+	protected _namespace: string | undefined;
+	protected _workspaceName: string | undefined;
 
-	constructor(_workspaceName?: string, _namespace?: string) {
-		super();
-		this.workspaceName = _workspaceName;
-		this.namespace = this.setNamespace(_namespace);
+	constructor(
+		@inject(CLASSES.ShellExecutor)
+		protected readonly shellExecutor: ShellExecutor
+	) {
+		this.kubernetesCommandLineTool = API_TEST_CONSTANTS.TS_API_TEST_KUBERNETES_COMMAND_LINE_TOOL;
 	}
 
-	get getWorkspaceName(): string {
-		return <string>this.workspaceName;
+	set namespace(value: string | undefined) {
+		this._namespace = value;
 	}
 
-	get getNamespace(): string {
-		return this.namespace;
+	set workspaceName(value: string | undefined) {
+		this._workspaceName = value;
+	}
+
+	get workspaceName(): string | undefined {
+		return this._workspaceName;
+	}
+
+	get namespace(): string | undefined {
+		this._namespace =
+			this._namespace !== undefined
+				? this._namespace
+				: BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL.includes('devspaces')
+				? OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME + '-devspaces'
+				: BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL.includes('che')
+				? OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME + '-che'
+				: 'default';
+		return this._namespace;
 	}
 
 	// login to Openshift cluster with username and password
-	loginToOcp(): void {
-		if (this.KUBERNETES_COMMAND_LINE_TOOL === KubernetesCommandLineTool.OC) {
-			Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - login to the "OC" client.`);
+	loginToOcp(user: string = OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME, password: string = OAUTH_CONSTANTS.TS_SELENIUM_OCP_PASSWORD): void {
+		if (this.kubernetesCommandLineTool === KubernetesCommandLineTool.OC) {
+			Logger.debug(`${this.kubernetesCommandLineTool} - login to the "OC" client.`);
 			const url: string = this.getServerUrl();
-			if (this.isUserLoggedIn()) {
-				Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - user already logged`);
+			if (this.isUserLoggedIn(user)) {
+				Logger.debug(`${this.kubernetesCommandLineTool} - user already logged`);
 			} else {
-				Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - login ${url}, ${OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME}`);
-				exec(
-					`oc login --server=${url} -u=${OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME} -p=${OAUTH_CONSTANTS.TS_SELENIUM_OCP_PASSWORD} --insecure-skip-tls-verify`
-				);
+				Logger.debug(`${this.kubernetesCommandLineTool} - login ${url}, ${user}`);
+				exec(`oc login --server=${url} -u=${user} -p=${password} --insecure-skip-tls-verify`);
 			}
 		} else {
-			Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - doesn't support login command`);
+			Logger.debug(`${this.kubernetesCommandLineTool} - doesn't support login command`);
 		}
 	}
 
 	getContainerName(): string {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - get container name.`);
-		const output: ShellString = ShellExecutor.execWithLog(
-			`${this.KUBERNETES_COMMAND_LINE_TOOL} get ${KubernetesCommandLineToolsExecutor.pod} -o jsonpath='{.spec.containers[*].name}' -n ${this.namespace}`
+		Logger.debug(`${this.kubernetesCommandLineTool} - get container name.`);
+
+		const output: ShellString = this.shellExecutor.executeCommand(
+			`${this.kubernetesCommandLineTool} get ${KubernetesCommandLineToolsExecutor.pod} -o jsonpath='{.spec.containers[*].name}' -n ${this.namespace}`
 		);
 		echo('\n');
 		return output.stderr ? output.stderr : output.stdout;
 	}
 
 	getWorkspacePodName(): string {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - get workspace pod name.`);
-		const output: ShellString = ShellExecutor.execWithLog(
-			`${this.KUBERNETES_COMMAND_LINE_TOOL} get pod -l controller.devfile.io/devworkspace_name=${this.workspaceName} -n ${this.namespace} -o name`
+		Logger.debug(`${this.kubernetesCommandLineTool} - get workspace pod name.`);
+
+		const output: ShellString = this.shellExecutor.executeCommand(
+			`${this.kubernetesCommandLineTool} get pod -l controller.devfile.io/devworkspace_name=${this.workspaceName} -n ${this.namespace} -o name`
 		);
 		return output.stderr ? output.stderr : output.stdout.replace('\n', '');
 	}
 
 	deleteDevWorkspace(): void {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - delete '${this.workspaceName}' workspace`);
-		ShellExecutor.execWithLog(
-			`${this.KUBERNETES_COMMAND_LINE_TOOL} patch dw ${this.workspaceName} -n ${this.namespace} -p '{ "metadata": { "finalizers": null }}' --type merge || true`
+		Logger.debug(`${this.kubernetesCommandLineTool} - delete '${this.workspaceName}' workspace`);
+
+		this.shellExecutor.executeCommand(
+			`${this.kubernetesCommandLineTool} patch dw ${this.workspaceName} -n ${this.namespace} -p '{ "metadata": { "finalizers": null }}' --type merge || true`
 		);
-		ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} delete dw ${this.workspaceName} -n ${this.namespace} || true`);
-		ShellExecutor.execWithLog(
-			`${this.KUBERNETES_COMMAND_LINE_TOOL} delete dwt ${BASE_TEST_CONSTANTS.TS_SELENIUM_EDITOR}-${this.workspaceName} -n ${this.namespace} || true`
+		this.shellExecutor.executeCommand(`${this.kubernetesCommandLineTool} delete dw ${this.workspaceName} -n ${this.namespace} || true`);
+		this.shellExecutor.executeCommand(
+			`${this.kubernetesCommandLineTool} delete dwt ${BASE_TEST_CONSTANTS.TS_SELENIUM_EDITOR}-${this.workspaceName} -n ${this.namespace} || true`
 		);
 	}
 
 	applyAndWaitDevWorkspace(yamlConfiguration: string): ShellString {
-		if (this.KUBERNETES_COMMAND_LINE_TOOL === KubernetesCommandLineTool.KUBECTL) {
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
+
+		if (this.kubernetesCommandLineTool === KubernetesCommandLineTool.KUBECTL) {
 			this.createNamespace();
 		}
 		this.applyYamlConfigurationAsStringOutput(yamlConfiguration);
@@ -91,116 +115,124 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
 	}
 
 	executeCommand(commandToExecute: string, container: string = KubernetesCommandLineToolsExecutor.container): ShellString {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL}`);
-		return ShellExecutor.execWithLog(
-			`${this.KUBERNETES_COMMAND_LINE_TOOL} exec -i ${KubernetesCommandLineToolsExecutor.pod} -n ${this.namespace} -c ${container} -- sh -c '${commandToExecute}'`
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
+
+		return this.shellExecutor.executeCommand(
+			`${this.kubernetesCommandLineTool} exec -i ${KubernetesCommandLineToolsExecutor.pod} -n ${this.namespace} -c ${container} -- sh -c '${commandToExecute}'`
 		);
 	}
 
 	applyYamlConfigurationAsStringOutput(yamlConfiguration: string): ShellString {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL}`);
-		return ShellExecutor.execWithLog(
-			`cat <<EOF | ${this.KUBERNETES_COMMAND_LINE_TOOL} apply -n ${this.namespace} -f - \n` + yamlConfiguration + '\n' + 'EOF'
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
+
+		return this.shellExecutor.executeCommand(
+			`cat <<EOF | ${this.kubernetesCommandLineTool} apply -n ${this.namespace} -f - \n` + yamlConfiguration + '\n' + 'EOF'
+		);
+	}
+
+	applyWithoutNamespace(yamlConfiguration: string): ShellString {
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
+
+		return this.shellExecutor.executeCommand(
+			`cat <<EOF | ${this.kubernetesCommandLineTool} apply -f - \n` + yamlConfiguration + '\n' + 'EOF'
 		);
 	}
 
 	applyYamlConfigurationAsFile(pathToFile: string): void {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL}`);
-		ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} apply -n ${this.namespace} -f "${path.resolve(pathToFile)}"`);
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
+
+		this.shellExecutor.executeCommand(`${this.kubernetesCommandLineTool} apply -n ${this.namespace} -f "${path.resolve(pathToFile)}"`);
 	}
 
 	getDevWorkspaceYamlConfiguration(): ShellString {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL}`);
-		return ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} get dw ${this.workspaceName} -n ${this.namespace} -o yaml`);
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
+
+		return this.shellExecutor.executeCommand(
+			`${this.kubernetesCommandLineTool} get dw ${this.workspaceName} -n ${this.namespace} -o yaml`
+		);
 	}
 
 	waitDevWorkspace(timeout: number = 360): ShellString {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - wait till workspace ready.`);
-		const output: ShellString = ShellExecutor.execWithLog(
-			`${this.KUBERNETES_COMMAND_LINE_TOOL} wait -n ${this.namespace} --for=condition=Ready dw ${this.workspaceName} --timeout=${timeout}s`
+		Logger.debug(`${this.kubernetesCommandLineTool} - wait till workspace ready.`);
+
+		const output: ShellString = this.shellExecutor.executeCommand(
+			`${this.kubernetesCommandLineTool} wait -n ${this.namespace} --for=condition=Ready dw ${this.workspaceName} --timeout=${timeout}s`
 		);
 		this.getPodAndContainerNames();
 		return output;
 	}
 
 	createNamespace(): void {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - create namespace "${this.namespace}".`);
-		ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} create namespace ${this.namespace}`);
+		Logger.debug(`${this.kubernetesCommandLineTool} - create namespace "${this.namespace}".`);
+
+		this.shellExecutor.executeCommand(`${this.kubernetesCommandLineTool} create namespace ${this.namespace}`);
 	}
 
 	createProject(projectName: string): void {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - create new project "${projectName}".`);
-		ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} new-project ${projectName} -n ${this.namespace}`);
+		Logger.debug(`${this.kubernetesCommandLineTool} - create new project "${projectName}".`);
+
+		this.shellExecutor.executeCommand(`${this.kubernetesCommandLineTool} new-project ${projectName} -n ${this.namespace}`);
 	}
 
 	deleteProject(projectName: string): void {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - delete "${projectName}".`);
-		ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} delete project ${projectName} -n ${this.namespace}`);
+		Logger.debug(`${this.kubernetesCommandLineTool} - delete "${projectName}".`);
+
+		this.shellExecutor.executeCommand(`${this.kubernetesCommandLineTool} delete project ${projectName} -n ${this.namespace}`);
 	}
 
-	private getPodAndContainerNames(): void {
+	getPodAndContainerNames(): void {
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
+
 		KubernetesCommandLineToolsExecutor.pod = this.getWorkspacePodName();
 		KubernetesCommandLineToolsExecutor.container = this.getContainerName();
 	}
 
-	private isUserLoggedIn(): boolean {
-		const whoamiCommandOutput: ShellString = ShellExecutor.execWithLog('oc whoami && oc whoami --show-server=true');
+	/**
+	 * @param userName
+	 */
+	isUserLoggedIn(userName: string): boolean {
+		Logger.debug(`${this.kubernetesCommandLineTool}`);
 
-		return (
-			whoamiCommandOutput.stdout.includes(OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME) &&
-			whoamiCommandOutput.stdout.includes(this.getServerUrl())
-		);
-	}
+		const whoamiCommandOutput: ShellString = this.shellExecutor.executeCommand('oc whoami && oc whoami --show-server=true');
 
-	private setNamespace(_namespace: string | undefined): string {
-		_namespace =
-			_namespace !== undefined
-				? _namespace
-				: BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL.includes('devspaces')
-				? OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME + '-devspaces'
-				: BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL.includes('che')
-				? OAUTH_CONSTANTS.TS_SELENIUM_OCP_USERNAME + '-che'
-				: 'default';
-		return _namespace;
+		return whoamiCommandOutput.stdout.includes(userName) && whoamiCommandOutput.stdout.includes(this.getServerUrl());
 	}
 
-	private getServerUrl(): string {
-		Logger.debug(`${this.KUBERNETES_COMMAND_LINE_TOOL} - get server api url.`);
+	getServerUrl(): string {
+		Logger.debug(`${this.kubernetesCommandLineTool} - get server api url.`);
+
 		return BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL.replace('devspaces.apps', 'api') + ':6443';
 	}
 }
 
-// eslint-disable-next-line no-redeclare
-export namespace KubernetesCommandLineToolsExecutor {
-	export class ContainerTerminal extends KubernetesCommandLineToolsExecutor {
-		constructor(cluster: KubernetesCommandLineToolsExecutor) {
-			super(cluster.getWorkspaceName, cluster.getNamespace);
-		}
-
-		ls(path: string = ''): ShellString {
-			return this.executeCommand('ls ' + path);
-		}
+@injectable()
+export class ContainerTerminal extends KubernetesCommandLineToolsExecutor {
+	constructor(
+		@inject(CLASSES.ShellExecutor)
+		readonly shellExecutor: ShellExecutor,
+		@inject(CLASSES.KubernetesCommandLineToolsExecutor)
+		readonly cluster: KubernetesCommandLineToolsExecutor
+	) {
+		super(shellExecutor);
+	}
 
-		pwd(): ShellString {
-			return this.executeCommand('pwd');
-		}
+	ls(path: string = ''): ShellString {
+		return this.shellExecutor.executeCommand('ls ' + path);
+	}
 
-		cd(path: string): ShellString {
-			return this.executeCommand('cd ' + path);
-		}
+	pwd(): ShellString {
+		return this.shellExecutor.executeCommand('pwd');
+	}
 
-		gitClone(repository: string): ShellString {
-			return this.executeCommand('git clone ' + repository);
-		}
+	cd(path: string): ShellString {
+		return this.shellExecutor.executeCommand('cd ' + path);
+	}
 
-		removeFolder(path: string): ShellString {
-			return this.executeCommand('rm -rf ' + path);
-		}
+	gitClone(repository: string): ShellString {
+		return this.shellExecutor.executeCommand('git clone ' + repository);
+	}
 
-		getEnvValue(envName: string): string {
-			envName = envName.replace(/[${}]/g, '');
-			const output: ShellString = this.executeCommand(`env | grep ${envName}`);
-			return output.stderr ? output.stderr : output.stdout.substring(output.stdout.lastIndexOf('=') + 1).replace('\n', '');
-		}
+	removeFolder(path: string): ShellString {
+		return this.shellExecutor.executeCommand('rm -rf ' + path);
 	}
 }

package/utils/ShellExecutor.ts

@@ -7,19 +7,22 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
-import { echo, exec, ShellString } from 'shelljs';
+import { exec, ShellString } from 'shelljs';
+import { Logger } from './Logger';
+import { injectable } from 'inversify';
 
+@injectable()
 export class ShellExecutor {
-	static wait(seconds: number): void {
-		this.execWithLog(`sleep ${seconds}s`);
+	wait(seconds: number): void {
+		this.executeCommand(`sleep ${seconds}s`);
 	}
 
-	static curl(link: string): ShellString {
-		return this.execWithLog(`curl -k ${link}`);
+	curl(link: string): ShellString {
+		return this.executeCommand(`curl -k ${link}`);
 	}
 
-	protected static execWithLog(command: string): ShellString {
-		echo(command);
+	executeCommand(command: string): ShellString {
+		Logger.debug(command);
 		return exec(command);
 	}
 }

package/utils/StringUtil.ts

@@ -8,8 +8,8 @@
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
 
-import { injectable } from 'inversify';
 import { Logger } from './Logger';
+import { injectable } from 'inversify';
 
 @injectable()
 export class StringUtil {
@@ -22,6 +22,7 @@ export class StringUtil {
 	 */
 	static getProjectNameFromGitUrl(url: string): string {
 		Logger.debug(`${url}`);
+
 		if (url.includes('?')) {
 			url = url.substring(0, url.indexOf('?'));
 		}
@@ -37,6 +38,8 @@ export class StringUtil {
 	}
 
 	static sanitizeTitle(arg: string): string {
+		Logger.trace();
+
 		return arg
 			.replace(/\//g, '+')
 			.replace(/,/g, '.')
@@ -52,6 +55,8 @@ export class StringUtil {
 	 */
 
 	static updateCommandEnvsToShStyle(command: string): string {
+		Logger.trace();
+
 		return command.replace(/[{}]/g, '').replace(/(?<!")\${?[a-zA-Z0-9_+\-\s]+\b}?/gm, '"$&"');
 	}
 }