@eclipse-che/che-e2e 7.39.0

package/utils/KeycloackUrlHandler.ts

@@ -0,0 +1,32 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import { TestConstants } from '../TestConstants';
+
+export class KeycloackUrlHandler {
+    public static getBaseKeycloakUrl(): string {
+        let baseKeycloakUrl: string = TestConstants.TS_SELENIUM_BASE_URL;
+
+        if (!TestConstants.TS_SELENIUM_SINGLE_HOST) {
+            baseKeycloakUrl = baseKeycloakUrl.replace('che', 'keycloak');
+        }
+
+        return baseKeycloakUrl;
+    }
+
+    public static getTokenEndpointUrl(): string {
+        return `${this.getBaseKeycloakUrl()}/auth/realms/che/protocol/openid-connect/token`;
+    }
+
+    public static getIdentityCallbackUrl(): string {
+        return `${this.getBaseKeycloakUrl()}/auth/realms/che/broker/github/endpoint`;
+    }
+
+}

package/utils/Logger.ts

@@ -0,0 +1,87 @@
+import { TestConstants } from '../TestConstants';
+
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+export abstract class Logger {
+
+    /**
+     * Uses for logging of fatal errors.
+     * @param text log text
+     */
+    public static error(text: string, indentLevel: number = 1) {
+        this.logText(indentLevel, `[ERROR] ${text}`);
+    }
+
+    /**
+     * Uses for logging of recoverable errors and general warnings.
+     * @param text log text
+     */
+    public static warn(text: string, indentLevel: number = 1) {
+        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR') {
+            return;
+        }
+        this.logText(indentLevel, `[WARN] ${text}`);
+    }
+
+    /**
+     * Uses for logging of the public methods of the pageobjects.
+     * @param text log text
+     */
+    public static info(text: string, indentLevel: number = 3) {
+        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
+            TestConstants.TS_SELENIUM_LOG_LEVEL === 'WARN') {
+            return;
+        }
+        this.logText(indentLevel, `• ${text}`);
+    }
+
+    /**
+     * Uses for logging of the public methods of the pageobjects.
+     * @param text log text
+     */
+    public static debug(text: string, indentLevel: number = 5) {
+        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
+            TestConstants.TS_SELENIUM_LOG_LEVEL === 'WARN' ||
+            TestConstants.TS_SELENIUM_LOG_LEVEL === 'INFO') {
+            return;
+        }
+        this.logText(indentLevel, `▼ ${text}`);
+    }
+
+    /**
+     * Uses for logging of the public methods of the {@link DriverHelper} or
+     * private methods inside of pageobjects.
+     * @param text log text
+     */
+    public static trace(text: string, indentLevel: number = 6) {
+        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
+            TestConstants.TS_SELENIUM_LOG_LEVEL === 'WARN' ||
+            TestConstants.TS_SELENIUM_LOG_LEVEL === 'INFO' ||
+            TestConstants.TS_SELENIUM_LOG_LEVEL === 'DEBUG') {
+            return;
+        }
+        this.logText(indentLevel, `‣ ${text}`);
+    }
+
+    private static logText(messageIndentationLevel: number, text: string) {
+        // start group for every level
+        for (let i = 0; i < messageIndentationLevel; i++) {
+            console.group();
+        }
+        // print the trimmed text
+        // if multiline, the message should be properly padded
+        console.log(text);
+        // end group for every level
+        for (let i = 0; i < messageIndentationLevel; i++) {
+            console.groupEnd();
+        }
+    }
+}

package/utils/PreferencesHandler.ts

