03/02: finish the solution

Author: kettanaito

.gitignore

@@ -11,6 +11,7 @@ data.db
 **/tsconfig.tsbuildinfo
 **/*.tsbuildinfo
 __screenshots__
+*.sqlite
 
 # in a real app you'd want to not commit the .env
 # file as well, but since this is for a workshop

exercises/03.context/02.solution.automatic-fixtures/src/db.ts renamed to exercises/03.context/02.solution.automatic-fixtures/src/database.ts

@@ -1,14 +1,11 @@
 import { test } from '../test-extend'
+import { queryUser } from './query-user'
 
 test('throws if the user is not found', async () => {
-	const { queryUser } = await import('./query-user')
-
 	await expect(queryUser('abc-123')).resolves.toBeUndefined()
 })
 
 test('returns the user by id', async ({ createMockDatabase }) => {
-	const { queryUser } = await import('./query-user')
-
 	await createMockDatabase((db, done) => {
 		db.run(
 			'INSERT INTO users (id, name) VALUES (?, ?)',

exercises/03.context/02.solution.automatic-fixtures/src/example.test.ts

@@ -1,4 +1,4 @@
-import { client } from './db'
+import { client } from './database'
 
 export interface User {
 	id: string

exercises/03.context/02.solution.automatic-fixtures/src/query-user.ts

@@ -1,43 +1,74 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
 import { test as testBase } from 'vitest'
 import sqlite3, { type Database } from 'sqlite3'
+import * as databaseModule from './src/database'
 
 interface Fixtures {
 	createMockDatabase: (
-		init: (database: Database, done: () => void) => void,
+		seed: (database: Database, handle: CallbackHandle) => void,
 	) => Promise<void>
 }
 
+type CallbackHandle = (error?: Error | null, ...args: Array<any>) => void
+
+function toPromise<T>(init: (handle: CallbackHandle) => T): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		const result = init((error) => {
+			if (error) {
+				return reject(error)
+			}
+			resolve(result)
+		})
+	})
+}
+
 export const test = testBase.extend<Fixtures>({
 	createMockDatabase: [
-		async ({ task }, use) => {
-			const db = new sqlite3.Database(':memory:')
+		async ({ task, onTestFinished }, use) => {
+			const dbFile = `${task.file.filepath}-${task.id}.sqlite`
+
+			if (fs.existsSync(dbFile)) {
+				await fs.promises.rm(dbFile)
+			}
+
+			const mockDatabase = await toPromise((handle) => {
+				return new sqlite3.Database(dbFile, handle)
+			})
 
-			vi.doMock(import('./src/db'), async (importOriginal) => {
-				const original = await importOriginal()
-				const mockClient = new original.DatabaseClient(db)
+			onTestFinished(async ({ task }) => {
+				await toPromise((handle) => mockDatabase.close(handle))
 
-				return {
-					...original,
-					client: mockClient,
+				if (task.type !== 'test') {
+					return
+				}
+
+				if (task.result?.state === 'pass') {
+					await fs.promises.rm(dbFile)
+				} else {
+					task.result?.errors?.push({
+						name: 'Mock database',
+						message: 'See the database state:',
+						codeFrame: path.relative(process.cwd(), dbFile),
+					})
 				}
 			})
 
-			await new Promise<void>((resolve) => {
-				db.serialize(() => {
-					db.run('CREATE TABLE users (id TEXT, name TEXT)', resolve)
-				})
+			const clientSpy = vi
+				.spyOn(databaseModule, 'client', 'get')
+				.mockReturnValue(new databaseModule.DatabaseClient(mockDatabase))
+
+			await toPromise((handle) => {
+				mockDatabase.run('CREATE TABLE users (id TEXT, name TEXT)', handle)
 			})
 
-			await use((initDatabase) => {
-				return new Promise((resolve) => {
-					initDatabase(db, resolve)
+			await use((seed) => {
+				return toPromise((handle) => {
+					seed(mockDatabase, handle)
 				})
 			})
 
-			await new Promise<void>((resolve) => {
-				db.close(() => resolve())
-			})
-			vi.doUnmock(import('./src/db'))
+			clientSpy.mockRestore()
 		},
 		{
 			auto: true,