@toolstackhq/create-qa-patterns 1.0.14 → 1.0.15

package/templates/wdio-template/wdio.conf.ts

@@ -0,0 +1,58 @@
+// Central WebdriverIO configuration for specs, retries, reporters, and runtime env values.
+import type { Capabilities, Options, Reporters } from '@wdio/types';
+
+import { loadRuntimeConfig } from './config/runtime-config';
+import StructuredReporter from './reporters/structured-reporter';
+
+const runtimeConfig = loadRuntimeConfig();
+const structuredReporter =
+  StructuredReporter as unknown as Reporters.ReporterClass;
+
+export const config: Options.Testrunner &
+  Capabilities.WithRequestedTestrunnerCapabilities = {
+  runner: 'local',
+  specs: ['./tests/**/*.spec.ts'],
+  maxInstances: 1,
+  baseUrl: runtimeConfig.uiBaseUrl,
+  framework: 'mocha',
+  tsConfigPath: './tsconfig.json',
+  mochaOpts: {
+    ui: 'bdd',
+    timeout: 60_000
+  },
+  logLevel: 'error',
+  waitforTimeout: 10_000,
+  connectionRetryTimeout: 120_000,
+  connectionRetryCount: 1,
+  reporters: [
+    'spec',
+    [
+      'allure',
+      {
+        outputDir: 'allure-results',
+        disableWebdriverStepsReporting: true,
+        disableWebdriverScreenshotsReporting: false
+      }
+    ],
+    [structuredReporter, { outputFile: 'reports/logs/wdio-events.jsonl' }]
+  ],
+  capabilities: [
+    {
+      browserName: 'chrome',
+      'goog:chromeOptions': {
+        args: ['--headless=new', '--disable-dev-shm-usage', '--no-sandbox']
+      }
+    }
+  ],
+  afterTest: async function (
+    _test: unknown,
+    _context: unknown,
+    result: { passed: boolean; error?: unknown }
+  ) {
+    if (!result.passed) {
+      await browser.saveScreenshot(
+        `test-results/${Date.now()}-${result.error ? 'failed' : 'result'}.png`
+      );
+    }
+  }
+};

package/tests/args.test.js

@@ -0,0 +1,58 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { DEFAULT_TEMPLATE, TEMPLATE_CATALOG } = require('../lib/constants');
+const { parseCliOptions, resolveNonInteractiveArgs } = require('../lib/args');
+const { createTemplateAliases, resolveTemplate } = require('../lib/templates');
+
+const templateAliases = createTemplateAliases(TEMPLATE_CATALOG);
+const supportedTemplateIds = TEMPLATE_CATALOG.map((template) => template.id);
+
+test('parseCliOptions resolves --template aliases', () => {
+  const options = parseCliOptions(['--template', 'pw', 'demo'], {
+    resolveTemplate: (value) => resolveTemplate(templateAliases, value),
+    supportedTemplateIds
+  });
+
+  assert.equal(options.templateName, 'playwright-template');
+  assert.deepEqual(options.positionalArgs, ['demo']);
+});
+
+test('resolveNonInteractiveArgs defaults to the default template for a directory name', () => {
+  const result = resolveNonInteractiveArgs(['demo-project'], {
+    defaultTemplate: DEFAULT_TEMPLATE,
+    resolveTemplate: (value) => resolveTemplate(templateAliases, value),
+    supportedTemplateIds
+  });
+
+  assert.equal(result.templateName, DEFAULT_TEMPLATE);
+  assert.equal(result.generatedInCurrentDirectory, false);
+  assert.match(result.targetDirectory, /demo-project$/);
+});
+
+test('resolveNonInteractiveArgs accepts explicit template and target directory', () => {
+  const result = resolveNonInteractiveArgs(
+    ['cypress-template', 'demo-project'],
+    {
+      defaultTemplate: DEFAULT_TEMPLATE,
+      resolveTemplate: (value) => resolveTemplate(templateAliases, value),
+      supportedTemplateIds
+    }
+  );
+
+  assert.equal(result.templateName, 'cypress-template');
+  assert.equal(result.generatedInCurrentDirectory, false);
+  assert.match(result.targetDirectory, /demo-project$/);
+});
+
+test('resolveNonInteractiveArgs accepts a WebdriverIO alias and target directory', () => {
+  const result = resolveNonInteractiveArgs(['wdio', 'demo-project'], {
+    defaultTemplate: DEFAULT_TEMPLATE,
+    resolveTemplate: (value) => resolveTemplate(templateAliases, value),
+    supportedTemplateIds
+  });
+
+  assert.equal(result.templateName, 'wdio-template');
+  assert.equal(result.generatedInCurrentDirectory, false);
+  assert.match(result.targetDirectory, /demo-project$/);
+});