@@ -0,0 +1,120 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import { injectable, inject } from 'inversify';
+import { Logger } from './Logger';
+import { CLASSES } from '../inversify.types';
+import { CheApiRequestHandler } from './requestHandlers/CheApiRequestHandler';
+import { Editor } from '../pageobjects/ide/Editor';
+import { QuickOpenContainer } from '../pageobjects/ide/QuickOpenContainer';
+import { TopMenu } from '../pageobjects/ide/TopMenu';
+import { Key } from 'selenium-webdriver';
+
+export enum TerminalRendererType {
+    canvas = 'canvas',
+    dom = 'dom'
+}
+
+export enum AskForConfirmationType {
+    never = 'never',
+    ifRquired = 'ifRequired',
+    always = 'always'
+}
+
+@injectable()
+export class PreferencesHandler {
+
+    constructor(@inject(CLASSES.CheApiRequestHandler) private readonly requestHandler: CheApiRequestHandler,
+        @inject(CLASSES.Editor) private readonly editor: Editor,
+        @inject(CLASSES.QuickOpenContainer) private readonly quickOpenContainer: QuickOpenContainer,
+        @inject(CLASSES.TopMenu) private readonly topMenu: TopMenu) {
+    }
+
+    /**
+     * Works properly only for the running workspace.
+     */
+    public async setPreferenceUsingUI(property: string, value: any) {
+        const tabTitle: string = 'settings.json';
+
+        await this.topMenu.selectOption('View', 'Find Command...');
+        await this.quickOpenContainer.typeAndSelectSuggestion('Preferences:', 'Preferences: Open Preferences (JSON)');
+
+        let editorText: string = await this.editor.getEditorVisibleText(tabTitle);
+        let preferences = JSON.parse(editorText);
+        preferences[property] = value;
+
+        await this.editor.deleteAllText(tabTitle);
+        await this.editor.type(tabTitle, JSON.stringify(preferences), 1);
+        await this.editor.type(tabTitle, Key.chord(Key.CONTROL, Key.SHIFT, 'i'), 1);
+    }
+
+    /**
+     * Works properly only if set before workspace startup.
+     */
+    public async setTerminalType(type: TerminalRendererType) {
+        Logger.debug('PreferencesHandler.setTerminalToDom');
+        await this.setPreference('terminal.integrated.rendererType', type);
+    }
+
+    /**
+     *
+     * @param askForConfirmation possible values are "never", "ifRequired" and "always"
+     */
+    public async setConfirmExit(askForConfirmation: AskForConfirmationType) {
+        Logger.debug(`PreferencesHandler.setConfirmExit to ${askForConfirmation}`);
+        await this.setPreference(`application.confirmExit`, askForConfirmation);
+    }
+
+    /**
+     * Works properly only if set before workspace startup.
+     */
+    public async setUseGoLanaguageServer() {
+        Logger.debug(`PreferencesHandler.setUseGoLanguageServer to true.`);
+        await this.setPreference('go.useLanguageServer', 'true');
+    }
+
+    /**
+     * Works properly only if set before workspace startup.
+     */
+    public async setVscodeKubernetesPluginConfig(vsKubernetesConfig: any) {
+        Logger.debug(`PreferencesHandler.setVscodeKubernetesPluginConfig`);
+        await this.setPreference('vs-kubernetes', vsKubernetesConfig);
+    }
+
+    public async setPreference(attribute: string, value: any) {
+        Logger.trace(`PreferencesHandler.setPreferences ${attribute} to ${value}`);
+        let response;
+        try {
+            response = await this.requestHandler.get('api/preferences');
+        } catch (e) {
+            Logger.error(`PreferencesHandler.setPreferences failed to get user preferences: ${e}`);
+            return;
+        }
+        let userPref = response.data;
+        try {
+            let theiaPref = JSON.parse(userPref['theia-user-preferences']);
+            theiaPref[attribute] = value;
+            userPref['theia-user-preferences'] = JSON.stringify(theiaPref);
+            await this.requestHandler.post('api/preferences', userPref);
+        } catch (e) {
+            // setting terminal before running a workspace, so no theia preferences are set
+            Logger.warn(`PreferencesHandler.setPreference could not set theia-user-preferences from api/preferences response, forcing manually.`);
+            let theiaPref = `{ "${attribute}":"${value}" }`;
+            userPref['theia-user-preferences'] = JSON.stringify(JSON.parse(theiaPref));
+            try {
+                await this.requestHandler.post('api/preferences', userPref);
+            } catch (e) {
+                Logger.error(`PreferencesHandler.setPreference failed to manually set preferences value: ${e}`);
+                return;
+            }
+        }
+        Logger.trace(`PreferencesHandler.setPreferences ${attribute} to ${value} done.`);
+    }
+}

package/utils/Sanitizer.ts

