@fromeroc9/testform 1.0.3 → 1.0.5

package/dist/core/policy.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPolicy = exports.policy = void 0;
+const logger_1 = require("../logger");
+const notify_1 = require("../notify");
+class Policy {
+    builtinPolicies = {};
+    userPolicies = {};
+    resolve(scope) {
+        const system = Object.values(this.builtinPolicies);
+        const user = Object.values(this.userPolicies);
+        return [...system, ...user].filter((policy) => policy.scope.includes(scope));
+    }
+    registry(policy, type = 'system') {
+        if (type === 'system') {
+            this.builtinPolicies[policy.id] = policy;
+        }
+        if (type === 'user') {
+            this.userPolicies[policy.id] = policy;
+        }
+    }
+    scanner(scenarios, scope, isJson = false, compactWarnings = false) {
+        const rules = [];
+        const activePolicies = this.resolve(scope);
+        for (const policy of activePolicies) {
+            try {
+                policy.action(scenarios, rules, scope);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : "Unknown policy execution error";
+                rules.push({
+                    id: `policy-runtime-error:${policy.id}`,
+                    title: `Policy "${policy.id}" failed during execution.`,
+                    detail: message,
+                    uri: "(policy-runtime)",
+                });
+            }
+        }
+        if (isJson) {
+            if (rules.length > 0) {
+                const data = {
+                    valid: false,
+                    error_count: rules.length,
+                    warning_count: 0,
+                    diagnostics: rules.map(r => ({
+                        severity: r.type ?? 'error',
+                        summary: r.title,
+                        detail: r.detail
+                    }))
+                };
+                console.log(JSON.stringify(data, null, 2));
+                process.exit(1);
+            }
+            return;
+        }
+        if (rules.length > 0) {
+            logger_1.logger.info("Review the violations above and fix them before continuing.", { bold: true });
+            logger_1.logger.info(`${rules.length} policy violation${rules.length > 1 ? "s" : ""} found:\n`, { bold: true });
+        }
+        let warningsCount = 0;
+        for (const violation of rules) {
+            const isWarning = violation.type === 'warning';
+            if (isWarning)
+                warningsCount++;
+            if (isWarning && compactWarnings)
+                continue;
+            let locationStr = `on ${violation.uri}`;
+            if (violation.line !== undefined)
+                locationStr += ` line ${violation.line}`;
+            if (violation.scenario)
+                locationStr += `, in scenario "${violation.scenario}"`;
+            notify_1.notify.push({
+                type: violation.type ?? 'error',
+                title: violation.title,
+                detail: [
+                    violation.detail,
+                    locationStr
+                ]
+            });
+        }
+        if (warningsCount > 0 && compactWarnings) {
+            logger_1.logger.warn(`\n${warningsCount} warning(s) found. (Details suppressed by -compact-warnings)`);
+        }
+        return rules.length > 0;
+    }
+}
+exports.policy = new Policy();
+const registerPolicy = (policyDefinition) => exports.policy.registry(policyDefinition, 'user');
+exports.registerPolicy = registerPolicy;
+exports.policy.registry({
+    id: "undeclared-fields",
+    scope: ["testcase"],
+    action: (scenarios, rules, scope) => {
+        for (const scenario of scenarios) {
+            for (const v of scenario.custom?.policy?.filter(v => v.type === 'undeclared-field') ?? []) {
+                rules.push({
+                    id: "undeclared-field",
+                    type: 'warning',
+                    title: `Value for undeclared field "${v.field}"`,
+                    detail: `Field "${v.field}" is not declared in the configuration. Add a "fields" entry to your config.`,
+                    uri: scenario.uri,
+                    scenario: scenario.name,
+                    line: scenario.location,
+                });
+            }
+        }
+    }
+});
+exports.policy.registry({
+    id: "required-fields",
+    scope: ["testcase", "testrun", "testplan"],
+    action: (scenarios, rules, scope) => {
+        for (const scenario of scenarios) {
+            for (const v of scenario.custom?.policy?.filter(v => v.type === 'required-field') ?? []) {
+                rules.push({
+                    id: "required-field-missing",
+                    title: `Required field "${v.field}" is missing`,
+                    detail: `Add a step: "field ${v.field} = <value>" to the scenario.`,
+                    uri: scenario.uri,
+                    scenario: scenario.name,
+                    line: scenario.location,
+                });
+            }
+        }
+    }
+});
+exports.policy.registry({
+    id: "required-gherkin",
+    scope: ["testcase"],
+    action: (scenarios, rules, scope) => {
+        const validKeywords = ["scenario", "scenario outline"];
+        for (const scenario of scenarios) {
+            // Check: Feature name is required
+            if (!scenario.feature.name || scenario.feature.name.trim() === "") {
+                rules.push({
+                    id: "feature-name-required",
+                    title: "Feature name is required",
+                    detail: "Every feature must have a name. Add a descriptive name after 'Feature'.",
+                    uri: scenario.uri,
+                    line: scenario.location
+                });
+            }
+            // Check: Scenario name is required
+            if (!scenario.name || scenario.name.trim() === "") {
+                rules.push({
+                    id: "scenario-name-required",
+                    title: "Scenario name is required",
+                    detail: "Every scenario must have a name. Add a descriptive name after 'Scenario:' or 'Scenario Outline:'.",
+                    uri: scenario.uri,
+                    line: scenario.location,
+                });
+                continue;
+            }
+            // Check: Valid keyword (Scenario or Scenario Outline)
+            if (!validKeywords.includes(scenario.keyword.trim().toLowerCase()))
+                continue;
+            // Check: Required steps (Given, When, Then)
+            const allSteps = [
+                ...(scenario.background?.steps ?? []),
+                ...scenario.steps,
+            ];
+            const missing = [];
+            if (!allSteps.some(s => s.keyword.trim().toLowerCase() === "given"))
+                missing.push("Given");
+            if (!allSteps.some(s => s.keyword.trim().toLowerCase() === "when"))
+                missing.push("When");
+            if (!allSteps.some(s => s.keyword.trim().toLowerCase() === "then"))
+                missing.push("Then");
+            if (missing.length > 0) {
+                rules.push({
+                    id: "steps-required",
+                    title: `Scenario is missing required step types: ${missing.join(", ")}.`,
+                    detail: "Each scenario must have at least one Given, When, and Then step.",
+                    uri: scenario.uri,
+                    scenario: scenario.name,
+                    line: scenario.location,
+                });
+            }
+        }
+    }
+});
+exports.policy.registry({
+    id: "no-feature-tags",
+    scope: ["testcase", "testrun", "testplan"],
+    action: (scenarios, rules, scope) => {
+        const expectedTag = `@${scope}`;
+        const seen = new Set();
+        for (const scenario of scenarios) {
+            const uri = scenario.uri ?? "(unknown)";
+            if (seen.has(uri))
+                continue;
+            seen.add(uri);
+            const allowedScopeTags = ["@testcase", "@testrun", "@testplan"];
+            const allowedFeatureTags = [...allowedScopeTags];
+            if (scenario.custom?.identity) {
+                allowedFeatureTags.push(scenario.custom.identity.toLowerCase());
+            }
+            const featureTags = scenario.feature?.tags ?? [];
+            const invalidTags = featureTags.filter(tag => !allowedFeatureTags.includes(tag.toLowerCase()));
+            if (invalidTags.length > 0) {
+                rules.push({
+                    id: "no-feature-tags",
+                    title: `Feature-level tags are not allowed in ${uri} scope (found: ${invalidTags.join(", ")}).`,
+                    detail: "Move any tags from Feature: to the individual Scenario level, except for scope tags and identity tags.",
+                    uri,
+                });
+            }
+            const declaredScopeTags = featureTags.filter(tag => allowedScopeTags.includes(tag.toLowerCase()));
+            for (const tag of declaredScopeTags) {
+                if (tag.toLowerCase() !== expectedTag) {
+                    rules.push({
+                        id: "invalid-scope-tag",
+                        title: `Mismatched scope: file is tagged as ${tag} but is being processed as ${expectedTag}.`,
+                        detail: `A feature file designed for ${tag} cannot be executed in -scope ${scope}.`,
+                        uri,
+                    });
+                }
+            }
+        }
+    }
+});
+exports.policy.registry({
+    id: "identity-required",
+    scope: ["testcase", "testrun", "testplan"],
+    action: (scenarios, rules, scope) => {
+        for (const scenario of scenarios ?? []) {
+            const identity = scenario.custom?.identity;
+            if (!identity || identity.trim() === "" || identity === scenario.uri) {
+                rules.push({
+                    id: "identity-required",
+                    title: scope === 'testcase'
+                        ? "Every scenario must have an identity tag matching the configured identity pattern."
+                        : "Every feature must have an identity tag matching the configured identity pattern.",
+                    detail: scope === 'testcase'
+                        ? "Add the identity tag (e.g. @tc-1) to each scenario."
+                        : "Add the identity tag (e.g. @tr-1) to the Feature level.",
+                    uri: scenario.uri ?? "(unknown)",
+                    scenario: scope === 'testcase' ? scenario.name : undefined,
+                    line: scope === 'testcase' ? scenario.location : (scenario.feature?.location ?? scenario.location),
+                });
+                continue;
+            }
+            if (scope === 'testrun' || scope === 'testplan') {
+                const featureTags = scenario.feature?.tags ?? [];
+                const hasFeatureTag = featureTags.some(t => t.toLowerCase() === identity.toLowerCase());
+                if (!hasFeatureTag) {
+                    rules.push({
+                        id: "identity-feature-level-required",
+                        title: `The identity tag ${identity} must be declared at the Feature level.`,
+                        detail: `Move the identity tag ${identity} so it is placed next to the @${scope} tag before the 'Feature:' keyword.`,
+                        uri: scenario.uri ?? "(unknown)",
+                        line: scenario.feature?.location ?? scenario.location,
+                    });
+                }
+            }
+        }
+    }
+});
+exports.policy.registry({
+    id: "identity-unique",
+    scope: ["testcase", "testrun", "testplan"],
+    action: (scenarios, rules, scope) => {
+        const seen = new Map();
+        for (const scenario of scenarios) {
+            const identity = scenario.custom?.identity?.trim();
+            if (!identity)
+                continue;
+            // Ignore if the identity is just the uri fallback
+            if (identity === scenario.uri)
+                continue;
+            const entry = { scenario: scenario.name, line: scenario.location, keyword: scenario.keyword || '', uri: scenario.uri || '' };
+            // For testcase, identities only need to be unique within the same file.
+            // For testrun/testplan, identities must be globally unique across all files.
+            const uniquenessKey = scope === 'testcase' ? `${scenario.uri}::${identity}` : identity;
+            const existing = seen.get(uniquenessKey);
+            if (existing) {
+                existing.push(entry);
+            }
+            else {
+                seen.set(uniquenessKey, [entry]);
+            }
+        }
+        for (const [key, entries] of seen) {
+            if (entries.length <= 1)
+                continue;
+            const identity = key.includes('::') ? key.split('::')[1] : key;
+            const allSameOutline = entries.every((e) => (e.keyword || '').trim() === "Scenario Outline") &&
+                entries.every((e) => e.line === entries[0].line && e.uri === entries[0].uri);
+            if (allSameOutline) {
+                rules.push({
+                    id: "unique-key-required",
+                    title: `Scenario Outline expanded ${entries.length} rows but all share the same identity "${identity}".`,
+                    detail: "Add a <key> inside the identity tag (e.g. @tc-<key>) so each expanded row has a unique identity.",
+                    uri: entries[0].uri,
+                    scenario: entries[0].scenario,
+                    line: entries[0].line,
+                });
+                continue;
+            }
+            for (const entry of entries) {
+                let suggestion = "";
+                const match = identity.match(/^(@[a-zA-Z0-9-]+?)-?(\d+)(.*)$/);
+                if (match) {
+                    const prefix = match[1] + (identity.includes('-') ? '-' : '');
+                    const suffix = match[3];
+                    let max = 0;
+                    for (const s of scenarios) {
+                        // For testcase, only check within the same file. For others, check globally.
+                        if (scope === 'testcase' && s.uri !== entry.uri)
+                            continue;
+                        const id = s.custom?.identity?.trim();
+                        if (id && id !== s.uri) {
+                            // Extract numbers from matching prefixes
+                            const m = id.match(new RegExp(`^${prefix}(\\d+)${suffix}$`));
+                            if (m) {
+                                const num = parseInt(m[1], 10);
+                                if (num > max)
+                                    max = num;
+                            }
+                        }
+                    }
+                    if (max > 0) {
+                        suggestion = ` The next available identity ${scope === 'testcase' ? 'in this file ' : ''}is ${prefix}${max + 1}${suffix}.`;
+                    }
+                }
+                rules.push({
+                    id: "identity-unique",
+                    title: scope === 'testcase'
+                        ? `Duplicate identity "${identity}" found in the same file.`
+                        : `Duplicate identity "${identity}" found.`,
+                    detail: (scope === 'testcase'
+                        ? "Each scenario within a file must have a unique identity tag."
+                        : "Each element must have a globally unique identity tag in the workspace.") + suggestion,
+                    uri: entry.uri,
+                    scenario: entry.scenario,
+                    line: entry.line,
+                });
+            }
+        }
+    }
+});

