@testsmith/testblocks 0.6.0 → 0.8.0

package/dist/core/blocks/playwright/navigation.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.navigationBlocks = void 0;
+const utils_1 = require("./utils");
+/**
+ * Navigation and waiting blocks for Playwright
+ */
+exports.navigationBlocks = [
+    // Navigate to URL
+    {
+        type: 'web_navigate',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Navigate to a URL',
+        inputs: [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'WAIT_UNTIL', type: 'field', fieldType: 'dropdown', options: [['Load', 'load'], ['DOM Content Loaded', 'domcontentloaded'], ['Network Idle', 'networkidle']], default: 'load' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const url = (0, utils_1.resolveVariables)(params.URL, context);
+            const waitUntil = params.WAIT_UNTIL;
+            context.logger.info(`Navigating to ${url}`);
+            await page.goto(url, { waitUntil });
+            return {
+                _summary: url,
+                url,
+                waitUntil,
+            };
+        },
+    },
+    // Wait for Element
+    {
+        type: 'web_wait_for_element',
+        category: 'Web',
+        color: '#9C27B0',
+        tooltip: 'Wait for an element to appear/disappear',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'STATE', type: 'field', fieldType: 'dropdown', options: [['Visible', 'visible'], ['Hidden', 'hidden'], ['Attached', 'attached'], ['Detached', 'detached']] },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = (0, utils_1.resolveSelector)(params, context);
+            const state = params.STATE;
+            const timeout = params.TIMEOUT;
+            context.logger.info(`Waiting for ${selector} to be ${state}`);
+            await page.waitForSelector(selector, { state, timeout });
+            return {
+                _summary: `${params.SELECTOR} is ${state}`,
+                selector,
+                state,
+            };
+        },
+    },
+    // Wait for URL
+    {
+        type: 'web_wait_for_url',
+        category: 'Web',
+        color: '#9C27B0',
+        tooltip: 'Wait for URL to match',
+        inputs: [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const url = (0, utils_1.resolveVariables)(params.URL, context);
+            const timeout = params.TIMEOUT;
+            context.logger.info(`Waiting for URL to match: ${url}`);
+            await page.waitForURL(url, { timeout });
+            return {
+                _summary: url,
+                url,
+            };
+        },
+    },
+    // Wait (pause)
+    {
+        type: 'web_wait',
+        category: 'Web',
+        color: '#9C27B0',
+        tooltip: 'Wait for a specified time',
+        inputs: [
+            { name: 'MILLISECONDS', type: 'field', fieldType: 'number', default: 1000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const ms = params.MILLISECONDS;
+            context.logger.info(`Waiting ${ms}ms`);
+            await page.waitForTimeout(ms);
+            return {
+                _summary: `${ms}ms`,
+                milliseconds: ms,
+            };
+        },
+    },
+    // Take Screenshot
+    {
+        type: 'web_screenshot',
+        category: 'Web',
+        color: '#607D8B',
+        tooltip: 'Take a screenshot',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', default: 'screenshot' },
+            { name: 'FULL_PAGE', type: 'field', fieldType: 'checkbox', default: false },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const name = params.NAME;
+            const fullPage = params.FULL_PAGE;
+            context.logger.info(`Taking screenshot: ${name}`);
+            const buffer = await page.screenshot({ fullPage });
+            return {
+                _summary: `${name}${fullPage ? ' (full page)' : ''}`,
+                name,
+                fullPage,
+                buffer: buffer.toString('base64'),
+            };
+        },
+    },
+];

package/dist/core/blocks/playwright/retrieval.d.ts

@@ -0,0 +1,5 @@
+import { BlockDefinition } from '../../types';
+/**
+ * Data retrieval blocks for Playwright (get text, attributes, values)
+ */
+export declare const retrievalBlocks: BlockDefinition[];