@@ -0,0 +1,20 @@
+/*********************************************************************
+ * Copyright (c) 2021 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import { injectable } from 'inversify';
+
+@injectable()
+export class Sanitizer {
+
+    public sanitize(arg: string): string {
+        return arg.replace(/[\/]/g, '+').replace(/[\,]/g, '.').replace(/[\:]/g, '-').replace(/[\'\"]/g, '').replace(/[^a-z0-9\+\-\.\(\)\[\]\_]/gi, '_');
+    }
+
+}

package/utils/ScreenCatcher.ts

@@ -0,0 +1,74 @@
+/*********************************************************************
+ * Copyright (c) 2021 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+import * as fs from 'fs';
+import { injectable, inject } from 'inversify';
+import { CLASSES } from '../inversify.types';
+import { DriverHelper } from './DriverHelper';
+import { TestConstants } from '..';
+import { Sanitizer } from './Sanitizer';
+import { error } from 'selenium-webdriver';
+
+@injectable()
+export class ScreenCatcher {
+    constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
+                @inject(CLASSES.Sanitizer) private readonly sanitizer: Sanitizer) { }
+
+    async catchMethodScreen(methodName: string, methodIndex: number, screenshotIndex: number) {
+        const executionScreenCastDir = `${TestConstants.TS_SELENIUM_REPORT_FOLDER}/executionScreencast`;
+        const executionScreenCastErrorsDir = `${TestConstants.TS_SELENIUM_REPORT_FOLDER}/executionScreencastErrors`;
+        const formattedMethodIndex: string = new Intl.NumberFormat('en-us', { minimumIntegerDigits: 3 }).format(methodIndex);
+        const formattedScreenshotIndex: string = new Intl.NumberFormat('en-us', { minimumIntegerDigits: 5 }).format(screenshotIndex).replace(/,/g, '');
+
+        if (!fs.existsSync(TestConstants.TS_SELENIUM_REPORT_FOLDER)) {
+            fs.mkdirSync(TestConstants.TS_SELENIUM_REPORT_FOLDER);
+        }
+
+        if (!fs.existsSync(executionScreenCastDir)) {
+            fs.mkdirSync(executionScreenCastDir);
+        }
+
+        const date: Date = new Date();
+        const timeStr: string = date.toLocaleTimeString('en-us', { hour12: false }) + '.' + new Intl.NumberFormat('en-us', { minimumIntegerDigits: 3 }).format(date.getMilliseconds());
+
+        const screenshotPath: string = `${executionScreenCastDir}/${formattedMethodIndex}-${formattedScreenshotIndex}--(${this.sanitizer.sanitize(timeStr)})_${this.sanitizer.sanitize(methodName)}.png`;
+
+        try {
+            await this.catchScreen(screenshotPath);
+        } catch (err) {
+            if (!fs.existsSync(executionScreenCastErrorsDir)) {
+                fs.mkdirSync(executionScreenCastErrorsDir);
+            }
+
+            let errorLogFilePath: string = screenshotPath.replace('.png', '.txt');
+            errorLogFilePath = errorLogFilePath.replace(executionScreenCastDir, executionScreenCastErrorsDir);
+            if (err instanceof error.IError) {
+                await this.writeErrorLog(errorLogFilePath, err);
+            }
+        }
+    }
+
+    async catchScreen(screenshotPath: string) {
+        const screenshot: string = await this.driverHelper.getDriver().takeScreenshot();
+        const screenshotStream = fs.createWriteStream(screenshotPath);
+        screenshotStream.write(Buffer.from(screenshot, 'base64'));
+        screenshotStream.end();
+    }
+
+    async writeErrorLog(errorLogPath: string, err: error.IError) {
+        console.log(`Failed to save screenshot, additional information in the ${errorLogPath}`);
+
+        if (err.stack) {
+            const screenshotStream = fs.createWriteStream(errorLogPath);
+            screenshotStream.write(Buffer.from(err.stack, 'utf8'));
+            screenshotStream.end();
+        }
+    }
+
+}

package/utils/VCS/CheGitApi.ts

@@ -0,0 +1,26 @@
+import { injectable, inject } from 'inversify';
+import { CLASSES } from '../../inversify.types';
+import { CheApiRequestHandler } from '../../utils/requestHandlers/CheApiRequestHandler';
+
+
+@injectable()
+export class CheGitApi {
+  static readonly GIT_API_ENTRIPOINT_URL = 'api/ssh/vcs';
+
+  constructor(@inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler) { }
+
+
+
+  public async  getPublicSSHKey(): Promise<string> {
+
+    try {
+      const responce = await this.processRequestHandler.get(CheGitApi.GIT_API_ENTRIPOINT_URL);
+      return responce.data[0].publicKey;
+    } catch (error) {
+      console.error('Cannot get public ssh key with API \n' + error);
+      throw error;
+    }
+
+  }
+
+}

package/utils/VCS/github/GitHubUtil.ts

@@ -0,0 +1,91 @@
+import { injectable } from 'inversify';
+import axios from 'axios';
+
+@injectable()
+export class GitHubUtil {
+  private static readonly GITHUB_API_ENTRIPOINT_URL = 'https://api.github.com/';
+  /**
+   * add public part of ssh key to the defied github account
+   * @param authToken
+   * @param title
+   * @param key
+   */
+  async addPublicSshKeyToUserAccount(authToken: string, title: string, key: string) {
+    const gitHubApiSshURL: string = GitHubUtil.GITHUB_API_ENTRIPOINT_URL + 'user/keys';
+    const authHeader = { headers: { 'Authorization': 'token ' + authToken, 'Content-Type': 'application/json' } };
+
+    const data = {
+      title: `${title}`,
+      key: `${key}`
+    };
+
+    try { await axios.post(gitHubApiSshURL, JSON.stringify(data), authHeader); } catch (error) {
+      console.error('Cannot add the public key to the GitHub account: ');
+      console.error(error);
+      throw error;
+    }
+  }
+
+  async getRawContentFromFile(pathToFile: string): Promise<string> {
+    const gitHubContentEntryPointUrl: string = 'https://raw.githubusercontent.com/';
+    const pathToRawContent: string = `${gitHubContentEntryPointUrl}${pathToFile}`;
+    const authorization: string = 'Authorization';
+    const contentType: string = 'Content-Type';
+
+    try {
+      delete axios.defaults.headers.common[authorization];
+      delete axios.defaults.headers.common[contentType];
+      const response = await axios.get(`${gitHubContentEntryPointUrl}${pathToFile}`);
+      return response.data;
+    } catch (error) {
+      console.error('Cannot get content form the raw github content: ' + pathToRawContent);
+      console.error(error);
+      throw error;
+    }
+  }
+
+  async getPublicSshKeys(authToken: string): Promise<Array<string>> {
+    const gitHubApiSshURL: string = GitHubUtil.GITHUB_API_ENTRIPOINT_URL + 'user/keys';
+    const authHeader = { headers: { 'Authorization': 'token ' + authToken, 'Content-Type': 'application/json' } };
+    try {
+      const response = await axios.get(gitHubApiSshURL, authHeader);
+      const stringified = JSON.stringify(response.data);
+      const arrayOfWorkspaces = JSON.parse(stringified);
+      const idOfRunningWorkspace: Array<string> = new Array();
+      for (let entry of arrayOfWorkspaces) {
+        idOfRunningWorkspace.push(entry.id);
+      }
+      return idOfRunningWorkspace;
+    } catch (error) {
+      console.error('Cannot get public Keys from github: ' + gitHubApiSshURL);
+      console.error(error);
+      throw error;
+    }
+  }
+
+  async removePublicSshKey(authToken: string, keyId: string) {
+    const gitHubApiSshURL: string = GitHubUtil.GITHUB_API_ENTRIPOINT_URL + 'user/keys/' + keyId;
+    const authHeader = { headers: { 'Authorization': 'token ' + authToken, 'Content-Type': 'application/json' } };
+    try { await axios.delete(gitHubApiSshURL, authHeader); } catch (error) {
+      console.error('Cannot delete the public key from the GitHub account: ');
+      console.error(error);
+      throw error;
+    }
+  }
+
+
+  async removeAllPublicSshKeys(authToken: string) {
+    try {
+      const idList: string[] = await this.getPublicSshKeys(authToken);
+      for (let id of idList) {
+        this.removePublicSshKey(authToken, id);
+      }
+
+    } catch (error) {
+      console.error('Cannot delete the public key from the GitHub account: ');
+      console.error(error);
+      throw error;
+    }
+  }
+
+}