package/dist/core/prompt.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * @fileoverview Interactive prompt utilities for CLI confirmation dialogs.
+ *
+ * Provides approval prompts used by `apply` and `destroy`
+ * commands before executing destructive or irreversible operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askConfirmation = askConfirmation;
+exports.askApproval = askApproval;
+exports.askDestroyApproval = askDestroyApproval;
+exports.askMigrationApproval = askMigrationApproval;
+exports.askStatus = askStatus;
+const readline_1 = require("readline");
+const chalk_1 = require("chalk");
+const const_1 = require("../const");
+/**
+ * Generic stdin confirmation prompt that accepts only "yes" as approval.
+ *
+ * @param lines - Lines of text to display before the prompt input.
+ * @returns `true` if the user typed "yes" (case-insensitive), `false` otherwise.
+ *
+ * @example
+ * const ok = await askConfirmation(['Are you sure you want to delete everything?']);
+ * if (!ok) process.exit(0);
+ */
+async function askConfirmation(lines) {
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        console.log('');
+        for (const line of lines) {
+            console.log(line);
+        }
+        console.log(`  ${const_1.MSG_APPROVE_ONLY_YES}`);
+        console.log('');
+        rl.question('  Enter a value: ', (answer) => {
+            rl.close();
+            console.log('');
+            resolve(answer.trim().toLowerCase() === 'yes');
+        });
+    });
+}
+/**
+ * Apply approval prompt.
+ * Shown before `testform apply` executes any planned changes.
+ *
+ * @returns `true` if the user approved, `false` if they declined.
+ */
+async function askApproval() {
+    return askConfirmation([
+        'Do you want to perform these actions?',
+        `  ${const_1.TITLE_APP} will perform the actions described above.`,
+    ]);
+}
+/**
+ * Destroy approval prompt.
+ * Shown before `testform destroy` removes all managed resources.
+ *
+ * @param count - Number of resources that will be destroyed.
+ * @returns `true` if the user approved, `false` if they declined.
+ */
+async function askDestroyApproval(count) {
+    return askConfirmation([
+        (0, chalk_1.red)((0, chalk_1.bold)(`${const_1.TITLE_APP} will destroy ${count} resource(s).`)),
+        '  This action cannot be undone.',
+    ]);
+}
+/**
+ * Interactive prompt for state migration when backend configuration changes.
+ *
+ * @param newBackendType - The type of the new backend being configured.
+ * @returns `true` if the user wants to copy state, `false` to start empty.
+ */
+async function askMigrationApproval(newBackendType) {
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        console.log('');
+        console.log((0, chalk_1.bold)('Do you want to copy existing state to the new backend?'));
+        console.log('  Pre-existing state was found while migrating the previous');
+        console.log(`  backend to the newly configured "${newBackendType}" backend.`);
+        console.log('  Do you want to copy this state to the new backend?');
+        console.log('  Enter "yes" to copy and "no" to start with an empty state.');
+        console.log('');
+        rl.question('  Enter a value: ', (answer) => {
+            rl.close();
+            console.log('');
+            resolve(answer.trim().toLowerCase() === 'yes');
+        });
+    });
+}
+/**
+ * Interactive prompt for selecting a status.
+ *
+ * @returns The selected status string.
+ */
+async function askStatus() {
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        console.log('');
+        console.log((0, chalk_1.bold)('Select the new status for this testcase:'));
+        console.log('  Available options: passed, failed, pending, skipped, blocked, etc.');
+        console.log('');
+        rl.question('  Enter the new status: ', (answer) => {
+            rl.close();
+            console.log('');
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+}

package/dist/core/state.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = void 0;
+const crypto_1 = require("crypto");
+const const_1 = require("../const");
+const notify_1 = require("../notify");
+const local_1 = require("./backends/local");
+const s3_1 = require("./backends/s3");
+const azurerm_1 = require("./backends/azurerm");
+const gcs_1 = require("./backends/gcs");
+const config_1 = require("./config");
+const workspace_1 = require("./workspace");
+class State {
+    state;
+    backend;
+    workspaceManager;
+    constructor(dir, customStatePath, customBackupPath, disableBackend = false, backendConfigRaw, explicitBackendConfig) {
+        const config = new config_1.Config(dir);
+        let backendConfig = explicitBackendConfig || config.getBackend();
+        this.workspaceManager = new workspace_1.WorkspaceManager(dir);
+        const currentWorkspace = this.workspaceManager.getCurrentWorkspace();
+        // If backend is explicitly disabled via CLI, force local
+        if (disableBackend) {
+            backendConfig = { type: 'local', config: {} };
+        }
+        else if (backendConfig && backendConfig.type !== 'local' && backendConfigRaw) {
+            // Apply CLI overrides to the backend config
+            const overrides = this.parseBackendOverrides(backendConfigRaw);
+            backendConfig.config = { ...backendConfig.config, ...overrides };
+        }
+        if (backendConfig?.type === 's3') {
+            this.backend = new s3_1.S3Backend(backendConfig.config, currentWorkspace);
+        }
+        else if (backendConfig?.type === 'azurerm') {
+            this.backend = new azurerm_1.AzureRMBackend(backendConfig.config, currentWorkspace);
+        }
+        else if (backendConfig?.type === 'gcs') {
+            this.backend = new gcs_1.GCSBackend(backendConfig.config, currentWorkspace);
+        }
+        else {
+            this.backend = new local_1.LocalBackend(dir, customStatePath, customBackupPath, currentWorkspace);
+        }
+    }
+    parseBackendOverrides(raw) {
+        const overrides = {};
+        const items = Array.isArray(raw) ? raw : [raw];
+        for (const item of items) {
+            const index = item.indexOf('=');
+            if (index > 0) {
+                const key = item.substring(0, index).trim();
+                const val = item.substring(index + 1).trim();
+                overrides[key] = val;
+            }
+        }
+        return overrides;
+    }
+    async hasState() {
+        return await this.backend.exists();
+    }
+    async init() {
+        const parsed = await this.backend.read();
+        // Validate version
+        if (!parsed.version) {
+            notify_1.notify.push({
+                type: 'error',
+                title: `${const_1.FILE_STATE} is missing the "version" field`,
+                detail: [`Add a "version" field to your ${const_1.FILE_STATE} file and rerun init.`],
+                close: true
+            });
+        }
+        else if (parsed.version !== const_1.VERSION_STATE) {
+            notify_1.notify.push({
+                type: 'error',
+                title: `state version mismatch`,
+                detail: [
+                    `Found version "${parsed.version}", but expected "${const_1.VERSION_STATE}".`,
+                    `Update ${const_1.FILE_STATE} to version ${const_1.VERSION_STATE} and rerun init.`,
+                ],
+                close: true
+            });
+        }
+        this.state = {
+            version: parsed.version || const_1.VERSION_STATE,
+            serial: parsed.serial ?? 0,
+            lineage: parsed.lineage ?? (0, crypto_1.randomUUID)(),
+            lastSync: parsed.lastSync ?? '',
+            resources: parsed.resources ?? [],
+        };
+    }
+    async acquireLock(enabled, timeoutRaw) {
+        if (!enabled)
+            return;
+        const success = await this.backend.lock(timeoutRaw);
+        if (!success) {
+            console.error(`\nError: Acquiring the state lock.\n\nTestform acquires a state lock to protect the state from being written\nby multiple users at the same time. Please resolve the issue above and try\nagain. For most commands, you can disable locking with the "-lock=false"\nflag, but this is not recommended.\n`);
+            process.exit(1);
+        }
+        const cleanup = async () => { await this.releaseLock(); process.exit(1); };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        // Using 'exit' with async is problematic, but we try to clean up synchronously if we can.
+        // Actually, we'll just handle clean exits gracefully via releaseLock().
+    }
+    async releaseLock() {
+        await this.backend.unlock();
+    }
+    async forceUnlock(lockId) {
+        return this.backend.forceUnlock(lockId);
+    }
+    /**
+     * Save state to disk or backend. Increments serial and updates lastSync.
+     */
+    async save() {
+        this.state.serial += 1;
+        this.state.lastSync = new Date().toISOString();
+        await this.backend.write(this.state);
+    }
+    /**
+     * Get current state (read-only snapshot).
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Replace the entire internal state with a new snapshot (useful for migration).
+     * Note: This does not automatically save to backend. Call .save() afterwards.
+     */
+    replaceState(newState) {
+        this.state = JSON.parse(JSON.stringify(newState)); // Deep copy to avoid reference issues
+    }
+    /**
+     * Get all resources of a given type.
+     */
+    getResources(type) {
+        if (!this.state.resources)
+            return [];
+        if (!type)
+            return this.state.resources;
+        return this.state.resources.filter(r => r.type === type);
+    }
+    // Workspace Delegation
+    getCurrentWorkspace() {
+        return this.workspaceManager.getCurrentWorkspace();
+    }
+    setCurrentWorkspace(name) {
+        this.workspaceManager.setCurrentWorkspace(name);
+    }
+    async listWorkspaces() {
+        return this.backend.listWorkspaces();
+    }
+    async deleteWorkspace(name) {
+        return this.backend.deleteWorkspace(name);
+    }
+    /**
+     * Find a resource by identity.
+     */
+    findResource(identity) {
+        return this.state.resources.find(r => r.identity === identity);
+    }
+    /**
+     * Add or update a resource after a successful apply operation.
+     */
+    upsertResource(resource) {
+        const idx = this.state.resources.findIndex(r => r.identity === resource.identity);
+        if (idx >= 0) {
+            this.state.resources[idx] = resource;
+        }
+        else {
+            this.state.resources.push(resource);
+        }
+    }
+    /**
+     * Remove a resource after a successful destroy operation.
+     */
+    removeResource(identity) {
+        this.state.resources = this.state.resources.filter(r => r.identity !== identity);
+    }
+    /**
+     * Clear all resources (used by full destroy).
+     */
+    clearResources() {
+        this.state.resources = [];
+    }
+}
+exports.State = State;