cdp-skill 1.0.8 → 1.0.14

package/src/tests/ExecuteDynamic.test.js

@@ -7,8 +7,6 @@ import os from 'os';
 import {
   executePageFunction,
   executePoll,
-  compilePipeline,
-  executePipeline,
   executeWriteSiteProfile,
   loadSiteProfile
 } from '../runner/execute-dynamic.js';
@@ -285,441 +283,6 @@ describe('executePoll', () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Tests: compilePipeline
-// ---------------------------------------------------------------------------
-
-describe('compilePipeline', () => {
-  it('should generate valid JS for find+fill', () => {
-    const js = compilePipeline([{ find: '#name', fill: 'John' }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#name'));
-    assert.ok(js.includes('John'));
-    assert.ok(js.includes('nativeSetter'));
-    assert.ok(js.includes("dispatchEvent(new Event('input'"));
-  });
-
-  it('should generate valid JS for find+click', () => {
-    const js = compilePipeline([{ find: '#btn', click: true }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#btn'));
-    assert.ok(js.includes('.click()'));
-  });
-
-  it('should generate valid JS for find+type', () => {
-    const js = compilePipeline([{ find: '#search', type: 'hello' }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#search'));
-    assert.ok(js.includes('focus'));
-    assert.ok(js.includes('KeyboardEvent'));
-    assert.ok(js.includes('hello'));
-  });
-
-  it('should generate valid JS for find+check', () => {
-    const js = compilePipeline([{ find: '#agree', check: true }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#agree'));
-    assert.ok(js.includes('checked'));
-    assert.ok(js.includes('true'));
-  });
-
-  it('should generate valid JS for find+select', () => {
-    const js = compilePipeline([{ find: '#color', select: 'red' }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#color'));
-    assert.ok(js.includes('"red"'));
-  });
-
-  it('should generate valid JS for waitFor', () => {
-    const js = compilePipeline([{ waitFor: '() => document.querySelector("#loaded")' }]);
-    assert.ok(js.includes('new Promise'));
-    assert.ok(js.includes('setInterval'));
-    assert.ok(js.includes('#loaded'));
-  });
-
-  it('should use custom timeout for waitFor', () => {
-    const js = compilePipeline([{ waitFor: '() => true', timeout: 5000 }]);
-    assert.ok(js.includes('5000'));
-  });
-
-  it('should generate valid JS for sleep', () => {
-    const js = compilePipeline([{ sleep: 200 }]);
-    assert.ok(js.includes('setTimeout'));
-    assert.ok(js.includes('200'));
-  });
-
-  it('should generate valid JS for return', () => {
-    const js = compilePipeline([{ return: '() => document.title' }]);
-    assert.ok(js.includes('document.title'));
-    assert.ok(js.includes('value:val'));
-  });
-
-  it('should throw on unrecognized micro-op', () => {
-    assert.throws(
-      () => compilePipeline([{ unknown: true }]),
-      { message: /unrecognized micro-op/ }
-    );
-  });
-
-  it('should combine multiple ops in sequence', () => {
-    const js = compilePipeline([
-      { find: '#user', fill: 'Alice' },
-      { find: '#pass', fill: 'secret' },
-      { find: '#submit', click: true }
-    ]);
-    assert.ok(js.includes('#user'));
-    assert.ok(js.includes('Alice'));
-    assert.ok(js.includes('#pass'));
-    assert.ok(js.includes('secret'));
-    assert.ok(js.includes('#submit'));
-    assert.ok(js.includes('.click()'));
-    assert.ok(js.includes('async function'));
-    assert.ok(js.includes('completed:true'));
-  });
-
-  it('should include error handling in generated code', () => {
-    const js = compilePipeline([{ find: '#el', click: true }]);
-    assert.ok(js.includes('catch'));
-    assert.ok(js.includes('failedAt'));
-    assert.ok(js.includes('completed:false'));
-  });
-
-  it('should track step index in error info', () => {
-    const js = compilePipeline([
-      { find: '#a', fill: 'x' },
-      { find: '#b', fill: 'y' }
-    ]);
-    assert.ok(js.includes('step:0'));
-    assert.ok(js.includes('step:1'));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: executePipeline
-// ---------------------------------------------------------------------------
-
-describe('executePipeline', () => {
-  afterEach(() => { mock.reset(); });
-
-  it('should execute array form', async () => {
-    const pc = createMockPageController({ completed: true, steps: 2, results: [{ok:true},{ok:true}] });
-    const result = await executePipeline(pc, [
-      { find: '#a', fill: 'x' },
-      { find: '#b', fill: 'y' }
-    ]);
-
-    assert.strictEqual(result.completed, true);
-    assert.strictEqual(result.steps, 2);
-    assert.strictEqual(pc.evaluateInFrame.mock.calls.length, 1);
-    // Should use awaitPromise: true
-    assert.strictEqual(pc.evaluateInFrame.mock.calls[0].arguments[1].awaitPromise, true);
-  });
-
-  it('should execute object form with steps and timeout', async () => {
-    const pc = createMockPageController({ completed: true, steps: 1, results: [{ok:true}] });
-    const result = await executePipeline(pc, {
-      steps: [{ find: '#x', click: true }],
-      timeout: 5000
-    });
-
-    assert.strictEqual(result.completed, true);
-  });
-
-  it('should throw on empty array', async () => {
-    const pc = createMockPageController(null);
-    await assert.rejects(
-      () => executePipeline(pc, []),
-      { message: /non-empty array/ }
-    );
-  });
-
-  it('should throw on non-array params without steps', async () => {
-    const pc = createMockPageController(null);
-    await assert.rejects(
-      () => executePipeline(pc, { timeout: 1000 }),
-      { message: /non-empty array/ }
-    );
-  });
-
-  it('should throw on browser exception', async () => {
-    const pc = createMockPageController(undefined, { exception: 'TypeError: el is null' });
-    await assert.rejects(
-      () => executePipeline(pc, [{ find: '#missing', click: true }]),
-      { message: /pipeline error/ }
-    );
-  });
-
-  it('should timeout when evaluation hangs', async () => {
-    const pc = {
-      evaluateInFrame: mock.fn(() => new Promise(() => { /* never resolves */ }))
-    };
-    await assert.rejects(
-      () => executePipeline(pc, { steps: [{ find: '#x', click: true }], timeout: 50 }),
-      { message: /timed out after 50ms/ }
-    );
-  });
-
-  it('should return result value from browser', async () => {
-    const pipelineResult = { completed: false, failedAt: 0, error: 'not found: #x', results: [] };
-    const pc = createMockPageController(pipelineResult);
-    const result = await executePipeline(pc, [{ find: '#x', click: true }]);
-
-    assert.strictEqual(result.completed, false);
-    assert.strictEqual(result.failedAt, 0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: executeWriteSiteProfile and loadSiteProfile
-// ---------------------------------------------------------------------------
-
-describe('executeWriteSiteProfile', () => {
-  const testDomain = `test-dyn-${Date.now()}.example.com`;
-
-  afterEach(async () => {
-    await cleanupTestProfiles([testDomain]);
-  });
-
-  it('should write a profile file', async () => {
-    const result = await executeWriteSiteProfile({
-      domain: testDomain,
-      content: '# Test profile\nContent here.'
-    });
-
-    assert.strictEqual(result.written, true);
-    assert.ok(result.path);
-    assert.strictEqual(result.domain, testDomain);
-
-    // Verify file was written
-    const content = await fs.readFile(result.path, 'utf8');
-    assert.strictEqual(content, '# Test profile\nContent here.');
-  });
-
-  it('should require domain', async () => {
-    await assert.rejects(
-      () => executeWriteSiteProfile({ content: 'test' }),
-      { message: /requires domain and content/ }
-    );
-  });
-
-  it('should require content', async () => {
-    await assert.rejects(
-      () => executeWriteSiteProfile({ domain: 'example.com' }),
-      { message: /requires domain and content/ }
-    );
-  });
-
-  it('should throw on missing params', async () => {
-    await assert.rejects(
-      () => executeWriteSiteProfile(null),
-      { message: /requires domain and content/ }
-    );
-  });
-});
-
-describe('loadSiteProfile', () => {
-  const testDomain = `test-load-${Date.now()}.example.com`;
-
-  afterEach(async () => {
-    await cleanupTestProfiles([testDomain]);
-  });
-
-  it('should return null when no profile exists', async () => {
-    const result = await loadSiteProfile('nonexistent-domain-xyz-12345.com');
-    assert.strictEqual(result, null);
-  });
-
-  it('should return content when profile exists', async () => {
-    // First write a profile
-    await executeWriteSiteProfile({
-      domain: testDomain,
-      content: '# Loaded content'
-    });
-
-    const result = await loadSiteProfile(testDomain);
-    assert.strictEqual(result, '# Loaded content');
-  });
-});
-
-
-
-
-// ---------------------------------------------------------------------------
-// Tests: StepValidator - Dynamic step types
-// ---------------------------------------------------------------------------
-
-describe('StepValidator - pageFunction validation', () => {
-  it('should accept valid string form', () => {
-    const errors = validateStepInternal({ pageFunction: '() => document.title' });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept valid object form', () => {
-    const errors = validateStepInternal({ pageFunction: { fn: '() => 42', refs: true, timeout: 5000 } });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject empty string', () => {
-    const errors = validateStepInternal({ pageFunction: '' });
-    assert.ok(errors.some(e => e.includes('non-empty function string')));
-  });
-
-  it('should reject missing fn in object form', () => {
-    const errors = validateStepInternal({ pageFunction: { timeout: 1000 } });
-    assert.ok(errors.some(e => e.includes('non-empty fn string')));
-  });
-
-  it('should reject invalid refs type', () => {
-    const errors = validateStepInternal({ pageFunction: { fn: '() => 1', refs: 'yes' } });
-    assert.ok(errors.some(e => e.includes('refs must be a boolean')));
-  });
-
-  it('should reject invalid timeout', () => {
-    const errors = validateStepInternal({ pageFunction: { fn: '() => 1', timeout: -100 } });
-    assert.ok(errors.some(e => e.includes('timeout must be a non-negative')));
-  });
-
-  it('should reject non-string non-object form', () => {
-    const errors = validateStepInternal({ pageFunction: 42 });
-    assert.ok(errors.some(e => e.includes('function string or params object')));
-  });
-});
-
-describe('StepValidator - poll validation', () => {
-  it('should accept valid string form', () => {
-    const errors = validateStepInternal({ poll: '() => document.readyState === "complete"' });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept valid object form', () => {
-    const errors = validateStepInternal({ poll: { fn: '() => true', interval: 200, timeout: 10000 } });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject empty string', () => {
-    const errors = validateStepInternal({ poll: '' });
-    assert.ok(errors.some(e => e.includes('non-empty function string')));
-  });
-
-  it('should reject missing fn', () => {
-    const errors = validateStepInternal({ poll: { interval: 100 } });
-    assert.ok(errors.some(e => e.includes('non-empty fn string')));
-  });
-
-  it('should reject invalid interval', () => {
-    const errors = validateStepInternal({ poll: { fn: '() => true', interval: -50 } });
-    assert.ok(errors.some(e => e.includes('interval must be a non-negative')));
-  });
-
-  it('should reject invalid timeout', () => {
-    const errors = validateStepInternal({ poll: { fn: '() => true', timeout: 'long' } });
-    assert.ok(errors.some(e => e.includes('timeout must be a non-negative')));
-  });
-
-  it('should reject non-string non-object form', () => {
-    const errors = validateStepInternal({ poll: 123 });
-    assert.ok(errors.some(e => e.includes('function string or params object')));
-  });
-});
-
-describe('StepValidator - pipeline validation', () => {
-  it('should accept valid array of micro-ops', () => {
-    const errors = validateStepInternal({
-      pipeline: [
-        { find: '#name', fill: 'John' },
-        { find: '#submit', click: true }
-      ]
-    });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept valid object form with steps', () => {
-    const errors = validateStepInternal({
-      pipeline: {
-        steps: [{ find: '#btn', click: true }],
-        timeout: 5000
-      }
-    });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject empty array', () => {
-    const errors = validateStepInternal({ pipeline: [] });
-    assert.ok(errors.some(e => e.includes('non-empty array')));
-  });
-
-  it('should reject invalid micro-ops without find/waitFor/sleep/return', () => {
-    const errors = validateStepInternal({ pipeline: [{ something: true }] });
-    assert.ok(errors.some(e => e.includes('unrecognized micro-op')));
-  });
-
-  it('should reject find without action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el' }] });
-    assert.ok(errors.some(e => e.includes('find requires an action')));
-  });
-
-  it('should accept find with fill action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', fill: 'val' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with click action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', click: true }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with type action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', type: 'text' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with check action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', check: true }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with select action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', select: 'opt' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept waitFor micro-op', () => {
-    const errors = validateStepInternal({ pipeline: [{ waitFor: '() => true' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept sleep micro-op', () => {
-    const errors = validateStepInternal({ pipeline: [{ sleep: 500 }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept return micro-op', () => {
-    const errors = validateStepInternal({ pipeline: [{ return: '() => document.title' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject invalid timeout on object form', () => {
-    const errors = validateStepInternal({
-      pipeline: {
-        steps: [{ find: '#el', click: true }],
-        timeout: -1
-      }
-    });
-    assert.ok(errors.some(e => e.includes('timeout must be a non-negative')));
-  });
-
-  it('should report errors for multiple invalid ops', () => {
-    const errors = validateStepInternal({
-      pipeline: [
-        { find: '#a' },  // missing action
-        { bad: true },   // unrecognized
-        { find: '#b', fill: 'ok' }  // valid
-      ]
-    });
-    assert.ok(errors.length >= 2);
-  });
-});
-
 describe('StepValidator - writeSiteProfile validation', () => {
   it('should accept valid params', () => {
     const errors = validateStepInternal({
@@ -815,9 +378,6 @@ describe('STEP_TYPES includes dynamic steps', () => {
     assert.ok(STEP_TYPES.includes('poll'));
   });
 
-  it('should include pipeline', () => {
-    assert.ok(STEP_TYPES.includes('pipeline'));
-  });
 
   it('should include writeSiteProfile', () => {
     assert.ok(STEP_TYPES.includes('writeSiteProfile'));
@@ -888,20 +448,6 @@ describe('step-executors dispatch for dynamic steps', () => {
     assert.ok(result.output.resolved);
   });
 
-  it('should dispatch pipeline step', async () => {
-    mockDeps.pageController.evaluateInFrame = mock.fn(() => Promise.resolve({
-      result: { value: { completed: true, steps: 1, results: [{ok:true}] } },
-      exceptionDetails: undefined
-    }));
-
-    const result = await executeStep(mockDeps, {
-      pipeline: [{ find: '#btn', click: true }]
-    });
-
-    assert.strictEqual(result.action, 'pipeline');
-    assert.strictEqual(result.status, 'ok');
-    assert.ok(result.output.completed);
-  });
 
   it('should dispatch writeSiteProfile step', async () => {
     const uniqueDomain = `dispatch-test-${Date.now()}.example.com`;
@@ -1105,6 +651,7 @@ describe('step-executors goto profile integration', () => {
           });
         }),
         navigate: mock.fn(() => Promise.resolve()),
+        waitForNetworkSettle: mock.fn(() => Promise.resolve({ settled: true, pendingCount: 0 })),
         getUrl: mock.fn(() => Promise.resolve(`https://${testDomain}/page`)),
         session: { send: mockSessionSend }
       },
@@ -1160,7 +707,6 @@ describe('validateSteps for dynamic steps', () => {
       { goto: 'https://example.com' },
       { pageFunction: '() => document.title' },
       { poll: { fn: '() => true', timeout: 5000 } },
-      { pipeline: [{ find: '#btn', click: true }] },
       { writeSiteProfile: { domain: 'example.com', content: '# test' } }
     ]);
     assert.strictEqual(result.valid, true);
@@ -1171,10 +717,9 @@ describe('validateSteps for dynamic steps', () => {
     const result = validateSteps([
       { pageFunction: '' },
       { poll: { interval: 100 } },
-      { pipeline: [] },
       { writeSiteProfile: { domain: 'x' } }
     ]);
     assert.strictEqual(result.valid, false);
-    assert.strictEqual(result.errors.length, 4);
+    assert.strictEqual(result.errors.length, 3);
   });
 });