codeceptjs 3.4.1 → 3.5.1

package/lib/command/dryRun.js

@@ -7,6 +7,7 @@ const store = require('../store');
 const Container = require('../container');
 
 module.exports = async function (test, options) {
+  if (options.grep) process.env.grep = options.grep.toLowerCase();
   const configFile = options.config;
   let codecept;
 
@@ -57,9 +58,16 @@ function printTests(files) {
 
   let numOfTests = 0;
   let numOfSuites = 0;
+  const filteredSuites = [];
 
   for (const suite of mocha.suite.suites) {
-    output.print(`${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')}`);
+    if (process.env.grep && suite.title.toLowerCase().includes(process.env.grep)) {
+      filteredSuites.push(suite);
+    }
+  }
+  const displayedSuites = process.env.grep ? filteredSuites : mocha.suite.suites;
+  for (const suite of displayedSuites) {
+    output.print(`${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${suite.tests.length} tests`);
     numOfSuites++;
 
     for (const test of suite.tests) {

package/lib/command/generate.js

@@ -24,6 +24,7 @@ Scenario('test something', async ({ {{actor}} }) => {
 // generates empty test
 module.exports.test = function (genPath) {
   const testsPath = getTestRoot(genPath);
+  global.codecept_dir = testsPath;
   const config = getConfig(testsPath);
   if (!config) return;
 
@@ -83,6 +84,29 @@ module.exports = {
 }
 `;
 
+const poModuleTemplateTS = `const { I } = inject();
+
+export = {
+
+  // insert your locators and methods here
+}
+`;
+
+const poClassTemplate = `const { I } = inject();
+
+class {{name}} {
+  constructor() {
+    //insert your locators
+    // this.button = '#button'
+  }
+  // insert your methods here
+}
+
+// For inheritance
+module.exports = new {{name}}();
+export = {{name}};
+`;
+
 module.exports.pageObject = function (genPath, opts) {
   const testsPath = getTestRoot(genPath);
   const config = getConfig(testsPath);
@@ -110,7 +134,15 @@ module.exports.pageObject = function (genPath, opts) {
       name: 'filename',
       message: 'Where should it be stored',
       default: answers => `./${kind}s/${answers.name}.${extension}`,
-    }]).then((result) => {
+    },
+    {
+      type: 'list',
+      name: 'objectType',
+      message: 'What is your preferred object type',
+      choices: ['module', 'class'],
+      default: 'module',
+    },
+  ]).then((result) => {
     const pageObjectFile = path.join(testsPath, result.filename);
     const dir = path.dirname(pageObjectFile);
     if (!fileExists(dir)) fs.mkdirSync(dir);
@@ -124,13 +156,24 @@ module.exports.pageObject = function (genPath, opts) {
       }
       actor = `require('${actorPath}')`;
     }
-    if (!safeFileWrite(pageObjectFile, pageObjectTemplate.replace('{{actor}}', actor))) return;
+
     const name = lcfirst(result.name) + ucfirst(kind);
+    if (result.objectType === 'module' && extension === 'ts') {
+      if (!safeFileWrite(pageObjectFile, poModuleTemplateTS.replace('{{actor}}', actor))) return;
+    } else if (result.objectType === 'module' && extension === 'js') {
+      if (!safeFileWrite(pageObjectFile, pageObjectTemplate.replace('{{actor}}', actor))) return;
+    } else if (result.objectType === 'class') {
+      const content = poClassTemplate.replace(/{{actor}}/g, actor).replace(/{{name}}/g, name);
+      if (!safeFileWrite(pageObjectFile, content)) return;
+    }
+
     let data = readConfig(configFile);
     config.include[name] = result.filename;
+
+    if (!data) throw Error('Config file is empty');
     const currentInclude = `${data.match(/include:[\s\S][^\}]*/i)[0]}\n ${name}:${JSON.stringify(config.include[name])}`;
 
-    data = data.replace(/include:[\s\S][^\}]*/i, `${currentInclude}`);
+    data = data.replace(/include:[\s\S][^\}]*/i, `${currentInclude},`);
 
     fs.writeFileSync(configFile, beautify(data), 'utf-8');
 

package/lib/command/init.js

@@ -55,6 +55,18 @@ module.exports = function() {
 }
 `;
 
+const defaultActorTs = `// in this file you can append custom step methods to 'I' object
+
+export = function() {
+  return actor({
+
+    // Define custom steps here, use 'this' to access default methods of I.
+    // It is recommended to place a general 'login' function here.
+
+  });
+}
+`;
+
 module.exports = function (initPath) {
   const testsPath = getTestRoot(initPath);
 
@@ -188,7 +200,7 @@ module.exports = function (initPath) {
       // create steps file by default
       // no extra step file for typescript (as it doesn't match TS conventions)
       const stepFile = `./steps_file.${extension}`;
-      fs.writeFileSync(path.join(testsPath, stepFile), defaultActor);
+      fs.writeFileSync(path.join(testsPath, stepFile), extension === 'ts' ? defaultActorTs : defaultActor);
       config.include.I = isTypeScript === true ? './steps_file' : stepFile;
       print(`Steps file created at ${stepFile}`);
 
@@ -305,6 +317,16 @@ module.exports = function (initPath) {
 
     print('Configure helpers...');
     inquirer.prompt(helperConfigs).then((helperResult) => {
+      if (helperResult.Playwright_browser === 'electron') {
+        delete helperResult.Playwright_url;
+        delete helperResult.Playwright_show;
+
+        helperResult.Playwright_electron = {
+          executablePath: '// require("electron") or require("electron-forge")',
+          args: ['path/to/your/main.js'],
+        };
+      }
+
       Object.keys(helperResult).forEach((key) => {
         const parts = key.split('_');
         const helperName = parts[0];

package/lib/command/interactive.js

@@ -1,8 +1,10 @@
 const { getConfig, getTestRoot } = require('./utils');
 const recorder = require('../recorder');
 const Codecept = require('../codecept');
+const Container = require('../container');
 const event = require('../event');
 const output = require('../output');
+const webHelpers = require('../plugin/standardActingHelpers');
 
 module.exports = async function (path, options) {
   // Backward compatibility for --profile
@@ -29,9 +31,21 @@ module.exports = async function (path, options) {
     });
     event.emit(event.test.before, {
       title: '',
+      artifacts: {},
     });
+
+    const enabledHelpers = Container.helpers();
+    for (const helperName of Object.keys(enabledHelpers)) {
+      if (webHelpers.includes(helperName)) {
+        const I = enabledHelpers[helperName];
+        recorder.add(() => I.amOnPage('/'));
+        recorder.catchWithoutStop(e => output.print(`Error while loading home page: ${e.message}}`));
+        break;
+      }
+    }
     require('../pause')();
-    recorder.add(() => event.emit(event.test.after));
+    // recorder.catchWithoutStop((err) => console.log(err.stack));
+    recorder.add(() => event.emit(event.test.after, {}));
     recorder.add(() => event.emit(event.suite.after, {}));
     recorder.add(() => event.emit(event.all.result, {}));
     recorder.add(() => codecept.teardown());

package/lib/command/run-workers.js

@@ -4,7 +4,7 @@ const output = require('../output');
 const event = require('../event');
 const Workers = require('../workers');
 
-module.exports = async function (workerCount, options) {
+module.exports = async function (workerCount, selectedRuns, options) {
   process.env.profile = options.profile;
 
   const { config: testConfig, override = '' } = options;
@@ -15,6 +15,7 @@ module.exports = async function (workerCount, options) {
     by,
     testConfig,
     options,
+    selectedRuns,
   };
 
   const numberOfWorkers = parseInt(workerCount, 10);

package/lib/container.js

@@ -165,7 +165,17 @@ function createHelpers(config) {
       } else {
         moduleName = `./helper/${helperName}`; // built-in helper
       }
-      const HelperClass = require(moduleName);
+
+      // @ts-ignore
+      let HelperClass;
+      // check if the helper is the built-in, use the require() syntax.
+      if (moduleName.startsWith('./helper/')) {
+        HelperClass = require(moduleName);
+      } else {
+        // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
+        HelperClass = require(moduleName).default || require(moduleName);
+      }
+
       if (HelperClass._checkRequirements) {
         const requirements = HelperClass._checkRequirements();
         if (requirements) {
@@ -351,8 +361,8 @@ function loadSupportObject(modulePath, supportObjectName) {
       }
     }
     if (typeof obj !== 'function'
-        && Object.getPrototypeOf(obj) !== Object.prototype
-        && !Array.isArray(obj)
+      && Object.getPrototypeOf(obj) !== Object.prototype
+      && !Array.isArray(obj)
     ) {
       const methods = getObjectMethods(obj);
       Object.keys(methods)

package/lib/event.js

@@ -91,6 +91,8 @@ module.exports = {
   bddStep: {
     before: 'bddStep.before',
     after: 'bddStep.after',
+    started: 'bddStep.started',
+    finished: 'bddStep.finished',
   },
   /**
    * @type {object}

package/lib/helper/Appium.js

@@ -17,6 +17,10 @@ const supportedPlatform = {
   iOS: 'iOS',
 };
 
+const vendorPrefix = {
+  appium: 'appium',
+};
+
 /**
  *  Appium helper extends [Webriver](http://codecept.io/helpers/WebDriver/) helper.
  *  It supports all browser methods and also includes special methods for mobile apps testing.
@@ -39,6 +43,7 @@ const supportedPlatform = {
  *
  * This helper should be configured in codecept.conf.ts or codecept.conf.js
  *
+ * * `appiumV2`: set this to true if you want to run tests with Appiumv2. See more how to setup [here](https://codecept.io/mobile/#setting-up)
  * * `app`: Application path. Local path or remote URL to an .ipa or .apk file, or a .zip containing one of these. Alias to desiredCapabilities.appPackage
  * * `host`: (default: 'localhost') Appium host
  * * `port`: (default: '4723') Appium port
@@ -116,7 +121,7 @@ const supportedPlatform = {
  *
  * ## Access From Helpers
  *
- * Receive a Appium client from a custom helper by accessing `browser` property:
+ * Receive Appium client from a custom helper by accessing `browser` property:
  *
  * ```js
  * let browser = this.helpers['Appium'].browser
@@ -135,6 +140,9 @@ class Appium extends Webdriver {
     super(config);
 
     this.isRunning = false;
+    if (config.appiumV2 === true) {
+      this.appiumV2 = true;
+    }
     this.axios = axios.create();
 
     webdriverio = require('webdriverio');
@@ -181,14 +189,22 @@ class Appium extends Webdriver {
 
     config.baseUrl = config.url || config.baseUrl;
     if (config.desiredCapabilities && Object.keys(config.desiredCapabilities).length) {
-      config.capabilities = config.desiredCapabilities;
+      config.capabilities = this.appiumV2 === true ? this._convertAppiumV2Caps(config.desiredCapabilities) : config.desiredCapabilities;
+    }
+
+    if (this.appiumV2) {
+      config.capabilities[`${vendorPrefix.appium}:deviceName`] = config[`${vendorPrefix.appium}:device`] || config.capabilities[`${vendorPrefix.appium}:deviceName`];
+      config.capabilities[`${vendorPrefix.appium}:browserName`] = config[`${vendorPrefix.appium}:browser`] || config.capabilities[`${vendorPrefix.appium}:browserName`];
+      config.capabilities[`${vendorPrefix.appium}:app`] = config[`${vendorPrefix.appium}:app`] || config.capabilities[`${vendorPrefix.appium}:app`];
+      config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`] = config[`${vendorPrefix.appium}:tunnelIdentifier`] || config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`]; // Adding the code to connect to sauce labs via sauce tunnel
+    } else {
+      config.capabilities.deviceName = config.device || config.capabilities.deviceName;
+      config.capabilities.browserName = config.browser || config.capabilities.browserName;
+      config.capabilities.app = config.app || config.capabilities.app;
+      config.capabilities.tunnelIdentifier = config.tunnelIdentifier || config.capabilities.tunnelIdentifier; // Adding the code to connect to sauce labs via sauce tunnel
     }
 
-    config.capabilities.deviceName = config.device || config.capabilities.deviceName;
-    config.capabilities.browserName = config.browser || config.capabilities.browserName;
-    config.capabilities.app = config.app || config.capabilities.app;
     config.capabilities.platformName = config.platform || config.capabilities.platformName;
-    config.capabilities.tunnelIdentifier = config.tunnelIdentifier || config.capabilities.tunnelIdentifier; // Adding the code to connect to sauce labs via sauce tunnel
     config.waitForTimeoutInSeconds = config.waitForTimeout / 1000; // convert to seconds
 
     // [CodeceptJS compatible] transform host to hostname
@@ -203,6 +219,10 @@ class Appium extends Webdriver {
     }
 
     this.platform = null;
+    if (config.capabilities[`${vendorPrefix.appium}:platformName`]) {
+      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase();
+    }
+
     if (config.capabilities.platformName) {
       this.platform = config.capabilities.platformName.toLowerCase();
     }
@@ -210,6 +230,18 @@ class Appium extends Webdriver {
     return config;
   }
 
+  _convertAppiumV2Caps(capabilities) {
+    const _convertedCaps = {};
+    for (const [key, value] of Object.entries(capabilities)) {
+      if (!key.startsWith(vendorPrefix.appium)) {
+        _convertedCaps[`${vendorPrefix.appium}:${key}`] = value;
+      } else {
+        _convertedCaps[`${key}`] = value;
+      }
+    }
+    return _convertedCaps;
+  }
+
   static _config() {
     return [{
       name: 'app',
@@ -229,6 +261,11 @@ class Appium extends Webdriver {
   }
 
   async _startBrowser() {
+    if (this.appiumV2 === true) {
+      this.options.capabilities = this._convertAppiumV2Caps(this.options.capabilities);
+      this.options.desiredCapabilities = this._convertAppiumV2Caps(this.options.desiredCapabilities);
+    }
+
     try {
       if (this.options.multiremote) {
         this.browser = await webdriverio.multiremote(this.options.multiremote);
@@ -445,6 +482,7 @@ class Appium extends Webdriver {
    */
   async checkIfAppIsInstalled(bundleId) {
     onlyForApps.call(this, supportedPlatform.android);
+
     return this.browser.isAppInstalled(bundleId);
   }
 
@@ -481,7 +519,7 @@ class Appium extends Webdriver {
   async seeAppIsNotInstalled(bundleId) {
     onlyForApps.call(this, supportedPlatform.android);
     const res = await this.browser.isAppInstalled(bundleId);
-    return truth(`app ${bundleId}`, 'to be installed').negate(res);
+    return truth(`app ${bundleId}`, 'not to be installed').negate(res);
   }
 
   /**

package/lib/helper/JSONResponse.js

@@ -300,16 +300,16 @@ class JSONResponse extends Helper {
    *
    * I.seeResponseMatchesJsonSchema(joi => {
    *   return joi.object({
-   *     name: joi.string();
-   *     id: joi.number();
+   *     name: joi.string(),
+   *     id: joi.number()
    *   })
    * });
    *
    * // or pass a valid schema
-   * const joi = require('joi);
+   * const joi = require('joi');
    *
    * I.seeResponseMatchesJsonSchema(joi.object({
-   *   name: joi.string();
+   *   name: joi.string(),
    *   id: joi.number();
    * });
    * ```

package/lib/helper/Nightmare.js

@@ -694,7 +694,7 @@ class Nightmare extends Helper {
   async appendField(field, value) {
     const el = await findField.call(this, field);
     assertElementExists(el, field, 'Field');
-    return this.browser.enterText(el, value, false)
+    return this.browser.enterText(el, value.toString(), false)
       .wait(this.options.waitForAction);
   }
 

package/lib/helper/OpenAI.js

@@ -0,0 +1,122 @@
+const Helper = require('@codeceptjs/helper');
+const AiAssistant = require('../ai');
+const standardActingHelpers = require('../plugin/standardActingHelpers');
+const Container = require('../container');
+const { splitByChunks, minifyHtml } = require('../html');
+
+/**
+ * OpenAI Helper for CodeceptJS.
+ *
+ * This helper class provides integration with the OpenAI GPT-3.5 or 4 language model for generating responses to questions or prompts within the context of web pages. It allows you to interact with the GPT-3.5 model to obtain intelligent responses based on HTML fragments or general prompts.
+ * This helper should be enabled with any web helpers like Playwright or Puppeteer or WebDrvier to ensure the HTML context is available.
+ *
+ * ## Configuration
+ *
+ * This helper should be configured in codecept.json or codecept.conf.js
+ *
+ * * `chunkSize`: (optional, default: 80000) - The maximum number of characters to send to the OpenAI API at once. We split HTML fragments by 8000 chars to not exceed token limit. Increase this value if you use GPT-4.
+ */
+class OpenAI extends Helper {
+  constructor(config) {
+    super(config);
+    this.aiAssistant = new AiAssistant();
+
+    this.options = {
+      chunkSize: 80000,
+    };
+    this.options = { ...this.options, ...config };
+
+    const helpers = Container.helpers();
+
+    for (const helperName of standardActingHelpers) {
+      if (Object.keys(helpers).indexOf(helperName) > -1) {
+        this.helper = helpers[helperName];
+        break;
+      }
+    }
+  }
+
+  /**
+ * Asks the OpenAI GPT language model a question based on the provided prompt within the context of the current page's HTML.
+ *
+ * ```js
+ * I.askGptOnPage('what does this page do?');
+ * ```
+ *
+ * @async
+ * @param {string} prompt - The question or prompt to ask the GPT model.
+ * @returns {Promise<string>} - A Promise that resolves to the generated responses from the GPT model, joined by newlines.
+ */
+  async askGptOnPage(prompt) {
+    const html = await this.helper.grabSource();
+
+    const htmlChunks = splitByChunks(html, this.options.chunkSize);
+
+    if (htmlChunks.length > 1) this.debug(`Splitting HTML into ${htmlChunks.length} chunks`);
+
+    const responses = [];
+
+    for (const chunk of htmlChunks) {
+      const messages = [
+        { role: 'user', content: prompt },
+        { role: 'user', content: `Within this HTML: ${minifyHtml(chunk)}` },
+      ];
+
+      if (htmlChunks.length > 1) messages.push({ role: 'user', content: 'If action is not possible on this page, do not propose anything, I will send another HTML fragment' });
+
+      const response = await this.aiAssistant.createCompletion(messages);
+
+      console.log(response);
+
+      responses.push(response);
+    }
+
+    return responses.join('\n\n');
+  }
+
+  /**
+   * Asks the OpenAI GPT-3.5 language model a question based on the provided prompt within the context of a specific HTML fragment on the current page.
+   *
+   * ```js
+   * I.askGptOnPageFragment('describe features of this screen', '.screen');
+   * ```
+   *
+   * @async
+   * @param {string} prompt - The question or prompt to ask the GPT-3.5 model.
+   * @param {string} locator - The locator or selector used to identify the HTML fragment on the page.
+   * @returns {Promise<string>} - A Promise that resolves to the generated response from the GPT model.
+   */
+  async askGptOnPageFragment(prompt, locator) {
+    const html = await this.helper.grabHTMLFrom(locator);
+
+    const messages = [
+      { role: 'user', content: prompt },
+      { role: 'user', content: `Within this HTML: ${minifyHtml(html)}` },
+    ];
+
+    const response = await this.aiAssistant.createCompletion(messages);
+
+    console.log(response);
+
+    return response;
+  }
+
+  /**
+   * Send a general request to ChatGPT and return response.
+   * @param {string} prompt
+   * @returns {Promise<string>} - A Promise that resolves to the generated response from the GPT model.
+   */
+  async askGptGeneralPrompt(prompt) {
+    const messages = [
+      { role: 'user', content: prompt },
+    ];
+
+    const completion = await this.aiAssistant.createCompletion(messages);
+
+    const response = completion?.data?.choices[0]?.message?.content;
+
+    console.log(response);
+
+    return response;
+  }
+}