@askjo/camoufox-browser 1.0.0

package/tests/e2e/concurrency.test.js

@@ -0,0 +1,103 @@
+const { startJoBrowser, stopJoBrowser, getServerUrl } = require('../helpers/startJoBrowser');
+const { startTestSite, stopTestSite, getTestSiteUrl } = require('../helpers/testSite');
+const { createClient } = require('../helpers/client');
+
+describe('Concurrency', () => {
+  let serverUrl;
+  let testSiteUrl;
+  
+  beforeAll(async () => {
+    const port = await startJoBrowser();
+    serverUrl = getServerUrl();
+    
+    const testPort = await startTestSite();
+    testSiteUrl = getTestSiteUrl();
+  }, 120000);
+  
+  afterAll(async () => {
+    await stopTestSite();
+    await stopJoBrowser();
+  }, 30000);
+  
+  test('concurrent operations on same tab are serialized', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/pageA`);
+      
+      // Fire multiple operations concurrently on the same tab
+      const operations = [
+        client.getSnapshot(tabId),
+        client.navigate(tabId, `${testSiteUrl}/pageB`),
+        client.getSnapshot(tabId),
+      ];
+      
+      // All should complete without errors (tab locking serializes them)
+      const results = await Promise.all(operations);
+      
+      expect(results.length).toBe(3);
+      // Each result should be valid (no crashes)
+      results.forEach(r => expect(r).toBeDefined());
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('parallel operations on different tabs work', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      // Create two tabs
+      const tab1 = await client.createTab(`${testSiteUrl}/pageA`);
+      const tab2 = await client.createTab(`${testSiteUrl}/pageB`);
+      
+      // Run operations on both tabs in parallel
+      const [snap1, snap2] = await Promise.all([
+        client.getSnapshot(tab1.tabId),
+        client.getSnapshot(tab2.tabId),
+      ]);
+      
+      // Both should return valid snapshots
+      expect(snap1.snapshot).toContain('Page A');
+      expect(snap2.snapshot).toContain('Page B');
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('multiple clients can work independently', async () => {
+    const client1 = createClient(serverUrl);
+    const client2 = createClient(serverUrl);
+    
+    try {
+      // Each client creates their own tab
+      const [tab1, tab2] = await Promise.all([
+        client1.createTab(`${testSiteUrl}/pageA`),
+        client2.createTab(`${testSiteUrl}/pageB`),
+      ]);
+      
+      // Verify they are independent
+      expect(tab1.tabId).not.toBe(tab2.tabId);
+      expect(client1.userId).not.toBe(client2.userId);
+      
+      // Both can operate independently
+      const [snap1, snap2] = await Promise.all([
+        client1.getSnapshot(tab1.tabId),
+        client2.getSnapshot(tab2.tabId),
+      ]);
+      
+      expect(snap1.snapshot).toContain('Page A');
+      expect(snap2.snapshot).toContain('Page B');
+      
+      // Closing one client's session doesn't affect the other
+      await client1.closeSession();
+      
+      // Client 2 still works
+      const snap2After = await client2.getSnapshot(tab2.tabId);
+      expect(snap2After.snapshot).toContain('Page B');
+    } finally {
+      await client1.cleanup();
+      await client2.cleanup();
+    }
+  });
+});

package/tests/e2e/formSubmission.test.js

@@ -0,0 +1,129 @@
+const { startJoBrowser, stopJoBrowser, getServerUrl } = require('../helpers/startJoBrowser');
+const { startTestSite, stopTestSite, getTestSiteUrl } = require('../helpers/testSite');
+const { createClient } = require('../helpers/client');
+
+describe('Form Submission', () => {
+  let serverUrl;
+  let testSiteUrl;
+  
+  beforeAll(async () => {
+    const port = await startJoBrowser();
+    serverUrl = getServerUrl();
+    
+    const testPort = await startTestSite();
+    testSiteUrl = getTestSiteUrl();
+  }, 120000);
+  
+  afterAll(async () => {
+    await stopTestSite();
+    await stopJoBrowser();
+  }, 30000);
+  
+  test('fill form fields and submit via button click', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/form`);
+      
+      // Fill username
+      await client.type(tabId, {
+        selector: '#username',
+        text: 'testuser'
+      });
+      
+      // Fill email
+      await client.type(tabId, {
+        selector: '#email',
+        text: 'test@example.com'
+      });
+      
+      // Click submit button
+      await client.click(tabId, {
+        selector: '#submitBtn'
+      });
+      
+      // Wait for form submission and navigation
+      const snapshot = await client.waitForUrl(tabId, '/submitted');
+      
+      expect(snapshot.url).toContain('/submitted');
+      expect(snapshot.snapshot).toContain('Form Submitted Successfully');
+      expect(snapshot.snapshot).toContain('Username: testuser');
+      expect(snapshot.snapshot).toContain('Email: test@example.com');
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('click button on page', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/click`);
+      
+      // Initial state
+      let snapshot = await client.getSnapshot(tabId);
+      expect(snapshot.snapshot).not.toContain('Button was clicked!');
+      
+      // Click the button
+      await client.click(tabId, {
+        selector: '#clickMe'
+      });
+      
+      // Verify click effect
+      snapshot = await client.waitForSnapshotContains(tabId, 'Button was clicked!');
+      expect(snapshot.snapshot).toContain('Button was clicked!');
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('click using ref', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/click`);
+      
+      // Get snapshot to find button ref
+      const snapshot = await client.getSnapshot(tabId);
+      
+      // Find ref for "Click Me" button
+      const match = snapshot.snapshot.match(/\[(e\d+)\].*button.*Click Me/i);
+      
+      if (match) {
+        const ref = match[1];
+        await client.click(tabId, { ref });
+        
+        const updatedSnapshot = await client.waitForSnapshotContains(tabId, 'Button was clicked!');
+        expect(updatedSnapshot.snapshot).toContain('Button was clicked!');
+      } else {
+        // Fallback to selector
+        await client.click(tabId, { selector: '#clickMe' });
+        const updatedSnapshot = await client.waitForSnapshotContains(tabId, 'Button was clicked!');
+        expect(updatedSnapshot.snapshot).toContain('Button was clicked!');
+      }
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('click link to navigate', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/pageA`);
+      
+      // Click the link to page B
+      await client.click(tabId, {
+        selector: 'a[href="/pageB"]'
+      });
+      
+      // Wait for navigation
+      const snapshot = await client.waitForUrl(tabId, '/pageB');
+      
+      expect(snapshot.url).toContain('/pageB');
+      expect(snapshot.snapshot).toContain('Page B');
+    } finally {
+      await client.cleanup();
+    }
+  });
+});

package/tests/e2e/macroNavigation.test.js

@@ -0,0 +1,92 @@
+const { startJoBrowser, stopJoBrowser, getServerUrl } = require('../helpers/startJoBrowser');
+const { startTestSite, stopTestSite, getTestSiteUrl } = require('../helpers/testSite');
+const { createClient } = require('../helpers/client');
+
+describe('Macro Navigation', () => {
+  let serverUrl;
+  let testSiteUrl;
+  
+  beforeAll(async () => {
+    const port = await startJoBrowser();
+    serverUrl = getServerUrl();
+    
+    const testPort = await startTestSite();
+    testSiteUrl = getTestSiteUrl();
+  }, 120000);
+  
+  afterAll(async () => {
+    await stopTestSite();
+    await stopJoBrowser();
+  }, 30000);
+  
+  test('unknown macro returns error when no fallback URL', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab();
+      
+      await expect(client.navigate(tabId, '@nonexistent_macro test query'))
+        .rejects.toThrow(/url or macro required/);
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('client parses @macro syntax correctly', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab();
+      
+      // Navigate to a real URL first so we have a valid tab
+      await client.navigate(tabId, `${testSiteUrl}/pageA`);
+      
+      // Now try an unknown macro - if client parsing works, 
+      // server will receive {macro: "@unknown", query: "with spaces"}
+      // and return "url or macro required" error
+      await expect(client.navigate(tabId, '@unknown with spaces'))
+        .rejects.toThrow(/url or macro required/);
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('regular URL still works after macro changes', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab();
+      
+      // Regular URL should still work
+      const result = await client.navigate(tabId, `${testSiteUrl}/pageA`);
+      
+      expect(result.ok).toBe(true);
+      expect(result.url).toContain('/pageA');
+      
+      const snapshot = await client.getSnapshot(tabId);
+      expect(snapshot.snapshot).toContain('Page A');
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('navigate API accepts macro and query params directly', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab();
+      
+      // Test the raw API with macro param directly (bypass client parsing)
+      // Unknown macro should fail
+      await expect(
+        client.request('POST', `/tabs/${tabId}/navigate`, {
+          userId: client.userId,
+          macro: '@fake_macro',
+          query: 'test'
+        })
+      ).rejects.toThrow(/url or macro required/);
+    } finally {
+      await client.cleanup();
+    }
+  });
+});

package/tests/e2e/navigation.test.js

@@ -0,0 +1,128 @@
+const { startJoBrowser, stopJoBrowser, getServerUrl } = require('../helpers/startJoBrowser');
+const { startTestSite, stopTestSite, getTestSiteUrl } = require('../helpers/testSite');
+const { createClient } = require('../helpers/client');
+
+describe('Navigation', () => {
+  let serverUrl;
+  let testSiteUrl;
+  
+  beforeAll(async () => {
+    const port = await startJoBrowser();
+    serverUrl = getServerUrl();
+    
+    const testPort = await startTestSite();
+    testSiteUrl = getTestSiteUrl();
+  }, 120000);
+  
+  afterAll(async () => {
+    await stopTestSite();
+    await stopJoBrowser();
+  }, 30000);
+  
+  test('navigate to URL', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab();
+      
+      const result = await client.navigate(tabId, `${testSiteUrl}/pageA`);
+      
+      expect(result.ok).toBe(true);
+      expect(result.url).toContain('/pageA');
+      
+      const snapshot = await client.getSnapshot(tabId);
+      expect(snapshot.snapshot).toContain('Welcome to Page A');
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('navigate back', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/pageA`);
+      await client.navigate(tabId, `${testSiteUrl}/pageB`);
+      
+      // Verify we're on page B
+      let snapshot = await client.getSnapshot(tabId);
+      expect(snapshot.snapshot).toContain('Page B');
+      
+      // Go back
+      const result = await client.back(tabId);
+      expect(result.ok).toBe(true);
+      expect(result.url).toContain('/pageA');
+      
+      snapshot = await client.getSnapshot(tabId);
+      expect(snapshot.snapshot).toContain('Page A');
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('navigate forward', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/pageA`);
+      await client.navigate(tabId, `${testSiteUrl}/pageB`);
+      await client.back(tabId);
+      
+      // Verify we're back on page A
+      let snapshot = await client.getSnapshot(tabId);
+      expect(snapshot.snapshot).toContain('Page A');
+      
+      // Go forward
+      const result = await client.forward(tabId);
+      expect(result.ok).toBe(true);
+      expect(result.url).toContain('/pageB');
+      
+      snapshot = await client.getSnapshot(tabId);
+      expect(snapshot.snapshot).toContain('Page B');
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('refresh page', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      // Use the refresh counter page
+      const { tabId } = await client.createTab(`${testSiteUrl}/refresh-test`);
+      
+      let snapshot = await client.getSnapshot(tabId);
+      const initialMatch = snapshot.snapshot.match(/Count: (\d+)/);
+      const initialCount = initialMatch ? parseInt(initialMatch[1]) : 0;
+      
+      // Refresh the page
+      const result = await client.refresh(tabId);
+      expect(result.ok).toBe(true);
+      
+      snapshot = await client.getSnapshot(tabId);
+      const newMatch = snapshot.snapshot.match(/Count: (\d+)/);
+      const newCount = newMatch ? parseInt(newMatch[1]) : 0;
+      
+      // Count should have incremented
+      expect(newCount).toBe(initialCount + 1);
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('navigation updates visited URLs', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/pageA`);
+      await client.navigate(tabId, `${testSiteUrl}/pageB`);
+      
+      const stats = await client.getStats(tabId);
+      
+      expect(stats.visitedUrls).toContain(`${testSiteUrl}/pageA`);
+      expect(stats.visitedUrls).toContain(`${testSiteUrl}/pageB`);
+    } finally {
+      await client.cleanup();
+    }
+  });
+});

