testdriverai 7.2.2 → 7.2.9

package/test/testdriver/launch-vscode-linux.test.mjs

@@ -0,0 +1,55 @@
+/**
+ * TestDriver SDK - Launch VS Code on Linux Test (Vitest)
+ * Tests launching Visual Studio Code on Debian/Ubuntu using provision.vscode()
+ */
+
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../../lib/vitest/hooks.mjs";
+
+describe("Launch VS Code on Linux", () => {
+  it(
+    "should launch VS Code on Debian/Ubuntu",
+    async (context) => {
+      const testdriver = TestDriver(context, { newSandbox: true });
+      
+      // provision.vscode() automatically calls ready() and starts dashcam
+      await testdriver.provision.vscode();
+
+      // Assert that VS Code is running
+      const result = await testdriver.assert(
+        "Visual Studio Code window is visible on screen",
+      );
+      expect(result).toBeTruthy();
+    },
+  );
+
+  it(
+    "should install and use a VS Code extension",
+    async (context) => {
+      const testdriver = TestDriver(context, { newSandbox: true });
+      
+      // Launch VS Code with the Prettier extension installed
+      await testdriver.provision.vscode({
+        extensions: ["esbenp.prettier-vscode"],
+      });
+
+      // Assert that VS Code is running
+      const vsCodeVisible = await testdriver.assert(
+        "Visual Studio Code window is visible on screen",
+      );
+      expect(vsCodeVisible).toBeTruthy();
+
+      // Open the extensions panel to verify Prettier is installed
+      await testdriver.pressKeys(["ctrl", "shift", "x"]);
+      
+      // Wait for extensions panel to open
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+
+      // Assert that Prettier extension is visible in the installed extensions
+      const prettierVisible = await testdriver.assert(
+        "Prettier extension is visible in the extensions panel or sidebar",
+      );
+      expect(prettierVisible).toBeTruthy();
+    },
+  );
+});

package/test/testdriver/setup/testHelpers.mjs

@@ -6,7 +6,6 @@
 import crypto from "crypto";
 import { config } from "dotenv";
 import fs from "fs";
-import os from "os";
 import path, { dirname } from "path";
 import { fileURLToPath } from "url";
 import TestDriver from "../../../sdk.js";
@@ -51,85 +50,6 @@ console.log(
   process.env.TD_OS || "Not set (will default to linux)",
 );
 
