@actionlogementservices/wdio-test-context 1.0.0

package/src/page-objects/page.js

@@ -0,0 +1,463 @@
+/**
+ * Base page object for WDIO page objects.
+ * @module
+ * @category public
+ */
+
+/* global browser,$,$$ */
+
+import { logger } from '../logger.js';
+
+export const TIMEOUT = process.env.DEBUG ? 60 * 60 * 1000 : 20_000;
+export const EXTRA_LARGE_TIMEOUT = 120_000;
+
+const tabs = new Map();
+
+export default class Page {
+  /**
+   * **Sets the browser url** for the specified **tab name**.
+   * @param {string} tabName tab name
+   * @param {string} url url to navigate to
+   * @param {boolean} [maximize] maximize window
+   * @returns {Promise<void>}
+   */
+  async setUrl(tabName, url, maximize = true) {
+    await browser.url(url);
+    if (maximize) await browser.maximizeWindow();
+    const handle = await browser.getWindowHandle();
+    tabs.set(tabName, handle);
+  }
+
+  /**
+   * **Opens** the specified **tab name** with the specified **url**.
+   * @param {string} tabName nom de l'onglet du navigateur
+   * @param {string} url url à atteindre
+   * @returns {Promise<void>}
+   */
+  async openNewTab(tabName, url) {
+    if (tabs.has(tabName)) {
+      const handle = tabs.get(tabName);
+      await browser.switchToWindow(handle);
+      await browser.url(url);
+      return;
+    }
+    await browser.newWindow(url);
+    await browser.maximizeWindow();
+    const handle = await browser.getWindowHandle();
+    tabs.set(tabName, handle);
+  }
+
+  /**
+   * **Switches to** the specified **tab name**.
+   * @param {string} tabName nom de l'onglet du navigateur
+   * @returns {Promise<void>}
+   */
+  async switchToTab(tabName) {
+    const handle = tabs.get(tabName);
+    await browser.switchToWindow(handle);
+  }
+
+  /**
+   * **Switches to** the **last opened tab**.
+   * @returns {Promise<void>}
+   */
+  async switchToLastOpenedTab() {
+    const handles = await browser.getWindowHandles();
+    return browser.switchToWindow(handles.at(-1));
+  }
+
+  /**
+   * Dumps tabs information.
+   */
+  async debugTabs() {
+    for (const tab of tabs) {
+      const [name, handle] = tab;
+      if (handle) {
+        await browser.switchToWindow(handle);
+        const url = await browser.getUrl();
+        logger.debug(`Tab ${name}: ${url}`);
+      } else {
+        logger.error(`Tab ${name} not set!`);
+      }
+    }
+  }
+
+  /**
+   * Switches to the frame specified by the css selector.
+   * @param {string} [css] css selector of top level frame if not specified
+   * @returns {Promise<void | string>}
+   */
+  async switchToFrame(css) {
+    if (!css) {
+      // eslint-disable-next-line unicorn/no-null
+      return browser.switchFrame(null);
+    }
+    try {
+      return browser.switchFrame($(css));
+    } catch (error) {
+      logger.detailError(error);
+    }
+  }
+
+  /**
+   * **Retrieves the text** corresponding to the specified css selector.
+   * Waits during the specified (or default) timeout **before throwing error**.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<string>} the corresponding text
+   */
+  async getText(css, timeout = TIMEOUT) {
+    await browser.waitUntil($(css).isDisplayed, { timeout });
+    return $(css).getText();
+  }
+
+  /**
+   * **Retrieves the value** corresponding to the specified css selector.
+   * Waits during the specified (or default) timeout **before throwing error**.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<string>} the corresponding value
+   */
+  async getValue(css, timeout = TIMEOUT) {
+    await browser.waitUntil($(css).isDisplayed, { timeout });
+    return $(css).getValue();
+  }
+
+  /**
+   * **Retrieves the inner html** corresponding to the specified css selector.
+   * Waits during the specified (or default) timeout **before throwing error**.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<string>} the corresponding inner html
+   */
+  async getHtml(css, timeout = TIMEOUT) {
+    await browser.waitUntil($(css).isDisplayed, { timeout });
+    return $(css).getHTML({ includeSelectorTag: false });
+  }
+
+  /**
+   * **Retrieves the list of values** of the specified **select** css selector.
+   * Waits during the specified (or default) timeout **before throwing error**.
+   * @param {string} css  css selector of the select
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<string[]>} the corresponding values
+   */
+  async getOptions(css, timeout = TIMEOUT) {
+    await this.waitElementHasChildren(css, timeout);
+    const options = await $$(`${css} option`).getElements();
+    // le tableau des options
+    const items = [];
+    for (const o of options) {
+      const item = await o.getValue();
+      items.push(item);
+    }
+    return items;
+  }
+
+  /**
+   * **Retrieves the selected text** of the specified **select** css selector.
+   * Waits during the specified (or default) timeout **before throwing error**.
+   * @param {string} css  css selector of the select
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<string>} the corresponding text
+   */
+  async getSelectedText(css, timeout = TIMEOUT) {
+    await this.waitElementHasChildren(css, timeout);
+    return $(`${css} option:checked`).getText();
+  }
+
+  /**
+   * **Retrieves the selected value** of the specified **select** css selector.
+   * Waits during the specified (or default) timeout **before throwing error**.
+   * @param {string} css css selector of the select
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<string>} the corresponding text
+   */
+  async getSelectedValue(css, timeout = TIMEOUT) {
+    await this.waitElementHasChildren(css, timeout);
+    return $(`${css} option:checked`).getValue();
+  }
+
+  /**
+   * **Verifies if the element** specified by the css selector **exists**.
+   * Will only verify for the **specified amount of seconds**.
+   * **Does not throw error**.
+   * @param {string} css css selector
+   * @param {Number} periodInSecond period of time to wait (in s)
+   * @returns {Promise<boolean>} true if element exists, false otherwise
+   */
+  async verifyElementExistsDuring(css, periodInSecond) {
+    const totalTime = Math.trunc(periodInSecond);
+    let elementExists = false;
+    let elapsedTime = 0;
+    while (!elementExists || elapsedTime <= totalTime) {
+      elementExists = await $(css).isExisting();
+      if (elementExists || elapsedTime === totalTime) break;
+      await browser.pause(1000);
+      elapsedTime++;
+    }
+    return elementExists;
+  }
+
+  /**
+   * **Verifies if the element** specified by the css selector **exists**.
+   * **Does not throw error**.
+   * @param {string} css css selector
+   * @returns {Promise<boolean>} true if element exists, false otherwise
+   */
+  async verifyElementExists(css) {
+    return $(css).isExisting();
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector **exists**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {ChainablePromiseElement} the element if it exists
+   */
+  async waitElementExists(css, timeout = TIMEOUT) {
+    await $(css).waitForExist();
+    await browser.waitUntil(async () => await $(css).isExisting(), { timeout });
+    return $(css);
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector **has no more** the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @param {string} oldText text that is supposed to disapear
+   * @returns {Promise<string>} the new text if it exists
+   */
+  async waitTextChanged(css, oldText, timeout = TIMEOUT) {
+    await browser.waitUntil(
+      async () => {
+        const existingText = await $(css).getText();
+        return !existingText.includes(oldText);
+      },
+      { timeout }
+    );
+    return $(css).getText();
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector **has** the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {string} text text to wait for
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitElementHasText(css, text, timeout = TIMEOUT) {
+    return browser.waitUntil(
+      async () => {
+        const existingText = await $(css).getText();
+        return existingText.includes(text);
+      },
+      { timeout }
+    );
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector **has the specified value**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {string | number | boolean} value value to wait for
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitElementHasValue(css, value, timeout = TIMEOUT) {
+    // eslint-disable-next-line eqeqeq
+    return await browser.waitUntil(async () => (await $(css).getValue()) == value, { timeout });
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector is **removed from the DOM**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitElementRemoved(css, timeout = TIMEOUT) {
+    return browser.waitUntil(async () => !(await $(css).isExisting()), { timeout });
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector is **clickable**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitElementClickable(css, timeout = TIMEOUT) {
+    return browser.waitUntil(() => $(css).isClickable(), { timeout });
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector is **displayed**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitElementDisplayed(css, timeout = TIMEOUT) {
+    return browser.waitUntil(() => $(css).isDisplayed(), { timeout });
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector is **hidden**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitElementHidden(css, timeout = TIMEOUT) {
+    return browser.waitUntil(async () => !(await $(css).isDisplayed()), { timeout });
+  }
+
+  /**
+   * **Waits until the element** specified by the css selector **has children**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {number} [childrenCount] optional count of children to wait for (default 1)
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitElementHasChildren(css, childrenCount = 1, timeout = TIMEOUT) {
+    return browser.waitUntil(async () => (await $$(css).length) >= childrenCount, { timeout });
+  }
+
+  /**
+   * **Waits until the browser url ends with** the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} text ending text
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitUrlEndsWith(text, timeout = TIMEOUT) {
+    return browser.waitUntil(
+      async () => {
+        const existingUrl = await browser.getUrl();
+        return existingUrl.endsWith(text);
+      },
+      { timeout }
+    );
+  }
+
+  /**
+   * **Waits until the browser url contains** the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} text ending text
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitUrlContains(text, timeout = TIMEOUT) {
+    return browser.waitUntil(
+      async () => {
+        const existingUrl = await browser.getUrl();
+        return existingUrl.includes(text);
+      },
+      { timeout }
+    );
+  }
+
+  /**
+   * **Waits until the browser url is not more** the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} text ending text
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<boolean>} true if condition is fullfilled
+   */
+  async waitUrlIsNoMore(text, timeout = TIMEOUT) {
+    return browser.waitUntil(async () => (await browser.getUrl()) !== text, { timeout });
+  }
+
+  /**
+   * **Clicks the element** specified by the css selector.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector
+   * @param {string} [cssParent] optional css selector of the parent
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<void>}
+   */
+  async click(css, cssParent, timeout = TIMEOUT) {
+    const element = cssParent ? $(cssParent).$(css) : $(css);
+    await browser.waitUntil(() => element.isClickable(), { timeout });
+    return element.click();
+  }
+
+  /**
+   * **Checks the checkbox or radio button** specified by the css selector.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector of checkbox or radio button
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<void>}
+   */
+  async check(css, timeout = TIMEOUT) {
+    const element = $(css);
+    await browser.waitUntil(() => element.isClickable(), { timeout });
+    return element.click();
+  }
+
+  /**
+   * **Checks the checkbox or radio button** specified by the label text and css selector.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} text label text
+   * @param {string} css css selector of the label
+   * @param {string} [cssParent] optional css selector for the parent
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<void>}
+   */
+  async checkByText(text, css, cssParent, timeout = TIMEOUT) {
+    return this.click(`${css}=${text}`, cssParent, timeout);
+  }
+
+  /**
+   * **Fills the input** specified by the css selector with the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector of the input
+   * @param {string | number} text text to fill in
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<void>}
+   */
+  async fillInput(css, text, timeout = TIMEOUT) {
+    await browser.waitUntil(() => $(css).isEnabled(), { timeout });
+    await $(css).setValue(text);
+    return browser.keys('Tab');
+  }
+
+  /**
+   * **Selects the option** specified by the **select** css selector with the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {string} css css selector of the select
+   * @param {string} text text of the option
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<void>}
+   */
+  async selectItem(css, text, timeout = TIMEOUT) {
+    await browser.waitUntil(
+      async () => {
+        const nbOptions = await $$(`${css} option`).length;
+        return nbOptions > 1;
+      },
+      { timeout }
+    );
+    await this.click(css);
+    await $(css).selectByVisibleText(text);
+  }
+
+  /**
+   * **Selects the option** specified by the wdio element with the specified **text**.
+   * **Throws an error** after the specified (or default) timeout has expired.
+   * @param {WebdriverIO.Element} element select element
+   * @param {string} text text of the option
+   * @param {number} [timeout] optional timeout before throwing error
+   * @returns {Promise<void>}
+   */
+  async selectObjectItem(element, text, timeout = TIMEOUT) {
+    await browser.waitUntil(() => element.isClickable(), { timeout });
+    await element.click();
+    return element.selectByVisibleText(text);
+  }
+}

package/src/page-objects/yopmail.page.js

@@ -0,0 +1,102 @@
+/**
+ * Page-object on top of YOPmail.
+ * @module
+ * @category internal
+ */
+/* global browser,$,$$ */
+
+import Page from './page.js';
+import { logger } from '../logger.js';
+
+/**
+ * Implements a page-object on top of YOPmail.
+ */
+class YopmailPage extends Page {
+  /** name of the provider */ name = 'YOPmail!';
+
+  /** domains exposed of the provider */ domains = ['yopmail.com'];
+
+  css = {
+    text: {
+      inbox: '#content div.mailbox table tbody'
+    },
+    button: {
+      refresh: '#refresh',
+      accepterpopup: 'button[aria-label=Autoriser]'
+    },
+    div: {
+      messages: 'div.m',
+      from: 'div.lmfd span.lmf',
+      subject: 'div.lms',
+      content: '#mail',
+      popup: 'div.fc-consent-root'
+    },
+    iframe: {
+      inbox: 'iframe[name=ifinbox]',
+      message: 'iframe[name=ifmail]'
+    }
+  };
+
+  /**
+   * WDIO logic to open the mailbox.
+   * @param {string} email disposable email
+   */
+  async openInbox(email) {
+    await this.openNewTab('inbox', `https://yopmail.com?${email}`);
+    const popup = await this.verifyElementExistsDuring(this.css.div.popup, 2);
+    if (popup) {
+      await this.click(this.css.button.accepterpopup);
+      logger.debug('Yopmail popup detected');
+    }
+  }
+
+  /**
+   * WDIO logic to get emails.
+   * @return {Promise<{ from: string, subject: string}[]>}
+   */
+  async getMessages() {
+    let noMessage = true;
+    // on attent que l'iframe inbox soit présent
+    do {
+      // on attend 1,5s avant de cliquer sur refresh
+      await browser.pause(1500);
+      // on bascule sur la fenêtre principale car le bouton refresh est dedans
+      await this.switchToFrame();
+      await this.click(this.css.button.refresh);
+      await browser.pause(500);
+      // on retourne sur l'iframe inbox pour contrôler les messages
+      await this.switchToFrame(this.css.iframe.inbox);
+      // on regarde s'il y a au moins un message (= un div.m)
+      noMessage = !(await this.verifyElementExists(this.css.div.messages));
+    } while (noMessage);
+    // on récupère la liste de tous les messages
+    const messages = await $$(this.css.div.messages).getElements();
+    const froms = [];
+    for (const message of messages) {
+      const from = await message.$(this.css.div.from).getText();
+      const subject = await message.$(this.css.div.subject).getText();
+      froms.push({ from, subject });
+    }
+    return froms;
+  }
+
+  /**
+   * WDIO logic to get the specified message content.
+   * @param {number} index
+   * @returns {Promise<string>}
+   */
+  async getMessageContent(index) {
+    // on clique sur le message correspondant à l'index demandé
+    const messages = await $$(this.css.div.messages);
+    await messages[index].click();
+    // on bascule sur la fenêtre principale car l'iframe message est dedans
+    await this.switchToFrame();
+    // on bascule sur l'iframe message pour lire le contenu du message
+    await this.switchToFrame(this.css.iframe.message);
+    return this.getHtml(this.css.div.content);
+  }
+}
+
+const page = new YopmailPage();
+
+export default page;

package/src/pdf-generator.js

@@ -0,0 +1,61 @@
+/**
+ * **Pdf file generator**.
+ * @module
+ * @category public
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { jsPDF } from 'jspdf';
+import moment from 'moment';
+
+import { logger } from './logger.js';
+
+/**
+ * Generates a pdf file with specified name and context data.
+ * @param {string} filename file name
+ * @param {import('./test-context.js').TestContext} context test context
+ * @returns {Promise<string>} the file path
+ */
+async function generatePdf(filename, context) {
+  const folder = path.join(process.cwd(), 'data', 'files');
+  await fs.mkdir(folder, { recursive: true });
+  const filepath = path.join(folder, `${filename}.pdf`);
+  logger.debug(`Generating '${filepath}'...`);
+  const timestamp = moment().format('[Le] DD/MM/YYYY [à] HH:mm:ss');
+  const {
+    user: { firstname, lastname, gender, email }
+  } = context;
+  const lines = [
+    filename.toUpperCase(),
+    timestamp,
+    `${gender} ${firstname} ${lastname}`,
+    `Adresse e-mail : ${email}`
+  ];
+  try {
+    const pdf = new jsPDF();
+    pdf.setFontSize(12);
+    pdf.text(lines, 10, 10);
+    const fileContent = Buffer.from(pdf.output('arraybuffer'));
+    await fs.writeFile(filepath, fileContent, { encoding: 'utf8' });
+    return filepath;
+  } catch (error) {
+    logger.detailError(error);
+    throw new Error(`Unable to create pdf file '${filepath}': ${error.message}!`);
+  }
+}
+
+/**
+ * Deletes the specified file.
+ * @param {string} filepath pdf file path
+ */
+async function deletePdf(filepath) {
+  try {
+    await fs.rm(filepath);
+  } catch (error) {
+    logger.detailError(error);
+  }
+}
+
+export default { deletePdf, generatePdf };