rhdh-e2e-test-utils 1.0.0 → 1.1.0

package/dist/playwright/helpers/api-helper.js

@@ -0,0 +1,285 @@
+import { request, expect } from "@playwright/test";
+import { GITHUB_API_ENDPOINTS } from "./api-endpoints.js";
+export class APIHelper {
+    static githubAPIVersion = "2022-11-28";
+    staticToken = "";
+    baseUrl = "";
+    useStaticToken = false;
+    static async githubRequest(method, url, body) {
+        const context = await request.newContext();
+        const options = {
+            method: method,
+            headers: {
+                Accept: "application/vnd.github+json",
+                Authorization: `Bearer ${process.env.GH_RHDH_QE_USER_TOKEN}`,
+                "X-GitHub-Api-Version": this.githubAPIVersion,
+            },
+        };
+        if (body) {
+            options.data = body;
+        }
+        const response = await context.fetch(url, options);
+        return response;
+    }
+    static async getGithubPaginatedRequest(url, pageNo = 1, response = []) {
+        const fullUrl = `${url}&page=${pageNo}`;
+        const result = await this.githubRequest("GET", fullUrl);
+        const body = await result.json();
+        if (!Array.isArray(body)) {
+            throw new Error(`Expected array but got ${typeof body}: ${JSON.stringify(body)}`);
+        }
+        if (body.length === 0) {
+            return response;
+        }
+        response = [...response, ...body];
+        return await this.getGithubPaginatedRequest(url, pageNo + 1, response);
+    }
+    static async createGitHubRepo(owner, repoName) {
+        const response = await APIHelper.githubRequest("POST", GITHUB_API_ENDPOINTS.createRepo(owner), {
+            name: repoName,
+            private: false,
+        });
+        expect(response.status() === 201 || response.ok()).toBeTruthy();
+    }
+    static async createGitHubRepoWithFile(owner, repoName, filename, fileContent) {
+        // Create the repository
+        await APIHelper.createGitHubRepo(owner, repoName);
+        // Add the specified file
+        await APIHelper.createFileInRepo(owner, repoName, filename, fileContent, `Add ${filename} file`);
+    }
+    static async createFileInRepo(owner, repoName, filePath, content, commitMessage, branch = "main") {
+        const encodedContent = Buffer.from(content).toString("base64");
+        const response = await APIHelper.githubRequest("PUT", `${GITHUB_API_ENDPOINTS.contents(owner, repoName)}/${filePath}`, {
+            message: commitMessage,
+            content: encodedContent,
+            branch: branch,
+        });
+        expect(response.status() === 201 || response.ok()).toBeTruthy();
+    }
+    static async initCommit(owner, repo, branch = "main") {
+        const content = Buffer.from("This is the initial commit for the repository.").toString("base64");
+        const response = await APIHelper.githubRequest("PUT", `${GITHUB_API_ENDPOINTS.contents(owner, repo)}/initial-commit.md`, {
+            message: "Initial commit",
+            content: content,
+            branch: branch,
+        });
+        expect(response.status() === 201 || response.ok()).toBeTruthy();
+    }
+    static async deleteGitHubRepo(owner, repoName) {
+        await APIHelper.githubRequest("DELETE", GITHUB_API_ENDPOINTS.deleteRepo(owner, repoName));
+    }
+    static async mergeGitHubPR(owner, repoName, pullNumber) {
+        await APIHelper.githubRequest("PUT", GITHUB_API_ENDPOINTS.mergePR(owner, repoName, pullNumber));
+    }
+    static async getGitHubPRs(owner, repoName, state, paginated = false) {
+        const url = GITHUB_API_ENDPOINTS.pull(owner, repoName, state);
+        if (paginated) {
+            return await APIHelper.getGithubPaginatedRequest(url);
+        }
+        const response = await APIHelper.githubRequest("GET", url);
+        return response.json();
+    }
+    static async getfileContentFromPR(owner, repoName, pr, filename) {
+        const response = await APIHelper.githubRequest("GET", GITHUB_API_ENDPOINTS.pullFiles(owner, repoName, pr));
+        const fileRawUrl = (await response.json()).find((file) => file.filename === filename).raw_url;
+        const rawFileContent = await (await APIHelper.githubRequest("GET", fileRawUrl)).text();
+        return rawFileContent;
+    }
+    async getGuestToken() {
+        const context = await request.newContext();
+        const response = await context.post("/api/auth/guest/refresh");
+        expect(response.status()).toBe(200);
+        const data = await response.json();
+        return data.backstageIdentity.token;
+    }
+    async getGuestAuthHeader() {
+        const token = await this.getGuestToken();
+        const headers = {
+            Authorization: `Bearer ${token}`,
+        };
+        return headers;
+    }
+    async setStaticToken(token) {
+        this.useStaticToken = true;
+        this.staticToken = "Bearer " + token;
+    }
+    async setBaseUrl(url) {
+        this.baseUrl = url;
+    }
+    static async apiRequestWithStaticToken(method, url, staticToken, body) {
+        const context = await request.newContext();
+        const options = {
+            method: method,
+            headers: {
+                Accept: "application/json",
+                Authorization: `${staticToken}`,
+            },
+            ...(body && { data: body }),
+        };
+        const response = await context.fetch(url, options);
+        return response;
+    }
+    async getAllCatalogUsersFromAPI() {
+        const url = `${this.baseUrl}/api/catalog/entities/by-query?orderField=metadata.name%2Casc&filter=kind%3Duser`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("GET", url, token);
+        return response.json();
+    }
+    async getAllCatalogLocationsFromAPI() {
+        const url = `${this.baseUrl}/api/catalog/entities/by-query?orderField=metadata.name%2Casc&filter=kind%3Dlocation`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("GET", url, token);
+        return response.json();
+    }
+    async getAllCatalogGroupsFromAPI() {
+        const url = `${this.baseUrl}/api/catalog/entities/by-query?orderField=metadata.name%2Casc&filter=kind%3Dgroup`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("GET", url, token);
+        return response.json();
+    }
+    async getGroupEntityFromAPI(group) {
+        const url = `${this.baseUrl}/api/catalog/entities/by-name/group/default/${group}`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("GET", url, token);
+        return response.json();
+    }
+    async getCatalogUserFromAPI(user) {
+        const url = `${this.baseUrl}/api/catalog/entities/by-name/user/default/${user}`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("GET", url, token);
+        return response.json();
+    }
+    async deleteUserEntityFromAPI(user) {
+        const r = await this.getCatalogUserFromAPI(user);
+        if (!r.metadata || !r.metadata.uid) {
+            return;
+        }
+        const url = `${this.baseUrl}/api/catalog/entities/by-uid/${r.metadata.uid}`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("DELETE", url, token);
+        return response.statusText;
+    }
+    async getCatalogGroupFromAPI(group) {
+        const url = `${this.baseUrl}/api/catalog/entities/by-name/group/default/${group}`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("GET", url, token);
+        return response.json();
+    }
+    async deleteGroupEntityFromAPI(group) {
+        const r = await this.getCatalogGroupFromAPI(group);
+        const url = `${this.baseUrl}/api/catalog/entities/by-uid/${r.metadata.uid}`;
+        const token = this.useStaticToken ? this.staticToken : "";
+        const response = await APIHelper.apiRequestWithStaticToken("DELETE", url, token);
+        return response.statusText;
+    }
+    async scheduleEntityRefreshFromAPI(entity, kind, token) {
+        const url = `${this.baseUrl}/api/catalog/refresh`;
+        const reqBody = { entityRef: `${kind}:default/${entity}` };
+        const responseRefresh = await APIHelper.apiRequestWithStaticToken("POST", url, token, reqBody);
+        return responseRefresh.status();
+    }
+    /**
+     * Fetches the UID of an entity by its name from the Backstage catalog.
+     *
+     * @param name - The name of the entity (e.g., 'hello-world-2').
+     * @returns The UID string if found, otherwise undefined.
+     */
+    static async getEntityUidByName(name) {
+        const baseUrl = process.env.BASE_URL;
+        const url = `${baseUrl}/api/catalog/entities/by-name/template/default/${name}`;
+        const context = await request.newContext();
+        const response = await context.get(url);
+        if (response.status() !== 200) {
+            return undefined;
+        }
+        const data = await response.json();
+        return data?.metadata?.uid;
+    }
+    /**
+     * Deletes a location from the Backstage catalog by its UID.
+     *
+     * @param uid - The UID of the location to delete.
+     * @returns The status code of the delete operation.
+     */
+    static async deleteLocationByUid(uid) {
+        const baseUrl = process.env.BASE_URL;
+        const url = `${baseUrl}/api/catalog/locations/${uid}`;
+        const context = await request.newContext();
+        const response = await context.delete(url);
+        return response.status();
+    }
+    /**
+     * Fetches the UID of a Template entity by its name and namespace from the Backstage catalog.
+     *
+     * @param name - The name of the template entity (e.g., 'hello-world-2').
+     * @param namespace - The namespace of the template entity (default: 'default').
+     * @returns The UID string if found, otherwise undefined.
+     */
+    static async getTemplateEntityUidByName(name, namespace = "default") {
+        const baseUrl = process.env.BASE_URL;
+        const url = `${baseUrl}/api/catalog/locations/by-entity/template/${namespace}/${name}`;
+        const context = await request.newContext();
+        const response = await context.get(url);
+        if (response.status() === 200) {
+            const data = await response.json();
+            return data?.metadata?.uid;
+        }
+        if (response.status() === 404) {
+            return undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Deletes an entity location from the Backstage catalog by its ID.
+     *
+     * @param id - The ID of the entity to delete.
+     * @returns The status code of the delete operation.
+     */
+    static async deleteEntityLocationById(id) {
+        const baseUrl = process.env.BASE_URL;
+        const url = `${baseUrl}/api/catalog/locations/${id}`;
+        const context = await request.newContext();
+        const response = await context.delete(url);
+        return response.status();
+    }
+    /**
+     * Registers a new location in the Backstage catalog.
+     *
+     * @param target - The target URL of the location to register.
+     * @returns The status code of the registration operation.
+     */
+    static async registerLocation(target) {
+        const baseUrl = process.env.BASE_URL;
+        const url = `${baseUrl}/api/catalog/locations`;
+        const context = await request.newContext();
+        const response = await context.post(url, {
+            data: {
+                type: "url",
+                target,
+            },
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        return response.status();
+    }
+    /**
+     * Fetches the ID of a location from the Backstage catalog by its target URL.
+     *
+     * @param target - The target URL of the location to search for.
+     * @returns The ID string if found, otherwise undefined.
+     */
+    static async getLocationIdByTarget(target) {
+        const baseUrl = process.env.BASE_URL;
+        const url = `${baseUrl}/api/catalog/locations`;
+        const context = await request.newContext();
+        const response = await context.get(url);
+        if (response.status() !== 200) {
+            return undefined;
+        }
+        const data = await response.json();
+        // data is expected to be an array of objects with a 'data' property
+        const location = (Array.isArray(data) ? data : []).find((entry) => entry?.data?.target === target);
+        return location?.data?.id;
+    }
+}

package/dist/playwright/helpers/common.d.ts

@@ -0,0 +1,31 @@
+import { UIhelper } from "./ui-helper.js";
+import type { Browser, Page, TestInfo } from "@playwright/test";
+export declare class LoginHelper {
+    page: Page;
+    uiHelper: UIhelper;
+    constructor(page: Page);
+    loginAsGuest(): Promise<void>;
+    signOut(): Promise<void>;
+    private logintoGithub;
+    logintoKeycloak(userid: string, password: string): Promise<void>;
+    loginAsKeycloakUser(userid?: string, password?: string): Promise<void>;
+    loginAsGithubUser(userid?: string): Promise<void>;
+    checkAndReauthorizeGithubApp(): Promise<void>;
+    googleSignIn(email: string): Promise<void>;
+    checkAndClickOnGHloginPopup(force?: boolean): Promise<void>;
+    getButtonSelector(label: string): string;
+    getLoginBtnSelector(): string;
+    clickOnGHloginPopup(): Promise<void>;
+    getGitHub2FAOTP(userid: string): string;
+    getGoogle2FAOTP(): string;
+    keycloakLogin(username: string, password: string): Promise<"Already logged in" | "Login successful" | "User does not exist">;
+    private handleGitHubPopupLogin;
+    githubLogin(username: string, password: string, twofactor: string): Promise<string>;
+    githubLoginFromSettingsPage(username: string, password: string, twofactor: string): Promise<string>;
+    microsoftAzureLogin(username: string, password: string): Promise<"Already logged in" | "Login successful" | "User does not exist">;
+}
+export declare function setupBrowser(browser: Browser, testInfo: TestInfo): Promise<{
+    page: Page;
+    context: import("playwright-core").BrowserContext;
+}>;
+//# sourceMappingURL=common.d.ts.map

package/dist/playwright/helpers/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/playwright/helpers/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG1C,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAOhE,qBAAa,WAAW;IACtB,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,QAAQ,CAAC;gBAEP,IAAI,EAAE,IAAI;IAKhB,YAAY;IAcZ,OAAO;YAMC,aAAa;IAmCrB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAYhD,mBAAmB,CACvB,MAAM,GAAE,MAAkC,EAC1C,QAAQ,GAAE,MAAkC;IASxC,iBAAiB,CAAC,MAAM,GAAE,MAAyC;IA4BnE,4BAA4B;IAqB5B,YAAY,CAAC,KAAK,EAAE,MAAM;IA2B1B,2BAA2B,CAAC,KAAK,UAAQ;IAU/C,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIxC,mBAAmB,IAAI,MAAM;IAIvB,mBAAmB;IAgBzB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAcvC,eAAe,IAAI,MAAM;IAKnB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;YAqCxC,sBAAsB;IAoD9B,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAYjE,2BAA2B,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;IAYb,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CA2C7D;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ;;;GAWtE"}

package/dist/playwright/helpers/common.js

@@ -0,0 +1,342 @@
+import { UIhelper } from "./ui-helper.js";
+import { authenticator } from "otplib";
+import { test, expect } from "@playwright/test";
+import { SETTINGS_PAGE_COMPONENTS } from "../page-objects/page-obj.js";
+import { UI_HELPER_ELEMENTS } from "../page-objects/global-obj.js";
+import * as path from "path";
+import * as fs from "fs";
+import { DEFAULT_USERS } from "../../deployment/keycloak/constants.js";
+export class LoginHelper {
+    page;
+    uiHelper;
+    constructor(page) {
+        this.page = page;
+        this.uiHelper = new UIhelper(page);
+    }
+    async loginAsGuest() {
+        await this.page.goto("/");
+        await this.uiHelper.waitForLoad(240000);
+        // TODO - Remove it after https://issues.redhat.com/browse/RHIDP-2043. A Dynamic plugin for Guest Authentication Provider needs to be created
+        this.page.on("dialog", async (dialog) => {
+            console.log(`Dialog message: ${dialog.message()}`);
+            await dialog.accept();
+        });
+        await this.uiHelper.verifyHeading("Select a sign-in method");
+        await this.uiHelper.clickButton("Enter");
+        await this.page.waitForSelector("nav a", { timeout: 10_000 });
+    }
+    async signOut() {
+        await this.page.click(SETTINGS_PAGE_COMPONENTS.userSettingsMenu);
+        await this.page.click(SETTINGS_PAGE_COMPONENTS.signOut);
+        await this.uiHelper.verifyHeading("Select a sign-in method");
+    }
+    async logintoGithub(userid) {
+        await this.page.goto("https://github.com/login");
+        await this.page.waitForSelector("#login_field");
+        await this.page.fill("#login_field", userid);
+        switch (userid) {
+            case process.env.GH_USER_ID:
+                await this.page.fill("#password", process.env.GH_USER_PASS);
+                break;
+            case process.env.GH_USER2_ID:
+                await this.page.fill("#password", process.env.GH_USER2_PASS);
+                break;
+            default:
+                throw new Error("Invalid User ID");
+        }
+        await this.page.click('[value="Sign in"]');
+        await this.page.fill("#app_totp", this.getGitHub2FAOTP(userid));
+        test.setTimeout(130000);
+        if ((await this.uiHelper.isTextVisible("The two-factor code you entered has already been used")) ||
+            (await this.uiHelper.isTextVisible("too many codes have been submitted", 3000))) {
+            await this.page.waitForTimeout(60000);
+            await this.page.fill("#app_totp", this.getGitHub2FAOTP(userid));
+        }
+        await this.page.waitForTimeout(3_000);
+    }
+    async logintoKeycloak(userid, password) {
+        await new Promise((resolve) => {
+            this.page.once("popup", async (popup) => {
+                await popup.waitForLoadState();
+                await popup.locator("#username").fill(userid);
+                await popup.locator("#password").fill(password);
+                await popup.locator("#kc-login").click();
+                resolve();
+            });
+        });
+    }
+    async loginAsKeycloakUser(userid = DEFAULT_USERS[0].username, password = DEFAULT_USERS[0].password) {
+        await this.page.goto("/");
+        await this.uiHelper.waitForLoad(240000);
+        await this.uiHelper.clickButton("Sign In");
+        await this.logintoKeycloak(userid, password);
+        await this.page.waitForSelector("nav a", { timeout: 10_000 });
+    }
+    async loginAsGithubUser(userid = process.env.GH_USER_ID) {
+        const sessionFileName = `authState_${userid}.json`;
+        // Check if a session file for this specific user already exists
+        if (fs.existsSync(sessionFileName)) {
+            // Load and reuse existing authentication state
+            const cookies = JSON.parse(fs.readFileSync(sessionFileName, "utf-8")).cookies;
+            await this.page.context().addCookies(cookies);
+            console.log(`Reusing existing authentication state for user: ${userid}`);
+            await this.page.goto("/");
+            await this.uiHelper.waitForLoad(12000);
+            await this.uiHelper.clickButton("Sign In");
+            await this.checkAndReauthorizeGithubApp();
+        }
+        else {
+            // Perform login if no session file exists, then save the state
+            await this.logintoGithub(userid);
+            await this.page.goto("/");
+            await this.uiHelper.waitForLoad(240000);
+            await this.uiHelper.clickButton("Sign In");
+            await this.checkAndReauthorizeGithubApp();
+            await this.page.waitForSelector("nav a", { timeout: 10_000 });
+            await this.page.context().storageState({ path: sessionFileName });
+            console.log(`Authentication state saved for user: ${userid}`);
+        }
+    }
+    async checkAndReauthorizeGithubApp() {
+        await new Promise((resolve) => {
+            this.page.once("popup", async (popup) => {
+                await popup.waitForLoadState();
+                // Check for popup closure for up to 10 seconds before proceeding
+                for (let attempts = 0; attempts < 10 && !popup.isClosed(); attempts++) {
+                    await this.page.waitForTimeout(1000); // Using page here because if the popup closes automatically, it throws an error during the wait
+                }
+                const locator = popup.locator("button.js-oauth-authorize-btn");
+                if (!popup.isClosed() && (await locator.isVisible())) {
+                    await popup.locator("body").click();
+                    await locator.waitFor();
+                    await locator.click();
+                }
+                resolve();
+            });
+        });
+    }
+    async googleSignIn(email) {
+        await new Promise((resolve) => {
+            this.page.once("popup", async (popup) => {
+                await popup.waitForLoadState();
+                const locator = popup
+                    .getByRole("link", { name: email, exact: false })
+                    .first();
+                await popup.waitForTimeout(3000);
+                await locator.waitFor({ state: "visible" });
+                await locator.click({ force: true });
+                await popup.waitForTimeout(3000);
+                await popup
+                    .locator("[name=Passwd]")
+                    .fill(process.env.GOOGLE_USER_PASS);
+                await popup.locator("[name=Passwd]").press("Enter");
+                await popup.waitForTimeout(3500);
+                await popup.locator("[name=totpPin]").fill(this.getGoogle2FAOTP());
+                await popup.locator("[name=totpPin]").press("Enter");
+                await popup
+                    .getByRole("button", { name: /Continue|Weiter/ })
+                    .click({ timeout: 60000 });
+                resolve();
+            });
+        });
+    }
+    async checkAndClickOnGHloginPopup(force = false) {
+        const frameLocator = this.page.getByLabel("Login Required");
+        try {
+            await frameLocator.waitFor({ state: "visible", timeout: 2000 });
+            await this.clickOnGHloginPopup();
+        }
+        catch (error) {
+            if (force)
+                throw error;
+        }
+    }
+    getButtonSelector(label) {
+        return `${UI_HELPER_ELEMENTS.MuiButtonLabel}:has-text("${label}")`;
+    }
+    getLoginBtnSelector() {
+        return 'MuiListItem-root li.MuiListItem-root button.MuiButton-root:has(span.MuiButton-label:text("Log in"))';
+    }
+    async clickOnGHloginPopup() {
+        const isLoginRequiredVisible = await this.uiHelper.isTextVisible("Sign in");
+        if (isLoginRequiredVisible) {
+            await this.uiHelper.clickButton("Sign in");
+            await this.uiHelper.clickButton("Log in");
+            await this.checkAndReauthorizeGithubApp();
+            await this.page.waitForSelector(this.getLoginBtnSelector(), {
+                state: "detached",
+            });
+        }
+        else {
+            console.log('"Log in" button is not visible. Skipping login popup actions.');
+        }
+    }
+    getGitHub2FAOTP(userid) {
+        const secrets = {
+            [process.env.GH_USER_ID]: process.env.GH_2FA_SECRET,
+            [process.env.GH_USER2_ID]: process.env.GH_USER2_2FA_SECRET,
+        };
+        const secret = secrets[userid];
+        if (!secret) {
+            throw new Error("Invalid User ID");
+        }
+        return authenticator.generate(secret);
+    }
+    getGoogle2FAOTP() {
+        const secret = process.env.GOOGLE_2FA_SECRET;
+        return authenticator.generate(secret);
+    }
+    async keycloakLogin(username, password) {
+        await this.page.goto("/");
+        await this.page.waitForSelector('p:has-text("Sign in using OIDC")');
+        const [popup] = await Promise.all([
+            this.page.waitForEvent("popup"),
+            this.uiHelper.clickButton("Sign In"),
+        ]);
+        await popup.waitForLoadState("domcontentloaded");
+        // Check if popup closes automatically (already logged in)
+        try {
+            await popup.waitForEvent("close", { timeout: 5000 });
+            return "Already logged in";
+        }
+        catch {
+            // Popup didn't close, proceed with login
+        }
+        try {
+            await popup.locator("#username").click();
+            await popup.locator("#username").fill(username);
+            await popup.locator("#password").fill(password);
+            await popup.locator("[name=login]").click({ timeout: 5000 });
+            await popup.waitForEvent("close", { timeout: 2000 });
+            return "Login successful";
+        }
+        catch (e) {
+            const usernameError = popup.locator("id=input-error");
+            if (await usernameError.isVisible()) {
+                await popup.close();
+                return "User does not exist";
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async handleGitHubPopupLogin(popup, username, password, twofactor) {
+        await expect(async () => {
+            await popup.waitForLoadState("domcontentloaded");
+            expect(popup).toBeTruthy();
+        }).toPass({
+            intervals: [5_000, 10_000],
+            timeout: 20 * 1000,
+        });
+        // Check if popup closes automatically
+        try {
+            await popup.waitForEvent("close", { timeout: 5000 });
+            return "Already logged in";
+        }
+        catch {
+            // Popup didn't close, proceed with login
+        }
+        try {
+            await popup.locator("#login_field").click({ timeout: 5000 });
+            await popup.locator("#login_field").fill(username, { timeout: 5000 });
+            const cookieLocator = popup.locator("#wcpConsentBannerCtrl");
+            if (await cookieLocator.isVisible()) {
+                await popup.click('button:has-text("Reject")', { timeout: 5000 });
+            }
+            await popup.locator("#password").click({ timeout: 5000 });
+            await popup.locator("#password").fill(password, { timeout: 5000 });
+            await popup
+                .locator("[type='submit'][value='Sign in']:not(webauthn-status *)")
+                .first()
+                .click({ timeout: 5000 });
+            const twofactorcode = authenticator.generate(twofactor);
+            await popup.locator("#app_totp").click({ timeout: 5000 });
+            await popup.locator("#app_totp").fill(twofactorcode, { timeout: 5000 });
+            await popup.waitForEvent("close", { timeout: 20000 });
+            return "Login successful";
+        }
+        catch (e) {
+            const authorization = popup.locator("button.js-oauth-authorize-btn");
+            if (await authorization.isVisible()) {
+                await authorization.click();
+                return "Login successful";
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async githubLogin(username, password, twofactor) {
+        await this.page.goto("/");
+        await this.page.waitForSelector('p:has-text("Sign in using GitHub")');
+        const [popup] = await Promise.all([
+            this.page.waitForEvent("popup"),
+            this.uiHelper.clickButton("Sign In"),
+        ]);
+        return this.handleGitHubPopupLogin(popup, username, password, twofactor);
+    }
+    async githubLoginFromSettingsPage(username, password, twofactor) {
+        await this.page.goto("/settings/auth-providers");
+        const [popup] = await Promise.all([
+            this.page.waitForEvent("popup"),
+            this.page.getByTitle("Sign in to GitHub").click(),
+            this.uiHelper.clickButton("Log in"),
+        ]);
+        return this.handleGitHubPopupLogin(popup, username, password, twofactor);
+    }
+    async microsoftAzureLogin(username, password) {
+        await this.page.goto("/");
+        await this.page.waitForSelector('p:has-text("Sign in using Microsoft")');
+        const [popup] = await Promise.all([
+            this.page.waitForEvent("popup"),
+            this.uiHelper.clickButton("Sign In"),
+        ]);
+        await popup.waitForLoadState("domcontentloaded");
+        if (popup.url().startsWith(process.env.BASE_URL)) {
+            // an active microsoft session is already logged in and the popup will automatically close
+            return "Already logged in";
+        }
+        else {
+            try {
+                await popup.locator("[name=loginfmt]").click();
+                await popup
+                    .locator("[name=loginfmt]")
+                    .fill(username, { timeout: 5000 });
+                await popup
+                    .locator('[type=submit]:has-text("Next")')
+                    .click({ timeout: 5000 });
+                await popup.locator("[name=passwd]").click();
+                await popup.locator("[name=passwd]").fill(password, { timeout: 5000 });
+                await popup
+                    .locator('[type=submit]:has-text("Sign in")')
+                    .click({ timeout: 5000 });
+                await popup
+                    .locator('[type=button]:has-text("No")')
+                    .click({ timeout: 15000 });
+                return "Login successful";
+            }
+            catch (e) {
+                const usernameError = popup.locator("id=usernameError");
+                if (await usernameError.isVisible()) {
+                    return "User does not exist";
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    }
+}
+export async function setupBrowser(browser, testInfo) {
+    const context = await browser.newContext({
+        recordVideo: {
+            dir: `test-results/${path
+                .parse(testInfo.file)
+                .name.replace(".spec", "")}/${testInfo.titlePath[1]}`,
+            size: { width: 1920, height: 1080 },
+        },
+    });
+    const page = await context.newPage();
+    return { page, context };
+}

package/dist/playwright/helpers/index.d.ts

@@ -0,0 +1,5 @@
+export { GITHUB_API_ENDPOINTS } from "./api-endpoints.js";
+export { APIHelper } from "./api-helper.js";
+export { LoginHelper, setupBrowser } from "./common.js";
+export { UIhelper } from "./ui-helper.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/playwright/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/playwright/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/playwright/helpers/index.js

@@ -0,0 +1,4 @@
+export { GITHUB_API_ENDPOINTS } from "./api-endpoints.js";
+export { APIHelper } from "./api-helper.js";
+export { LoginHelper, setupBrowser } from "./common.js";
+export { UIhelper } from "./ui-helper.js";