page-analyzer 1.2.1 → 1.2.3

package/test/smoke.test.js

@@ -1,10 +1,20 @@
 import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
 import { EventAnalyzer } from '../llm/analyzers/event-analyzer/event-analyzer.js';
 import { buildBlockAnalysisArtifact } from '../llm/analyzers/event-analyzer/event-analyzer-blocks.js';
 import { OpenAiProvider } from '../llm/providers/openai-provider.js';
+import {
+  createLlmProvider,
+  CodexCliProvider,
+  ClaudeCliProvider
+} from '../llm/providers/index.js';
 import { PageExtractor } from '../page-extractor.js';
 import { analyzeUrl } from '../index.js';
 
+function md5(value) {
+  return createHash('md5').update(value).digest('hex');
+}
+
 class FakeProvider {
   constructor() {
     this.calls = [];
@@ -26,9 +36,10 @@ class FakeProvider {
 }
 
 class FakeLocator {
-  constructor({ count = 1, throwOnScreenshot = false } = {}) {
+  constructor({ count = 1, throwOnScreenshot = false, screenshotBodies = null } = {}) {
     this.countValue = count;
     this.throwOnScreenshot = throwOnScreenshot;
+    this.screenshotBodies = Array.isArray(screenshotBodies) ? screenshotBodies : null;
     this.screenshots = [];
   }
 
@@ -41,11 +52,14 @@ class FakeLocator {
   }
 
   async screenshot(options) {
+    const screenshotIndex = this.screenshots.length;
     this.screenshots.push(options);
     if (this.throwOnScreenshot) {
       throw new Error('selector screenshot failed');
     }
-    return Buffer.from(`locator screenshot:${options?.path || 'buffer'}`);
+    return Buffer.from(
+      this.screenshotBodies?.[screenshotIndex] || `locator screenshot:${options?.path || 'buffer'}`
+    );
   }
 }
 
@@ -74,22 +88,36 @@ class FakePage {
 }
 
 class FakeS3Client {
-  constructor({ failPredicate = null } = {}) {
+  constructor({ failPredicate = null, existingKeys = [] } = {}) {
     this.failPredicate = failPredicate;
+    this.existingKeys = new Set(existingKeys);
+    this.headCommands = [];
     this.commands = [];
     this.attemptsByKey = new Map();
   }
 
   async send(command) {
     const input = command.input;
-    this.commands.push(input);
+    if (command.constructor.name === 'HeadObjectCommand') {
+      this.headCommands.push(input);
+      if (this.existingKeys.has(input.Key)) {
+        return {};
+      }
+      const error = new Error(`s3 object not found for ${input.Key}`);
+      error.name = 'NotFound';
+      error.$metadata = { httpStatusCode: 404 };
+      throw error;
+    }
+
     const attempts = (this.attemptsByKey.get(input.Key) || 0) + 1;
     this.attemptsByKey.set(input.Key, attempts);
+    this.commands.push(input);
 
     if (this.failPredicate?.(input, attempts)) {
       throw new Error(`s3 upload failed for ${input.Key}`);
     }
 
+    this.existingKeys.add(input.Key);
     return {};
   }
 }
@@ -182,6 +210,23 @@ async function analyzeWith(options = {}) {
         height: 24,
         selectorNthOfType: 'body > main:nth-of-type(1) > section:nth-of-type(1) > a:nth-of-type(1)'
       }],
+      sizedElements: [{
+        tag: 'a',
+        text: 'Sign up',
+        href: 'https://example.com/signup',
+        src: '',
+        width: 80,
+        height: 30,
+        top: 0,
+        left: 0,
+        cssSelector: 'body > main:nth-of-type(1) > section:nth-of-type(1) > a:nth-of-type(1)',
+        id: '',
+        class: 'cta',
+        role: '',
+        ariaLabel: '',
+        imageAlt: '',
+        interactive: true
+      }],
       screenshots: { fullPage: '/tmp/full-page.png' },
       pageSize: { width: 1000, height: 800 }
     };
@@ -218,7 +263,9 @@ async function analyzeWith(options = {}) {
       },
       fullPageScreenshot: true,
       blockScreenshots: true,
-      showBlockIdx: true
+      showBlockIdx: true,
+      showElement: true,
+      elementSize: 24
     });
 
     assert.equal(calls.filter((call) => call[0] === 'withPreparedPage').length, 1);
