🧪 Improve test coverage to 99%

Add comprehensive tests for:
- viewport utilities (parseViewport, formatViewport, setViewport, getCommonViewports)
- pattern matching (matchPattern, filterByPattern, findMatchingHook edge cases)
- screenshot functions (captureScreenshot, captureAndSendScreenshot)
- crawler functions (readIndexJson, discoverStories, generateStoryUrl validation)

Coverage: 99.33% lines, 92.86% branches, 97.06% functions

Author: Robdel12

clients/storybook/tests/crawler.test.js

@@ -4,11 +4,16 @@
 
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import { writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import {
   extractStoryConfig,
   filterStories,
   generateStoryUrl,
   parseStories,
+  readIndexJson,
+  discoverStories,
 } from '../src/crawler.js';
 
 describe('parseStories', () => {
@@ -179,4 +184,116 @@ describe('generateStoryUrl', () => {
 
     assert.ok(url.includes('id=my%20story%2Fwith%20spaces'));
   });
+
+  it('should throw error for empty baseUrl', () => {
+    assert.throws(() => generateStoryUrl('', 'button--primary'), {
+      message: 'baseUrl must be a non-empty string',
+    });
+  });
+
+  it('should throw error for null baseUrl', () => {
+    assert.throws(() => generateStoryUrl(null, 'button--primary'), {
+      message: 'baseUrl must be a non-empty string',
+    });
+  });
+
+  it('should throw error for empty storyId', () => {
+    assert.throws(() => generateStoryUrl('http://localhost:6006', ''), {
+      message: 'storyId must be a non-empty string',
+    });
+  });
+
+  it('should throw error for null storyId', () => {
+    assert.throws(() => generateStoryUrl('http://localhost:6006', null), {
+      message: 'storyId must be a non-empty string',
+    });
+  });
+});
+
+describe('readIndexJson', () => {
+  let testDir;
+
+  it('should read and parse valid index.json', async () => {
+    testDir = join(tmpdir(), `storybook-test-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+
+    let indexData = {
+      v: 7,
+      entries: {
+        'test--story': { id: 'test--story', title: 'Test', name: 'Story', type: 'story' },
+      },
+    };
+    await writeFile(join(testDir, 'index.json'), JSON.stringify(indexData));
+
+    let result = await readIndexJson(testDir);
+
+    assert.deepEqual(result, indexData);
+
+    await rm(testDir, { recursive: true });
+  });
+
+  it('should throw error for missing index.json', async () => {
+    testDir = join(tmpdir(), `storybook-test-missing-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+
+    await assert.rejects(readIndexJson(testDir), /Failed to read Storybook index\.json/);
+
+    await rm(testDir, { recursive: true });
+  });
+
+  it('should throw error for invalid JSON', async () => {
+    testDir = join(tmpdir(), `storybook-test-invalid-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+    await writeFile(join(testDir, 'index.json'), 'not valid json');
+
+    await assert.rejects(readIndexJson(testDir), /Failed to read Storybook index\.json/);
+
+    await rm(testDir, { recursive: true });
+  });
+});
+
+describe('discoverStories', () => {
+  let testDir;
+
+  it('should discover and filter stories from storybook path', async () => {
+    testDir = join(tmpdir(), `storybook-test-discover-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+
+    let indexData = {
+      v: 7,
+      entries: {
+        'button--primary': { id: 'button--primary', title: 'Button', name: 'Primary', type: 'story' },
+        'button--secondary': { id: 'button--secondary', title: 'Button', name: 'Secondary', type: 'story' },
+        'card--default': { id: 'card--default', title: 'Card', name: 'Default', type: 'story' },
+      },
+    };
+    await writeFile(join(testDir, 'index.json'), JSON.stringify(indexData));
+
+    let stories = await discoverStories(testDir, { include: 'button*' });
+
+    assert.equal(stories.length, 2);
+    assert.ok(stories.every(s => s.id.startsWith('button')));
+
+    await rm(testDir, { recursive: true });
+  });
+
+  it('should return all stories when no filter', async () => {
+    testDir = join(tmpdir(), `storybook-test-discover-all-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+
+    let indexData = {
+      v: 7,
+      entries: {
+        'button--primary': { id: 'button--primary', title: 'Button', name: 'Primary', type: 'story' },
+        'card--default': { id: 'card--default', title: 'Card', name: 'Default', type: 'story' },
+      },
+    };
+    await writeFile(join(testDir, 'index.json'), JSON.stringify(indexData));
+
+    let stories = await discoverStories(testDir, {});
+
+    assert.equal(stories.length, 2);
+
+    await rm(testDir, { recursive: true });
+  });
 });

clients/storybook/tests/patterns.test.js

@@ -0,0 +1,193 @@
+/**
+ * Tests for pattern matching utilities
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  matchPattern,
+  filterByPattern,
+  findMatchingHook,
+} from '../src/utils/patterns.js';
+
+describe('matchPattern', () => {
+  it('should match exact string', () => {
+    assert.ok(matchPattern('button--primary', 'button--primary'));
+  });
+
+  it('should match with wildcard', () => {
+    assert.ok(matchPattern('button--primary', 'button*'));
+    assert.ok(matchPattern('button--secondary', 'button*'));
+  });
+
+  it('should match with double wildcard', () => {
+    assert.ok(matchPattern('components/atoms/button', 'components/**'));
+    assert.ok(matchPattern('components/atoms/button/primary', 'components/**'));
+  });
+
+  it('should not match different strings', () => {
+    assert.ok(!matchPattern('card--default', 'button*'));
+  });
+
+  it('should return true for empty pattern', () => {
+    assert.ok(matchPattern('anything', ''));
+    assert.ok(matchPattern('anything', null));
+  });
+
+  it('should return false for empty string', () => {
+    assert.ok(!matchPattern('', 'pattern'));
+    assert.ok(!matchPattern(null, 'pattern'));
+  });
+});
+
+describe('filterByPattern', () => {
+  let stories = [
+    { id: 'button--primary', title: 'Button' },
+    { id: 'button--secondary', title: 'Button' },
+    { id: 'card--default', title: 'Card' },
+  ];
+
+  it('should filter by include pattern', () => {
+    let filtered = filterByPattern(stories, 'button*', null);
+
+    assert.equal(filtered.length, 2);
+    assert.ok(filtered.every(s => s.id.startsWith('button')));
+  });
+
+  it('should filter by exclude pattern', () => {
+    let filtered = filterByPattern(stories, null, 'button*');
+
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].id, 'card--default');
+  });
+
+  it('should apply both include and exclude', () => {
+    let filtered = filterByPattern(stories, 'button*', 'button--secondary');
+
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].id, 'button--primary');
+  });
+
+  it('should return all stories when no patterns', () => {
+    let filtered = filterByPattern(stories, null, null);
+
+    assert.equal(filtered.length, 3);
+  });
+
+  it('should use title as fallback when no id', () => {
+    let storiesWithoutId = [
+      { title: 'Button' },
+      { title: 'Card' },
+    ];
+
+    let filtered = filterByPattern(storiesWithoutId, 'Button', null);
+
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].title, 'Button');
+  });
+});
+
+describe('findMatchingHook', () => {
+  it('should find matching hook from simple object format', () => {
+    let hook = () => {};
+    let interactions = {
+      'button*': hook,
+    };
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, interactions);
+
+    assert.equal(result, hook);
+  });
+
+  it('should return null when no match in simple format', () => {
+    let interactions = {
+      'card*': () => {},
+    };
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, interactions);
+
+    assert.equal(result, null);
+  });
+
+  it('should find matching hook from patterns array format', () => {
+    let hook = () => {};
+    let interactions = {
+      patterns: [
+        { match: 'card*', beforeScreenshot: () => {} },
+        { match: 'button*', beforeScreenshot: hook },
+      ],
+    };
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, interactions);
+
+    assert.equal(result, hook);
+  });
+
+  it('should return null when no match in patterns array format', () => {
+    let interactions = {
+      patterns: [
+        { match: 'card*', beforeScreenshot: () => {} },
+      ],
+    };
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, interactions);
+
+    assert.equal(result, null);
+  });
+
+  it('should return null for null interactions', () => {
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, null);
+
+    assert.equal(result, null);
+  });
+
+  it('should return null for undefined interactions', () => {
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, undefined);
+
+    assert.equal(result, null);
+  });
+
+  it('should return null for empty interactions object', () => {
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, {});
+
+    assert.equal(result, null);
+  });
+
+  it('should use title as fallback when no id', () => {
+    let hook = () => {};
+    let interactions = {
+      'Button*': hook,
+    };
+    let story = { title: 'Button' };
+
+    let result = findMatchingHook(story, interactions);
+
+    assert.equal(result, hook);
+  });
+
+  it('should return first matching hook in patterns array', () => {
+    let firstHook = () => 'first';
+    let secondHook = () => 'second';
+    let interactions = {
+      patterns: [
+        { match: 'button*', beforeScreenshot: firstHook },
+        { match: 'button--primary', beforeScreenshot: secondHook },
+      ],
+    };
+    let story = { id: 'button--primary' };
+
+    let result = findMatchingHook(story, interactions);
+
+    assert.equal(result, firstHook);
+  });
+});