package/dist/core/blocks/playwright/retrieval.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrievalBlocks = void 0;
+const utils_1 = require("./utils");
+/**
+ * Data retrieval blocks for Playwright (get text, attributes, values)
+ */
+exports.retrievalBlocks = [
+    // Get Text Content
+    {
+        type: 'web_get_text',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get text content of an element',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = (0, utils_1.resolveSelector)(params, context);
+            const text = await page.textContent(selector);
+            context.logger.debug(`Text content of ${selector}: "${text}"`);
+            const displayText = text && text.length > 40 ? text.substring(0, 40) + '...' : text;
+            return {
+                _summary: `"${displayText}"`,
+                _value: text,
+                selector,
+                text,
+            };
+        },
+    },
+    // Get Attribute
+    {
+        type: 'web_get_attribute',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get attribute value of an element',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'ATTRIBUTE', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = (0, utils_1.resolveSelector)(params, context);
+            const attribute = params.ATTRIBUTE;
+            const value = await page.getAttribute(selector, attribute);
+            context.logger.debug(`Attribute ${attribute} of ${selector}: "${value}"`);
+            return {
+                _summary: `${attribute} = "${value}"`,
+                _value: value,
+                selector,
+                attribute,
+                value,
+            };
+        },
+    },
+    // Get Input Value
+    {
+        type: 'web_get_input_value',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get current value of an input field',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = (0, utils_1.resolveSelector)(params, context);
+            const value = await page.inputValue(selector);
+            context.logger.debug(`Input value of ${selector}: "${value}"`);
+            const displayValue = value.length > 40 ? value.substring(0, 40) + '...' : value;
+            return {
+                _summary: `"${displayValue}"`,
+                _value: value,
+                selector,
+                value,
+            };
+        },
+    },
+    // Get Page Title
+    {
+        type: 'web_get_title',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get the page title',
+        inputs: [],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const title = await page.title();
+            context.logger.debug(`Page title: "${title}"`);
+            return {
+                _summary: `"${title}"`,
+                _value: title,
+                title,
+            };
+        },
+    },
+    // Get Current URL
+    {
+        type: 'web_get_url',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get the current URL',
+        inputs: [],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const url = page.url();
+            context.logger.debug(`Current URL: "${url}"`);
+            return {
+                _summary: url,
+                _value: url,
+                url,
+            };
+        },
+    },
+    // Count Elements
+    {
+        type: 'web_count_elements',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Count the number of elements matching a selector',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'Number' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = (0, utils_1.resolveSelector)(params, context);
+            const count = await page.locator(selector).count();
+            context.logger.debug(`Found ${count} elements matching ${selector}`);
+            return {
+                _summary: `${count} elements`,
+                _value: count,
+                selector,
+                count,
+            };
+        },
+    },
+];