@@ -230,6 +277,16 @@ async function analyzeWith(options = {}) {
       result.analysis.block_analysis.blocks[0].blockScreenshotPaths[0],
       '/tmp/logical-block-0.png'
     );
+
+    const firstBlockElements = result.analysis.block_analysis.blocks[0].elements;
+    assert.ok(Array.isArray(firstBlockElements), 'block should carry a sized elements array');
+    assert.equal(firstBlockElements.length, 1);
+    assert.equal(firstBlockElements[0].tag, 'a');
+    assert.equal(firstBlockElements[0].interactive, true);
+    assert.equal(firstBlockElements[0].cssSelector, 'body > main:nth-of-type(1) > section:nth-of-type(1) > a:nth-of-type(1)');
+    assert.equal(firstBlockElements[0].class, 'cta');
+    assert.equal(firstBlockElements[0].semantic, undefined);
+    assert.equal(firstBlockElements[0].event_type, undefined);
   } finally {
     PageExtractor.prototype.withPreparedPage = originalWithPreparedPage;
     PageExtractor.prototype.extractPreparedPage = originalExtractPreparedPage;
@@ -348,14 +405,16 @@ async function analyzeWith(options = {}) {
   assert.deepEqual(page.pageScreenshots[0], { fullPage: true });
   assert.equal(locator.screenshots.length, 1);
   assert.deepEqual(locator.screenshots[0], {});
+  assert.equal(s3Client.headCommands.length, 2);
   assert.equal(s3Client.commands.length, 2);
 
   const [fullPageUpload, blockUpload] = s3Client.commands;
   assert.equal(fullPageUpload.Bucket, 'page-analyzer-test');
   assert.equal(fullPageUpload.ContentType, 'image/png');
   assert.equal(Buffer.isBuffer(fullPageUpload.Body), true);
-  assert.match(fullPageUpload.Key, /^page-analyzer\/snapshots\/example-com-demo-.*-full-page\.png$/);
-  assert.match(blockUpload.Key, /^page-analyzer\/snapshots\/example-com-demo-.*-block-000\.png$/);
+  assert.match(fullPageUpload.Key, /^page-analyzer\/snapshots\/example\.com\/[a-f0-9]{32}\.png$/);
+  assert.match(blockUpload.Key, /^page-analyzer\/snapshots\/example\.com\/[a-f0-9]{32}\.png$/);
+  assert.notEqual(fullPageUpload.Key, blockUpload.Key);
 
   assert.equal(
     screenshots.fullPage,
@@ -384,21 +443,49 @@ async function analyzeWith(options = {}) {
   });
 
   const uploadedKey = s3Client.commands[0].Key;
-  assert.match(uploadedKey, /^nested\/prefix\/example-com-demo-.*-block-000\.png$/);
+  assert.match(uploadedKey, /^nested\/prefix\/example\.com\/[a-f0-9]{32}\.png$/);
   assert.equal(
     screenshots.blocks[0].path,
     `https://page-analyzer-test.s3.ap-northeast-1.amazonaws.com/${uploadedKey}`
   );
 }
 
+{
+  const body = Buffer.from('already uploaded screenshot');
+  const existingKey = `page-analyzer/snapshots/example.com/${md5(body)}.png`;
+  const s3Client = new FakeS3Client({
+    existingKeys: [existingKey]
+  });
+  const extractor = new PageExtractor({
+    s3: {
+      bucket: 'page-analyzer-test',
+      region: 'ap-northeast-1',
+      prefix: 'page-analyzer/snapshots',
+      publicBaseUrl: 'https://cdn.example.com',
+      client: s3Client
+    }
+  });
+
+  const url = await extractor.uploadScreenshotToS3('https://example.com/demo', body);
+
+  assert.equal(s3Client.headCommands.length, 1);
+  assert.equal(s3Client.headCommands[0].Key, existingKey);
+  assert.equal(s3Client.commands.length, 0);
+  assert.equal(url, `https://cdn.example.com/${existingKey}`);
+}
+
 {
   const originalWarn = console.warn;
   const warnings = [];
   console.warn = (message) => warnings.push(message);
 
   try {
+    const failingBlockKey =
+      `page-analyzer/snapshots/example.com/${md5('locator screenshot:block-0')}.png`;
+    const successfulBlockKey =
+      `page-analyzer/snapshots/example.com/${md5('locator screenshot:block-1')}.png`;
     const s3Client = new FakeS3Client({
-      failPredicate: (input) => input.Key.endsWith('-block-000.png')
+      failPredicate: (input) => input.Key === failingBlockKey
     });
     const extractor = new PageExtractor({
       s3: {
@@ -409,7 +496,12 @@ async function analyzeWith(options = {}) {
         client: s3Client
       }
     });
-    const locator = new FakeLocator();
+    const locator = new FakeLocator({
+      screenshotBodies: [
+        'locator screenshot:block-0',
+        'locator screenshot:block-1'
+      ]
+    });
     const page = new FakePage(locator);
     const screenshots = await extractor.captureScreenshots(page, 'https://example.com/demo', [
       { blockName: 'Hero', blockCssPath: '#hero' },
@@ -421,8 +513,8 @@ async function analyzeWith(options = {}) {
 
     assert.equal(screenshots.blocks.length, 1);
     assert.equal(screenshots.blocks[0].blockIdx, 1);
-    assert.equal(s3Client.commands.filter((input) => input.Key.endsWith('-block-000.png')).length, 3);
-    assert.equal(s3Client.commands.filter((input) => input.Key.endsWith('-block-001.png')).length, 1);
+    assert.equal(s3Client.commands.filter((input) => input.Key === failingBlockKey).length, 3);
+    assert.equal(s3Client.commands.filter((input) => input.Key === successfulBlockKey).length, 1);
     assert.equal(warnings.some((message) => message.includes('retrying')), true);
     assert.equal(warnings.some((message) => message.includes('Failed to capture/upload block 0')), true);
   } finally {
@@ -449,4 +541,51 @@ async function analyzeWith(options = {}) {
   assert.equal(artifact.blocks[0].blockCssPath, 'body > main:nth-of-type(1)');
 }
 
+{
+  // Factory dispatches to the right provider class
+  const openaiProvider = createLlmProvider({
+    type: 'openai',
+    apiKey: 'k',
+    apiEndpoint: 'https://example.invalid/v1/chat/completions',
+    model: 'm'
+  });
+  assert.ok(openaiProvider instanceof OpenAiProvider, 'type=openai → OpenAiProvider');
+
+  const codexProvider = createLlmProvider({ type: 'codex', model: 'gpt-5.5' });
+  assert.ok(codexProvider instanceof CodexCliProvider, 'type=codex → CodexCliProvider');
+  assert.equal(codexProvider.fast, true, 'gpt-5.5 auto-enables fast');
+  assert.ok(codexProvider.buildArgs('/tmp/x').includes('service_tier="fast"'), 'fast injects -c service_tier');
+
+  const codexOther = createLlmProvider({ type: 'codex', model: 'gpt-5-codex' });
+  assert.equal(codexOther.fast, false, 'other models do not auto-enable fast');
+  assert.ok(!codexOther.buildArgs('/tmp/x').includes('service_tier="fast"'));
+
+  const codexExplicitFast = createLlmProvider({ type: 'codex', model: 'gpt-5-codex', fast: true });
+  assert.equal(codexExplicitFast.fast, true, 'explicit fast:true overrides');
+
+  const codexExplicitOff = createLlmProvider({ type: 'codex', model: 'gpt-5.5', fast: false });
+  assert.equal(codexExplicitOff.fast, false, 'explicit fast:false overrides gpt-5.5');
+
+  const claudeProvider = createLlmProvider({ type: 'claude', model: 'sonnet' });
+  assert.ok(claudeProvider instanceof ClaudeCliProvider, 'type=claude → ClaudeCliProvider');
+
+  // Default type is openai
+  const defaultProvider = createLlmProvider({
+    apiKey: 'k',
+    apiEndpoint: 'https://example.invalid/v1/chat/completions',
+    model: 'm'
+  });
+  assert.ok(defaultProvider instanceof OpenAiProvider, 'missing type → openai default');
+
+  // Unknown type rejects
+  assert.throws(
+    () => createLlmProvider({ type: 'unknown', model: 'm' }),
+    /Unknown llm\.type/
+  );
+
+  // CLI providers require model
+  assert.throws(() => createLlmProvider({ type: 'codex' }), /model is required/);
+  assert.throws(() => createLlmProvider({ type: 'claude' }), /model is required/);
+}
+
 console.log('smoke tests passed');