codeceptjs 4.0.0-rc.2 → 4.0.0-rc.21

package/lib/helper/AI.js

@@ -1,214 +0,0 @@
-import HelperModule from '@codeceptjs/helper'
-import ora from 'ora-classic'
-import fs from 'fs'
-import path from 'path'
-import ai from '../ai.js'
-import Container from '../container.js'
-import { splitByChunks, minifyHtml } from '../html.js'
-import { beautify } from '../utils.js'
-import output from '../output.js'
-import { registerVariable } from '../pause.js'
-
-const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
-
-const gtpRole = {
-  user: 'user',
-}
-
-/**
- * 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 WebDriver to ensure the HTML context is available.
- *
- * Use it only in development mode. It is recommended to run it only inside pause() mode.
- *
- * ## Configuration
- *
- * This helper should be configured in codecept.conf.{js|ts}
- *
- * * `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 }
-    this.aiAssistant.enable(this.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: gtpRole.user, content: prompt },
-        { role: gtpRole.user, content: `Within this HTML: ${await 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._processAIRequest(messages)
-
-      output.print(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: gtpRole.user, content: prompt },
-      { role: gtpRole.user, content: `Within this HTML: ${await minifyHtml(html)}` },
-    ]
-
-    const response = await this._processAIRequest(messages)
-
-    output.print(response)
-
-    return response
-  }
-
-  /**
-   * Send a general request to AI 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: gtpRole.user, content: prompt }]
-
-    const response = await this._processAIRequest(messages)
-
-    output.print(response)
-
-    return response
-  }
-
-  /**
-   * Generates PageObject for current page using AI.
-   *
-   * It saves the PageObject to the output directory. You can review the page object and adjust it as needed and move to pages directory.
-   * Prompt can be customized in a global config file.
-   *
-   * ```js
-   * // create page object for whole page
-   * I.askForPageObject('home');
-   *
-   * // create page object with extra prompt
-   * I.askForPageObject('home', 'implement signIn(username, password) method');
-   *
-   * // create page object for a specific element
-   * I.askForPageObject('home', null, '.detail');
-   * ```
-   *
-   * Asks for a page object based on the provided page name, locator, and extra prompt.
-   *
-   * @async
-   * @param {string} pageName - The name of the page to retrieve the object for.
-   * @param {string|null} [extraPrompt=null] - An optional extra prompt for additional context or information.
-   * @param {string|null} [locator=null] - An optional locator to find a specific element on the page.
-   * @returns {Promise<Object>} A promise that resolves to the requested page object.
-   */
-  async askForPageObject(pageName, extraPrompt = null, locator = null) {
-    const spinner = ora(' Processing AI request...').start()
-
-    try {
-      const html = locator ? await this.helper.grabHTMLFrom(locator) : await this.helper.grabSource()
-      await this.aiAssistant.setHtmlContext(html)
-      const response = await this.aiAssistant.generatePageObject(extraPrompt, locator)
-      spinner.stop()
-
-      if (!response[0]) {
-        output.error('No response from AI')
-        return ''
-      }
-
-      const code = beautify(response[0])
-
-      output.print('----- Generated PageObject ----')
-      output.print(code)
-      output.print('-------------------------------')
-
-      const fileName = path.join(output_dir, `${pageName}Page-${Date.now()}.js`)
-
-      output.print(output.styles.bold(`Page object for ${pageName} is saved to ${output.styles.bold(fileName)}`))
-      fs.writeFileSync(fileName, code)
-
-      try {
-        registerVariable('page', require(fileName))
-        output.success('Page object registered for this session as `page` variable')
-        output.print('Use `=>page.methodName()` in shell to run methods of page object')
-        output.print('Use `click(page.locatorName)` to check locators of page object')
-      } catch (err) {
-        output.error('Error while registering page object')
-        output.error(err.message)
-      }
-
-      return code
-    } catch (e) {
-      spinner.stop()
-      throw Error(`Something went wrong! ${e.message}`)
-    }
-  }
-
-  async _processAIRequest(messages) {
-    const spinner = ora(' Processing AI request...').start()
-    const response = await this.aiAssistant.createCompletion(messages)
-    spinner.stop()
-    return response
-  }
-}
-
-export default AI

package/lib/listener/enhancedGlobalRetry.js