package/dist/core/blocks/playwright/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Type definitions for Playwright (we use dynamic import at runtime)
+ */
+export interface PlaywrightLocator {
+    click(options?: {
+        timeout?: number;
+    }): Promise<void>;
+    fill(value: string): Promise<void>;
+    type(text: string, options?: {
+        delay?: number;
+    }): Promise<void>;
+    selectOption(values: string | string[]): Promise<string[]>;
+    check(): Promise<void>;
+    uncheck(): Promise<void>;
+    hover(): Promise<void>;
+    focus(): Promise<void>;
+    press(key: string): Promise<void>;
+    textContent(): Promise<string | null>;
+    getAttribute(name: string): Promise<string | null>;
+    inputValue(): Promise<string>;
+    isVisible(): Promise<boolean>;
+    isEnabled(): Promise<boolean>;
+    isChecked(): Promise<boolean>;
+    count(): Promise<number>;
+}
+export interface PlaywrightPage {
+    goto(url: string, options?: {
+        waitUntil?: string;
+    }): Promise<unknown>;
+    click(selector: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    fill(selector: string, value: string): Promise<void>;
+    type(selector: string, text: string, options?: {
+        delay?: number;
+    }): Promise<void>;
+    selectOption(selector: string, values: string | string[]): Promise<string[]>;
+    check(selector: string): Promise<void>;
+    uncheck(selector: string): Promise<void>;
+    waitForSelector(selector: string, options?: {
+        state?: string;
+        timeout?: number;
+    }): Promise<unknown>;
+    waitForTimeout(timeout: number): Promise<void>;
+    waitForURL(url: string | RegExp, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    screenshot(options?: {
+        path?: string;
+        fullPage?: boolean;
+    }): Promise<Buffer>;
+    textContent(selector: string): Promise<string | null>;
+    getAttribute(selector: string, name: string): Promise<string | null>;
+    inputValue(selector: string): Promise<string>;
+    isVisible(selector: string): Promise<boolean>;
+    isEnabled(selector: string): Promise<boolean>;
+    isChecked(selector: string): Promise<boolean>;
+    evaluate<T>(fn: () => T): Promise<T>;
+    locator(selector: string): PlaywrightLocator;
+    title(): Promise<string>;
+    url(): string;
+    press(selector: string, key: string): Promise<void>;
+    hover(selector: string): Promise<void>;
+    focus(selector: string): Promise<void>;
+}

package/dist/core/blocks/playwright/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for Playwright (we use dynamic import at runtime)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/blocks/playwright/utils.d.ts

@@ -0,0 +1,26 @@
+import { ExecutionContext } from '../../types';
+export declare function getExpect(): Promise<any>;
+/**
+ * Execute a web assertion with soft assertion support
+ * Wraps Playwright's expect() to handle soft assertion mode
+ */
+export declare function executeWebAssertion(context: ExecutionContext, assertionFn: () => Promise<void>, errorMessage: string, details?: {
+    stepType?: string;
+    expected?: unknown;
+    actual?: unknown;
+}): Promise<void>;
+/**
+ * Resolve ${variable} placeholders in text
+ * Supports dot notation for object properties (e.g., ${user.email})
+ */
+export declare function resolveVariables(text: string, context: ExecutionContext): string;
+/**
+ * Resolve a selector based on its type
+ * - For 'testid:value' format: constructs [testIdAttribute="value"] using the global testIdAttribute
+ * - For other formats: returns the selector as-is
+ */
+export declare function resolveSelector(params: Record<string, unknown>, context: ExecutionContext): string;
+/**
+ * Get a display-friendly version of the selector (strips testid: prefix)
+ */
+export declare function getDisplaySelector(params: Record<string, unknown>, context: ExecutionContext): string;

package/dist/core/blocks/playwright/utils.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpect = getExpect;
+exports.executeWebAssertion = executeWebAssertion;
+exports.resolveVariables = resolveVariables;
+exports.resolveSelector = resolveSelector;
+exports.getDisplaySelector = getDisplaySelector;
+// Import Playwright's expect for assertions with auto-waiting
+// We use dynamic import with string concatenation to prevent Vite from
+// trying to bundle the playwright package (which is Node.js-only)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let playwrightExpect = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function getExpect() {
+    if (!playwrightExpect) {
+        // Use string concatenation to hide import from Vite's static analysis
+        const moduleName = '@playwright' + '/test';
+        const { expect } = await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+        playwrightExpect = expect;
+    }
+    return playwrightExpect;
+}
+/**
+ * Execute a web assertion with soft assertion support
+ * Wraps Playwright's expect() to handle soft assertion mode
+ */
+async function executeWebAssertion(context, assertionFn, errorMessage, details) {
+    try {
+        await assertionFn();
+    }
+    catch (err) {
+        if (context.softAssertions) {
+            // Soft assertion mode - collect error
+            const softError = {
+                message: err.message || errorMessage,
+                stepType: details?.stepType,
+                expected: details?.expected,
+                actual: details?.actual,
+                timestamp: new Date().toISOString(),
+            };
+            if (!context.softAssertionErrors) {
+                context.softAssertionErrors = [];
+            }
+            context.softAssertionErrors.push(softError);
+            context.logger.warn(`Soft assertion failed: ${softError.message}`);
+        }
+        else {
+            // Hard assertion mode - re-throw
+            throw err;
+        }
+    }
+}
+/**
+ * Resolve ${variable} placeholders in text
+ * Supports dot notation for object properties (e.g., ${user.email})
+ */
+function resolveVariables(text, context) {
+    return text.replace(/\$\{([\w.]+)\}/g, (match, path) => {
+        const parts = path.split('.');
+        const varName = parts[0];
+        let value = context.variables.get(varName);
+        // Handle dot notation for nested object access
+        if (parts.length > 1 && value !== undefined && value !== null) {
+            for (let i = 1; i < parts.length; i++) {
+                if (value === undefined || value === null)
+                    break;
+                value = value[parts[i]];
+            }
+        }
+        if (value === undefined || value === null)
+            return match;
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    });
+}
+/**
+ * Resolve a selector based on its type
+ * - For 'testid:value' format: constructs [testIdAttribute="value"] using the global testIdAttribute
+ * - For other formats: returns the selector as-is
+ */
+function resolveSelector(params, context) {
+    const rawSelector = resolveVariables(params.SELECTOR, context);
+    // Check for testid: prefix (e.g., "testid:nav-sign-in")
+    if (rawSelector.startsWith('testid:')) {
+        const testIdValue = rawSelector.substring(7); // Remove 'testid:' prefix
+        const testIdAttr = context.testIdAttribute || 'data-testid';
+        return `[${testIdAttr}="${testIdValue}"]`;
+    }
+    return rawSelector;
+}
+/**
+ * Get a display-friendly version of the selector (strips testid: prefix)
+ */
+function getDisplaySelector(params, context) {
+    const rawSelector = params.SELECTOR;
+    // For testid: prefix, show the actual CSS selector that will be used
+    if (rawSelector.startsWith('testid:')) {
+        const testIdValue = rawSelector.substring(7);
+        const testIdAttr = context.testIdAttribute || 'data-testid';
+        return `[${testIdAttr}="${testIdValue}"]`;
+    }
+    return rawSelector;
+}

package/dist/core/blocks/playwright.d.ts

@@ -1,2 +1,13 @@
-import { BlockDefinition } from '../types';
-export declare const playwrightBlocks: BlockDefinition[];
+/**
+ * Playwright blocks - Re-export from modular structure
+ *
+ * This file re-exports all Playwright blocks from the playwright/ directory
+ * for backwards compatibility. The blocks are now organized in:
+ * - playwright/navigation.ts - Navigate, wait, screenshot
+ * - playwright/interactions.ts - Click, fill, type, select, checkbox, hover
+ * - playwright/retrieval.ts - Get text, attributes, values, title, URL
+ * - playwright/assertions.ts - Visibility, text, value assertions
+ * - playwright/utils.ts - Shared utilities (resolveVariables, resolveSelector)
+ * - playwright/types.ts - TypeScript interfaces
+ */
+export { playwrightBlocks } from './playwright/index';