ui-omakase-framework/dist/framework-config.js

A comprehensive E2E testing framework library with pre-built Cucumber step definitions and utilities for web automation testing

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createFrameworkConfig = createFrameworkConfig;
var _dotenv = _interopRequireDefault(require("dotenv"));
var _enhancedParseEnv = require("./env/enhanced-parseEnv");
var _tagHelper = require("./support/tag-helper");
var _fs = _interopRequireDefault(require("fs"));
var _path = _interopRequireDefault(require("path"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
/**
 * Creates a framework configuration for consumer projects
 */
function createFrameworkConfig(options = {}) {
  const {
    configPath = './config',
    envPath = './env/',
    environment = (0, _enhancedParseEnv.env)('NODE_ENV') || 'localhost',
    commonConfigFile = (0, _enhancedParseEnv.env)('COMMON_CONFIG_FILE') || 'env/common.env',
    featuresPath = './src/features/**/*.feature',
    customStepDefsPath = './src/step-definitions/**/*.ts'
  } = options;

  // Load environment configuration
  _dotenv.default.config({
    path: commonConfigFile
  });
  _dotenv.default.config({
    path: `${envPath}${environment}.env`
  });

  // Resolve config paths
  const resolvedConfigPath = _path.default.resolve(process.cwd(), configPath);

  // Load configuration files with fallback to framework defaults
  const hostsConfig = (0, _enhancedParseEnv.loadConfigWithFallbacks)(_path.default.join(resolvedConfigPath, 'hosts.json'), [`${process.cwd()}${(0, _enhancedParseEnv.env)('HOSTS_URLS_PATH')}`]) || {};
  const pagesConfig = (0, _enhancedParseEnv.loadConfigWithFallbacks)(_path.default.join(resolvedConfigPath, 'pages.json'), [`${process.cwd()}${(0, _enhancedParseEnv.env)('PAGE_URLS_PATH')}`]) || {};
  const emailsConfig = (0, _enhancedParseEnv.loadConfigWithFallbacks)(_path.default.join(resolvedConfigPath, 'emails.json'), [`${process.cwd()}${(0, _enhancedParseEnv.env)('EMAILS_URLS_PATH')}`]) || {};
  const errorsConfig = (0, _enhancedParseEnv.loadConfigWithFallbacks)(_path.default.join(resolvedConfigPath, 'errors.json'), [`${process.cwd()}${(0, _enhancedParseEnv.env)('ERRORS_URLS_PATH')}`]) || [];
  const mocksConfig = (0, _enhancedParseEnv.loadConfigWithFallbacks)(_path.default.join(resolvedConfigPath, 'mocks.json'), [`${process.cwd()}${(0, _enhancedParseEnv.env)('MOCKS_URLS_PATH')}`]) || {};

  // Load page element mappings
  const mappingsPath = _path.default.join(resolvedConfigPath, 'mappings');
  const pageElementMappings = loadMappings(mappingsPath, (0, _enhancedParseEnv.env)('PAGE_ELEMENTS_PATH'));

  // Load mock payload mappings
  const payloadsPath = _path.default.join(resolvedConfigPath, 'json_payloads');
  const mockPayloadMappings = loadPayloads(payloadsPath, (0, _enhancedParseEnv.env)('MOCK_PAYLOAD_PATH'));
  const worldParameters = {
    hostsConfig,
    pagesConfig,
    emailsConfig,
    errorsConfig,
    mocksConfig,
    pageElementMappings,
    mockPayloadMappings
  };

  // Get environment list
  const envList = getEnvList(hostsConfig);

  // Build Cucumber command configuration
  // Note: Step definitions are loaded via imports in the main index.ts
  // The consumer project just needs to import the framework
  const requirePaths = ['--require-module ts-node/register', customStepDefsPath ? `--require ${customStepDefsPath}` : ''].filter(Boolean).join(' ');
  const common = `${featuresPath} \\
                ${requirePaths} \\
                -f json:./reports/report.json \\
                --world-parameters '${JSON.stringify(worldParameters)}' \\
                --format progress-bar \\
                --parallel ${(0, _enhancedParseEnv.env)('PARALLEL') || '1'} \\
                --retry ${(0, _enhancedParseEnv.env)('RETRY') || '0'}`;
  const cucumberConfig = {
    dev: (0, _tagHelper.generateCucumberRuntimeTag)(common, environment, envList, 'dev'),
    smoke: (0, _tagHelper.generateCucumberRuntimeTag)(common, environment, envList, 'smoke'),
    regression: (0, _tagHelper.generateCucumberRuntimeTag)(common, environment, envList, 'regression')
  };
  return {
    worldParameters,
    cucumberConfig
  };
}

/**
 * Load page element mappings from directory
 */
function loadMappings(mappingsPath, fallbackPath) {
  let mappingFiles = [];
  let basePath = '';
  if (_fs.default.existsSync(mappingsPath) && _fs.default.statSync(mappingsPath).isDirectory()) {
    mappingFiles = _fs.default.readdirSync(mappingsPath).filter(file => file.endsWith('.json'));
    basePath = mappingsPath;
  } else if (fallbackPath) {
    const fallbackFullPath = `${process.cwd()}${fallbackPath}`;
    if (_fs.default.existsSync(fallbackFullPath)) {
      mappingFiles = _fs.default.readdirSync(fallbackFullPath).filter(file => file.endsWith('.json'));
      basePath = fallbackFullPath;
    }
  }
  return mappingFiles.reduce((pageElementConfigAcc, file) => {
    const key = file.replace('.json', '');
    const elementMappings = require(_path.default.join(basePath, file));
    return {
      ...pageElementConfigAcc,
      [key]: elementMappings
    };
  }, {});
}

/**
 * Load mock payload mappings from directory
 */
function loadPayloads(payloadsPath, fallbackPath) {
  let payloadFiles = [];
  let basePath = '';
  if (_fs.default.existsSync(payloadsPath) && _fs.default.statSync(payloadsPath).isDirectory()) {
    payloadFiles = _fs.default.readdirSync(payloadsPath).filter(file => file.endsWith('.json'));
    basePath = payloadsPath;
  } else if (fallbackPath) {
    const fallbackFullPath = `${process.cwd()}${fallbackPath}`;
    if (_fs.default.existsSync(fallbackFullPath)) {
      payloadFiles = _fs.default.readdirSync(fallbackFullPath).filter(file => file.endsWith('.json'));
      basePath = fallbackFullPath;
    }
  }
  return payloadFiles.reduce((payloadConfigAcc, file) => {
    const key = file.replace('.json', '');
    const payloadMappings = require(_path.default.join(basePath, file));
    return {
      ...payloadConfigAcc,
      [key]: payloadMappings
    };
  }, {});
}

/**
 * Get list of available environments
 */
function getEnvList(hostsConfig) {
  const envList = Object.keys(hostsConfig);
  if (envList.length === 0) {
    throw Error('🧨 No environments found in hosts configuration');
  }
  return envList;
}