@eclipse-che/che-e2e 7.73.0-dev-11985ec → 7.73.0-dev-62c0c9d

package/utils/ShellExecutor.ts

@@ -2,16 +2,16 @@ import { echo, exec, ShellString } from 'shelljs';
 
 export class ShellExecutor {
 
-    static wait(seconds: number): void {
-        this.execWithLog(`sleep ${seconds}s`);
-    }
+  static wait(seconds: number): void {
+    this.execWithLog(`sleep ${seconds}s`);
+  }
 
-    static curl(link: string): ShellString {
-        return this.execWithLog(`curl -k ${link}`);
-    }
+  static curl(link: string): ShellString {
+    return this.execWithLog(`curl -k ${link}`);
+  }
 
-    protected static execWithLog(command: string): ShellString {
-        echo(command);
-        return exec(command);
-    }
+  protected static execWithLog(command: string): ShellString {
+    echo(command);
+    return exec(command);
+  }
 }

package/utils/StringUtil.ts

@@ -10,41 +10,40 @@
 
 import { injectable } from 'inversify';
 import { Logger } from './Logger';
-import { KubernetesCommandLineToolsExecutor } from './KubernetesCommandLineToolsExecutor';
 
 @injectable()
 export class StringUtil {
-    /**
-     * Method extracts a test repo name from git clone https url;
-     * it splits the url into string[] by "/" or ".", deletes empty elements and elements that contains just "git", "main" or "tree" word, than returns the last one;
-     * please, avoid to call the test repo as just "git" or to use dots in the name, like: github.com/user/git.git, github.com/user/name.with.dots.
-     * @param url git https url (which using for "git clone")
-     * @return project name
-     */
-    static getProjectNameFromGitUrl(url: string): string {
-        Logger.debug(`${this.constructor.name}.${this.getProjectNameFromGitUrl.name} - ${url}`);
-        if (url.includes('?')) {
-            url = url.substring(0, url.indexOf('?'));
-        }
-        if (url.includes('/tree/')) {
-            url = url.split('/').slice(0, -2).join('/');
-        }
-        const projectName: string = url.split(/[\/.]/).filter((e: string) => !['git', ''].includes(e)).reverse()[0];
-        Logger.debug(`${this.constructor.name}.${this.getProjectNameFromGitUrl.name} - ${projectName}`);
-        return projectName;
+  /**
+   * Method extracts a test repo name from git clone https url;
+   * it splits the url into string[] by "/" or ".", deletes empty elements and elements that contains just "git", "main" or "tree" word, than returns the last one;
+   * please, avoid to call the test repo as just "git" or to use dots in the name, like: github.com/user/git.git, github.com/user/name.with.dots.
+   * @param url git https url (which using for "git clone")
+   * @return project name
+   */
+  static getProjectNameFromGitUrl(url: string): string {
+    Logger.debug(`${url}`);
+    if (url.includes('?')) {
+      url = url.substring(0, url.indexOf('?'));
     }
-
-    static sanitizeTitle(arg: string): string {
-        return arg.replace(/\//g, '+').replace(/,/g, '.').replace(/:/g, '-').replace(/['"]/g, '').replace(/[^a-z0-9+\-.()\[\]_]/gi, '_');
+    if (url.includes('/tree/')) {
+      url = url.split('/').slice(0, -2).join('/');
     }
+    const projectName: string = url.split(/[\/.]/).filter((e: string) => !['git', ''].includes(e)).reverse()[0];
+    Logger.debug(`${projectName}`);
+    return projectName;
+  }
 
-    /**
-     * Replaces ${ENV}, $ENV to "$ENV"
-     * @param command string command with environmental variables in unsupported format
-     * @return updated command with environmental variables in supported format
-     */
+  static sanitizeTitle(arg: string): string {
+    return arg.replace(/\//g, '+').replace(/,/g, '.').replace(/:/g, '-').replace(/['"]/g, '').replace(/[^a-z0-9+\-.()\[\]_]/gi, '_');
+  }
 
-    static updateCommandEnvsToShStyle(command: string): string {
-        return command.replace(/[{}]/g, '').replace(/(?<!")\${?[a-zA-Z0-9_+\-\s]+\b}?/gm, `"\$&"`);
-    }
+  /**
+   * Replaces ${ENV}, $ENV to "$ENV"
+   * @param command string command with environmental variables in unsupported format
+   * @return updated command with environmental variables in supported format
+   */
+
+  static updateCommandEnvsToShStyle(command: string): string {
+    return command.replace(/[{}]/g, '').replace(/(?<!")\${?[a-zA-Z0-9_+\-\s]+\b}?/gm, `"\$&"`);
+  }
 }

package/utils/request-handlers/CheApiRequestHandler.ts

@@ -8,7 +8,7 @@
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
 
-import axios, { AxiosResponse, AxiosRequestConfig } from 'axios';
+import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { TYPES } from '../../configs/inversify.types';
 import { inject, injectable } from 'inversify';
 import { IAuthorizationHeaderHandler } from './headers/IAuthorizationHeaderHandler';
@@ -18,93 +18,95 @@ import { BaseTestConstants } from '../../constants/BaseTestConstants';
 @injectable()
 export class CheApiRequestHandler {
 
-    /**
-     * This method adds a request interceptor into axios request interceptors list and returns an ID of the interceptor
-     */
-    static enableRequestInterceptor(): number {
-        Logger.debug(`CheApiRequestHandler.enableRequestInterceptor`);
-        return axios.interceptors.request.use( request => {
-                try {
-                    let request_censored: AxiosRequestConfig = JSON.parse(JSON.stringify(request));
-                    if (request_censored === undefined) {
-                        Logger.error('JSON.parse returned an undefined object, cannot process request');
-                        return request;
-                    }
-                    if (request_censored.headers === undefined) {
-                        Logger.warn('Request does not contain any headers object');
-                        return request;
-                    }
-                    request_censored.headers.Authorization = 'CENSORED';
-                    request_censored.headers.Cookie = 'CENSORED';
-                    Logger.info(`RequestHandler request:\n` + request_censored);
-                } catch (err) {
-                    Logger.error(`RequestHandler request: Failed to deep clone AxiosRequestConfig:` + err);
-                }
-            return request;
-        });
-    }
+  /**
+   * This method adds a request interceptor into axios request interceptors list and returns an ID of the interceptor
+   */
+  static enableRequestInterceptor(): number {
+    Logger.debug();
+    return axios.interceptors.request.use(request => {
+      try {
+        let request_censored: AxiosRequestConfig = JSON.parse(JSON.stringify(request));
+        if (request_censored === undefined) {
+          Logger.error('JSON.parse returned an undefined object, cannot process request');
+          return request;
+        }
+        if (request_censored.headers === undefined) {
+          Logger.warn('request does not contain any headers object');
+          return request;
+        }
+        request_censored.headers.Authorization = 'CENSORED';
+        request_censored.headers.Cookie = 'CENSORED';
+        Logger.info(`request:\n` + request_censored);
+      } catch (err) {
+        Logger.error(`request: Failed to deep clone AxiosRequestConfig:` + err);
+      }
+      return request;
+    });
+  }
 
-    /**
-     * This method adds a response interceptor into axios response interceptors list and returns an ID of the interceptor
-     */
-    static enableResponseInterceptor(): number {
-        Logger.debug(`CheApiRequestHandler.enableResponseRedirects`);
-        return axios.interceptors.response.use( response => {
-                try {
-                    let response_censored: AxiosResponse = JSON.parse(JSON.stringify(response, (key, value) => {
-                        switch (key) {
-                            case 'request': return 'CENSORED';
-                            default: return value;
-                        }
-                    }));
-                    if (response_censored === undefined) {
-                        Logger.error('JSON.parse returned an undefined object, cannot process response');
-                        return response;
-                    }
-                    if (response_censored.config === undefined) {
-                        Logger.warn('Response does not contain any config object');
-                        return response;
-                    }
-                    if (response_censored.config.headers === undefined) {
-                        Logger.warn('Response does not contain any config.headers object');
-                        return response;
-                    }
-                    response_censored.config.headers.Authorization = 'CENSORED';
-                    response_censored.config.headers.Cookie = 'CENSORED';
-                    if (response_censored.data.access_token !== null) {
-                        response_censored.data.access_token = 'CENSORED';
-                    }
-                    if (response_censored.data.refresh_token !== null) {
-                        response_censored.data.refresh_token = 'CENSORED';
-                    }
-                    Logger.info(`RequestHandler response:\n` + response_censored);
-                } catch (err) {
-                    Logger.error(`RequestHandler response: Failed to deep clone AxiosResponse:` + err);
-                }
-            return response;
-        });
-    }
+  /**
+   * This method adds a response interceptor into axios response interceptors list and returns an ID of the interceptor
+   */
+  static enableResponseInterceptor(): number {
+    Logger.debug();
+    return axios.interceptors.response.use(response => {
+      try {
+        let response_censored: AxiosResponse = JSON.parse(JSON.stringify(response, (key, value) => {
+          switch (key) {
+            case 'request':
+              return 'CENSORED';
+            default:
+              return value;
+          }
+        }));
+        if (response_censored === undefined) {
+          Logger.error('JSON.parse returned an undefined object, cannot process response');
+          return response;
+        }
+        if (response_censored.config === undefined) {
+          Logger.warn('response does not contain any config object');
+          return response;
+        }
+        if (response_censored.config.headers === undefined) {
+          Logger.warn('response does not contain any config.headers object');
+          return response;
+        }
+        response_censored.config.headers.Authorization = 'CENSORED';
+        response_censored.config.headers.Cookie = 'CENSORED';
+        if (response_censored.data.access_token !== null) {
+          response_censored.data.access_token = 'CENSORED';
+        }
+        if (response_censored.data.refresh_token !== null) {
+          response_censored.data.refresh_token = 'CENSORED';
+        }
+        Logger.info(`response:\n` + response_censored);
+      } catch (err) {
+        Logger.error(`response: Failed to deep clone AxiosResponse:` + err);
+      }
+      return response;
+    });
+  }
 
-    constructor(@inject(TYPES.IAuthorizationHeaderHandler) private readonly headerHandler: IAuthorizationHeaderHandler) { }
+  constructor(@inject(TYPES.IAuthorizationHeaderHandler) private readonly headerHandler: IAuthorizationHeaderHandler) { }
 
-    async get(relativeUrl: string): Promise<AxiosResponse> {
-        return await axios.get(this.assembleUrl(relativeUrl), await this.headerHandler.get());
-    }
+  async get(relativeUrl: string): Promise<AxiosResponse> {
+    return await axios.get(this.assembleUrl(relativeUrl), await this.headerHandler.get());
+  }
 
-    async post(relativeUrl: string, data?: string | any ): Promise<AxiosResponse> {
-        return await axios.post(this.assembleUrl(relativeUrl), data, await this.headerHandler.get());
-    }
+  async post(relativeUrl: string, data?: string | any): Promise<AxiosResponse> {
+    return await axios.post(this.assembleUrl(relativeUrl), data, await this.headerHandler.get());
+  }
 
-    async delete(relativeUrl: string): Promise<AxiosResponse> {
-        return await axios.delete(this.assembleUrl(relativeUrl), await this.headerHandler.get());
-    }
+  async delete(relativeUrl: string): Promise<AxiosResponse> {
+    return await axios.delete(this.assembleUrl(relativeUrl), await this.headerHandler.get());
+  }
 
-    async patch(relativeUrl: string, patchParams: object): Promise<AxiosResponse> {
-        return await axios.patch(this.assembleUrl(relativeUrl), patchParams, await this.headerHandler.get());
-    }
+  async patch(relativeUrl: string, patchParams: object): Promise<AxiosResponse> {
+    return await axios.patch(this.assembleUrl(relativeUrl), patchParams, await this.headerHandler.get());
+  }
 
-    private assembleUrl(relativeUrl: string): string {
-        return `${BaseTestConstants.TS_SELENIUM_BASE_URL}/${relativeUrl}`;
-    }
+  private assembleUrl(relativeUrl: string): string {
+    return `${BaseTestConstants.TS_SELENIUM_BASE_URL}/${relativeUrl}`;
+  }
 
 }

package/utils/request-handlers/headers/CheMultiuserAuthorizationHeaderHandler.ts

@@ -18,25 +18,25 @@ import { BaseTestConstants, Platform } from '../../../constants/BaseTestConstant
 
 @injectable()
 export class CheMultiuserAuthorizationHeaderHandler implements IAuthorizationHeaderHandler {
-    private authorizationToken: string = '';
-    private readonly cookiesType: string = BaseTestConstants.TS_PLATFORM === Platform.OPENSHIFT ? '_oauth_proxy' : '_oauth2_proxy';
+  private authorizationToken: string = '';
+  private readonly cookiesType: string = BaseTestConstants.TS_PLATFORM === Platform.OPENSHIFT ? '_oauth_proxy' : '_oauth2_proxy';
 
-    constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
+  constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
 
-    async get(): Promise<AxiosRequestConfig> {
-        try {
-            let token: IWebDriverCookie = await this.driverHelper.getDriver().manage().getCookie(this.cookiesType);
-            if (this.authorizationToken !== token.value) {
-                this.authorizationToken = token.value;
-            }
-        } catch (err) {
-            if (this.authorizationToken.length > 0) {
-                Logger.warn(`Could not obtain _oauth_proxy cookie from chromedriver, browser session may have been killed. Using stored value.`);
-            } else {
-                throw new Error(`Could not obtain _oauth_proxy cookie from chromedriver, browser session may have been killed. No stored token present!`);
-            }
-        }
-
-        return { headers: { 'cookie': `${this.cookiesType}=${this.authorizationToken}` } };
+  async get(): Promise<AxiosRequestConfig> {
+    try {
+      let token: IWebDriverCookie = await this.driverHelper.getDriver().manage().getCookie(this.cookiesType);
+      if (this.authorizationToken !== token.value) {
+        this.authorizationToken = token.value;
+      }
+    } catch (err) {
+      if (this.authorizationToken.length > 0) {
+        Logger.warn(`could not obtain _oauth_proxy cookie from chromedriver, browser session may have been killed. Using stored value.`);
+      } else {
+        throw new Error(`Could not obtain _oauth_proxy cookie from chromedriver, browser session may have been killed. No stored token present!`);
+      }
     }
+
+    return { headers: { 'cookie': `${this.cookiesType}=${this.authorizationToken}` } };
+  }
 }

package/utils/request-handlers/headers/IAuthorizationHeaderHandler.ts

@@ -11,5 +11,5 @@
 import { AxiosRequestConfig } from 'axios';
 
 export interface IAuthorizationHeaderHandler {
-    get(): Promise<AxiosRequestConfig>;
+  get(): Promise<AxiosRequestConfig>;
 }

package/utils/workspace/ApiUrlResolver.ts

@@ -15,33 +15,33 @@ import { AxiosResponse } from 'axios';
 
 @injectable()
 export class ApiUrlResolver {
-    private static readonly DASHBOARD_API_URL: string = 'dashboard/api/namespace';
-    private static readonly KUBERNETES_API_URL: string = 'api/kubernetes/namespace';
+  private static readonly DASHBOARD_API_URL: string = 'dashboard/api/namespace';
+  private static readonly KUBERNETES_API_URL: string = 'api/kubernetes/namespace';
 
-    private userNamespace: string = '';
+  private userNamespace: string = '';
 
-    constructor(@inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler) {}
+  constructor(@inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler) {}
 
-    async getWorkspaceApiUrl(workspaceName: string): Promise<string> {
-        return `${await this.getWorkspacesApiUrl()}/${workspaceName}`;
-    }
+  async getWorkspaceApiUrl(workspaceName: string): Promise<string> {
+    return `${await this.getWorkspacesApiUrl()}/${workspaceName}`;
+  }
 
-    async getWorkspacesApiUrl(): Promise<string> {
-        const namespace: string = await this.obtainUserNamespace();
-        return `${ApiUrlResolver.DASHBOARD_API_URL}/${namespace}/devworkspaces`;
-    }
+  async getWorkspacesApiUrl(): Promise<string> {
+    const namespace: string = await this.obtainUserNamespace();
+    return `${ApiUrlResolver.DASHBOARD_API_URL}/${namespace}/devworkspaces`;
+  }
 
-    private async obtainUserNamespace(): Promise<string> {
-        Logger.debug(`ApiUrlResolver.obtainUserNamespace ${this.userNamespace}`);
-        if (this.userNamespace.length === 0) {
-            Logger.trace(`ApiUrlResolver.obtainUserNamespace USER_NAMESPACE.length = 0, calling kubernetes API`);
-            const kubernetesResponse: AxiosResponse = await this.processRequestHandler.get(ApiUrlResolver.KUBERNETES_API_URL);
-            if (kubernetesResponse.status !== 200) {
-                throw new Error(`Cannot get user namespace from kubernetes API. Code: ${kubernetesResponse.status} Data: ${kubernetesResponse.data}`);
-            }
-            this.userNamespace = kubernetesResponse.data[0].name;
-            Logger.debug(`ApiUrlResolver.obtainUserNamespace kubeapi success: ${this.userNamespace}`);
-        }
-        return this.userNamespace;
+  private async obtainUserNamespace(): Promise<string> {
+    Logger.debug(`${this.userNamespace}`);
+    if (this.userNamespace.length === 0) {
+      Logger.trace(`USER_NAMESPACE.length = 0, calling kubernetes API`);
+      const kubernetesResponse: AxiosResponse = await this.processRequestHandler.get(ApiUrlResolver.KUBERNETES_API_URL);
+      if (kubernetesResponse.status !== 200) {
+        throw new Error(`Cannot get user namespace from kubernetes API. Code: ${kubernetesResponse.status} Data: ${kubernetesResponse.data}`);
+      }
+      this.userNamespace = kubernetesResponse.data[0].name;
+      Logger.debug(`kubeapi success: ${this.userNamespace}`);
     }
+    return this.userNamespace;
+  }
 }

package/utils/workspace/ITestWorkspaceUtil.ts

@@ -11,33 +11,33 @@
 import { WorkspaceStatus } from './WorkspaceStatus';
 
 export interface ITestWorkspaceUtil {
-    waitWorkspaceStatus(namespace: string, workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus): void;
-
-    stopWorkspaceByName(workspaceName: string): void;
-
-    /**
-     * Delete a workspace without stopping phase (similar with force deleting)
-     */
-    deleteWorkspaceByName(workspaceName: string): void;
-
-    /**
-     * Stop workspace before deleting with checking stopping phase
-     */
-    stopAndDeleteWorkspaceByName(workspaceName: string): void;
-
-    /**
-     * Stop all run workspaces in the namespace
-     */
-    stopAllRunningWorkspaces(namespace: string): void;
-
-    /**
-     * Stop all run workspaces, check statused and remove the workspaces
-     */
-    stopAndDeleteAllRunningWorkspaces(namespace: string): void;
-
-    /**
-     * Stop all run workspaces without stopping and waiting for of 'Stopped' phase
-     * Similar with 'force' deleting
-     */
-    deleteAllWorkspaces(namespace: string): void;
+  waitWorkspaceStatus(namespace: string, workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus): void;
+
+  stopWorkspaceByName(workspaceName: string): void;
+
+  /**
+   * Delete a workspace without stopping phase (similar with force deleting)
+   */
+  deleteWorkspaceByName(workspaceName: string): void;
+
+  /**
+   * Stop workspace before deleting with checking stopping phase
+   */
+  stopAndDeleteWorkspaceByName(workspaceName: string): void;
+
+  /**
+   * Stop all run workspaces in the namespace
+   */
+  stopAllRunningWorkspaces(namespace: string): void;
+
+  /**
+   * Stop all run workspaces, check statused and remove the workspaces
+   */
+  stopAndDeleteAllRunningWorkspaces(namespace: string): void;
+
+  /**
+   * Stop all run workspaces without stopping and waiting for of 'Stopped' phase
+   * Similar with 'force' deleting
+   */
+  deleteAllWorkspaces(namespace: string): void;
 }