package/tests/e2e/scroll.test.js

@@ -0,0 +1,81 @@
+const { startJoBrowser, stopJoBrowser, getServerUrl } = require('../helpers/startJoBrowser');
+const { startTestSite, stopTestSite, getTestSiteUrl } = require('../helpers/testSite');
+const { createClient } = require('../helpers/client');
+
+describe('Scroll', () => {
+  let serverUrl;
+  let testSiteUrl;
+  
+  beforeAll(async () => {
+    const port = await startJoBrowser();
+    serverUrl = getServerUrl();
+    
+    const testPort = await startTestSite();
+    testSiteUrl = getTestSiteUrl();
+  }, 120000);
+  
+  afterAll(async () => {
+    await stopTestSite();
+    await stopJoBrowser();
+  }, 30000);
+  
+  test('scroll down page', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/scroll`);
+      
+      // Scroll down
+      const result = await client.scroll(tabId, {
+        direction: 'down',
+        amount: 500
+      });
+      
+      expect(result.ok).toBe(true);
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('scroll to bottom of page', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/scroll`);
+      
+      // Scroll to bottom
+      const result = await client.scroll(tabId, {
+        direction: 'down',
+        amount: 10000 // Large number to reach bottom
+      });
+      
+      expect(result.ok).toBe(true);
+      
+      // The snapshot might now include "Bottom of page" text
+      // (depending on viewport and scroll behavior)
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('scroll up page', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/scroll`);
+      
+      // First scroll down
+      await client.scroll(tabId, { direction: 'down', amount: 1000 });
+      
+      // Then scroll up
+      const result = await client.scroll(tabId, {
+        direction: 'up',
+        amount: 500
+      });
+      
+      expect(result.ok).toBe(true);
+    } finally {
+      await client.cleanup();
+    }
+  });
+});

package/tests/e2e/snapshotLinks.test.js

@@ -0,0 +1,141 @@
+const { startJoBrowser, stopJoBrowser, getServerUrl } = require('../helpers/startJoBrowser');
+const { startTestSite, stopTestSite, getTestSiteUrl } = require('../helpers/testSite');
+const { createClient } = require('../helpers/client');
+
+describe('Snapshot and Links', () => {
+  let serverUrl;
+  let testSiteUrl;
+  
+  beforeAll(async () => {
+    const port = await startJoBrowser();
+    serverUrl = getServerUrl();
+    
+    const testPort = await startTestSite();
+    testSiteUrl = getTestSiteUrl();
+  }, 120000);
+  
+  afterAll(async () => {
+    await stopTestSite();
+    await stopJoBrowser();
+  }, 30000);
+  
+  test('get snapshot returns page content', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/pageA`);
+      
+      const snapshot = await client.getSnapshot(tabId);
+      
+      expect(snapshot.url).toContain('/pageA');
+      expect(snapshot.snapshot).toBeDefined();
+      expect(typeof snapshot.snapshot).toBe('string');
+      expect(snapshot.snapshot).toContain('Page A');
+      expect(snapshot.refsCount).toBeDefined();
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('snapshot contains element refs', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/links`);
+      
+      const snapshot = await client.getSnapshot(tabId);
+      
+      // Snapshot should contain ref markers like [e1], [e2], etc.
+      expect(snapshot.snapshot).toMatch(/\[e\d+\]/);
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('get links returns all links on page', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/links`);
+      
+      const result = await client.getLinks(tabId);
+      
+      expect(result.links).toBeDefined();
+      expect(Array.isArray(result.links)).toBe(true);
+      expect(result.links.length).toBe(5);
+      
+      // Check link structure
+      const link = result.links[0];
+      expect(link.url).toContain('example.com');
+      expect(link.text).toBeDefined();
+      
+      // Check pagination info
+      expect(result.pagination).toBeDefined();
+      expect(result.pagination.total).toBe(5);
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('get links supports pagination', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/links`);
+      
+      // Get first 2 links
+      const page1 = await client.getLinks(tabId, { limit: 2, offset: 0 });
+      expect(page1.links.length).toBe(2);
+      expect(page1.pagination.hasMore).toBe(true);
+      
+      // Get next 2 links
+      const page2 = await client.getLinks(tabId, { limit: 2, offset: 2 });
+      expect(page2.links.length).toBe(2);
+      expect(page2.pagination.hasMore).toBe(true);
+      
+      // Get last link
+      const page3 = await client.getLinks(tabId, { limit: 2, offset: 4 });
+      expect(page3.links.length).toBe(1);
+      expect(page3.pagination.hasMore).toBe(false);
+      
+      // Links should be different
+      expect(page1.links[0].url).not.toBe(page2.links[0].url);
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('screenshot returns PNG buffer', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      const { tabId } = await client.createTab(`${testSiteUrl}/pageA`);
+      
+      const buffer = await client.screenshot(tabId);
+      
+      expect(buffer).toBeDefined();
+      expect(buffer.byteLength).toBeGreaterThan(0);
+      
+      // Check PNG magic bytes
+      const bytes = new Uint8Array(buffer);
+      expect(bytes[0]).toBe(0x89);
+      expect(bytes[1]).toBe(0x50); // P
+      expect(bytes[2]).toBe(0x4E); // N
+      expect(bytes[3]).toBe(0x47); // G
+    } finally {
+      await client.cleanup();
+    }
+  });
+  
+  test('snapshot for non-existent tab returns 404', async () => {
+    const client = createClient(serverUrl);
+    
+    try {
+      await expect(client.getSnapshot('non-existent-tab-id')).rejects.toMatchObject({
+        status: 404
+      });
+    } finally {
+      await client.cleanup();
+    }
+  });
+});