package/utils/WorkspaceNameHandler.ts

@@ -0,0 +1,48 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import { CLASSES } from '../inversify.types';
+import { inject, injectable } from 'inversify';
+import { BrowserTabsUtil } from './BrowserTabsUtil';
+import { Logger } from './Logger';
+
+@injectable()
+export class WorkspaceNameHandler {
+
+    constructor(@inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil) {}
+
+    public generateWorkspaceName(prefix: string, randomLength: number): string {
+        const possibleCharacters: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        const possibleCharactersLength: number = possibleCharacters.length;
+        let randomPart: string = '';
+        Logger.debug('WorkspaceNameHandler.generateWorkspaceName');
+
+        for (let i = 0; i < randomLength; i++) {
+            let currentRandomIndex: number = Math.floor(Math.random() * Math.floor(possibleCharactersLength));
+
+            randomPart += possibleCharacters[currentRandomIndex];
+        }
+
+        return prefix + randomPart;
+    }
+
+    public async getNameFromUrl(): Promise<string> {
+        let workspaceUrl: string = await this.browserTabsUtil.getCurrentUrl();
+        Logger.debug(`WorkspaceNameHandler.fromWorkspaceUrl  workspaceUrl: ${workspaceUrl}`);
+
+        const workspaceUrlParts: string[] = workspaceUrl.split('/');
+        const workspaceNameQueryString: string = workspaceUrlParts[workspaceUrlParts.length - 1];
+        const workspaceName: string = workspaceNameQueryString.split('?')[0];
+
+        Logger.debug(`workspaceName: ${workspaceName}`);
+
+        return workspaceName;
+    }
+}