-// Global test results storage
-const testResults = {
-  tests: [],
-  startTime: Date.now(),
-};
-
-/**
- * Store test result with dashcam URL
- * @param {string} testName - Name of the test
- * @param {string} testFile - Test file path
- * @param {string|null} dashcamUrl - Dashcam URL if available
- * @param {Object} sessionInfo - Session information
- */
-export function storeTestResult(
-  testName,
-  testFile,
-  dashcamUrl,
-  sessionInfo = {},
-) {
-
-  // Extract replay object ID from dashcam URL
-  let replayObjectId = null;
-  if (dashcamUrl) {
-    const replayIdMatch = dashcamUrl.match(/\/replay\/([^?]+)/);
-    replayObjectId = replayIdMatch ? replayIdMatch[1] : null;
-    if (replayObjectId) {
-      console.log(`   Replay Object ID: ${replayObjectId}`);
-    }
-  }
-
-  testResults.tests.push({
-    name: testName,
-    file: testFile,
-    dashcamUrl,
-    replayObjectId,
-    sessionId: sessionInfo.sessionId,
-    timestamp: new Date().toISOString(),
-  });
-}
-
-/**
- * Get all test results
- * @returns {Object} All collected test results
- */
-export function getTestResults() {
-  return {
-    ...testResults,
-    endTime: Date.now(),
-    duration: Date.now() - testResults.startTime,
-  };
-}
-
-/**
- * Save test results to a JSON file
- * @param {string} outputPath - Path to save the results
- */
-export function saveTestResults(outputPath = "test-results/sdk-summary.json") {
-  const results = getTestResults();
-  const dir = path.dirname(outputPath);
-
-  // Create directory if it doesn't exist
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  fs.writeFileSync(outputPath, JSON.stringify(results, null, 2));
-  console.log(`\n📊 Test results saved to: ${outputPath}`);
-
-  // Also print dashcam URLs to console
-  console.log("\n🎥 Dashcam URLs:");
-  results.tests.forEach((test) => {
-    if (test.dashcamUrl) {
-      console.log(`  ${test.name}: ${test.dashcamUrl}`);
-    }
-  });
-
-  return results;
-}
-
 /**
  * Intercept console logs and forward to TestDriver sandbox
  * @param {TestDriver} client - TestDriver client instance
@@ -494,21 +414,9 @@ export async function teardownTest(client, options = {}) {
       console.log("⏭️  Postrun skipped (disabled in options)");
     }
 
-    // Write test result to a file for the reporter to pick up (cross-process communication)
+    // Use Vitest's task.meta for cross-process communication with the reporter
     if (options.task) {
-      const testResultFile = path.join(
-        os.tmpdir(),
-        "testdriver-results",
-        `${options.task.id}.json`,
-      );
-
       try {
-        // Ensure directory exists
-        const dir = path.dirname(testResultFile);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
-        }
-
         // Get test file path - make it relative to project root
         const absolutePath =
           options.task.file?.filepath || options.task.file?.name || "unknown";
@@ -523,33 +431,15 @@ export async function teardownTest(client, options = {}) {
           testOrder = options.task.suite.tasks.indexOf(options.task);
         }
 
-        // Note: Duration is calculated by Vitest and passed via result.duration
-        // We include it in the test result file so the reporter can use it
-
-        // Get duration from Vitest result
-        const result = options.task.result?.();
-        const duration = result?.duration || 0;
-
-        // Write test result with dashcam URL, platform, and metadata
-        const testResult = {
-          testId: options.task.id,
-          testName: options.task.name,
-          testFile: testFile,
-          testOrder: testOrder,
-          dashcamUrl: dashcamUrl,
-          replayObjectId: dashcamUrl
-            ? dashcamUrl.match(/\/replay\/([^?]+)/)?.[1]
-            : null,
-          platform: client.os, // Include platform from SDK client (source of truth)
-          timestamp: Date.now(),
-          duration: duration, // Include duration from Vitest
-        };
-
-        fs.writeFileSync(testResultFile, JSON.stringify(testResult, null, 2));
-   
+        // Set metadata on task for the reporter to pick up
+        options.task.meta.dashcamUrl = dashcamUrl;
+        options.task.meta.platform = client.os; // Include platform from SDK client (source of truth)
+        options.task.meta.testFile = testFile;
+        options.task.meta.testOrder = testOrder;
+        options.task.meta.sessionId = client.getSessionId?.() || null;
       } catch (error) {
         console.error(
-          `[TestHelpers] ❌ Failed to write test result file:`,
+          `[TestHelpers] ❌ Failed to set test metadata:`,
           error.message,
         );
       }

package/tests/example.test.js

@@ -0,0 +1,33 @@
+import { test, expect } from 'vitest';
+import { TestDriver } from 'testdriverai/vitest/hooks';
+import { login } from './login.js';
+
+test('should login and add item to cart', async (context) => {
+
+  // Create TestDriver instance - automatically connects to sandbox
+  const testdriver = TestDriver(context);
+
+  // Launch chrome and navigate to demo app
+  await testdriver.provision.chrome({ url: 'http://testdriver-sandbox.vercel.app/login' });
+
+  // Use the login snippet to handle authentication
+  // This demonstrates how to reuse test logic across multiple tests
+  await login(testdriver);
+
+  // Add item to cart
+  const addToCartButton = await testdriver.find(
+    'add to cart button under TestDriver Hat'
+  );
+  await addToCartButton.click();
+
+  // Open cart
+  const cartButton = await testdriver.find(
+    'cart button in the top right corner'
+  );
+  await cartButton.click();
+
+  // Verify item in cart
+  const result = await testdriver.assert('TestDriver Hat is in the cart');
+  expect(result).toBeTruthy();
+  
+});

package/tests/login.js

@@ -0,0 +1,28 @@
+/**
+ * Login snippet - reusable login function
+ * 
+ * This demonstrates how to create reusable test snippets that can be
+ * imported and used across multiple test files.
+ */
+export async function login(testdriver) {
+
+  // The password is displayed on screen, have TestDriver extract it
+  const password = await testdriver.extract('the password');
+
+  // Find the username field
+  const usernameField = await testdriver.find(
+    'Username, label above the username input field on the login form'
+  );
+  await usernameField.click();
+
+  // Type username
+  await testdriver.type('standard_user');
+
+  // Enter password form earlier 
+  // Marked as secret so it's not logged or stored
+  await testdriver.pressKeys(['tab']);
+  await testdriver.type(password, { secret: true });
+
+  // Submit the form
+  await testdriver.find('submit button on the login form').click();
+}

