+58 -12

packages/runner/src/fixture.ts

Reviewed

··· 44 44 return context 45 45 } 46 46 47 47 + const fixtureValueMap = new Map<FixtureItem, any>() 48 48 + const fixtureCleanupFnMap = new Map<string, Array<() => void | Promise<void>>>() 49 49 + 50 50 + export async function callFixtureCleanup(id: string) { 51 51 + const cleanupFnArray = fixtureCleanupFnMap.get(id) 52 52 + if (!cleanupFnArray) 53 53 + return 54 54 + 55 55 + for (const cleanup of cleanupFnArray.reverse()) 56 56 + await cleanup() 57 57 + 58 58 + fixtureCleanupFnMap.delete(id) 59 59 + } 60 60 + 47 61 export function withFixtures(fn: Function, testContext?: TestContext) { 48 62 return (hookContext?: TestContext) => { 49 63 const context: TestContext & { [key: string]: any } | undefined = hookContext || testContext 50 64 51 65 if (!context) 52 66 return fn({}) 67 67 + 68 68 + let cleanupFnArray = fixtureCleanupFnMap.get(context.task.suite.id)! 69 69 + if (!cleanupFnArray) { 70 70 + cleanupFnArray = [] 71 71 + fixtureCleanupFnMap.set(context.task.suite.id, cleanupFnArray) 72 72 + } 53 73 54 74 const fixtures = getFixture(context) 55 75 if (!fixtures?.length) ··· 63 83 const pendingFixtures = resolveDeps(usedFixtures) 64 84 let cursor = 0 65 85 66 66 - async function use(fixtureValue: any) { 67 67 - const { prop } = pendingFixtures[cursor++] 68 68 - context![prop] = fixtureValue 86 86 + return new Promise((resolve, reject) => { 87 87 + async function use(fixtureValue: any) { 88 88 + const fixture = pendingFixtures[cursor++] 89 89 + context![fixture.prop] = fixtureValue 69 90 70 70 - if (cursor < pendingFixtures.length) 71 71 - await next() 72 72 - else await fn(context) 73 73 - } 91 91 + if (!fixtureValueMap.has(fixture)) { 92 92 + fixtureValueMap.set(fixture, fixtureValue) 93 93 + cleanupFnArray.unshift(() => { 94 94 + fixtureValueMap.delete(fixture) 95 95 + }) 96 96 + } 74 97 75 75 - async function next() { 76 76 - const { value } = pendingFixtures[cursor] 77 77 - typeof value === 'function' ? await value(context, use) : await use(value) 78 78 - } 98 98 + if (cursor < pendingFixtures.length) { 99 99 + await next() 100 100 + } 101 101 + else { 102 102 + // When all fixtures setup, call the test function 103 103 + try { 104 104 + resolve(await fn(context)) 105 105 + } 106 106 + catch (err) { 107 107 + reject(err) 108 108 + } 109 109 + return new Promise<void>((resolve) => { 110 110 + cleanupFnArray.push(resolve) 111 111 + }) 112 112 + } 113 113 + } 79 114 80 80 - return next() 115 115 + async function next() { 116 116 + const fixture = pendingFixtures[cursor] 117 117 + const { isFn, value } = fixture 118 118 + if (fixtureValueMap.has(fixture)) 119 119 + return use(fixtureValueMap.get(fixture)) 120 120 + else 121 121 + return isFn ? value(context, use) : use(value) 122 122 + } 123 123 + 124 124 + const setupFixturePromise = next() 125 125 + cleanupFnArray.unshift(() => setupFixturePromise) 126 126 + }) 81 127 } 82 128 } 83 129

+2

packages/runner/src/run.ts

Reviewed

··· 10 10 import { setCurrentTest } from './test-state' 11 11 import { hasFailed, hasTests } from './utils/tasks' 12 12 import { PendingError } from './errors' 13 13 + import { callFixtureCleanup } from './fixture' 13 14 14 15 const now = Date.now 15 16 ··· 321 322 } 322 323 323 324 try { 325 325 + await callFixtureCleanup(suite.id) 324 326 await callSuiteHook(suite, suite, 'afterAll', runner, [suite]) 325 327 await callCleanupHooks(beforeAllCleanups) 326 328 }

+154 -27

test/core/test/test-extend.test.ts

Reviewed

··· 1 1 /* eslint-disable prefer-rest-params */ 2 2 /* eslint-disable no-empty-pattern */ 3 3 - import { describe, expect, expectTypeOf, test, vi } from 'vitest' 3 3 + import { afterAll, afterEach, beforeEach, describe, expect, expectTypeOf, test, vi } from 'vitest' 4 4 5 5 interface Fixtures { 6 6 todoList: number[] ··· 38 38 }) 39 39 40 40 describe('test.extend()', () => { 41 41 - myTest('todoList and doneList', ({ todoList, doneList, archiveList }) => { 42 42 - expect(todoFn).toBeCalledTimes(1) 43 43 - expect(doneFn).toBeCalledTimes(1) 41 41 + describe('basic', () => { 42 42 + myTest('todoList and doneList', ({ todoList, doneList, archiveList }) => { 43 43 + expect(todoFn).toBeCalledTimes(1) 44 44 + expect(doneFn).toBeCalledTimes(1) 44 45 45 45 - expectTypeOf(todoList).toEqualTypeOf<number[]>() 46 46 - expectTypeOf(doneList).toEqualTypeOf<number[]>() 47 47 - expectTypeOf(doneList).toEqualTypeOf<number[]>() 46 46 + expectTypeOf(todoList).toEqualTypeOf<number[]>() 47 47 + expectTypeOf(doneList).toEqualTypeOf<number[]>() 48 48 + expectTypeOf(doneList).toEqualTypeOf<number[]>() 48 49 49 49 - expect(todoList).toEqual([1, 2, 3]) 50 50 - expect(doneList).toEqual([]) 51 51 - expect(archiveList).toEqual([]) 50 50 + expect(todoList).toEqual([1, 2, 3]) 51 51 + expect(doneList).toEqual([]) 52 52 + expect(archiveList).toEqual([]) 52 53 53 53 - doneList.push(todoList.shift()!) 54 54 - expect(todoList).toEqual([2, 3]) 55 55 - expect(doneList).toEqual([1]) 54 54 + doneList.push(todoList.shift()!) 55 55 + expect(todoList).toEqual([2, 3]) 56 56 + expect(doneList).toEqual([1]) 56 57 57 57 - doneList.push(todoList.shift()!) 58 58 - expect(todoList).toEqual([3]) 59 59 - expect(doneList).toEqual([1, 2]) 58 58 + doneList.push(todoList.shift()!) 59 59 + expect(todoList).toEqual([3]) 60 60 + expect(doneList).toEqual([1, 2]) 60 61 61 61 - archiveList.push(todoList.shift()!) 62 62 - expect(todoList).toEqual([]) 63 63 - expect(archiveList).toEqual([3]) 62 62 + archiveList.push(todoList.shift()!) 63 63 + expect(todoList).toEqual([]) 64 64 + expect(archiveList).toEqual([3]) 64 65 65 65 - archiveList.pop() 66 66 + archiveList.pop() 67 67 + }) 66 68 }) 67 67 - 68 68 - myTest('should called cleanup functions', ({ todoList, doneList, archiveList }) => { 69 69 - expect(todoList).toEqual([1, 2, 3]) 70 70 - expect(doneList).toEqual([]) 71 71 - expect(archiveList).toEqual([]) 72 72 - }) 73 73 - 74 69 describe('smartly init fixtures', () => { 75 70 myTest('should not init any fixtures', function () { 76 71 expect(todoFn).not.toBeCalled() ··· 148 143 expect(todos).toEqual([1, 2, 3]) 149 144 expect(done).toEqual([]) 150 145 expect(archive).toEqual([]) 146 146 + }) 147 147 + }) 148 148 + 149 149 + describe('fixture call times', () => { 150 150 + const apiFn = vi.fn(() => true) 151 151 + const serviceFn = vi.fn(() => true) 152 152 + const teardownFn = vi.fn() 153 153 + 154 154 + interface APIFixture { 155 155 + api: boolean 156 156 + service: boolean 157 157 + } 158 158 + 159 159 + const testAPI = test.extend<APIFixture>({ 160 160 + api: async ({}, use) => { 161 161 + await use(apiFn()) 162 162 + apiFn.mockClear() 163 163 + teardownFn() 164 164 + }, 165 165 + service: async ({}, use) => { 166 166 + await use(serviceFn()) 167 167 + serviceFn.mockClear() 168 168 + teardownFn() 169 169 + }, 170 170 + }) 171 171 + 172 172 + beforeEach<APIFixture>(({ api, service }) => { 173 173 + expect(api).toBe(true) 174 174 + expect(service).toBe(true) 175 175 + }) 176 176 + 177 177 + testAPI('Should init1 time', ({ api }) => { 178 178 + expect(api).toBe(true) 179 179 + expect(apiFn).toBeCalledTimes(1) 180 180 + }) 181 181 + 182 182 + testAPI('Should init 1 time has multiple fixture', ({ api, service }) => { 183 183 + expect(api).toBe(true) 184 184 + expect(service).toBe(true) 185 185 + expect(serviceFn).toBeCalledTimes(1) 186 186 + expect(apiFn).toBeCalledTimes(1) 187 187 + }) 188 188 + 189 189 + afterEach<APIFixture>(({ api, service }) => { 190 190 + expect(api).toBe(true) 191 191 + expect(service).toBe(true) 192 192 + expect(apiFn).toBeCalledTimes(1) 193 193 + expect(serviceFn).toBeCalledTimes(1) 194 194 + }) 195 195 + 196 196 + afterAll(() => { 197 197 + expect(serviceFn).toBeCalledTimes(0) 198 198 + expect(apiFn).toBeCalledTimes(0) 199 199 + expect(teardownFn).toBeCalledTimes(2) 200 200 + }) 201 201 + }) 202 202 + 203 203 + describe('fixture in nested describe', () => { 204 204 + interface Fixture { 205 205 + foo: number 206 206 + bar: number 207 207 + } 208 208 + 209 209 + const fooFn = vi.fn(() => 0) 210 210 + const fooCleanup = vi.fn() 211 211 + 212 212 + const barFn = vi.fn(() => 0) 213 213 + const barCleanup = vi.fn() 214 214 + 215 215 + const nestedTest = test.extend<Fixture>({ 216 216 + async foo({}, use) { 217 217 + await use(fooFn()) 218 218 + fooCleanup() 219 219 + }, 220 220 + async bar({}, use) { 221 221 + await use(barFn()) 222 222 + barCleanup() 223 223 + }, 224 224 + }) 225 225 + 226 226 + beforeEach<Fixture>(({ foo }) => { 227 227 + expect(foo).toBe(0) 228 228 + }) 229 229 + 230 230 + nestedTest('should only initialize foo', ({ foo }) => { 231 231 + expect(foo).toBe(0) 232 232 + expect(fooFn).toBeCalledTimes(1) 233 233 + expect(barFn).toBeCalledTimes(0) 234 234 + }) 235 235 + 236 236 + describe('level 2, using both foo and bar together', () => { 237 237 + beforeEach<Fixture>(({ foo, bar }) => { 238 238 + expect(foo).toBe(0) 239 239 + expect(bar).toBe(0) 240 240 + }) 241 241 + 242 242 + nestedTest('should only initialize bar', ({ foo, bar }) => { 243 243 + expect(foo).toBe(0) 244 244 + expect(bar).toBe(0) 245 245 + expect(fooFn).toBeCalledTimes(1) 246 246 + expect(barFn).toBeCalledTimes(1) 247 247 + }) 248 248 + 249 249 + afterEach<Fixture>(({ foo, bar }) => { 250 250 + expect(foo).toBe(0) 251 251 + expect(bar).toBe(0) 252 252 + }) 253 253 + 254 254 + afterAll(() => { 255 255 + // foo setup in outside describe 256 256 + // cleanup also called in outside describe 257 257 + expect(fooCleanup).toHaveBeenCalledTimes(0) 258 258 + // bar setup in inside describe 259 259 + // cleanup also called in inside describe 260 260 + expect(barCleanup).toHaveBeenCalledTimes(1) 261 261 + }) 262 262 + }) 263 263 + 264 264 + nestedTest('level 2 will not call foo cleanup', ({ foo }) => { 265 265 + expect(foo).toBe(0) 266 266 + expect(fooFn).toBeCalledTimes(1) 267 267 + }) 268 268 + 269 269 + afterEach<Fixture>(({ foo }) => { 270 270 + expect(foo).toBe(0) 271 271 + }) 272 272 + 273 273 + afterAll(() => { 274 274 + // foo setup in this describe 275 275 + // cleanup also called in this describe 276 276 + expect(fooCleanup).toHaveBeenCalledTimes(1) 277 277 + expect(barCleanup).toHaveBeenCalledTimes(1) 151 278 }) 152 279 }) 153 280 })