@actionlogementservices/wdio-test-context 1.0.0

package/src/ado-client.js

@@ -0,0 +1,96 @@
+/**
+ * Azure DevOps rest client to push test results.
+ * @module
+ * @category internal
+ */
+
+import { WebApi, getPersonalAccessTokenHandler, getBearerHandler } from 'azure-devops-node-api';
+
+import { logger } from './logger.js';
+
+/** @typedef { import('azure-devops-node-api/TestApi.d.ts').ITestApi } ITestApi */
+/** @typedef { { token: string, url: string, project: string } } ConnectionInfo */
+/** @typedef { { testAgent: ITestApi } } Apis */
+/**
+ * @typedef {Omit<import('azure-devops-node-api/interfaces/TestInterfaces.d.ts').RunCreateModel, "plan" | "configurationIds"> & import('azure-devops-node-api/interfaces/TestInterfaces.d.ts').RunUpdateModel & { results: import('azure-devops-node-api/interfaces/TestInterfaces.d.ts').TestCaseResult[]}} RunModel
+ */
+
+/** @type {(input: string)=> boolean} */
+const isNullOrEmpty = input => !input || !input.trim();
+
+/**
+ * Retrieves Azure DevOps connection information.
+ * @returns {ConnectionInfo}
+ */
+function getConnectionInfo() {
+  return {
+    token: process.env.SYSTEM_ACCESSTOKEN || process.env.TOKEN,
+    url: process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI,
+    project: process.env.SYSTEM_TEAMPROJECT
+  };
+}
+
+/**
+ * Gets all necessary REST API clients.
+ * See https://github.com/Microsoft/azure-devops-node-api and https://docs.microsoft.com/en-us/rest/api/azure/devops/
+ * @param {ConnectionInfo} connectionInfo
+ * @returns {Promise<Apis>}
+ */
+async function getApis(connectionInfo) {
+  if (isNullOrEmpty(connectionInfo.token))
+    throw new Error(
+      `Impossible de récupérer l'access token de l'agent via la variable d'environnement SYSTEM_ACCESSTOKEN.`
+    );
+  if (isNullOrEmpty(connectionInfo.url))
+    throw new Error(
+      `Impossible de récupérer l'url Azure DevOps via la variable d'environnement SYSTEM_TEAMFOUNDATIONCOLLECTIONURI.`
+    );
+  if (isNullOrEmpty(connectionInfo.project))
+    throw new Error(
+      `Impossible de récupérer le projet Azure DevOps via la variable d'environnement SYSTEM_TEAMPROJECT.`
+    );
+  const patAuthentication = !isNullOrEmpty(process.env.TOKEN);
+  const connection = new WebApi(
+    connectionInfo.url,
+    patAuthentication
+      ? getPersonalAccessTokenHandler(connectionInfo.token)
+      : getBearerHandler(connectionInfo.token)
+  );
+  const testAgent = await connection.getTestApi();
+  return { testAgent };
+}
+
+/**
+ * Creates the Azure DevOps TestRun.
+ * @param {RunModel} testRun
+ */
+async function createAdoTestRun({ name, startDate, comment, results, state, completedDate, build }) {
+  try {
+    // get REST API clients
+    const connectionInfo = getConnectionInfo();
+    const apis = await getApis(connectionInfo);
+    const testRun = await apis.testAgent.createTestRun(
+      // @ts-ignore
+      { automated: true, name, startDate, build, state: 'InProgress', comment },
+      connectionInfo.project
+    );
+    if (testRun === null) throw new Error('Vérifier les droits.');
+    await apis.testAgent.addTestResultsToTestRun(results, connectionInfo.project, testRun.id);
+    // en cas de suite Aborted il faut déjà la sauvegarder en Completed avant sinon tous les tests sont marqués à Failed
+    await apis.testAgent.updateTestRun(
+      { state: 'Completed', completedDate },
+      connectionInfo.project,
+      testRun.id
+    );
+    if (state === 'Aborted')
+      await apis.testAgent.updateTestRun(
+        { state: 'Aborted', completedDate },
+        connectionInfo.project,
+        testRun.id
+      );
+  } catch (error) {
+    logger.detailError(error);
+  }
+}
+
+export { createAdoTestRun };

package/src/index.js

@@ -0,0 +1,8 @@
+export { AdoReporter } from './wdio/ado-reporter.js';
+export { default as TestContextWorkerService } from './wdio/test-context-worker-service.js';
+
+export { default as BasePage } from './page-objects/page.js';
+
+export { default as pdfGenerator } from './pdf-generator.js';
+
+export { TestContext } from './test-context.js';