package/vitest.config.js

@@ -0,0 +1,18 @@
+import { defineConfig } from 'vitest/config';
+import TestDriver from 'testdriverai/vitest';
+import { config } from 'dotenv';
+
+// Load environment variables from .env file
+config();
+
+export default defineConfig({
+  test: {
+    testTimeout: 300000,
+    hookTimeout: 300000,
+    reporters: [
+      'default',
+      TestDriver(),
+    ],
+    setupFiles: ['testdriverai/vitest/setup'],
+  },
+});

package/vitest.config.mjs

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

package/agent/lib/cache.js

@@ -1,142 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-/**
- * Generate a cache key from a prompt
- * Uses a hash to create a safe filename
- */
-function getCacheKey(prompt) {
-  // Normalize the prompt by trimming and converting to lowercase
-  const normalized = prompt.trim().toLowerCase();
-
-  // Create a hash for the filename
-  const hash = crypto.createHash("md5").update(normalized).digest("hex");
-
-  // Also create a sanitized version of the prompt for readability
-  const sanitized = normalized
-    .replace(/[^a-z0-9\s]/g, "") // Remove special chars
-    .replace(/\s+/g, "-") // Replace spaces with hyphens
-    .substring(0, 50); // Limit length
-
-  // Combine sanitized prompt with hash for uniqueness
-  return `${sanitized}-${hash}.yaml`;
-}
-
-/**
- * Get the cache directory path
- * Creates it if it doesn't exist
- */
-function getCacheDir() {
-  const cacheDir = path.join(process.cwd(), ".testdriver", ".cache");
-
-  if (!fs.existsSync(cacheDir)) {
-    fs.mkdirSync(cacheDir, { recursive: true });
-  }
-
-  return cacheDir;
-}
-
-/**
- * Get the full path to a cache file
- */
-function getCachePath(prompt) {
-  const cacheDir = getCacheDir();
-  const key = getCacheKey(prompt);
-  return path.join(cacheDir, key);
-}
-
-/**
- * Check if a cached response exists for a prompt
- */
-function hasCache(prompt) {
-  const cachePath = getCachePath(prompt);
-  return fs.existsSync(cachePath);
-}
-
-/**
- * Read cached YAML for a prompt
- * Returns null if no cache exists
- */
-function readCache(prompt) {
-  if (!hasCache(prompt)) {
-    return null;
-  }
-
-  try {
-    const cachePath = getCachePath(prompt);
-    const yaml = fs.readFileSync(cachePath, "utf8");
-    return yaml;
-  } catch {
-    // If there's an error reading the cache, return null
-    return null;
-  }
-}
-
-/**
- * Write YAML to cache for a prompt
- */
-function writeCache(prompt, yaml) {
-  try {
-    const cachePath = getCachePath(prompt);
-    fs.writeFileSync(cachePath, yaml, "utf8");
-    return cachePath;
-  } catch {
-    // Silently fail if we can't write to cache
-    return null;
-  }
-}
-
-/**
- * Clear all cached prompts
- */
-function clearCache() {
-  const cacheDir = getCacheDir();
-
-  try {
-    const files = fs.readdirSync(cacheDir);
-
-    for (const file of files) {
-      if (file.endsWith(".yaml")) {
-        fs.unlinkSync(path.join(cacheDir, file));
-      }
-    }
-
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get cache statistics
- */
-function getCacheStats() {
-  const cacheDir = getCacheDir();
-
-  try {
-    const files = fs.readdirSync(cacheDir);
-    const yamlFiles = files.filter((f) => f.endsWith(".yaml"));
-
-    return {
-      count: yamlFiles.length,
-      files: yamlFiles,
-    };
-  } catch {
-    return {
-      count: 0,
-      files: [],
-    };
-  }
-}
-
-module.exports = {
-  getCacheKey,
-  getCacheDir,
-  getCachePath,
-  hasCache,
-  readCache,
-  writeCache,
-  clearCache,
-  getCacheStats,
-};