test: add tests

nerdstep · nerdstep · commit b8d04efe5242 · 2025-06-13T11:29:29.000-07:00
diff --git a/src/__tests__/recipe-extractor.test.ts b/src/__tests__/recipe-extractor.test.ts
@@ -0,0 +1,138 @@
+import { beforeEach, describe, expect, it, spyOn } from 'bun:test'
+import { load } from 'cheerio'
+import type { ExtractorPlugin } from '../abstract-extractor-plugin'
+import { ExtractorNotFoundException } from '../exceptions'
+import { RecipeExtractor } from '../recipe-extractor'
+import type { ScraperDiagnostics } from '../scraper-diagnostics'
+import type { RecipeFields } from '../types/recipe.interface'
+
+describe('RecipeExtractor', () => {
+  const scraperName = 'TestScraper'
+  let diagnostics: ScraperDiagnostics
+
+  beforeEach(() => {
+    diagnostics = {
+      recordFailure: () => {},
+      recordSuccess: () => {},
+    } as unknown as ScraperDiagnostics
+  })
+
+  it('uses a single plugin to extract a field', async () => {
+    const pluginA = {
+      name: 'PluginA',
+      priority: 10,
+      $: load('<html><body></body></html>'),
+      supports: (field: keyof RecipeFields) => field === 'title',
+      extract: async (_: keyof RecipeFields) => 'PluginA-Name',
+    } as ExtractorPlugin
+
+    const extractor = new RecipeExtractor([pluginA], scraperName, diagnostics)
+    const result = await extractor.extract('title')
+    expect(result).toBe('PluginA-Name')
+  })
+
+  it('respects plugin priority (higher first)', async () => {
+    // lower priority returns L1, higher priority returns H1
+    const low = {
+      name: 'Low',
+      priority: 1,
+      $: load('<html><body></body></html>'),
+      supports: () => true,
+      extract: () => 'L1',
+    } as ExtractorPlugin
+    const high = {
+      name: 'High',
+      priority: 100,
+      $: load('<html><body></body></html>'),
+      supports: () => true,
+      extract: () => 'H1',
+    } as ExtractorPlugin
+
+    const spyLow = spyOn(low, 'extract')
+    const spyHigh = spyOn(high, 'extract')
+
+    const extractor = new RecipeExtractor([low, high], scraperName, diagnostics)
+    const result = await extractor.extract('title')
+    expect(result).toBe('H1')
+    expect(spyHigh).toHaveBeenCalled()
+    expect(spyLow).not.toHaveBeenCalled()
+  })
+
+  it('records plugin failures and continues to next plugin', async () => {
+    const err = new Error('fail1')
+    const bad = {
+      name: 'Bad',
+      priority: 50,
+      $: load('<html><body></body></html>'),
+      supports: () => true,
+      extract: () => {
+        throw err
+      },
+    } as ExtractorPlugin
+    const good = {
+      name: 'Good',
+      priority: 10,
+      $: load('<html><body></body></html>'),
+      supports: () => true,
+      extract: () => 'GoodValue',
+    } as ExtractorPlugin
+
+    const spyFailure = spyOn(diagnostics, 'recordFailure')
+    const extractor = new RecipeExtractor([bad, good], scraperName, diagnostics)
+    const result = await extractor.extract('title')
+    expect(result).toBe('GoodValue')
+    expect(spyFailure).toHaveBeenCalledWith('Bad', 'title', err)
+  })
+
+  it('uses site-specific extractor when provided', async () => {
+    const plugin = {
+      name: 'X',
+      priority: 0,
+      $: load('<html><body></body></html>'),
+      supports: () => false,
+      extract: () => 'X',
+    } as ExtractorPlugin
+
+    const extractor = new RecipeExtractor([plugin], scraperName, diagnostics)
+    const siteValue = await extractor.extract('title', (prev) => {
+      expect(prev).toBeUndefined()
+      return 'SiteName'
+    })
+    expect(siteValue).toBe('SiteName')
+  })
+
+  it('chains plugin result into site-specific extractor', async () => {
+    const plugin = {
+      name: 'P',
+      priority: 0,
+      $: load('<html><body></body></html>'),
+      supports: () => true,
+      extract: () => 'FromPlugin',
+    } as ExtractorPlugin
+
+    const extractor = new RecipeExtractor([plugin], scraperName, diagnostics)
+    const final = await extractor.extract('title', (prev) => {
+      expect(prev).toBe('FromPlugin')
+      return `${prev}-Site`
+    })
+    expect(final).toBe('FromPlugin-Site')
+  })
+
+  it('throws ExtractorNotFoundException when no plugin or extractor applies', async () => {
+    const plugin = {
+      name: 'None',
+      priority: 0,
+      $: load('<html><body></body></html>'),
+      supports: () => false,
+      extract: () => 'X',
+    } as ExtractorPlugin
+
+    const extractor = new RecipeExtractor([plugin], scraperName, diagnostics)
+    await expect(extractor.extract('title')).rejects.toThrow(
+      ExtractorNotFoundException,
+    )
+    await expect(extractor.extract('title')).rejects.toThrow(
+      'No extractor found for field: title',
+    )
+  })
+})
diff --git a/src/utils/__tests__/index.test.ts b/src/utils/__tests__/index.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  isDefined,
+  isFunction,
+  isNumber,
+  isPlainObject,
+  isString,
+} from '../index'
+
+describe('isDefined', () => {
+  it('returns false for undefined', () => {
+    let value: number | undefined
+    expect(isDefined(value)).toBe(false)
+  })
+
+  it('returns true for null or other values', () => {
+    expect(isDefined(null)).toBe(true)
+    expect(isDefined(0)).toBe(true)
+    expect(isDefined('')).toBe(true)
+    expect(isDefined(false)).toBe(true)
+  })
+})
+
+describe('isFunction', () => {
+  it('returns true for functions', () => {
+    expect(isFunction(() => {})).toBe(true)
+    expect(isFunction(function named() {})).toBe(true)
+    expect(isFunction(async () => {})).toBe(true)
+  })
+
+  it('returns false for non-functions', () => {
+    expect(isFunction(null)).toBe(false)
+    expect(isFunction({})).toBe(false)
+    expect(isFunction(123)).toBe(false)
+    expect(isFunction('fn')).toBe(false)
+    expect(isFunction([])).toBe(false)
+  })
+})
+
+describe('isNumber', () => {
+  it('returns true for numbers', () => {
+    expect(isNumber(0)).toBe(true)
+    expect(isNumber(42)).toBe(true)
+    expect(isNumber(-3.14)).toBe(true)
+    expect(isNumber(Number.NaN)).toBe(true)
+    expect(isNumber(Number.POSITIVE_INFINITY)).toBe(true)
+  })
+
+  it('returns false for non-numbers', () => {
+    expect(isNumber('123')).toBe(false)
+    expect(isNumber(null)).toBe(false)
+    expect(isNumber(undefined)).toBe(false)
+    expect(isNumber({})).toBe(false)
+    expect(isNumber(() => 1)).toBe(false)
+  })
+})
+
+describe('isPlainObject', () => {
+  it('returns true for plain object literals', () => {
+    expect(isPlainObject({})).toBe(true)
+    expect(isPlainObject({ a: 1, b: '2' })).toBe(true)
+    const obj = Object.create(Object.prototype)
+    expect(isPlainObject(obj)).toBe(true)
+  })
+
+  it('returns false for null, arrays, functions, and class instances', () => {
+    expect(isPlainObject(null)).toBe(false)
+    expect(isPlainObject([])).toBe(false)
+    expect(isPlainObject(() => {})).toBe(false)
+    class C {}
+    expect(isPlainObject(new C())).toBe(false)
+  })
+
+  it('returns false for objects with non-default prototype', () => {
+    const noProto = Object.create(null)
+    expect(isPlainObject(noProto)).toBe(false)
+  })
+})
+
+describe('isString', () => {
+  it('returns true for string primitives', () => {
+    expect(isString('')).toBe(true)
+    expect(isString('hello')).toBe(true)
+    expect(isString(String(123))).toBe(true)
+  })
+
+  it('returns false for non-strings', () => {
+    expect(isString(new String('str'))).toBe(false)
+    expect(isString(123)).toBe(false)
+    expect(isString(null)).toBe(false)
+    expect(isString(undefined)).toBe(false)
+    expect(isString({})).toBe(false)
+  })
+})
diff --git a/src/utils/__tests__/parsing.test.ts b/src/utils/__tests__/parsing.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'bun:test'
+import { normalizeString, parseMinutes, splitToList } from '../parsing'
+
+describe('normalizeString', () => {
+  it('trims leading and trailing whitespace', () => {
+    expect(normalizeString('  hello world  ')).toBe('hello world')
+  })
+
+  it('collapses multiple whitespace characters into single spaces', () => {
+    expect(normalizeString('foo   bar\tbaz\nqux')).toBe('foo bar baz qux')
+  })
+
+  it('returns empty string for null or undefined', () => {
+    expect(normalizeString(null)).toBe('')
+    expect(normalizeString(undefined)).toBe('')
+  })
+
+  it('returns empty string for input that becomes empty after trim', () => {
+    expect(normalizeString('    ')).toBe('')
+  })
+})
+
+describe('splitToList', () => {
+  it('returns empty array for empty input', () => {
+    expect(splitToList('', ',')).toEqual([])
+  })
+
+  it('splits by comma and trims items', () => {
+    const input = ' apple, banana ,  cherry ,,  '
+    expect(splitToList(input, ',')).toEqual(['apple', 'banana', 'cherry'])
+  })
+
+  it('splits by custom separator', () => {
+    const input = 'one|two| three | |four'
+    expect(splitToList(input, '|')).toEqual(['one', 'two', 'three', 'four'])
+  })
+
+  it('ignores items that normalize to empty strings', () => {
+    const input = 'a,, ,b'
+    expect(splitToList(input, ',')).toEqual(['a', 'b'])
+  })
+})
+
+describe('parseMinutes', () => {
+  it('parses hours and minutes', () => {
+    expect(parseMinutes('PT1H30M')).toBe(90)
+  })
+
+  it('parses only minutes', () => {
+    expect(parseMinutes('PT45M')).toBe(45)
+  })
+
+  it('parses only seconds and rounds to minutes', () => {
+    expect(parseMinutes('PT90S')).toBe(2)
+  })
+
+  it('parses hours only', () => {
+    expect(parseMinutes('PT2H')).toBe(120)
+  })
+
+  it('parses days and hours', () => {
+    // 1 day = 24h, +2h = 26h -> 1560 minutes
+    expect(parseMinutes('P1DT2H')).toBe(1560)
+  })
+
+  it('throws on invalid input', () => {
+    expect(() => parseMinutes('')).toThrow('invalid duration')
+  })
+})