package/src/logger.js

@@ -0,0 +1,125 @@
+/**
+ * Internal logger.
+ * @module
+ * @category internal
+ */
+
+/* eslint-disable no-console */
+import chalk from 'chalk';
+
+const noop = () => {};
+/** console implementation @type {(message: string) => void} */
+const logError = message => console.error(chalk.red(message));
+/** console implementation @type {(message: string) => void} */
+const logWarn = message => console.warn(chalk.yellow(message));
+/** console implementation @type {(message: string) => void} */
+const logInfo = message => console.info(chalk.bold.green(message));
+/** console implementation @type {(message: string) => void} */
+const logDebug = message => console.debug(chalk.blueBright.italic(message));
+/** console implementation @type {(message: string) => void} */
+const log = message => console.log(message);
+
+/** @type {(message: string) => string} */
+const bold = text => chalk.bold(text);
+
+const level = {
+  none: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+
+class Logger {
+  /** @type {Map<'error' | 'warn' | 'info' | 'debug' | 'log', (message: string) => void>} */ _logMethodFactory;
+  /** @type {Number} */ _level;
+
+  /**
+   * Implements an internal Logger plugged on console.
+   * @param {import('./types').LogLevel} logLevel logging level
+   */
+  constructor(logLevel) {
+    this.setLogLevel(logLevel);
+  }
+
+  /**
+   * Sets the logging level.
+   * @param {import('./types').LogLevel} logLevel logging level
+   */
+  setLogLevel(logLevel) {
+    this._level = level[logLevel] ?? level.none;
+    this._logMethodFactory = new Map();
+    this._logMethodFactory.set('error', this._level >= level.error ? logError : noop);
+    this._logMethodFactory.set('warn', this._level >= level.warn ? logWarn : noop);
+    this._logMethodFactory.set('info', this._level >= level.info ? logInfo : noop);
+    this._logMethodFactory.set('debug', this._level >= level.debug ? logDebug : noop);
+    this._logMethodFactory.set('log', this._level >= level.debug ? log : noop);
+  }
+
+  /**
+   * Logs an **informational** message.
+   * @param {string} message the message to log
+   */
+  info(message) {
+    this._logMethodFactory.get('info')(message);
+  }
+
+  /**
+   * Logs a message.
+   * @param {string} message the message to log
+   */
+  log(message) {
+    this._logMethodFactory.get('log')(message);
+  }
+
+  /**
+   * Logs a **warning** message.
+   * @param {string} message the message to log
+   */
+  warn(message) {
+    this._logMethodFactory.get('warn')(message);
+  }
+
+  /**
+   * Logs an **error** message.
+   * @param {string} message the message to log
+   */
+  error(message) {
+    this._logMethodFactory.get('error')(message);
+  }
+
+  /**
+   * Logs a **debug** message
+   * @param {string} message the message to log
+   */
+  debug(message) {
+    this._logMethodFactory.get('debug')(message);
+  }
+
+  /**
+   * Logs an **error** message based on the specified error object.
+   * @param {Error} detailedError the error object to log
+   */
+  detailError(detailedError) {
+    if (this._level === level.none) return;
+    const { message, stack } = detailedError;
+    console.error('Error: ' + chalk.red.bold(message));
+    if (stack) console.error('Stack: ' + chalk.gray(stack));
+  }
+
+  /**
+   * Logs an **warning** message based on the specified error object.
+   * @param {string} text the text message to log
+   * @param {{ message: string, errorType: string }} meaningfulErrorInfo the meaningfull error info to log
+   */
+  warnError(text, meaningfulErrorInfo) {
+    if (this._level < level.warn) return;
+    const { message, errorType } = meaningfulErrorInfo;
+    logWarn(`${text}${bold(errorType)}: ${message}`);
+  }
+}
+
+/**
+ * The common logger instance.
+ */
+export const logger = new Logger('error');

package/src/mail-service.js

@@ -0,0 +1,81 @@
+/**
+ * **Mail service** to send and retrieve mail from various provider.
+ * Accessible through the **mailService property** of the TestContext instance.
+ * @module
+ * @category public
+ */
+
+import nodemailer from 'nodemailer';
+
+import * as provider from './page-objects/index.js';
+import { logger } from './logger.js';
+
+/** @typedef {import('./types.js').MailProvider} MailProvider */
+
+export class MailService {
+  /** disposable email provider @type {MailProvider} */ provider;
+
+  /**
+   * Implements a service that sends and retrieves emails with a given provider.
+   * @param {import('./types.js').MailProviderName} providerName disposable email provider name
+   */
+  constructor(providerName) {
+    this.provider = provider[providerName].default;
+  }
+
+  /**
+   * Provider name
+   * @type {string}
+   */
+  get name() {
+    return this.provider?.name;
+  }
+
+  /**
+   * Emails domains exposed by the provider.
+   * @type {string[]}
+   */
+  get domains() {
+    return this.provider?.domains;
+  }
+
+  /**
+   * Sends a mail.
+   * @param {string} from sender
+   * @param {string} to recipient
+   * @param {string} subject subject of the mail
+   * @param {string} html html body string of the mail
+   * @returns {Promise<void>}
+   */
+  async sendMessage(from, to, subject, html) {
+    const transporter = nodemailer.createTransport({ host: 'smtp.als.lan', secure: false, port: 25 });
+    await transporter.sendMail({ from, to, subject, html });
+  }
+
+  /**
+   * Waits for an email from the specified sender and containing the specified subject
+   * and gets its content.
+   * @param {string} email recipient email
+   * @param {string} from sender
+   * @param {string} subject subject of email
+   * @returns {Promise<string>} content of email
+   */
+  async waitForMessage(email, from, subject) {
+    logger.debug('1/3 - Opening mailbox...');
+    await this.provider.openInbox(email);
+    logger.debug('2/3 - Looking for mails...');
+    const messages = await this.provider.getMessages();
+    logger.debug(`    - ${messages.length} mails in inbox.`);
+    const correspondingIndex = messages.findIndex(
+      m =>
+        m.from.toLowerCase().includes(from.toLowerCase()) &&
+        m.subject.toLowerCase().includes(subject.toLowerCase())
+    );
+    if (correspondingIndex === -1) {
+      logger.warn('    No corresponding mail found!');
+      return;
+    }
+    logger.debug('3/3 - Mail found, extracting content...');
+    return this.provider.getMessageContent(correspondingIndex);
+  }
+}

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

@@ -0,0 +1,144 @@
+/**
+ * Page-object on top of Guerilla Mail.
+ * @module
+ * @category internal
+ */
+
+/* global browser,$,$$ */
+
+import Page from './page.js';
+import { logger } from '../logger.js';
+
+const mailFromGuerilla = 'no-reply@guerrillamail.com';
+
+/**
+ * Implements a page-object on top of Guerilla Mail.
+ */
+class GuerillamailPage extends Page {
+  /** name of the provider */ name = 'Guerilla Mail';
+
+  /** domains exposed of the provider */
+  domains = [
+    'sharklasers.com',
+    'guerrillamail.info',
+    'grr.la',
+    'guerrillamail.biz',
+    'guerrillamail.com',
+    'guerrillamail.de',
+    'guerrillamail.net',
+    'guerrillamail.org',
+    'guerrillamailblock.com',
+    'pokemail.net',
+    'spam4.me'
+  ];
+
+  css = {
+    text: {
+      inbox: '#content div.mailbox table tbody'
+    },
+    input: {
+      nom: '#inbox-id input'
+    },
+    button: {
+      nom: '#inbox-id',
+      set: 'button.save',
+      consent: 'div.fc-consent-root button[aria-label=Consent]'
+    },
+    options: {
+      domaines: '#gm-host-select option'
+    },
+    tbody: {
+      messages: '#email_list'
+    },
+    select: {
+      domaine: '#gm-host-select'
+    },
+    div: {
+      messages: '#email_list tr',
+      content: 'div.email_body',
+      popup: 'div.fc-consent-root'
+    },
+    td: {
+      from: 'td:nth-of-type(2)',
+      fromguerrilla: '#email_list tr:nth-of-type(1) td.td2',
+      subject: 'td:nth-of-type(3)'
+    }
+  };
+
+  /**
+   * WDIO logic to open the mailbox.
+   * @param {string} email disposable email
+   */
+  async openInbox(email) {
+    await this.openNewTab('inbox', `https://www.guerrillamail.com/fr/inbox`);
+    const popup = await this.verifyElementExistsDuring(this.css.div.popup, 5);
+    if (popup) {
+      await this.click(this.css.button.consent);
+      logger.debug('Guerilla Mail popup detected');
+    }
+    const [alias, domain] = email.split('@');
+    await this.click(this.css.button.nom);
+    await this.fillInput(this.css.input.nom, alias);
+    await this.click(this.css.button.set);
+    await this.selectItem(this.css.select.domaine, domain);
+  }
+
+  /**
+   * WDIO logic to retrieve domains exposed by the provider.
+   * @returns {Promise<string[]>}
+   */
+  async retrieveDomains() {
+    // le tableau contenant tous les domaines
+    const domains = await this.getOptions(this.css.options.domaines);
+    return domains;
+  }
+
+  /**
+   * WDIO logic to get emails.
+   * @return {Promise<{ from: string, subject: string}[]>}
+   */
+  async getMessages() {
+    let noMessage = true;
+    do {
+      // on attend 1s avant de revérifier
+      await browser.pause(1000);
+      // on vérifie s'il y a des messages autre que celui de guerilla
+      const from = await $(this.css.td.fromguerrilla).getText();
+      noMessage = from === mailFromGuerilla;
+    } while (noMessage);
+    const froms = [];
+    const messagesCount = await $$(this.css.div.messages).length;
+    for (let index = 0; index < messagesCount; index++) {
+      const from = await $(`tr:nth-of-type(${index + 1}) td:nth-of-type(2)`).getText();
+      const subject = await $(`tr:nth-of-type(${index + 1}) td:nth-of-type(3)`).getText();
+      froms.push({ from, subject });
+    }
+    // // étrangement, ne fonctionne pas avec les tableaux
+    // const messages = await $$(this.css.div.messages).getElements();
+    // for (const message of messages) {
+    //   const from = await message.$(this.css.td.from).getText();
+    //   const subject = await message.$(this.css.td.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 attend que la zone contenant les messages soit prête
+    await $(this.css.div.messages).parentElement().waitForStable();
+    const messages = await $$(this.css.div.messages);
+    const message = messages[index];
+    await message.click();
+    const content = await $(this.css.div.content);
+    return content.getHTML({ includeSelectorTag: false });
+  }
+}
+
+const page = new GuerillamailPage();
+
+export default page;

package/src/page-objects/index.js

@@ -0,0 +1,3 @@
+export * as guerrillamail from './guerrillamail.page.js';
+export * as yopmail from './yopmail.page.js';
+export * as maildrop from './maildrop.page.js';

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

@@ -0,0 +1,97 @@
+/**
+ * Page-object on top of maildrop.
+ * @module
+ * @category internal
+ */
+
+/* global browser,$,$$ */
+
+import Page from './page.js';
+
+/**
+ * Implements a page-object on top of maildrop.
+ */
+class MaildropPage extends Page {
+  /** name of the provider */ name = 'maildrop';
+
+  /** domains exposed of the provider */ domains = ['maildrop.cc'];
+
+  css = {
+    text: {
+      inbox: '#content div.mailbox table tbody'
+    },
+    div: {
+      messageZone: 'main div.subhead',
+      messages: 'main div.message',
+      from: 'div:nth-of-type(1)',
+      subject: 'div:nth-of-type(3)',
+      content: 'html body'
+    },
+    input: {
+      name: 'main + section form input[placeholder=view-this-mailbox]'
+    },
+    button: {
+      view: 'main + section form button',
+      refresh: 'main button'
+    },
+    iframe: {
+      messages: 'iframe[srcdoc]'
+    }
+  };
+
+  /**
+   * WDIO logic to open the mailbox.
+   * @param {string} email disposable email
+   */
+  async openInbox(email) {
+    await this.openNewTab('inbox', `https://maildrop.cc`);
+    const alias = email.split('@')[0];
+    // on clique dans le champ sinon le site change son contenu quand on clique sur le bouton View
+    await this.click(this.css.input.name);
+    await browser.pause(400);
+    await this.fillInput(this.css.input.name, alias);
+    await browser.pause(300);
+    await this.click(this.css.button.view);
+    await $(this.css.button.refresh).waitForExist();
+  }
+
+  /**
+   * WDIO logic to get emails.
+   * @return {Promise<{ from: string, subject: string}[]>}
+   */
+  async getMessages() {
+    let noMessage = true;
+    do {
+      // on attend 1,5s avant de cliquer sur refresh
+      await this.click(this.css.button.refresh);
+      // on attend que la zone contenant les messages soit prête
+      await $(this.css.div.messageZone).waitForDisplayed();
+      // on vérifie s'il y a des messages
+      noMessage = !(await this.verifyElementExists(this.css.div.messages));
+      if (noMessage) await browser.pause(1500);
+    } while (noMessage);
+    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) {
+    await this.click(`${this.css.div.messages}:nth-of-type(${index + 1})`);
+    await this.switchToFrame(this.css.iframe.messages);
+    return this.getHtml(this.css.div.content);
+  }
+}
+
+const page = new MaildropPage();
+
+export default page;