package/tests/local-env.test.js

@@ -0,0 +1,70 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  createLocalCredentials,
+  renderLocalEnv,
+  writeGeneratedLocalEnv
+} = require('../lib/local-env');
+
+test('createLocalCredentials generates non-empty username and password', () => {
+  const credentials = createLocalCredentials('/tmp/my-project');
+
+  assert.match(credentials.username, /^my-project-/);
+  assert.ok(credentials.password.length > 10);
+});
+
+test('renderLocalEnv includes api base url only for playwright', () => {
+  const credentials = {
+    username: 'local-user',
+    password: 'local-password'
+  };
+
+  const playwrightEnv = renderLocalEnv('playwright-template', credentials);
+  const cypressEnv = renderLocalEnv('cypress-template', credentials);
+  const wdioEnv = renderLocalEnv('wdio-template', credentials);
+
+  assert.match(playwrightEnv, /DEV_API_BASE_URL=http:\/\/127.0.0.1:3001/);
+  assert.doesNotMatch(cypressEnv, /DEV_API_BASE_URL/);
+  assert.doesNotMatch(wdioEnv, /DEV_API_BASE_URL/);
+  assert.match(playwrightEnv, /DEV_APP_USERNAME=local-user/);
+  assert.match(cypressEnv, /UI_DEMO_PASSWORD=local-password/);
+  assert.match(wdioEnv, /UI_DEMO_PASSWORD=local-password/);
+});
+
+test('writeGeneratedLocalEnv creates .env only once', () => {
+  const targetDirectory = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'qa-patterns-env-')
+  );
+  const credentials = {
+    username: 'first-user',
+    password: 'first-password'
+  };
+
+  const firstWrite = writeGeneratedLocalEnv(
+    targetDirectory,
+    'cypress-template',
+    credentials
+  );
+  const secondWrite = writeGeneratedLocalEnv(
+    targetDirectory,
+    'cypress-template',
+    {
+      username: 'second-user',
+      password: 'second-password'
+    }
+  );
+
+  const envContents = fs.readFileSync(
+    path.join(targetDirectory, '.env'),
+    'utf8'
+  );
+
+  assert.equal(firstWrite.created, true);
+  assert.equal(secondWrite.created, false);
+  assert.match(envContents, /first-user/);
+  assert.doesNotMatch(envContents, /second-user/);
+});

package/tests/metadata.test.js

