codeceptjs 3.6.0-beta.1.ai-healers → 3.6.1

package/docs/best.md

@@ -1,237 +0,0 @@
----
-permalink: /best
-title: Best Practices
----
-
-# Best Practices
-
-## Focus on Readability
-
-In CodeceptJS we encourage users to follow semantic elements on page while writing tests.
-Instead of CSS/XPath locators try to stick to visible keywords on page.
-
-Take a look into the next example:
-
-```js
-// it's fine but...
-I.click({css: 'nav.user .user-login'});
-// can be better
-I.click('Login', 'nav.user');
-```
-
-If we replace raw CSS selector with a button title we can improve readability of such test.
-Even if the text on the button changes, it's much easier to update it.
-
-> If your code goes beyond using `I` object or page objects, you are probably doing something wrong.
-
-When it's hard to match text to element we recommend using [locator builder](/locators#locator-builder). It allows to build complex locators via fluent API.
-So if you want to click an element which is not a button or a link and use its text you can use `locate()` to build a readable locator:
-
-```js
-// clicks element <span class="button">Click me</span>
-I.click(locate('.button').withText('Click me'));
-```
-
-## Short Cuts
-
-To write simpler and effective tests we encourage to use short cuts.
-Make test be focused on one feature and try to simplify everything that is not related directly to test.
-
-* If data is required for a test, try to create that data via API. See how to do it in [Data Management](/data) chapter.
-* If user login is required, use [autoLogin plugin](/plugins#autoLogin) instead of putting login steps inside a test.
-* Break a long test into few. Long test can be fragile and complicated to follow and update.
-* Use [custom steps and page objects](/pageobjects) to hide steps which are not relevant to current test.
-
-Make test as simple as:
-
-```js
-Scenario('editing a metric', async ({ I, loginAs, metricPage }) => {
-  // login via autoLogin
-  loginAs('admin');
-  // create data with ApiDataFactory
-  const metric = await I.have('metric', { type: 'memory', duration: 'day' })
-  // use page object to open a page
-  metricPage.open(metric.id);
-  I.click('Edit');
-  I.see('Editing Metric');
-  // using a custom step
-  I.selectFromDropdown('duration', 'week');
-  I.click('Save');
-  I.see('Duration: Week', '.summary');
-});
-```
-## Locators
-
-* If you don't use multi-lingual website or you don't update texts often it is OK to click on links by their texts or match fields by their placeholders.
-* If you don't want to rely on guessing locators, specify them manually with `{ css: 'button' }` or `{ xpath: '//button' }`.  We call them strict locators. Those locators will be faster but less readable.
-* Even better if you have a convention on active elements with special attributes like `data-test` or `data-qa`. Use `customLocator` plugin to easily add them to tests.
-* Keep tests readable which will make them maintainable.
-
-## Page Objects
-
-When a project is growing and more and more tests are required, it's time to think about reusing test code across the tests. Some common actions should be moved from tests to other files so to be accessible from different tests.
-
-Here is a recommended strategy what to store where:
-
-* Move site-wide actions into an **Actor** file (`custom_steps.js` file). Such actions like `login`, using site-wide common controls, like drop-downs, rich text editors, calendars.
-* Move page-based actions and selectors into **Page Object**. All activities made on that page can go into methods of page object. If you test Single Page Application a PageObject should represent a screen of your application.
-* When site-wide widgets are used, interactions with them should be placed in **Page Fragments**. This should be applied to global navigation, modals, widgets.
-* A custom action that requires some low-level driver access, should be placed into a **Helper**. For instance, database connections, complex mouse actions, email testing, filesystem, services access.
-
-> [Learn more](/pageobjects) about different refactoring options
-
-However, it's recommended to not overengineer and keep tests simple. If a test code doesn't require reusage at this point it should not be transformed to use page objects.
-
-
-* use page objects to store common actions
-* don't make page objects for every page! Only for pages shared across different tests and suites.
-* use classes for page objects, this allows inheritace. Export instance of that classes.
-* if a page object is focused around a form with multiple fields in it, use a flexible set of arguments in it:
-
-```js
-class CheckoutForm {
-
-  fillBillingInformation(data = {}) {
-    // take data in a flexible format
-    // iterate over fields to fill them all
-    for (let key of Object.keys(data)) {
-      I.fillField(key, data[key]); // like this one
-    }
-  }
-
-}
-module.exports = new CheckoutForm();
-module.exports.CheckoutForm = CheckoutForm; // for inheritance
-```
-
-* for components that are repeated accross a website (widgets) but don't belong to any page, use component objects. They are the same as page objects but focused only aroung one element:
-
-```js
-class DropDownComponent {
-
-  selectFirstItem(locator) {
-    I.click(locator);
-    I.click('#dropdown-items li');
-  }
-
-  selectItemByName(locator, name) {
-    I.click(locator);
-    I.click(locate('li').withText(name), '#dropdown-items');
-  }
-}
-```
-* another good example is datepicker component:
-```js
-const { I } = inject();
-
-/**
- * Calendar works
- */
-class DatePicker {
-
-  selectToday(locator) {
-    I.click(locator);
-    I.click('.currentDate', '.date-picker');
-  }
-
-  selectInNextMonth(locator, date = '15') {
-    I.click(locator);
-    I.click('show next month', '.date-picker')
-    I.click(date, '.date-picker')
-  }
-
-}
-
-
-module.exports = new DatePicker();
-module.exports.DatePicker = DatePicker; // for inheritance
-```
-
-## Configuration
-
-* create multiple config files for different setups/enrionments:
-  * `codecept.conf.js` - default one
-  * `codecept.ci.conf.js` - for CI
-  * `codecept.windows.conf.js` - for Windows, etc
-* use `.env` files and dotenv package to load sensitive data
-
-```js
-require('dotenv').config({ path: '.env' });
-```
-
-* move similar parts in those configs by moving them to modules and putting them to `config` dir
-* when you need to load lots of page objects/components, you can get components/pageobjects file declaring them:
-
-```js
-// inside config/components.js
-module.exports = {
-    DatePicker: "./components/datePicker",
-    Dropdown: "./components/dropdown",
-}
-```
-
-include them like this:
-
-```js
-  include: {
-      I: './steps_file',
-      ...require('./config/pages'), // require POs and DOs for module
-      ...require('./config/components'), // require all components
-  },
-```
-
-* move long helpers configuration into `config/plugins.js` and export them
-* move long configuration into `config/plugins.js` and export them
-* inside config files import the exact helpers or plugins needed for this setup & environment
-* to pass in data from config to a test use a container:
-
-```js
-// inside codecept conf file
-bootstrap: () => {
-  codeceptjs.container.append({
-    testUser: {
-      email: 'test@test.com',
-      password: '123456'
-    }
-  });
-}
-// now `testUser` can be injected into a test
-```
-* (alternatively) if you have more test data to pass into tests, create a separate file for them and import them similarly to page object:
-
-```js
-include: {
-  // ...
-  testData: './config/testData'
-
-}
-```
-* .env / different configs / different test data allows you to get configs for multiple environments
-
-## Data Access Objects
-
-* Concept is similar to page objects but Data access objects can act like factories or data providers for tests
-* Data Objects require REST or GraphQL helpers to be enabled for data interaction
-* When you need to customize access to API and go beyond what ApiDataFactory provides, implement DAO:
-
-```js
-const { faker } = require('@faker-js/faker');
-const { I } = inject();
-const { output } = require('codeceptjs');
-
-class InterfaceData {
-
-  async getLanguages() {
-      const { data } = await I.sendGetRequest('/api/languages');
-      const { records } = data;
-      output.debug(`Languages ${records.map(r => r.language)}`);
-      return records;
-  }
-
-  async getUsername() {
-    return faker.user.name();
-  }
-}
-
-module.exports = new InterfaceData;
-```

package/docs/books.md

@@ -1,37 +0,0 @@
----
-permalink: /books
-layout: Section
-sidebar: false
-title: Books & Posts
-editLink: false
----
-
-# Books & Posts
-> Add your own books or posts to our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Books-&-Posts)
-### [Practical End 2 End Testing with CodeceptJS](https://leanpub.com/codeceptjs/)
-
-A book by **Paul Vincent Beigang**
-
-[![](https://user-images.githubusercontent.com/220264/58870454-e2e8ce80-86c8-11e9-868e-7deefdde47ce.png)](https://leanpub.com/codeceptjs/)
-
-#### Contents:
-
-1. Preparation for End 2 End Testing with CodeceptJS
-1. Setup CodeceptJS with WebdriverIO
-1. Create Your First CodeceptJS Test
-1. Run Your First CodeceptJS Test Locally
-1. Run Test on BrowserStack Against with the Safari Browser
-1. How to Debug & Fix a Failing E2E Test
-1. Run a CodeceptJS Test in GitLab´s Continuous Integration (CI) Environment
-1. Delicious Test Reports With Allure
-
-### Posts
-
-A list of good educational posts about CodeceptJS
-
-* [QA Automation From Zero-to-Hero with CodeceptJS End-to-End Testing](https://medium.com/@dan.ryan.emmons/qa-automation-from-zero-to-hero-with-codeceptjs-end-to-end-testing-719db9d6ff5c) by Dan Emmons
-* [Effective End2End Tests with CodeceptJS](https://hackernoon.com/effective-end-2-end-testing-in-javascript-with-codeceptjs-37c8d7d6a928) by @davertmik
-* [Customizing CodeceptJS Skeleton](https://medium.com/@successivetech/codeceptjs-skeleton-9ba86d3b45ec)
-* [Running End to End tests as Google Cloud Functions](https://hackernoon.com/running-end-to-end-tests-as-google-cloud-functions-f5e34ffc3984)
-* [End-To-End Testing With CodeceptJS](https://www.monterail.com/blog/end-to-end-testing-with-codeceptjs) by Piotr Michalski
-* [Getting started with CodeceptJS and Selenium WebDriver](https://medium.com/@garrettvorce/getting-started-with-selenium-and-codeceptjs-c0698e8df677)

package/docs/bootstrap.md

@@ -1,135 +0,0 @@
----
-permalink: /bootstrap
-title: Bootstrap
----
-
-# Bootstrap
-
-In case you need to execute arbitrary code before or after the tests,
-you can use the `bootstrap` and `teardown` config. Use it to start and stop a webserver, Selenium, etc.
-
-When using the [parallel execution](/parallel) mode, there are two additional hooks available; `bootstrapAll` and `teardownAll`. See [bootstrapAll & teardownAll](#bootstrapall-teardownall) for more information.
-
-
-> ⚠ In CodeceptJS 2 bootstrap could be set as a function with `done` parameter. This way of handling async function was replaced with native async functions in CodeceptJS 3.
-
-### Example: Bootstrap & Teardown
-
-If you are using JavaScript-style config `codecept.conf.js`, bootstrap and teardown functions can be placed inside of it:
-
-```js
-var server = require('./app_server');
-
-exports.config = {
-  tests: "./*_test.js",
-  helpers: {},
-
-  // adding bootstrap/teardown
-  async bootstrap() {
-    await server.launch();
-  },
-  async teardown() {
-    await server.stop();
-  }
-  // ...
-  // other config options
-}
-
-```
-
-## BootstrapAll & TeardownAll
-
-There are two additional hooks for [parallel execution](/parallel) in `run-multiple` or `run-workers` commands.
-
-These hooks are only called in the parent process. Before child processes start (`bootstrapAll`) and after all of runs have finished (`teardownAll`). Each worker process will call `bootstrap` & `teardown` in their own process.
-
-For example, when you run tests in 2 workers using the following command:
-
-```
-npx codeceptjs run-workers 2
-```
-
-First, `bootstrapAll` is called. Then two `bootstrap` runs in each of workers. Then tests in worker #1 ends and `teardown` is called. Same for worker #2. Finally, `teardownAll` runs in the main process.
-
-> The same behavior is set for `run-multiple` command
-
-The `bootstrapAll` and `teardownAll` hooks are preferred to use for setting up common logic of tested project: to start the application server or database or to start webdriver's grid.
-
-The `bootstrap` and `teardown` hooks are used for setting up each testing browser: to create unique [cloud testing server](/helpers/WebDriver#cloud-providers) connection or to create specific browser-related test data in database (like users with names with browsername in it).
-
-### Example: BootstrapAll & TeardownAll Inside Config
-
-Using JavaScript-style config `codecept.conf.js`, bootstrapAll and teardownAll functions can be placed inside of it:
-
-
-```js
-const fs = require('fs');
-const tempFolder = process.cwd() + '/tmpFolder';
-
-exports.config = {
-  tests: "./*_test.js",
-  helpers: {},
-
-  // adding bootstrapAll/teardownAll
-  async bootstrapAll() {
-    fs.mkdirSync(tempFolder);
-  },
-
-  async bootstrap() {
-    console.log('Do some pretty suite setup stuff');
-  },
-
-  async teardown() {
-    console.log('Cool, one of the workers have finished');
-  },
-
-  async teardownAll() {
-    console.log('All workers have finished running tests so we should clean up the temp folder');
-    fs.rmdirSync(tempFolder);
-  },
-
-  // ...
-  // other config options
-}
-```
-
-## Combining Bootstrap & BootstrapAll
-
-It is quite common that you expect that bootstrapAll and bootstrap will do the same thing. If an application server is already started in `bootstrapAll` we should not run it again inside `bootstrap` for each worker. To avoid code duplication we can run bootstrap script only when we are not inside a worker. And we will use NodeJS `isMainThread` Workers API to detect that:
-
-```js
-// inside codecept.conf.js
-
-// detect if we are in a worker thread
-const { isMainThread } = require('worker_threads');
-
-async function startServer() {
-  // implement starting server logic here
-}
-async function stopServer() {
-  // and stop server too
-}
-
-
-exports.config = {
-  // codeceptjs config goes here
-
-  async bootstrapAll() {
-    await startServer();
-  },
-  async bootstrap() {
-    // start a server only if we are not in worker
-    if (isMainThread) return startServer();
-  }
-
-  async teardown() {
-    // start a server only if we are not in worker
-    if (isMainThread) return stopServer();
-  }
-
-  async teardownAll() {
-    await stopServer();
-  },
-}
-
-```

package/docs/build/AI.js

@@ -1,124 +0,0 @@
-const Helper = require('@codeceptjs/helper');
-const ai = require('../ai');
-const standardActingHelpers = require('../plugin/standardActingHelpers');
-const Container = require('../container');
-const { splitByChunks, minifyHtml } = require('../html');
-
-/**
- * AI Helper for CodeceptJS.
- *
- * This helper class provides integration with the AI 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 AI API at once. We split HTML fragments by 8000 chars to not exceed token limit. Increase this value if you use GPT-4.
- */
-class AI extends Helper {
-  constructor(config) {
-    super(config);
-    this.aiAssistant = ai;
-
-    this.options = {
-      chunkSize: 80000,
-    };
-    this.options = { ...this.options, ...config };
-  }
-
-  _beforeSuite() {
-    const helpers = Container.helpers();
-
-    for (const helperName of standardActingHelpers) {
-      if (Object.keys(helpers).indexOf(helperName) > -1) {
-        this.helper = helpers[helperName];
-        break;
-      }
-    }
-  }
-
-  /**
-   * Asks the AI 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 AI 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 response = await this.aiAssistant.createCompletion(messages);
-
-    console.log(response);
-
-    return response;
-  }
-}
-
-module.exports = AI;