@@ -1,110 +0,0 @@
-import event from '../event.js'
-import output from '../output.js'
-import Config from '../config.js'
-import { isNotSet } from '../utils.js'
-
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
-
-/**
- * Priority levels for retry mechanisms (higher number = higher priority)
- * This ensures consistent behavior when multiple retry mechanisms are active
- */
-const RETRY_PRIORITIES = {
-  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
-  STEP_PLUGIN: 50, // retryFailedStep plugin
-  SCENARIO_CONFIG: 30, // Global scenario retry config
-  FEATURE_CONFIG: 20, // Global feature retry config
-  HOOK_CONFIG: 10, // Hook retry config - lowest priority
-}
-
-/**
- * Enhanced global retry mechanism that coordinates with other retry types
- */
-export default function () {
-  event.dispatcher.on(event.suite.before, suite => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // is number - apply as feature-level retry
-      const retryNum = +retryConfig
-      output.log(`[Global Retry] Feature retries: ${retryNum}`)
-
-      // Only set if not already set by higher priority mechanism
-      if (isNotSet(suite.retries())) {
-        suite.retries(retryNum)
-        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!suite.title.includes(config.grep)) continue
-      }
-
-      // Handle hook retries with priority awareness
-      hooks
-        .filter(hook => !!config[hook])
-        .forEach(hook => {
-          const retryKey = `retry${hook}`
-          if (isNotSet(suite.opts[retryKey])) {
-            suite.opts[retryKey] = config[hook]
-            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
-          }
-        })
-
-      // Handle feature-level retries
-      if (config.Feature) {
-        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
-          suite.retries(config.Feature)
-          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
-        }
-      }
-    }
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // Only set if not already set by higher priority mechanism
-      if (test.retries() === -1) {
-        test.retries(retryConfig)
-        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    retryConfig = retryConfig.filter(config => !!config.Scenario)
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!test.fullTitle().includes(config.grep)) continue
-      }
-
-      if (config.Scenario) {
-        // Respect priority system
-        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
-          test.retries(config.Scenario)
-          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-          output.log(`[Global Retry] Scenario retries: ${config.Scenario}`)
-        }
-      }
-    }
-  })
-}
-
-// Export priority constants for use by other retry mechanisms
-export { RETRY_PRIORITIES }

package/lib/plugin/enhancedRetryFailedStep.js

@@ -1,99 +0,0 @@
-import event from '../event.js'
-import recorder from '../recorder.js'
-import store from '../store.js'
-import output from '../output.js'
-import { RETRY_PRIORITIES } from '../retryCoordinator.js'
-
-const defaultConfig = {
-  retries: 3,
-  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
-  factor: 1.5,
-  ignoredSteps: [],
-}
-
-/**
- * Enhanced retryFailedStep plugin that coordinates with other retry mechanisms
- *
- * This plugin provides step-level retries and coordinates with global retry settings
- * to avoid conflicts and provide predictable behavior.
- */
-export default config => {
-  config = Object.assign({}, defaultConfig, config)
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
-  const customWhen = config.when
-
-  let enableRetry = false
-
-  const when = err => {
-    if (!enableRetry) return false
-    if (store.debugMode) return false
-    if (!store.autoRetries) return false
-    if (customWhen) return customWhen(err)
-    return true
-  }
-  config.when = when
-
-  event.dispatcher.on(event.step.started, step => {
-    // if a step is ignored - return
-    for (const ignored of config.ignoredSteps) {
-      if (step.name === ignored) return
-      if (ignored instanceof RegExp) {
-        if (step.name.match(ignored)) return
-      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
-    }
-    enableRetry = true // enable retry for a step
-  })
-
-  event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    // pass disableRetryFailedStep is a preferred way to disable retries
-    // test.disableRetryFailedStep is used for backward compatibility
-    if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
-      store.autoRetries = false
-      output.log(`[Step Retry] Disabled for test: ${test.title}`)
-      return // disable retry when a test is not active
-    }
-
-    // Check if step retries should be disabled due to higher priority scenario retries
-    const scenarioRetries = test.retries()
-    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
-    const scenarioPriority = test.opts.retryPriority || 0
-
-    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
-      // Scenario retries are configured with higher or equal priority
-      // Option 1: Disable step retries (conservative approach)
-      store.autoRetries = false
-      output.log(`[Step Retry] Deferred to scenario retries (${scenarioRetries} retries)`)
-      return
-
-      // Option 2: Reduce step retries to avoid excessive total retries
-      // const reducedStepRetries = Math.max(1, Math.floor(config.retries / scenarioRetries))
-      // config.retries = reducedStepRetries
-      // output.log(`[Step Retry] Reduced to ${reducedStepRetries} retries due to scenario retries (${scenarioRetries})`)
-    }
-
-    // this option is used to set the retries inside _before() block of helpers
-    store.autoRetries = true
-    test.opts.conditionalRetries = config.retries
-    test.opts.stepRetryPriority = stepRetryPriority
-
-    recorder.retry(config)
-
-    output.log(`[Step Retry] Enabled with ${config.retries} retries for test: ${test.title}`)
-  })
-
-  // Add coordination info for debugging
-  event.dispatcher.on(event.test.finished, test => {
-    if (test.state === 'passed' && test.opts.conditionalRetries && store.autoRetries) {
-      const stepRetries = test.opts.conditionalRetries || 0
-      const scenarioRetries = test.retries() || 0
-
-      if (stepRetries > 0 && scenarioRetries > 0) {
-        output.log(`[Retry Coordination] Test used both step retries (${stepRetries}) and scenario retries (${scenarioRetries})`)
-      }
-    }
-  })
-}