69 lines
2.9 KiB
JavaScript
69 lines
2.9 KiB
JavaScript
import { test } from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { alignParsedIngredients } from '#import-recipes/recipes/alignParsedIngredients.js'
|
|
|
|
const LINES = ['200 g de tomates', 'une poignée de pois chiches', 'sel au goût']
|
|
const PARSED = [
|
|
{ raw: '200 g de tomates', name: 'tomates', quantity: 200, unit: 'g', imprecise: false },
|
|
{ raw: 'une poignée de pois chiches', name: 'pois chiches', quantity: 1, unit: 'poignée', imprecise: true },
|
|
{ raw: 'sel au goût', name: 'sel', quantity: null, unit: null, imprecise: true }
|
|
]
|
|
|
|
test('keeps a split that already matches the raw lines', () => {
|
|
const { parsedIngredients, repaired } = alignParsedIngredients(LINES, PARSED)
|
|
assert.equal(repaired, 0)
|
|
assert.deepEqual(parsedIngredients, PARSED)
|
|
})
|
|
|
|
test('keeps imprecise units as written, never converted', () => {
|
|
const { parsedIngredients } = alignParsedIngredients(LINES, PARSED)
|
|
assert.equal(parsedIngredients[1].unit, 'poignée')
|
|
assert.equal(parsedIngredients[1].imprecise, true)
|
|
assert.equal(parsedIngredients[2].quantity, null)
|
|
})
|
|
|
|
test('puts a reordered split back in the order of the raw lines', () => {
|
|
const shuffled = [PARSED[2], PARSED[0], PARSED[1]]
|
|
const { parsedIngredients, repaired } = alignParsedIngredients(LINES, shuffled)
|
|
assert.deepEqual(parsedIngredients.map((entry) => entry.raw), LINES)
|
|
assert.equal(parsedIngredients[0].name, 'tomates')
|
|
assert.equal(repaired, 3)
|
|
})
|
|
|
|
// The model rewrote the line: the raw line wins, and what it invented is dropped
|
|
// rather than trusted.
|
|
test('replaces a rewritten entry by an openly imprecise one', () => {
|
|
const rewritten = [
|
|
{ raw: '200 grammes de tomates', name: 'tomate', quantity: 200, unit: 'g', imprecise: false },
|
|
PARSED[1],
|
|
PARSED[2]
|
|
]
|
|
const { parsedIngredients, repaired } = alignParsedIngredients(LINES, rewritten)
|
|
assert.equal(repaired, 1)
|
|
assert.deepEqual(parsedIngredients[0], {
|
|
raw: '200 g de tomates',
|
|
name: '200 g de tomates',
|
|
quantity: null,
|
|
unit: null,
|
|
imprecise: true
|
|
})
|
|
})
|
|
|
|
test('always returns one entry per raw line, in the same order', () => {
|
|
const { parsedIngredients, repaired } = alignParsedIngredients(LINES, [PARSED[0]])
|
|
assert.equal(parsedIngredients.length, LINES.length)
|
|
assert.deepEqual(parsedIngredients.map((entry) => entry.raw), LINES)
|
|
assert.equal(repaired, 2)
|
|
assert.equal(parsedIngredients[2].imprecise, true)
|
|
})
|
|
|
|
test('never keeps a quantity that is not a finite number', () => {
|
|
const broken = [{ raw: '200 g de tomates', name: 'tomates', quantity: '200', unit: 'g', imprecise: false }]
|
|
const { parsedIngredients } = alignParsedIngredients(['200 g de tomates'], broken)
|
|
assert.equal(parsedIngredients[0].quantity, null)
|
|
})
|
|
|
|
test('survives a missing or invalid split', () => {
|
|
assert.deepEqual(alignParsedIngredients([], undefined), { parsedIngredients: [], repaired: 0 })
|
|
assert.deepEqual(alignParsedIngredients(undefined, PARSED), { parsedIngredients: [], repaired: 0 })
|
|
})
|