package/utils/requestHandlers/CheApiRequestHandler.ts

@@ -0,0 +1,83 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import axios, { AxiosResponse, AxiosRequestConfig } from 'axios';
+import { TestConstants } from '../../TestConstants';
+import { TYPES } from '../../inversify.types';
+import { inject, injectable } from 'inversify';
+import { IAuthorizationHeaderHandler } from './headers/IAuthorizationHeaderHandler';
+
+@injectable()
+export class CheApiRequestHandler {
+
+    /**
+     * This method adds a request interceptor into axios request interceptors list and returns an ID of the interceptor
+     */
+    public static enableRequestInteceptor(): number {
+        console.log(`CheApiRequestHandler.enableRequestInterceptor`);
+        return axios.interceptors.request.use( request => {
+                try {
+                    let request_censored: AxiosRequestConfig = JSON.parse(JSON.stringify(request));
+                    request_censored.headers.Authorization = 'CENSORED';
+                    console.log(`RequestHandler request:\n`, request_censored);
+                } catch (err) {
+                    console.log(`RequestHandler 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
+     */
+    public static enableResponseInterceptor(): number {
+        console.log(`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;
+                        }
+                    }));
+                    response_censored.config.headers.Authorization = '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';
+                    }
+                    console.log(`RequestHandler response:\n`, response_censored);
+                } catch (err) {
+                    console.log(`RequestHandler response: Failed to deep clone AxiosResponse:`, err);
+                }
+            return response;
+        });
+    }
+
+    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 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());
+    }
+
+    private assembleUrl(relativeUrl: string): string {
+        return `${TestConstants.TS_SELENIUM_BASE_URL}/${relativeUrl}`;
+    }
+
+}

package/utils/requestHandlers/headers/CheMultiuserAuthorizationHeaderHandler.ts

@@ -0,0 +1,27 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+import { AxiosRequestConfig } from 'axios';
+
+import { TYPES } from '../../../inversify.types';
+import { IAuthorizationHeaderHandler } from './IAuthorizationHeaderHandler';
+import { injectable, inject } from 'inversify';
+import { ITokenHandler } from '../tokens/ITokenHandler';
+
+@injectable()
+export class CheMultiuserAuthorizationHeaderHandler implements IAuthorizationHeaderHandler {
+
+    constructor(@inject(TYPES.ITokenHandler) private readonly tokenHandler: ITokenHandler) {
+    }
+
+    async get(): Promise<AxiosRequestConfig> {
+        const token = await this.tokenHandler.get();
+        return { headers: { 'Authorization': `Bearer ${token}` } };
+    }
+}

package/utils/requestHandlers/headers/IAuthorizationHeaderHandler.ts

@@ -0,0 +1,15 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import { AxiosRequestConfig } from 'axios';
+
+export interface IAuthorizationHeaderHandler {
+    get(): Promise<AxiosRequestConfig>;
+}

package/utils/requestHandlers/tokens/CheMultiuserTokenHandler.ts

@@ -0,0 +1,39 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+import axios from 'axios';
+import querystring from 'querystring';
+import { injectable } from 'inversify';
+import { TestConstants } from '../../../TestConstants';
+import { ITokenHandler } from './ITokenHandler';
+import { KeycloackUrlHandler } from '../../KeycloackUrlHandler';
+
+@injectable()
+export class CheMultiuserTokenHandler implements ITokenHandler {
+    async get(): Promise<string> {
+        const keycloakUrl = KeycloackUrlHandler.getTokenEndpointUrl();
+
+        const params = {
+            client_id: 'che-public',
+            username: TestConstants.TS_SELENIUM_USERNAME,
+            password: TestConstants.TS_SELENIUM_PASSWORD,
+            grant_type: 'password'
+        };
+
+        try {
+            const responseToObtainBearerToken = await axios.post(keycloakUrl, querystring.stringify(params));
+            return responseToObtainBearerToken.data.access_token;
+        } catch (err) {
+            console.log(`Can not get bearer token. URL used: ${keycloakUrl}`);
+            throw err;
+        }
+
+    }
+
+}