assure-testing 1.0.0 → 1.0.1

package/README.md

@@ -2,6 +2,8 @@
 
 **Assure** is a custom testing language (DSL) built from scratch with a unique browser automation engine using Chrome DevTools Protocol (CDP).
 
+📚 **[Complete Tutorial →](TUTORIAL.md)** | 🚀 **[Quick Start Guide →](QUICK_START.md)** | 🌐 **[Documentation Site →](https://upendra-manike.github.io/assure/)** | 📦 [npm](https://www.npmjs.com/package/assure-testing) | 🐙 [GitHub](https://github.com/upendra-manike/assure)
+
 ## ✨ Features
 
 - 🎯 **Custom Syntax** - Human-readable test commands
@@ -48,7 +50,7 @@ npm install --save-dev assure-testing
 ### Install from source
 
 ```bash
-git clone https://github.com/yourusername/assure.git
+git clone https://github.com/upendra-manike/assure.git
 cd assure
 npm install
 npm run build
@@ -230,6 +232,9 @@ session = await createBrowser(false); // visible browser
 | `EXPECT URL` | Assert URL | `EXPECT URL CONTAINS "/home"` |
 | `EXPECT TEXT` | Assert text | `EXPECT TEXT "#el" CONTAINS "text"` |
 | `EXPECT VISIBLE` | Assert visibility | `EXPECT VISIBLE "#modal"` |
+| `OTP MANUAL` | Enter OTP manually | `OTP MANUAL "123456" "#otp-input"` |
+| `OTP FROM FILE` | Read OTP from file | `OTP FROM FILE "otp.txt" "#otp-input"` |
+| `OTP FROM CLIPBOARD` | Read OTP from clipboard | `OTP FROM CLIPBOARD "#otp-input"` |
 | `TEST` | Test label | `TEST "My Test"` |
 
 ## 🚧 Future Enhancements

package/dist/commands/open.js

@@ -1,11 +1,13 @@
 /**
- * OPEN command - Navigates to a URL
+ * OPEN command - Navigates to a URL (enhanced for dynamic pages)
  */
-import { navigate } from '../engine/browser.js';
+import { navigate, waitForNetworkIdle } from '../engine/browser.js';
 export async function executeOpen(session, args) {
     if (args.length === 0) {
         throw new Error('OPEN command requires a URL argument');
     }
     const url = args[0];
     await navigate(session, url);
+    // Wait for network to be idle (handles dynamic content loading)
+    await waitForNetworkIdle(session);
 }

package/dist/commands/otp.js

@@ -0,0 +1,185 @@
+/**
+ * OTP command - Handles One-Time Password validation
+ * Supports reading OTP from email, SMS, clipboard, or manual input
+ */
+import { typeText, waitForElementVisible } from '../engine/browser.js';
+import { readFileSync } from 'fs';
+/**
+ * Extract OTP from text (common patterns)
+ */
+function extractOTP(text) {
+    // Common OTP patterns
+    const patterns = [
+        /\b\d{4}\b/, // 4 digits
+        /\b\d{6}\b/, // 6 digits
+        /\b\d{8}\b/, // 8 digits
+        /code[:\s]+(\d{4,8})/i, // "code: 123456"
+        /otp[:\s]+(\d{4,8})/i, // "otp: 123456"
+        /verification[:\s]+(\d{4,8})/i, // "verification: 123456"
+        /(\d{4,8})/g, // Any 4-8 digit number
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match) {
+            // Return the first match, prefer longer matches
+            const matches = text.match(/\d{4,8}/g);
+            if (matches && matches.length > 0) {
+                // Return the longest match (most likely to be OTP)
+                return matches.sort((a, b) => b.length - a.length)[0];
+            }
+            return match[1] || match[0];
+        }
+    }
+    return null;
+}
+/**
+ * Read OTP from email (simulated - in real scenario, would connect to email service)
+ */
+async function readOTPFromEmail(emailService) {
+    // In a real implementation, this would:
+    // 1. Connect to email service (Gmail API, IMAP, etc.)
+    // 2. Fetch latest email
+    // 3. Extract OTP from email body
+    // 4. Return OTP
+    // For now, return null - user should provide OTP manually or via file
+    console.log('⚠️  Email OTP reading requires email service integration');
+    console.log('   Please use OTP FROM FILE or OTP MANUAL instead');
+    return null;
+}
+/**
+ * Read OTP from SMS (simulated - in real scenario, would connect to SMS service)
+ */
+async function readOTPFromSMS(phoneNumber) {
+    // In a real implementation, this would:
+    // 1. Connect to SMS service (Twilio, AWS SNS, etc.)
+    // 2. Fetch latest SMS
+    // 3. Extract OTP from SMS body
+    // 4. Return OTP
+    console.log('⚠️  SMS OTP reading requires SMS service integration');
+    console.log('   Please use OTP FROM FILE or OTP MANUAL instead');
+    return null;
+}
+/**
+ * Read OTP from clipboard
+ */
+async function readOTPFromClipboard() {
+    try {
+        // Try to read from clipboard using system command
+        const { execSync } = require('child_process');
+        const platform = process.platform;
+        let clipboardContent = '';
+        if (platform === 'darwin') {
+            // macOS
+            clipboardContent = execSync('pbpaste', { encoding: 'utf-8' });
+        }
+        else if (platform === 'linux') {
+            // Linux (requires xclip or xsel)
+            try {
+                clipboardContent = execSync('xclip -selection clipboard -o', { encoding: 'utf-8' });
+            }
+            catch {
+                clipboardContent = execSync('xsel --clipboard --output', { encoding: 'utf-8' });
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows
+            clipboardContent = execSync('powershell -command "Get-Clipboard"', { encoding: 'utf-8' });
+        }
+        if (clipboardContent) {
+            const otp = extractOTP(clipboardContent.trim());
+            if (otp) {
+                return otp;
+            }
+        }
+    }
+    catch (error) {
+        // Clipboard reading failed
+    }
+    return null;
+}
+/**
+ * Read OTP from file
+ */
+function readOTPFromFile(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const otp = extractOTP(content.trim());
+        return otp;
+    }
+    catch (error) {
+        throw new Error(`Failed to read OTP from file: ${filePath}`);
+    }
+}
+/**
+ * Execute OTP command
+ */
+export async function executeOTP(session, args) {
+    if (args.length < 2) {
+        throw new Error('OTP command requires: OTP FROM <source> [selector] or OTP MANUAL <code> [selector]');
+    }
+    const action = args[0].toUpperCase();
+    const source = args[1];
+    const selector = args.length > 2 ? args[2] : 'input[type="text"]'; // Default OTP input selector
+    let otpCode = null;
+    // Wait for OTP input field to be ready
+    await waitForElementVisible(session, selector);
+    if (action === 'FROM') {
+        const sourceType = source.toUpperCase();
+        switch (sourceType) {
+            case 'EMAIL':
+                otpCode = await readOTPFromEmail();
+                if (!otpCode) {
+                    throw new Error('Could not read OTP from email. Use OTP FROM FILE or OTP MANUAL instead.');
+                }
+                break;
+            case 'SMS':
+                otpCode = await readOTPFromSMS();
+                if (!otpCode) {
+                    throw new Error('Could not read OTP from SMS. Use OTP FROM FILE or OTP MANUAL instead.');
+                }
+                break;
+            case 'CLIPBOARD':
+                otpCode = await readOTPFromClipboard();
+                if (!otpCode) {
+                    throw new Error('Could not read OTP from clipboard. Make sure OTP is copied to clipboard.');
+                }
+                console.log(`✓ OTP read from clipboard: ${otpCode}`);
+                break;
+            case 'FILE':
+                if (args.length < 3) {
+                    throw new Error('OTP FROM FILE requires a file path');
+                }
+                const filePath = args[2];
+                const selectorForFile = args.length > 3 ? args[3] : selector;
+                otpCode = readOTPFromFile(filePath);
+                if (!otpCode) {
+                    throw new Error(`Could not extract OTP from file: ${filePath}`);
+                }
+                console.log(`✓ OTP read from file: ${otpCode}`);
+                await typeText(session, selectorForFile, otpCode);
+                return;
+            default:
+                throw new Error(`Unknown OTP source: ${source}. Use EMAIL, SMS, CLIPBOARD, or FILE`);
+        }
+    }
+    else if (action === 'MANUAL') {
+        // OTP MANUAL <code> [selector]
+        otpCode = args[1];
+        const manualSelector = args.length > 2 ? args[2] : selector;
+        if (!otpCode || !/^\d{4,8}$/.test(otpCode)) {
+            throw new Error(`Invalid OTP code: ${otpCode}. OTP should be 4-8 digits`);
+        }
+        console.log(`✓ Using manual OTP: ${otpCode}`);
+        await typeText(session, manualSelector, otpCode);
+        return;
+    }
+    else {
+        throw new Error(`Unknown OTP action: ${action}. Use FROM or MANUAL`);
+    }
+    if (!otpCode) {
+        throw new Error('Failed to get OTP code');
+    }
+    // Type OTP into the input field
+    await typeText(session, selector, otpCode);
+    console.log(`✓ OTP entered: ${otpCode}`);
+}

package/dist/commands/wait-for.js

@@ -0,0 +1,40 @@
+/**
+ * WAIT FOR command - Wait for dynamic elements and conditions
+ */
+import { waitForElementVisible, waitForText, waitForUrl, waitForNetworkIdle } from '../engine/browser.js';
+export async function executeWaitFor(session, args) {
+    if (args.length < 2) {
+        throw new Error('WAIT FOR command requires a condition and value');
+    }
+    const condition = args[0].toUpperCase();
+    const value = args[1];
+    switch (condition) {
+        case 'ELEMENT':
+            // WAIT FOR ELEMENT selector
+            if (args.length < 2) {
+                throw new Error('WAIT FOR ELEMENT requires a selector');
+            }
+            const selector = args[1];
+            await waitForElementVisible(session, selector);
+            break;
+        case 'TEXT':
+            // WAIT FOR TEXT selector "text"
+            if (args.length < 3) {
+                throw new Error('WAIT FOR TEXT requires a selector and text');
+            }
+            const textSelector = args[1];
+            const textToWait = args.slice(2).join(' ');
+            await waitForText(session, textSelector, textToWait);
+            break;
+        case 'URL':
+            // WAIT FOR URL "url"
+            await waitForUrl(session, value);
+            break;
+        case 'NETWORK':
+            // WAIT FOR NETWORK IDLE
+            await waitForNetworkIdle(session);
+            break;
+        default:
+            throw new Error(`Unknown WAIT FOR condition: ${condition}`);
+    }
+}

package/dist/engine/browser.js

@@ -143,16 +143,20 @@ export async function getUrl(session) {
     return result.result.value;
 }
 /**
- * Wait for element to be available
+ * Wait for element to be available (enhanced for dynamic elements)
  */
-export async function waitForSelector(session, selector, timeout = 5000) {
+export async function waitForSelector(session, selector, timeout = 10000) {
     const startTime = Date.now();
     const checkInterval = 100;
     while (Date.now() - startTime < timeout) {
         try {
             const nodeId = await querySelector(session, selector);
             if (nodeId !== null) {
-                return nodeId;
+                // Also check if element is visible and in viewport
+                const isVisible = await checkElementVisible(session, nodeId);
+                if (isVisible) {
+                    return nodeId;
+                }
             }
         }
         catch (error) {
@@ -160,7 +164,170 @@ export async function waitForSelector(session, selector, timeout = 5000) {
         }
         await setTimeout(checkInterval);
     }
-    throw new Error(`Element "${selector}" not found within ${timeout}ms`);
+    throw new Error(`Element "${selector}" not found or not visible within ${timeout}ms`);
+}
+/**
+ * Wait for element to be visible and clickable
+ */
+export async function waitForElementVisible(session, selector, timeout = 10000) {
+    const startTime = Date.now();
+    const checkInterval = 100;
+    while (Date.now() - startTime < timeout) {
+        try {
+            const nodeId = await querySelector(session, selector);
+            if (nodeId !== null) {
+                const visible = await checkElementVisible(session, nodeId);
+                const clickable = await checkElementClickable(session, nodeId);
+                if (visible && clickable) {
+                    return nodeId;
+                }
+            }
+        }
+        catch (error) {
+            // Continue waiting
+        }
+        await setTimeout(checkInterval);
+    }
+    throw new Error(`Element "${selector}" not visible or clickable within ${timeout}ms`);
+}
+/**
+ * Check if element is visible in viewport
+ */
+async function checkElementVisible(session, nodeId) {
+    try {
+        const result = await session.DOM.resolveNode({ nodeId });
+        if (!result.object.objectId)
+            return false;
+        const visibilityResult = await session.Runtime.callFunctionOn({
+            objectId: result.object.objectId,
+            functionDeclaration: `
+        function() {
+          const rect = this.getBoundingClientRect();
+          const style = window.getComputedStyle(this);
+          return (
+            style.display !== 'none' &&
+            style.visibility !== 'hidden' &&
+            style.opacity !== '0' &&
+            rect.width > 0 &&
+            rect.height > 0 &&
+            rect.top >= 0 &&
+            rect.left >= 0 &&
+            rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
+            rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+          );
+        }
+      `,
+            returnByValue: true
+        });
+        return visibilityResult.result.value === true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Check if element is clickable (not disabled, not covered)
+ */
+async function checkElementClickable(session, nodeId) {
+    try {
+        const result = await session.DOM.resolveNode({ nodeId });
+        if (!result.object.objectId)
+            return false;
+        const clickableResult = await session.Runtime.callFunctionOn({
+            objectId: result.object.objectId,
+            functionDeclaration: `
+        function() {
+          if (this.disabled) return false;
+          if (this.getAttribute('aria-disabled') === 'true') return false;
+          
+          // Check if element is covered by another element
+          const rect = this.getBoundingClientRect();
+          const centerX = rect.left + rect.width / 2;
+          const centerY = rect.top + rect.height / 2;
+          const topElement = document.elementFromPoint(centerX, centerY);
+          
+          return topElement === this || this.contains(topElement);
+        }
+      `,
+            returnByValue: true
+        });
+        return clickableResult.result.value === true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Wait for text to appear in element
+ */
+export async function waitForText(session, selector, text, timeout = 10000) {
+    const startTime = Date.now();
+    const checkInterval = 200;
+    while (Date.now() - startTime < timeout) {
+        try {
+            const elementText = await getTextContent(session, selector);
+            if (elementText.includes(text)) {
+                return;
+            }
+        }
+        catch (error) {
+            // Continue waiting
+        }
+        await setTimeout(checkInterval);
+    }
+    throw new Error(`Text "${text}" not found in element "${selector}" within ${timeout}ms`);
+}
+/**
+ * Wait for URL to change or contain specific text
+ */
+export async function waitForUrl(session, expectedUrl, timeout = 10000) {
+    const startTime = Date.now();
+    const checkInterval = 200;
+    while (Date.now() - startTime < timeout) {
+        try {
+            const currentUrl = await getUrl(session);
+            if (currentUrl.includes(expectedUrl)) {
+                return;
+            }
+        }
+        catch (error) {
+            // Continue waiting
+        }
+        await setTimeout(checkInterval);
+    }
+    throw new Error(`URL did not contain "${expectedUrl}" within ${timeout}ms`);
+}
+/**
+ * Wait for network to be idle (no pending requests)
+ */
+export async function waitForNetworkIdle(session, timeout = 5000) {
+    // Wait a bit for any pending requests
+    await setTimeout(500);
+    // Check if there are active network requests
+    const startTime = Date.now();
+    const checkInterval = 100;
+    while (Date.now() - startTime < timeout) {
+        try {
+            const result = await session.Runtime.evaluate({
+                expression: `
+          (function() {
+            if (typeof window.fetch === 'undefined') return true;
+            // Simple check - in real implementation, track fetch/XHR requests
+            return document.readyState === 'complete';
+          })()
+        `,
+                returnByValue: true
+            });
+            if (result.result.value === true) {
+                await setTimeout(500); // Wait a bit more to ensure stability
+                return;
+            }
+        }
+        catch (error) {
+            // Continue waiting
+        }
+        await setTimeout(checkInterval);
+    }
 }
 /**
  * Query selector and return nodeId
@@ -174,10 +341,11 @@ export async function querySelector(session, selector) {
     return nodeId;
 }
 /**
- * Click an element
+ * Click an element (enhanced for dynamic elements)
  */
 export async function clickElement(session, selector) {
-    const nodeId = await waitForSelector(session, selector);
+    // Wait for element to be visible and clickable (handles dynamic elements)
+    const nodeId = await waitForElementVisible(session, selector);
     // Get bounding box
     const boxModel = await session.DOM.getBoxModel({ nodeId });
     if (!boxModel.model) {
@@ -205,10 +373,11 @@ export async function clickElement(session, selector) {
     await setTimeout(100);
 }
 /**
- * Type text into an input field
+ * Type text into an input field (enhanced for dynamic elements)
  */
 export async function typeText(session, selector, text) {
-    const nodeId = await waitForSelector(session, selector);
+    // Wait for element to be visible and ready (handles dynamic elements)
+    const nodeId = await waitForElementVisible(session, selector);
     // Focus the element
     await session.DOM.focus({ nodeId });
     // Clear existing value using nodeId
@@ -229,9 +398,10 @@ export async function typeText(session, selector, text) {
     }
 }
 /**
- * Get text content of an element
+ * Get text content of an element (enhanced for dynamic elements)
  */
 export async function getTextContent(session, selector) {
+    // Wait for element to be available (handles dynamic elements)
     const nodeId = await waitForSelector(session, selector);
     const result = await session.DOM.resolveNode({ nodeId });
     if (result.object.objectId) {

package/dist/engine/executor.js

@@ -5,6 +5,8 @@ import { executeOpen } from '../commands/open.js';
 import { executeClick } from '../commands/click.js';
 import { executeType } from '../commands/type.js';
 import { executeExpect } from '../commands/expect.js';
+import { executeWaitFor } from '../commands/wait-for.js';
+import { executeOTP } from '../commands/otp.js';
 import { wait } from './browser.js';
 export async function execute(commands, session) {
     for (const cmd of commands) {
@@ -24,17 +26,29 @@ export async function execute(commands, session) {
                     console.log(`✓ Line ${lineNumber}: TYPE "${args[0]}" "${args.slice(1).join(' ')}"`);
                     break;
                 case 'WAIT':
-                    const seconds = Number(args[0]);
-                    if (isNaN(seconds)) {
-                        throw new Error(`WAIT command requires a valid number, got: ${args[0]}`);
+                    // Check if it's WAIT FOR (dynamic element waiting)
+                    if (args.length > 0 && args[0].toUpperCase() === 'FOR') {
+                        await executeWaitFor(session, args.slice(1));
+                        console.log(`✓ Line ${lineNumber}: WAIT FOR ${args.slice(1).join(' ')}`);
+                    }
+                    else {
+                        // Regular WAIT command
+                        const seconds = Number(args[0]);
+                        if (isNaN(seconds)) {
+                            throw new Error(`WAIT command requires a valid number, got: ${args[0]}`);
+                        }
+                        await wait(seconds);
+                        console.log(`✓ Line ${lineNumber}: WAIT ${seconds}`);
                     }
-                    await wait(seconds);
-                    console.log(`✓ Line ${lineNumber}: WAIT ${seconds}`);
                     break;
                 case 'EXPECT':
                     await executeExpect(session, args);
                     console.log(`✓ Line ${lineNumber}: EXPECT ${args.join(' ')}`);
                     break;
+                case 'OTP':
+                    await executeOTP(session, args);
+                    console.log(`✓ Line ${lineNumber}: OTP ${args.join(' ')}`);
+                    break;
                 case 'TEST':
                     // TEST is just a label, skip execution
                     console.log(`\n🧪 ${args.join(' ')}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assure-testing",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Assure - A custom testing language (DSL) for browser automation. Test files use .assure extension.",
   "type": "module",
   "main": "dist/runner.js",
@@ -36,12 +36,12 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourusername/assure.git"
+    "url": "https://github.com/upendra-manike/assure.git"
   },
   "bugs": {
-    "url": "https://github.com/yourusername/assure/issues"
+    "url": "https://github.com/upendra-manike/assure/issues"
   },
-  "homepage": "https://github.com/yourusername/assure#readme",
+  "homepage": "https://github.com/upendra-manike/assure#readme",
   "engines": {
     "node": ">=18.0.0"
   },
@@ -54,4 +54,3 @@
     "typescript": "^5.3.0"
   }
 }
-