@@ -0,0 +1,147 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  analyzeUpgrade,
+  applySafeUpdates,
+  readProjectMetadata,
+  renderTemplateFile,
+  writeProjectMetadata
+} = require('../lib/metadata');
+const {
+  DEFAULT_GITIGNORE,
+  MANAGED_FILE_PATTERNS,
+  METADATA_FILENAME
+} = require('../lib/constants');
+const { getTemplateDirectory, toPackageName } = require('../lib/templates');
+
+const metadataOptions = {
+  cliPackageVersion: '1.0.14',
+  defaultGitignore: DEFAULT_GITIGNORE,
+  getTemplateDirectory: (templateId) =>
+    getTemplateDirectory(path.resolve(__dirname, '..'), templateId),
+  managedPatterns: MANAGED_FILE_PATTERNS,
+  metadataFilename: METADATA_FILENAME,
+  toPackageName
+};
+
+const template = {
+  id: 'playwright-template',
+  defaultPackageName: 'playwright-template'
+};
+
+function prepareScaffoldBaseline(targetDirectory) {
+  fs.cpSync(
+    metadataOptions.getTemplateDirectory(template.id),
+    targetDirectory,
+    { recursive: true }
+  );
+
+  for (const relativePath of ['package.json', 'package-lock.json']) {
+    const absolutePath = path.join(targetDirectory, relativePath);
+    fs.writeFileSync(
+      absolutePath,
+      renderTemplateFile(
+        template,
+        relativePath,
+        targetDirectory,
+        metadataOptions
+      ),
+      'utf8'
+    );
+  }
+}
+
+test('analyzeUpgrade reports up-to-date state for a fresh scaffold baseline', () => {
+  const targetDirectory = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'qa-patterns-meta-')
+  );
+  prepareScaffoldBaseline(targetDirectory);
+  writeProjectMetadata(template, targetDirectory, undefined, metadataOptions);
+
+  const metadata = readProjectMetadata(targetDirectory, METADATA_FILENAME);
+  const results = analyzeUpgrade(
+    template,
+    targetDirectory,
+    metadata,
+    metadataOptions
+  );
+
+  assert.equal(
+    results.every((entry) => entry.status === 'up-to-date'),
+    true
+  );
+});
+
+test('analyzeUpgrade reports conflicts for user-edited managed files', () => {
+  const targetDirectory = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'qa-patterns-meta-')
+  );
+  prepareScaffoldBaseline(targetDirectory);
+  writeProjectMetadata(template, targetDirectory, undefined, metadataOptions);
+
+  const packageJsonPath = path.join(targetDirectory, 'package.json');
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  packageJson.name = `${packageJson.name}-custom`;
+  fs.writeFileSync(
+    packageJsonPath,
+    `${JSON.stringify(packageJson, null, 2)}\n`,
+    'utf8'
+  );
+
+  const metadata = readProjectMetadata(targetDirectory, METADATA_FILENAME);
+  const results = analyzeUpgrade(
+    template,
+    targetDirectory,
+    metadata,
+    metadataOptions
+  );
+  const packageResult = results.find(
+    (entry) => entry.relativePath === 'package.json'
+  );
+
+  assert.equal(packageResult.status, 'conflict');
+});
+
+test('applySafeUpdates adopts a missing managed baseline entry', () => {
+  const targetDirectory = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'qa-patterns-meta-')
+  );
+  prepareScaffoldBaseline(targetDirectory);
+  writeProjectMetadata(template, targetDirectory, undefined, metadataOptions);
+
+  const metadataPath = path.join(targetDirectory, METADATA_FILENAME);
+  const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+  delete metadata.managedFiles['.github/workflows/playwright-tests.yml'];
+  fs.writeFileSync(
+    metadataPath,
+    `${JSON.stringify(metadata, null, 2)}\n`,
+    'utf8'
+  );
+
+  const nextMetadata = readProjectMetadata(targetDirectory, METADATA_FILENAME);
+  const results = analyzeUpgrade(
+    template,
+    targetDirectory,
+    nextMetadata,
+    metadataOptions
+  );
+  const outcome = applySafeUpdates(
+    targetDirectory,
+    nextMetadata,
+    results,
+    metadataOptions
+  );
+
+  assert.equal(outcome.appliedCount >= 1, true);
+  const updatedMetadata = readProjectMetadata(
+    targetDirectory,
+    METADATA_FILENAME
+  );
+  assert.ok(
+    updatedMetadata.managedFiles['.github/workflows/playwright-tests.yml']
+  );
+});

package/tests/templates.test.js

@@ -0,0 +1,44 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  createTemplateAliases,
+  resolveTemplate,
+  toPackageName
+} = require('../lib/templates');
+
+test('toPackageName normalizes directory names for generated packages', () => {
+  assert.equal(
+    toPackageName('/tmp/My QA Project', {
+      defaultPackageName: 'fallback-template'
+    }),
+    'my-qa-project'
+  );
+  assert.equal(
+    toPackageName('/tmp/---', { defaultPackageName: 'fallback-template' }),
+    'fallback-template'
+  );
+});
+
+test('createTemplateAliases resolves template ids and aliases', () => {
+  const aliases = createTemplateAliases([
+    {
+      id: 'playwright-template',
+      aliases: ['playwright', 'pw']
+    },
+    {
+      id: 'wdio-template',
+      aliases: ['webdriverio', 'wdio']
+    }
+  ]);
+
+  assert.equal(
+    resolveTemplate(aliases, 'playwright-template'),
+    'playwright-template'
+  );
+  assert.equal(resolveTemplate(aliases, 'playwright'), 'playwright-template');
+  assert.equal(resolveTemplate(aliases, 'pw'), 'playwright-template');
+  assert.equal(resolveTemplate(aliases, 'wdio-template'), 'wdio-template');
+  assert.equal(resolveTemplate(aliases, 'webdriverio'), 'wdio-template');
+  assert.equal(resolveTemplate(aliases, 'wdio'), 'wdio-template');
+});