Hera Zhao
e9626a08b9
All checks were successful
PR Preview / test (pull_request) Has been skipped
Deploy Production / test (push) Successful in 7s
PR Preview / teardown-preview (pull_request) Successful in 14s
Test / unit-test (push) Successful in 5s
PR Preview / deploy-preview (pull_request) Has been skipped
Test / build-check (push) Successful in 4s
Deploy Production / deploy (push) Successful in 7s
Test / e2e-test (push) Successful in 53s
- parseOilChunk: 无数字默认1滴、混合格式、_ml标记 - findOil: 2字不模糊匹配、同音词和子串仍可用 - parseMultiRecipes: 多配方分割、空行/分号、名称识别、去重 - e2e: audit-log create_recipe → share_recipe Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
527 lines
19 KiB
JavaScript
527 lines
19 KiB
JavaScript
import { describe, it, expect } from 'vitest'
|
||
import {
|
||
editDistance,
|
||
findOil,
|
||
greedyMatchOils,
|
||
parseOilChunk,
|
||
parseSingleBlock,
|
||
splitRawIntoBlocks,
|
||
parseMultiRecipes,
|
||
OIL_HOMOPHONES,
|
||
} from '../composables/useSmartPaste'
|
||
import prodData from './fixtures/production-data.json'
|
||
|
||
const oilNames = Object.keys(prodData.oils)
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// editDistance
|
||
// ---------------------------------------------------------------------------
|
||
describe('editDistance', () => {
|
||
it('returns 0 for identical strings', () => {
|
||
expect(editDistance('abc', 'abc')).toBe(0)
|
||
expect(editDistance('薰衣草', '薰衣草')).toBe(0)
|
||
})
|
||
|
||
it('returns correct distance for single insertion', () => {
|
||
expect(editDistance('abc', 'abcd')).toBe(1)
|
||
})
|
||
|
||
it('returns correct distance for single deletion', () => {
|
||
expect(editDistance('abcd', 'abc')).toBe(1)
|
||
})
|
||
|
||
it('returns correct distance for single substitution', () => {
|
||
expect(editDistance('abc', 'aXc')).toBe(1)
|
||
})
|
||
|
||
it('handles empty strings', () => {
|
||
expect(editDistance('', '')).toBe(0)
|
||
expect(editDistance('abc', '')).toBe(3)
|
||
expect(editDistance('', 'abc')).toBe(3)
|
||
})
|
||
|
||
it('handles Chinese characters', () => {
|
||
expect(editDistance('薰衣草', '薰衣')).toBe(1)
|
||
expect(editDistance('博荷', '薄荷')).toBe(1)
|
||
expect(editDistance('永久化', '永久花')).toBe(1)
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// findOil
|
||
// ---------------------------------------------------------------------------
|
||
describe('findOil', () => {
|
||
// Exact match
|
||
it('finds exact oil name: 薰衣草', () => {
|
||
expect(findOil('薰衣草', oilNames)).toBe('薰衣草')
|
||
})
|
||
|
||
it('finds exact oil name: 乳香', () => {
|
||
expect(findOil('乳香', oilNames)).toBe('乳香')
|
||
})
|
||
|
||
it('finds exact oil name: 椒样薄荷', () => {
|
||
expect(findOil('椒样薄荷', oilNames)).toBe('椒样薄荷')
|
||
})
|
||
|
||
// Homophone correction
|
||
it('corrects 相貌 → 香茅', () => {
|
||
expect(findOil('相貌', oilNames)).toBe('香茅')
|
||
})
|
||
|
||
it('corrects 如香 → 乳香', () => {
|
||
expect(findOil('如香', oilNames)).toBe('乳香')
|
||
})
|
||
|
||
it('corrects 博荷 → 薄荷 (but 薄荷 is not a standalone oil)', () => {
|
||
// OIL_HOMOPHONES maps 博荷 → 薄荷, but 薄荷 is not in oilNames
|
||
// (only 椒样薄荷, 清醇薄荷, etc. exist). The homophone check requires
|
||
// the canonical name to be in oilNames, so it falls through.
|
||
// 博荷 (2 chars) is too short for substring/edit-distance to match reliably.
|
||
const result = findOil('博荷', oilNames)
|
||
// Verifies the actual behavior: null because 薄荷 is not in oilNames
|
||
expect(result).toBeNull()
|
||
})
|
||
|
||
it('corrects 永久化 → 永久花', () => {
|
||
expect(findOil('永久化', oilNames)).toBe('永久花')
|
||
})
|
||
|
||
it('corrects 洋甘菊 → 罗马洋甘菊', () => {
|
||
expect(findOil('洋甘菊', oilNames)).toBe('罗马洋甘菊')
|
||
})
|
||
|
||
it('corrects 椒样博荷 → 椒样薄荷', () => {
|
||
expect(findOil('椒样博荷', oilNames)).toBe('椒样薄荷')
|
||
})
|
||
|
||
it('corrects 茶树油 → 茶树', () => {
|
||
expect(findOil('茶树油', oilNames)).toBe('茶树')
|
||
})
|
||
|
||
it('corrects 薰衣草油 → 薰衣草', () => {
|
||
expect(findOil('薰衣草油', oilNames)).toBe('薰衣草')
|
||
})
|
||
|
||
// Substring match
|
||
it('matches substring: input contained in oil name', () => {
|
||
// 薄荷 is a substring of 椒样薄荷, 清醇薄荷, 绿薄荷, 薄荷呵护
|
||
const result = findOil('薄荷', oilNames)
|
||
expect(result).not.toBeNull()
|
||
expect(result).toContain('薄荷')
|
||
})
|
||
|
||
// Missing char match
|
||
it('handles missing one character: 茶 → 茶树 (via substring)', () => {
|
||
const result = findOil('茶树呵', oilNames)
|
||
// 茶树呵护 is 4 chars, input is 3 chars — missing one char
|
||
expect(result).toBe('茶树呵护')
|
||
})
|
||
|
||
// Returns null for garbage
|
||
it('returns null for empty input', () => {
|
||
expect(findOil('', oilNames)).toBeNull()
|
||
})
|
||
|
||
it('returns null for whitespace-only input', () => {
|
||
expect(findOil(' ', oilNames)).toBeNull()
|
||
})
|
||
|
||
it('returns null for completely unrelated text', () => {
|
||
expect(findOil('XYZXYZXYZXYZ', oilNames)).toBeNull()
|
||
})
|
||
|
||
// Edge cases
|
||
it('handles single character input', () => {
|
||
// Single char — may or may not match via substring
|
||
const result = findOil('柠', oilNames)
|
||
// 柠 is a substring of 柠檬, 柠檬草, etc.
|
||
expect(result).not.toBeNull()
|
||
})
|
||
|
||
it('trims whitespace from input', () => {
|
||
expect(findOil(' 薰衣草 ', oilNames)).toBe('薰衣草')
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// greedyMatchOils
|
||
// ---------------------------------------------------------------------------
|
||
describe('greedyMatchOils', () => {
|
||
it('splits concatenated oil names: 薰衣草茶树 → [薰衣草, 茶树]', () => {
|
||
const result = greedyMatchOils('薰衣草茶树', oilNames)
|
||
expect(result).toEqual(['薰衣草', '茶树'])
|
||
})
|
||
|
||
it('handles single oil', () => {
|
||
const result = greedyMatchOils('乳香', oilNames)
|
||
expect(result).toEqual(['乳香'])
|
||
})
|
||
|
||
it('returns empty for no match', () => {
|
||
const result = greedyMatchOils('XYZXYZ', oilNames)
|
||
expect(result).toEqual([])
|
||
})
|
||
|
||
it('prefers longest match', () => {
|
||
// 椒样薄荷 should match as one oil, not 椒 + something
|
||
const result = greedyMatchOils('椒样薄荷', oilNames)
|
||
expect(result).toEqual(['椒样薄荷'])
|
||
})
|
||
|
||
it('handles three concatenated oils', () => {
|
||
const result = greedyMatchOils('薰衣草茶树乳香', oilNames)
|
||
expect(result).toEqual(['薰衣草', '茶树', '乳香'])
|
||
})
|
||
|
||
it('handles homophones in concatenated text', () => {
|
||
// 相貌 is a homophone for 香茅
|
||
const result = greedyMatchOils('相貌', oilNames)
|
||
expect(result).toEqual(['香茅'])
|
||
})
|
||
|
||
it('skips unrecognized characters between oils', () => {
|
||
const result = greedyMatchOils('薰衣草X茶树', oilNames)
|
||
expect(result).toEqual(['薰衣草', '茶树'])
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// parseOilChunk
|
||
// ---------------------------------------------------------------------------
|
||
describe('parseOilChunk', () => {
|
||
it('parses "薰衣草5" → [{oil: 薰衣草, drops: 5}]', () => {
|
||
const result = parseOilChunk('薰衣草5', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]).toEqual({ oil: '薰衣草', drops: 5 })
|
||
})
|
||
|
||
it('parses "芳香调理8永久花10" → two ingredients', () => {
|
||
const result = parseOilChunk('芳香调理8永久花10', oilNames)
|
||
expect(result).toHaveLength(2)
|
||
expect(result[0]).toEqual({ oil: '芳香调理', drops: 8 })
|
||
expect(result[1]).toEqual({ oil: '永久花', drops: 10 })
|
||
})
|
||
|
||
it('parses "薰衣草3ml" → [{薰衣草, drops: 60, _ml: 3}] (3ml * 20)', () => {
|
||
const result = parseOilChunk('薰衣草3ml', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]).toMatchObject({ oil: '薰衣草', drops: 60, _ml: 3 })
|
||
})
|
||
|
||
it('parses "薰衣草5毫升" → [{薰衣草, drops: 100, _ml: 5}] (5 * 20)', () => {
|
||
const result = parseOilChunk('薰衣草5毫升', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]).toMatchObject({ oil: '薰衣草', drops: 100, _ml: 5 })
|
||
})
|
||
|
||
it('parses "薰衣草3ML" → case-insensitive ml', () => {
|
||
const result = parseOilChunk('薰衣草3ML', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]).toMatchObject({ oil: '薰衣草', drops: 60, _ml: 3 })
|
||
})
|
||
|
||
it('handles decimal drops "乳香1.5"', () => {
|
||
const result = parseOilChunk('乳香1.5', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0].oil).toBe('乳香')
|
||
expect(result[0].drops).toBeCloseTo(1.5)
|
||
})
|
||
|
||
it('handles "滴" unit without conversion', () => {
|
||
const result = parseOilChunk('薰衣草5滴', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]).toEqual({ oil: '薰衣草', drops: 5 })
|
||
})
|
||
|
||
it('parses oil name without number → default 1 drop', () => {
|
||
const result = parseOilChunk('薰衣草', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]).toEqual({ oil: '薰衣草', drops: 1 })
|
||
})
|
||
|
||
it('parses multiple oil names without numbers', () => {
|
||
const result = parseOilChunk('薰衣草 茶树 乳香', oilNames)
|
||
expect(result).toHaveLength(3)
|
||
expect(result.map(r => r.oil)).toEqual(['薰衣草', '茶树', '乳香'])
|
||
expect(result.every(r => r.drops === 1)).toBe(true)
|
||
})
|
||
|
||
it('parses mixed: some with numbers, some without', () => {
|
||
const result = parseOilChunk('薰衣草3茶树乳香2', oilNames)
|
||
expect(result).toHaveLength(3)
|
||
expect(result[0]).toEqual({ oil: '薰衣草', drops: 3 })
|
||
expect(result[1]).toEqual({ oil: '茶树', drops: 1 })
|
||
expect(result[2]).toEqual({ oil: '乳香', drops: 2 })
|
||
})
|
||
|
||
it('parses trailing oil after last number', () => {
|
||
const result = parseOilChunk('薰衣草3茶树2乳香', oilNames)
|
||
expect(result).toHaveLength(3)
|
||
expect(result[2]).toEqual({ oil: '乳香', drops: 1 })
|
||
})
|
||
|
||
it('preserves _ml for ml unit (coconut oil)', () => {
|
||
const result = parseOilChunk('椰子油15ml', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]._ml).toBe(15)
|
||
expect(result[0].drops).toBe(300)
|
||
})
|
||
|
||
it('no _ml for drops unit', () => {
|
||
const result = parseOilChunk('椰子油15滴', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]._ml).toBeUndefined()
|
||
expect(result[0].drops).toBe(15)
|
||
})
|
||
|
||
it('no _ml for no unit', () => {
|
||
const result = parseOilChunk('椰子油15', oilNames)
|
||
expect(result).toHaveLength(1)
|
||
expect(result[0]._ml).toBeUndefined()
|
||
expect(result[0].drops).toBe(15)
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// parseSingleBlock
|
||
// ---------------------------------------------------------------------------
|
||
describe('parseSingleBlock', () => {
|
||
it('parses "助眠，薰衣草15，雪松10" correctly', () => {
|
||
const result = parseSingleBlock('助眠，薰衣草15，雪松10', oilNames)
|
||
expect(result.name).toBe('助眠')
|
||
expect(result.ingredients).toHaveLength(2)
|
||
expect(result.ingredients[0]).toEqual({ oil: '薰衣草', drops: 15 })
|
||
expect(result.ingredients[1]).toEqual({ oil: '雪松', drops: 10 })
|
||
})
|
||
|
||
it('parses "头疗，椒样薄荷5，生姜3，迷迭香3" correctly', () => {
|
||
const result = parseSingleBlock('头疗，椒样薄荷5，生姜3，迷迭香3', oilNames)
|
||
expect(result.name).toBe('头疗')
|
||
expect(result.ingredients).toHaveLength(3)
|
||
expect(result.ingredients[0]).toEqual({ oil: '椒样薄荷', drops: 5 })
|
||
expect(result.ingredients[1]).toEqual({ oil: '生姜', drops: 3 })
|
||
expect(result.ingredients[2]).toEqual({ oil: '迷迭香', drops: 3 })
|
||
})
|
||
|
||
it('handles recipe with no name (all parts have oils)', () => {
|
||
const result = parseSingleBlock('薰衣草10，茶树5', oilNames)
|
||
expect(result.name).toBe('')
|
||
expect(result.ingredients).toHaveLength(2)
|
||
})
|
||
|
||
it('deduplicates ingredients (sums drops)', () => {
|
||
const result = parseSingleBlock('测试，薰衣草5，薰衣草3', oilNames)
|
||
expect(result.ingredients).toHaveLength(1)
|
||
expect(result.ingredients[0]).toEqual({ oil: '薰衣草', drops: 8 })
|
||
})
|
||
|
||
it('handles English commas as separator', () => {
|
||
const result = parseSingleBlock('助眠,薰衣草15,雪松10', oilNames)
|
||
expect(result.name).toBe('助眠')
|
||
expect(result.ingredients).toHaveLength(2)
|
||
})
|
||
|
||
it('handles newlines as separator', () => {
|
||
const result = parseSingleBlock('助眠\n薰衣草15\n雪松10', oilNames)
|
||
expect(result.name).toBe('助眠')
|
||
expect(result.ingredients).toHaveLength(2)
|
||
})
|
||
|
||
it('collects notFound oils', () => {
|
||
const result = parseSingleBlock('测试，不存在的油99', oilNames)
|
||
expect(result.notFound.length).toBeGreaterThan(0)
|
||
})
|
||
|
||
it('parses complex real-world recipe', () => {
|
||
const result = parseSingleBlock(
|
||
'酸痛包，椒样薄荷1，舒缓2，芳香调理1，冬青1，柠檬草1，生姜2，茶树1，乳香1，椰子油10',
|
||
oilNames
|
||
)
|
||
expect(result.name).toBe('酸痛包')
|
||
expect(result.ingredients).toHaveLength(9)
|
||
// Verify the first and last
|
||
expect(result.ingredients[0]).toEqual({ oil: '椒样薄荷', drops: 1 })
|
||
expect(result.ingredients[8]).toEqual({ oil: '椰子油', drops: 10 })
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// splitRawIntoBlocks
|
||
// ---------------------------------------------------------------------------
|
||
describe('splitRawIntoBlocks', () => {
|
||
it('splits by blank lines', () => {
|
||
const blocks = splitRawIntoBlocks('助眠，薰衣草15\n\n头疗，薄荷5', oilNames)
|
||
expect(blocks).toHaveLength(2)
|
||
expect(blocks[0]).toBe('助眠，薰衣草15')
|
||
expect(blocks[1]).toBe('头疗，薄荷5')
|
||
})
|
||
|
||
it('splits by semicolons', () => {
|
||
const blocks = splitRawIntoBlocks('助眠，薰衣草15；头疗，薄荷5', oilNames)
|
||
expect(blocks).toHaveLength(2)
|
||
})
|
||
|
||
it('splits by English semicolons', () => {
|
||
const blocks = splitRawIntoBlocks('助眠，薰衣草15;头疗，薄荷5', oilNames)
|
||
expect(blocks).toHaveLength(2)
|
||
})
|
||
|
||
it('single block stays single', () => {
|
||
const blocks = splitRawIntoBlocks('助眠，薰衣草15，雪松10', oilNames)
|
||
expect(blocks).toHaveLength(1)
|
||
})
|
||
|
||
it('filters out empty blocks', () => {
|
||
const blocks = splitRawIntoBlocks('助眠\n\n\n\n头疗', oilNames)
|
||
expect(blocks).toHaveLength(2)
|
||
})
|
||
|
||
it('handles mixed separators', () => {
|
||
const blocks = splitRawIntoBlocks('A；B\n\nC', oilNames)
|
||
expect(blocks).toHaveLength(3)
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// OIL_HOMOPHONES
|
||
// ---------------------------------------------------------------------------
|
||
describe('OIL_HOMOPHONES', () => {
|
||
it('is an object with string→string mappings', () => {
|
||
expect(typeof OIL_HOMOPHONES).toBe('object')
|
||
for (const [key, value] of Object.entries(OIL_HOMOPHONES)) {
|
||
expect(typeof key).toBe('string')
|
||
expect(typeof value).toBe('string')
|
||
}
|
||
})
|
||
|
||
it('maps all aliases to oils that exist in the fixture', () => {
|
||
for (const canonical of Object.values(OIL_HOMOPHONES)) {
|
||
// The canonical name should exist in either the oil list or be a common base name
|
||
// Some like 薄荷 might not be a standalone oil but it's used as a component
|
||
expect(typeof canonical).toBe('string')
|
||
expect(canonical.length).toBeGreaterThan(0)
|
||
}
|
||
})
|
||
|
||
it('contains expected entries', () => {
|
||
expect(OIL_HOMOPHONES['相貌']).toBe('香茅')
|
||
expect(OIL_HOMOPHONES['如香']).toBe('乳香')
|
||
expect(OIL_HOMOPHONES['博荷']).toBe('薄荷')
|
||
expect(OIL_HOMOPHONES['永久化']).toBe('永久花')
|
||
expect(OIL_HOMOPHONES['茶树油']).toBe('茶树')
|
||
expect(OIL_HOMOPHONES['薰衣草油']).toBe('薰衣草')
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// findOil — short string fuzzy match restriction
|
||
// ---------------------------------------------------------------------------
|
||
describe('findOil — short string protection', () => {
|
||
it('does not fuzzy-match 2-char non-oil text', () => {
|
||
// 美容 should NOT match any oil via edit distance
|
||
expect(findOil('美容', oilNames)).toBeNull()
|
||
})
|
||
|
||
it('still matches 2-char exact oil names', () => {
|
||
expect(findOil('乳香', oilNames)).toBe('乳香')
|
||
expect(findOil('茶树', oilNames)).toBe('茶树')
|
||
})
|
||
|
||
it('still matches 2-char homophones', () => {
|
||
expect(findOil('如香', oilNames)).toBe('乳香')
|
||
})
|
||
|
||
it('still matches 2-char substrings', () => {
|
||
// 薄荷 is a substring of 椒样薄荷 etc.
|
||
const result = findOil('薄荷', oilNames)
|
||
expect(result).not.toBeNull()
|
||
})
|
||
|
||
it('fuzzy matches 3+ char inputs via edit distance', () => {
|
||
// 永久化 → 永久花 (1 edit)
|
||
expect(findOil('永久化', oilNames)).toBe('永久花')
|
||
})
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// parseMultiRecipes
|
||
// ---------------------------------------------------------------------------
|
||
describe('parseMultiRecipes', () => {
|
||
it('parses single recipe with name', () => {
|
||
const results = parseMultiRecipes('助眠，薰衣草3，茶树2', oilNames)
|
||
expect(results).toHaveLength(1)
|
||
expect(results[0].name).toBe('助眠')
|
||
expect(results[0].ingredients).toHaveLength(2)
|
||
})
|
||
|
||
it('splits two recipes by name detection', () => {
|
||
const results = parseMultiRecipes('助眠 薰衣草3 茶树2 头疗 柠檬5 椒样薄荷3', oilNames)
|
||
expect(results).toHaveLength(2)
|
||
expect(results[0].name).toBe('助眠')
|
||
expect(results[1].name).toBe('头疗')
|
||
})
|
||
|
||
it('splits by blank lines', () => {
|
||
const results = parseMultiRecipes('助眠\n薰衣草3\n\n头疗\n柠檬5', oilNames)
|
||
expect(results).toHaveLength(2)
|
||
expect(results[0].name).toBe('助眠')
|
||
expect(results[1].name).toBe('头疗')
|
||
})
|
||
|
||
it('splits by semicolons when both sides have oils', () => {
|
||
const results = parseMultiRecipes('助眠，薰衣草3，茶树2;头疗，柠檬5', oilNames)
|
||
expect(results).toHaveLength(2)
|
||
})
|
||
|
||
it('does NOT split by semicolons when one side has no oil', () => {
|
||
const results = parseMultiRecipes('助眠;薰衣草3，茶树2', oilNames)
|
||
expect(results).toHaveLength(1)
|
||
expect(results[0].ingredients.length).toBeGreaterThanOrEqual(2)
|
||
})
|
||
|
||
it('handles oils without numbers (default 1 drop)', () => {
|
||
const results = parseMultiRecipes('头疗，薰衣草，茶树，乳香', oilNames)
|
||
expect(results).toHaveLength(1)
|
||
expect(results[0].name).toBe('头疗')
|
||
expect(results[0].ingredients).toHaveLength(3)
|
||
expect(results[0].ingredients.every(i => i.drops === 1)).toBe(true)
|
||
})
|
||
|
||
it('recognizes non-oil text with number as recipe name (first part)', () => {
|
||
// 美容1 is not an oil, should be treated as name "美容"
|
||
const results = parseMultiRecipes('美容1 牛至2 乳香3', oilNames)
|
||
expect(results).toHaveLength(1)
|
||
expect(results[0].name).toBe('美容')
|
||
expect(results[0].ingredients).toHaveLength(2)
|
||
})
|
||
|
||
it('returns empty name when no name detected', () => {
|
||
const results = parseMultiRecipes('薰衣草3，茶树2', oilNames)
|
||
expect(results).toHaveLength(1)
|
||
expect(results[0].name).toBe('')
|
||
})
|
||
|
||
it('deduplicates ingredients within a recipe', () => {
|
||
const results = parseMultiRecipes('测试 薰衣草3 薰衣草2', oilNames)
|
||
expect(results[0].ingredients).toHaveLength(1)
|
||
expect(results[0].ingredients[0].drops).toBe(5)
|
||
})
|
||
|
||
it('handles coconut oil with ml unit', () => {
|
||
const results = parseMultiRecipes('测试 薰衣草3 椰子油15ml', oilNames)
|
||
const coco = results[0].ingredients.find(i => i.oil === '椰子油')
|
||
expect(coco).toBeTruthy()
|
||
expect(coco._ml).toBe(15)
|
||
})
|
||
|
||
it('handles complex real-world multi-recipe input', () => {
|
||
const input = '美容 牛至2 迷迭香3 乳香4 椰子油15 头疗七八九 檀香3 乳香4 薰衣草3'
|
||
const results = parseMultiRecipes(input, oilNames)
|
||
expect(results).toHaveLength(2)
|
||
expect(results[0].name).toBe('美容')
|
||
expect(results[0].ingredients.find(i => i.oil === '椰子油')).toBeTruthy()
|
||
expect(results[1].name).toBe('头疗七八九')
|
||
})
|
||
})
|