|
4 | 4 | import { describe, expect, it, vi } from 'vitest' |
5 | 5 | import type { ExecutionContext } from '@/executor/types' |
6 | 6 | import type { VariableResolver } from '@/executor/variables/resolver' |
7 | | -import { findEffectiveContainerId, resolveArrayInput } from './subflow-utils' |
| 7 | +import { findEffectiveContainerId, resolveArrayInputAsync } from './subflow-utils' |
8 | 8 |
|
9 | | -describe('resolveArrayInput', () => { |
| 9 | +describe('resolveArrayInputAsync', () => { |
10 | 10 | const fakeCtx = {} as unknown as ExecutionContext |
11 | 11 |
|
12 | | - it('returns arrays as-is', () => { |
13 | | - expect(resolveArrayInput(fakeCtx, [1, 2, 3], null)).toEqual([1, 2, 3]) |
| 12 | + it('returns arrays as-is', async () => { |
| 13 | + await expect(resolveArrayInputAsync(fakeCtx, [1, 2, 3], null)).resolves.toEqual([1, 2, 3]) |
14 | 14 | }) |
15 | 15 |
|
16 | | - it('converts plain objects to entries', () => { |
17 | | - expect(resolveArrayInput(fakeCtx, { a: 1, b: 2 }, null)).toEqual([ |
| 16 | + it('converts plain objects to entries', async () => { |
| 17 | + await expect(resolveArrayInputAsync(fakeCtx, { a: 1, b: 2 }, null)).resolves.toEqual([ |
18 | 18 | ['a', 1], |
19 | 19 | ['b', 2], |
20 | 20 | ]) |
21 | 21 | }) |
22 | 22 |
|
23 | | - it('returns empty array when a pure reference resolves to null (skipped block)', () => { |
| 23 | + it('returns empty array when a pure reference resolves to null (skipped block)', async () => { |
24 | 24 | // `resolveSingleReference` returns `null` for a reference that points at a |
25 | 25 | // block that exists in the workflow but did not execute on this path. |
26 | 26 | // A loop/parallel over such a reference should run zero iterations rather |
27 | 27 | // than fail the workflow. |
28 | 28 | const resolver = { |
29 | | - resolveSingleReference: vi.fn().mockReturnValue(null), |
| 29 | + resolveSingleReference: vi.fn().mockResolvedValue(null), |
30 | 30 | } as unknown as VariableResolver |
31 | 31 |
|
32 | | - const result = resolveArrayInput(fakeCtx, '<SkippedBlock.result.items>', resolver) |
| 32 | + const result = await resolveArrayInputAsync(fakeCtx, '<SkippedBlock.result.items>', resolver) |
33 | 33 |
|
34 | 34 | expect(result).toEqual([]) |
35 | 35 | expect(resolver.resolveSingleReference).toHaveBeenCalled() |
36 | 36 | }) |
37 | 37 |
|
38 | | - it('returns the array from a pure reference that resolved to an array', () => { |
| 38 | + it('returns the array from a pure reference that resolved to an array', async () => { |
39 | 39 | const resolver = { |
40 | | - resolveSingleReference: vi.fn().mockReturnValue([1, 2, 3]), |
| 40 | + resolveSingleReference: vi.fn().mockResolvedValue([1, 2, 3]), |
41 | 41 | } as unknown as VariableResolver |
42 | 42 |
|
43 | | - expect(resolveArrayInput(fakeCtx, '<Block.items>', resolver)).toEqual([1, 2, 3]) |
| 43 | + await expect(resolveArrayInputAsync(fakeCtx, '<Block.items>', resolver)).resolves.toEqual([ |
| 44 | + 1, 2, 3, |
| 45 | + ]) |
44 | 46 | }) |
45 | 47 |
|
46 | | - it('converts resolved objects to entries', () => { |
| 48 | + it('converts resolved objects to entries', async () => { |
47 | 49 | const resolver = { |
48 | | - resolveSingleReference: vi.fn().mockReturnValue({ x: 1, y: 2 }), |
| 50 | + resolveSingleReference: vi.fn().mockResolvedValue({ x: 1, y: 2 }), |
49 | 51 | } as unknown as VariableResolver |
50 | 52 |
|
51 | | - expect(resolveArrayInput(fakeCtx, '<Block.obj>', resolver)).toEqual([ |
| 53 | + await expect(resolveArrayInputAsync(fakeCtx, '<Block.obj>', resolver)).resolves.toEqual([ |
52 | 54 | ['x', 1], |
53 | 55 | ['y', 2], |
54 | 56 | ]) |
55 | 57 | }) |
56 | 58 |
|
57 | | - it('throws when a pure reference resolves to a non-array, non-object, non-null value', () => { |
| 59 | + it('throws when a pure reference resolves to a non-array, non-object, non-null value', async () => { |
58 | 60 | const resolver = { |
59 | | - resolveSingleReference: vi.fn().mockReturnValue(42), |
| 61 | + resolveSingleReference: vi.fn().mockResolvedValue(42), |
60 | 62 | } as unknown as VariableResolver |
61 | 63 |
|
62 | | - expect(() => resolveArrayInput(fakeCtx, '<Block.count>', resolver)).toThrow( |
| 64 | + await expect(resolveArrayInputAsync(fakeCtx, '<Block.count>', resolver)).rejects.toThrow( |
63 | 65 | /did not resolve to an array or object/ |
64 | 66 | ) |
65 | 67 | }) |
66 | 68 |
|
67 | | - it('throws when a pure reference resolves to undefined (unknown block)', () => { |
| 69 | + it('throws when a pure reference resolves to undefined (unknown block)', async () => { |
68 | 70 | // `undefined` means the reference could not be matched to any block at |
69 | 71 | // all (typo / deleted block). This must still fail loudly. |
70 | 72 | const resolver = { |
71 | | - resolveSingleReference: vi.fn().mockReturnValue(undefined), |
| 73 | + resolveSingleReference: vi.fn().mockResolvedValue(undefined), |
72 | 74 | } as unknown as VariableResolver |
73 | 75 |
|
74 | | - expect(() => resolveArrayInput(fakeCtx, '<Missing.items>', resolver)).toThrow( |
| 76 | + await expect(resolveArrayInputAsync(fakeCtx, '<Missing.items>', resolver)).rejects.toThrow( |
75 | 77 | /did not resolve to an array or object/ |
76 | 78 | ) |
77 | 79 | }) |
78 | 80 |
|
79 | | - it('parses a JSON array string', () => { |
80 | | - expect(resolveArrayInput(fakeCtx, '[1, 2, 3]', null)).toEqual([1, 2, 3]) |
| 81 | + it('parses a JSON array string', async () => { |
| 82 | + await expect(resolveArrayInputAsync(fakeCtx, '[1, 2, 3]', null)).resolves.toEqual([1, 2, 3]) |
81 | 83 | }) |
82 | 84 |
|
83 | | - it('throws on a string that is neither a reference nor valid JSON array/object', () => { |
84 | | - expect(() => resolveArrayInput(fakeCtx, 'not json', null)).toThrow() |
| 85 | + it('throws on a string that is neither a reference nor valid JSON array/object', async () => { |
| 86 | + await expect(resolveArrayInputAsync(fakeCtx, 'not json', null)).rejects.toThrow() |
85 | 87 | }) |
86 | 88 | }) |
87 | 89 |
|
|
0 commit comments