testdriverai 7.2.9 → 7.2.10

package/tests/table-sort-enrollments.test.mjs

@@ -0,0 +1,72 @@
+/**
+ * Test case 7: Sort by Enrollments (ascending, numeric)
+ * 
+ * 1. Open page: https://practicetestautomation.com/practice-test-table/
+ * 2. Set Sort by = Enrollments
+ * 3. Verify visible rows are ordered from smallest to largest enrollment
+ * 4. Verify numbers with commas sort correctly
+ * 5. Fails if the sort is lexicographic (string-based) instead of numeric
+ * 
+ * EXPECTED: This test should PASS if enrollments are sorted ascending numerically
+ *           This test should FAIL if sort is lexicographic or descending
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+
+describe("Table Sort - Enrollments", () => {
+
+  it("should sort enrollments numerically ascending", async (context) => {
+    const testdriver = TestDriver(context, { 
+      newSandbox: true, 
+      headless: false 
+    });
+    
+    // Step 1: Open the page
+    await testdriver.provision.chrome({
+      url: 'https://practicetestautomation.com/practice-test-table/',
+    });
+
+    // Scroll down to see the Sort by dropdown
+    await testdriver.scroll("down");
+    await testdriver.scroll("down");
+    
+    // Step 2: Find and click the Sort by dropdown
+    const sortDropdown = await testdriver.find("Sort by dropdown", { timeout: 15000 });
+    console.log("Sort by dropdown found:", sortDropdown.found());
+    expect(sortDropdown.found()).toBeTruthy();
+    await sortDropdown.click();
+    
+    // Select "Enrollments" from the dropdown options
+    const enrollmentsOption = await testdriver.find("Enrollments option", { timeout: 10000 });
+    console.log("Enrollments option found:", enrollmentsOption.found());
+    expect(enrollmentsOption.found()).toBeTruthy();
+    await enrollmentsOption.click();
+    
+    // Scroll to the TOP of the page to see the first rows of the sorted table
+    await testdriver.scroll("up");
+    await testdriver.scroll("up");
+    await testdriver.scroll("up");
+    
+    // Small wait for sort to complete
+    await testdriver.pressKeys([""]); // No-op to add small delay
+    
+    // Scroll down just enough to see the table header and first data rows
+    await testdriver.scroll("down");
+    
+    // Step 3: Verify the sort is NUMERIC ASCENDING (smallest to largest)
+    // For numeric ascending: 10 < 11 < 50 < 1000 < 1200 < 1365
+    // If lexicographic: "1,000" < "10" < "11" < "1,200" < "1365" < "50" (wrong - strings compare char by char)
+    // 
+    // The TEST PASSES if first rows show small numbers like 10, 11, 50
+    // The TEST FAILS if first rows show large numbers like 1000, 1200, 1365
+    const sortResult = await testdriver.assert(
+      "The table is sorted by Enrollments in ASCENDING numeric order. " +
+      "The FIRST visible enrollment numbers in the table should be the SMALLEST values. " +
+      "For example, if the data contains values like 10, 11, 50, 1000, and 1365, " +
+      "then 10 or 11 should appear at the TOP of the sorted table. " +
+      "If a large number like 1365 appears first, the sort is WRONG (descending or lexicographic)."
+    );
+    console.log("Numeric ascending sort assertion result:", sortResult);
+    expect(sortResult).toBeTruthy();
+  });
+});

package/tests/table-sort-experiment.test.mjs

@@ -0,0 +1,42 @@
+/**
+ * Experiment file - reconnects to existing sandbox
+ * Test case 7: Sort by Enrollments (ascending, numeric)
+ * Run AFTER table-sort-setup.test.mjs passes (within 2 minutes)
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+
+describe("Table Sort Experiment", () => {
+
+  it("should sort by Enrollments and verify numeric ordering", async (context) => {
+    const testdriver = TestDriver(context, { 
+      newSandbox: true, 
+      headless: false,
+      reconnect: true  // Reconnects to last sandbox
+    });
+    
+    // NO provision here! The sandbox is already running from setup.test.mjs
+    
+    // Click on the Sort By dropdown and select Enrollments
+    const sortDropdown = await testdriver.find("Sort By dropdown");
+    console.log("Sort dropdown found:", sortDropdown.found());
+    await sortDropdown.click();
+    
+    // Select Enrollments from the dropdown
+    const enrollmentsOption = await testdriver.find("Enrollments option in dropdown");
+    console.log("Enrollments option found:", enrollmentsOption.found());
+    await enrollmentsOption.click();
+    
+    // Verify the table is now sorted by enrollments (ascending, numeric)
+    // The numbers should be ordered from smallest to largest: 10, 11, 50, 1000, 1,200
+    // If lexicographic: 1,000, 1,200, 10, 11, 50 (wrong - strings sort by first character)
+    const result = await testdriver.assert("The table shows enrollment numbers in ascending numeric order where smaller numbers like 10 or 11 appear before larger numbers like 1000 or 1200");
+    console.log("Sort assertion result:", result);
+    expect(result).toBeTruthy();
+    
+    // Also verify numbers with commas sort correctly (1,200 should be after 1,000)
+    const commaResult = await testdriver.assert("Numbers with commas like 1,000 and 1,200 are sorted correctly as numbers, not as text");
+    console.log("Comma sort assertion:", commaResult);
+    expect(commaResult).toBeTruthy();
+  });
+});

package/tests/table-sort-setup.test.mjs

@@ -0,0 +1,59 @@
+/**
+ * Test case 7: Sort by Enrollments (ascending, numeric)
+ * 
+ * 1. Open page: https://practicetestautomation.com/practice-test-table/
+ * 2. Set Sort by = Enrollments
+ * 3. Verify visible rows are ordered from smallest to largest enrollment
+ * 4. Verify numbers with commas sort correctly
+ * 5. Fails if the sort is lexicographic
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+
+describe("Table Sort - Enrollments", () => {
+
+  it("should sort enrollments numerically ascending", async (context) => {
+    const testdriver = TestDriver(context, { 
+      newSandbox: true, 
+      headless: false 
+    });
+    
+    // Step 1: Open the page
+    await testdriver.provision.chrome({
+      url: 'https://practicetestautomation.com/practice-test-table/',
+    });
+
+    // Wait for page to load - find the Sort By dropdown
+    const sortDropdown = await testdriver.find("Sort By dropdown or select box", { timeout: 30000 });
+    console.log("Sort dropdown found:", sortDropdown.found());
+    expect(sortDropdown.found()).toBeTruthy();
+    
+    // Step 2: Click the Sort By dropdown
+    await sortDropdown.click();
+    
+    // Select "Enrollments" from the dropdown options
+    const enrollmentsOption = await testdriver.find("Enrollments option in the dropdown list", { timeout: 10000 });
+    console.log("Enrollments option found:", enrollmentsOption.found());
+    await enrollmentsOption.click();
+    
+    // Step 3 & 4: Verify the sort is numeric ascending (not lexicographic)
+    // If numeric: smaller numbers (10, 11, 50) come before larger numbers (1000, 1200)
+    // If lexicographic: would sort as strings (1,000 before 10 because '1' < '1')
+    const sortResult = await testdriver.assert(
+      "The table enrollment column is sorted in ascending NUMERIC order: " +
+      "smaller enrollment numbers like 10, 11, 50 appear BEFORE larger numbers like 1000 or 1200. " +
+      "This is correct numeric sorting, not alphabetical/lexicographic sorting."
+    );
+    console.log("Numeric sort assertion result:", sortResult);
+    expect(sortResult).toBeTruthy();
+    
+    // Step 5: Verify numbers with commas are handled correctly
+    // 1,200 should be treated as 1200 (greater than 1000), not as a string
+    const commaResult = await testdriver.assert(
+      "Any enrollment numbers with commas (like 1,200 or 1,000) are sorted correctly as numbers, " +
+      "with 1,000 appearing before 1,200 in ascending order"
+    );
+    console.log("Comma number sorting result:", commaResult);
+    expect(commaResult).toBeTruthy();
+  });
+});

package/vitest.config.mjs

@@ -11,6 +11,7 @@ export default defineConfig({
     testTimeout: 900000,
     hookTimeout: 900000,
     disableConsoleIntercept: true,
+    maxConcurrency: 3,
     reporters: [
       'default',
       TestDriver(),

package/docs/v7/api/assertions.mdx

@@ -1,403 +0,0 @@
----
-title: "Assertions & Testing"
-sidebarTitle: "Assertions"
-description: "AI-powered assertions and validation"
-icon: "check-circle"
----
-
-## Overview
-
-TestDriver provides AI-powered assertions that can verify complex visual states and conditions on screen without requiring explicit element locators or coordinates.
-
-## AI Assertions
-
-### assert()
-
-Make an AI-powered assertion about the current screen state.
-
-```javascript
-await testdriver.assert(assertion)
-```
-
-**Parameters:**
-- `assertion` (string) - Natural language description of what should be true
-
-**Returns:** `Promise<boolean>` - `true` if assertion passes, throws error if fails
-
-### Basic Assertions
-
-```javascript
-// Verify page elements
-await testdriver.assert('the login page is displayed');
-await testdriver.assert('submit button is visible');
-await testdriver.assert('error message is shown');
-
-// Verify text content
-await testdriver.assert('the page title is "Welcome"');
-await testdriver.assert('username field contains "john.doe"');
-await testdriver.assert('success message says "Account created"');
-
-// Verify states
-await testdriver.assert('the form is empty');
-await testdriver.assert('the checkbox is checked');
-await testdriver.assert('the dropdown shows "United States"');
-
-// Verify visual appearance
-await testdriver.assert('the button is blue');
-await testdriver.assert('the loading spinner is displayed');
-await testdriver.assert('the modal dialog is open');
-```
-
-## Pattern: Polling Assertions
-
-For conditions that may take time to become true, use polling:
-
-```javascript
-// Poll until condition is true
-async function waitForAssertion(testdriver, assertion, timeout = 30000) {
-  const startTime = Date.now();
-  
-  while (Date.now() - startTime < timeout) {
-    try {
-      await testdriver.assert(assertion);
-      return true; // Assertion passed
-    } catch (error) {
-      // Assertion failed, wait and retry
-      await new Promise(resolve => setTimeout(resolve, 1000));
-    }
-  }
-  
-  throw new Error(`Assertion timeout: "${assertion}"`);
-}
-
-// Usage
-await waitForAssertion(testdriver, 'the page has finished loading', 30000);
-await waitForAssertion(testdriver, 'results are displayed', 10000);
-```
-
-## Extracting Information
-
-### extract()
-
-Extract information from the screen using AI.
-
-```javascript
-await testdriver.extract(description)
-```
-
-**Parameters:**
-- `description` (string) - What information to extract from the screen
-
-**Returns:** `Promise<string>` - Extracted information
-
-### Examples
-
-```javascript
-// Extract text from screen
-const password = await testdriver.extract('the password displayed on screen');
-const total = await testdriver.extract('the order total amount');
-const errorMessage = await testdriver.extract('the error message text');
-
-// Extract structured data
-const email = await testdriver.extract('the email address in the confirmation');
-const orderId = await testdriver.extract('the order ID number');
-const phoneNumber = await testdriver.extract('the phone number');
-
-// Use extracted data
-const password = await testdriver.extract('the password for standard_user');
-const passwordField = await testdriver.find('password input');
-await passwordField.click();
-await testdriver.type(password);
-```
-
-### Use Cases
-
-**Dynamic Content:**
-```javascript
-// Extract generated values
-const confirmationCode = await testdriver.extract('the 6-digit confirmation code');
-console.log('Code:', confirmationCode);
-
-// Use it later in the test
-await testdriver.type(confirmationCode);
-```
-
-**Verification:**
-```javascript
-// Extract and verify
-const displayedTotal = await testdriver.extract('the cart total');
-const expectedTotal = '$99.99';
-
-expect(displayedTotal).toBe(expectedTotal);
-```
-
-**Conditional Logic:**
-```javascript
-// Extract state and make decisions
-const status = await testdriver.extract('the order status');
-
-if (status.includes('Pending')) {
-  // Wait for processing
-  await new Promise(resolve => setTimeout(resolve, 5000));
-} else if (status.includes('Completed')) {
-  // Continue with test
-  const downloadButton = await testdriver.find('download receipt button');
-  await downloadButton.click();
-}
-```
-
-## Testing Patterns
-
-### Test-Driven Assertions
-
-Structure tests with clear arrange-act-assert pattern:
-
-```javascript
-it('should display validation error for empty email', async () => {
-  // Arrange
-  await testdriver.focusApplication('Google Chrome');
-  
-  // Act
-  const submitButton = await testdriver.find('submit button');
-  await submitButton.click();
-  
-  // Assert
-  const result = await testdriver.assert('validation error says "Email is required"');
-  expect(result).toBeTruthy();
-});
-```
-
-### Multi-Step Assertions
-
-Verify state at each step of a workflow:
-
-```javascript
-it('should complete checkout flow', async () => {
-  // Add item to cart
-  const addButton = await testdriver.find('add to cart button');
-  await addButton.click();
-  
-  // Verify item added
-  await testdriver.assert('cart shows 1 item');
-  
-  // Go to checkout
-  const cartIcon = await testdriver.find('cart icon');
-  await cartIcon.click();
-  
-  // Verify cart page
-  await testdriver.assert('shopping cart page is displayed');
-  await testdriver.assert('cart contains the selected item');
-  
-  // Proceed to checkout
-  const checkoutButton = await testdriver.find('proceed to checkout button');
-  await checkoutButton.click();
-  
-  // Verify checkout page
-  await testdriver.assert('checkout form is displayed');
-});
-```
-
-### Soft Assertions
-
-Collect multiple assertion failures without stopping:
-
-```javascript
-it('should validate all form fields', async () => {
-  const errors = [];
-  
-  // Try multiple assertions
-  try {
-    await testdriver.assert('username field has error border');
-  } catch (e) {
-    errors.push('Username validation failed');
-  }
-  
-  try {
-    await testdriver.assert('email field has error border');
-  } catch (e) {
-    errors.push('Email validation failed');
-  }
-  
-  try {
-    await testdriver.assert('password field has error border');
-  } catch (e) {
-    errors.push('Password validation failed');
-  }
-  
-  // Report all errors
-  if (errors.length > 0) {
-    throw new Error(`Validation errors:\n${errors.join('\n')}`);
-  }
-});
-```
-
-## Complete Example
-
-```javascript
-import { beforeAll, afterAll, describe, it, expect } from 'vitest';
-import TestDriver from 'testdriverai';
-
-describe('E2E Shopping Flow', () => {
-  let testdriver;
-
-  beforeAll(async () => {
-    client = new TestDriver(process.env.TD_API_KEY);
-    await testdriver.auth();
-    await testdriver.connect({ newSandbox: true });
-  });
-
-  afterAll(async () => {
-    await testdriver.disconnect();
-  });
-
-  it('should complete a purchase', async () => {
-    await testdriver.focusApplication('Google Chrome');
-    
-    // Verify initial state
-    await testdriver.assert('the product listing page is displayed');
-    await testdriver.assert('cart is empty');
-    
-    // Add product to cart
-    const addButton = await testdriver.find('add to cart button for first product');
-    await addButton.click();
-    
-    // Verify cart updated
-    await testdriver.assert('cart badge shows 1 item');
-    
-    // Extract product details
-    const productName = await testdriver.extract('the name of the product just added');
-    const price = await testdriver.extract('the price of the product');
-    
-    console.log(`Added ${productName} at ${price}`);
-    
-    // Go to cart
-    const cartIcon = await testdriver.find('shopping cart icon');
-    await cartIcon.click();
-    
-    // Verify cart contents
-    await testdriver.assert(`cart contains ${productName}`);
-    await testdriver.assert(`cart total is ${price}`);
-    
-    // Proceed to checkout
-    const checkoutButton = await testdriver.find('checkout button');
-    await checkoutButton.click();
-    
-    // Fill shipping info
-    const emailField = await testdriver.find('email input');
-    await emailField.click();
-    await testdriver.type('test@example.com');
-    
-    await testdriver.pressKeys(['tab']);
-    await testdriver.type('John Doe');
-    
-    await testdriver.pressKeys(['tab']);
-    await testdriver.type('123 Main St');
-    
-    // Submit order
-    const submitButton = await testdriver.find('place order button');
-    await submitButton.click();
-    
-    // Verify success
-    await testdriver.assert('order confirmation page is displayed');
-    await testdriver.assert('success message is shown');
-    
-    // Extract order number
-    const orderNumber = await testdriver.extract('the order number');
-    console.log('Order placed:', orderNumber);
-    expect(orderNumber).toBeTruthy();
-  });
-
-  it('should show validation errors', async () => {
-    // Try to submit empty form
-    const submitButton = await testdriver.find('submit button');
-    await submitButton.click();
-    
-    // Verify multiple validation errors
-    await testdriver.assert('email field shows "required" error');
-    await testdriver.assert('name field shows "required" error');
-    await testdriver.assert('address field shows "required" error');
-    
-    // Verify form not submitted
-    await testdriver.assert('still on checkout page', false, false);
-    await testdriver.assert('order confirmation page is shown', false, true); // Inverted
-  });
-});
-```
-
-## Best Practices
-
-<AccordionGroup>
-  <Accordion title="Be specific in assertions">
-    More specific assertions are more reliable:
-    
-    ```javascript
-    // ❌ Too vague
-    await testdriver.assert('button is visible');
-    
-    // ✅ Specific
-    await testdriver.assert('blue submit button is visible below the form');
-    ```
-  </Accordion>
-  
-  <Accordion title="Assert state changes">
-    Verify state before and after actions:
-    
-    ```javascript
-    // Before
-    await testdriver.assert('cart is empty');
-    
-    // Action
-    const addButton = await testdriver.find('add to cart');
-    await addButton.click();
-    
-    // After
-    await testdriver.assert('cart contains 1 item');
-    ```
-  </Accordion>
-  
-  <Accordion title="Use polling for dynamic content">
-    Some assertions may need time to become true:
-    
-    ```javascript
-    async function waitFor(assertion, timeout = 10000) {
-      const start = Date.now();
-      while (Date.now() - start < timeout) {
-        try {
-          await testdriver.assert(assertion);
-          return;
-        } catch {
-          await new Promise(r => setTimeout(r, 1000));
-        }
-      }
-      throw new Error(`Timeout: ${assertion}`);
-    }
-    
-    await waitFor('loading complete');
-    ```
-  </Accordion>
-  
-  <Accordion title="Extract before comparing">
-    Use `extract()` to extract values for detailed comparisons:
-    
-    ```javascript
-    const actualTotal = await testdriver.extract('the cart total');
-    const expectedTotal = '$99.99';
-    
-    expect(actualTotal).toBe(expectedTotal);
-    ```
-  </Accordion>
-  
-  <Accordion title="Combine with traditional assertions">
-    Mix AI assertions with framework assertions for comprehensive testing:
-    
-    ```javascript
-    // AI assertion for UI state
-    await testdriver.assert('success message is displayed');
-    
-    // Extract and use traditional assertion for exact values
-    const message = await testdriver.extract('the success message text');
-    expect(message).toContain('successfully');
-    expect(message).toMatch(/order #\d+/i);
-    ```
-  </Accordion>
-</AccordionGroup>