@strav/testing 0.1.1 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strav/testing",
-  "version": "0.1.1",
+  "version": "0.1.6",
   "type": "module",
   "description": "Testing utilities for the Strav framework",
   "license": "MIT",
@@ -15,10 +15,10 @@
     "CHANGELOG.md"
   ],
   "peerDependencies": {
-    "@strav/kernel": "0.1.0",
-    "@strav/http": "0.1.0",
-    "@strav/view": "0.1.0",
-    "@strav/database": "0.1.0"
+    "@strav/kernel": "0.1.4",
+    "@strav/http": "0.1.4",
+    "@strav/view": "0.1.4",
+    "@strav/database": "0.1.4"
   },
   "scripts": {
     "test": "bun test tests/",

package/src/database_manager.ts

@@ -0,0 +1,130 @@
+import { app } from '@strav/kernel'
+import { Database, BaseModel } from '@strav/database'
+
+/**
+ * Singleton database manager for test isolation
+ *
+ * Manages a shared database connection across multiple test files
+ * while ensuring proper cleanup and preventing "Connection closed" errors.
+ */
+export class TestDatabaseManager {
+  private static instance: TestDatabaseManager | null = null
+  private database: Database | null = null
+  private referenceCount = 0
+  private isInitialized = false
+  private closeTimeout: Timer | null = null
+  private readonly CLOSE_DELAY_MS = 100 // Small delay to allow other test files to start
+
+  private constructor() {
+    // Private constructor for singleton pattern
+  }
+
+  /**
+   * Get the singleton instance
+   */
+  static getInstance(): TestDatabaseManager {
+    if (!TestDatabaseManager.instance) {
+      TestDatabaseManager.instance = new TestDatabaseManager()
+    }
+    return TestDatabaseManager.instance
+  }
+
+  /**
+   * Get a shared database instance
+   * Increments reference count to track active users
+   */
+  async getDatabase(): Promise<Database> {
+    this.referenceCount++
+
+    // Cancel any pending close operation
+    if (this.closeTimeout) {
+      clearTimeout(this.closeTimeout)
+      this.closeTimeout = null
+    }
+
+    if (!this.database || !this.isInitialized) {
+      await this.initializeDatabase()
+    }
+
+    return this.database!
+  }
+
+  /**
+   * Release the database reference
+   * Decrements reference count and closes connection when no more users
+   */
+  async releaseDatabase(): Promise<void> {
+    this.referenceCount--
+
+    if (this.referenceCount <= 0 && this.database) {
+      // Schedule database close with a small delay
+      // This allows other test files to start and increment the reference count
+      this.closeTimeout = setTimeout(async () => {
+        if (this.referenceCount <= 0 && this.database) {
+          await this.database.close()
+          this.database = null
+          this.isInitialized = false
+          this.referenceCount = 0
+        }
+        this.closeTimeout = null
+      }, this.CLOSE_DELAY_MS)
+    }
+  }
+
+  /**
+   * Initialize the shared database connection
+   */
+  private async initializeDatabase(): Promise<void> {
+    if (this.isInitialized && this.database) {
+      return
+    }
+
+    // Register database singleton if not already registered
+    if (!app.has(Database)) {
+      app.singleton(Database)
+    }
+
+    this.database = app.resolve(Database)
+
+    // Configure BaseModel with the shared database
+    new BaseModel(this.database)
+
+    this.isInitialized = true
+  }
+
+  /**
+   * Get current reference count (for debugging)
+   */
+  getReferenceCount(): number {
+    return this.referenceCount
+  }
+
+  /**
+   * Force close the database connection (for cleanup)
+   */
+  async forceClose(): Promise<void> {
+    if (this.database) {
+      await this.database.close()
+      this.database = null
+      this.isInitialized = false
+      this.referenceCount = 0
+    }
+  }
+}
+
+/**
+ * Utility function to clean up database connections on process exit
+ */
+export function cleanupTestDatabase(): void {
+  const manager = TestDatabaseManager.getInstance()
+
+  process.on('SIGINT', async () => {
+    await manager.forceClose()
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', async () => {
+    await manager.forceClose()
+    process.exit(0)
+  })
+}

package/src/index.ts

@@ -1,3 +1,6 @@
 export { TestCase } from './test_case.ts'
 export type { TestCaseOptions } from './test_case.ts'
 export { Factory } from './factory.ts'
+
+// Database management
+export { TestDatabaseManager, cleanupTestDatabase } from './database_manager.ts'

package/src/test_case.ts

@@ -3,6 +3,7 @@ import { app, Configuration, ExceptionHandler } from '@strav/kernel'
 import { Database, BaseModel } from '@strav/database'
 import { Router } from '@strav/http'
 import { Factory } from './factory.ts'
+import { TestDatabaseManager } from './database_manager.ts'
 
 export interface TestCaseOptions {
   /** Route loader — called during setup to register routes. */
@@ -15,6 +16,8 @@ export interface TestCaseOptions {
   transaction?: boolean
   /** User resolver for Auth.useResolver() (required when auth: true). */
   userResolver?: (id: string | number) => Promise<unknown>
+  /** Base domain for subdomain extraction (default: 'localhost'). */
+  domain?: string
 }
 
 /**
@@ -26,6 +29,7 @@ export interface TestCaseOptions {
  *
  * const t = await TestCase.boot({
  *   auth: true,
+ *   domain: 'example.com',
  *   routes: () => import('../start/api_routes'),
  * })
  *
@@ -47,8 +51,12 @@ export class TestCase {
   private _headers: Record<string, string> = {}
   private _originalSql: SQL | null = null
   private _reserved: ReservedSQL | null = null
+  private _subdomain: string | null = null
+  private _domain: string
 
-  constructor(private options: TestCaseOptions = {}) {}
+  constructor(private options: TestCaseOptions = {}) {
+    this._domain = options.domain || 'localhost'
+  }
 
   // ---------------------------------------------------------------------------
   // Lifecycle
@@ -57,16 +65,17 @@ export class TestCase {
   /** Boot the app — mirrors index.ts bootstrap, minus Server. Call in beforeAll. */
   async setup(): Promise<void> {
     if (!app.has(Configuration)) app.singleton(Configuration)
-    if (!app.has(Database)) app.singleton(Database)
     if (!app.has(Router)) app.singleton(Router)
 
     this.config = app.resolve(Configuration)
     await this.config.load()
 
-    this.db = app.resolve(Database)
-    new BaseModel(this.db)
+    // Use shared database manager to prevent connection closed errors
+    const dbManager = TestDatabaseManager.getInstance()
+    this.db = await dbManager.getDatabase()
 
     this.router = app.resolve(Router)
+    this.router.setDomain(this._domain)
 
     // Auth + Session
     if (this.options.auth) {
@@ -120,7 +129,10 @@ export class TestCase {
       this._reserved = null
     }
 
-    await this.db.close()
+    // Release database reference instead of closing it directly
+    // This allows multiple test files to share the same connection
+    const dbManager = TestDatabaseManager.getInstance()
+    await dbManager.releaseDatabase()
   }
 
   /** Begin a transaction for test isolation. Call in beforeEach. */
@@ -153,6 +165,7 @@ export class TestCase {
     // Clear per-test state
     this._token = null
     this._headers = {}
+    this._subdomain = null
   }
 
   // ---------------------------------------------------------------------------
@@ -211,6 +224,18 @@ export class TestCase {
     return this
   }
 
+  /** Set subdomain for subsequent requests in this test. */
+  onSubdomain(subdomain: string): this {
+    this._subdomain = subdomain
+    return this
+  }
+
+  /** Clear subdomain for subsequent requests. */
+  withoutSubdomain(): this {
+    this._subdomain = null
+    return this
+  }
+
   // ---------------------------------------------------------------------------
   // Static shorthand
   // ---------------------------------------------------------------------------
@@ -221,6 +246,7 @@ export class TestCase {
    * @example
    * const t = await TestCase.boot({
    *   auth: true,
+   *   domain: 'example.com',
    *   routes: () => import('../start/api_routes'),
    * })
    */
@@ -250,6 +276,13 @@ export class TestCase {
     if (this._token) merged['Authorization'] = `Bearer ${this._token}`
     if (body !== undefined) merged['Content-Type'] = 'application/json'
 
+    // Set Host header for subdomain routing
+    if (this._subdomain) {
+      merged['Host'] = `${this._subdomain}.${this._domain}`
+    } else {
+      merged['Host'] = this._domain
+    }
+
     if (headers) {
       const entries =
         headers instanceof Headers
@@ -260,8 +293,10 @@ export class TestCase {
       Object.assign(merged, entries)
     }
 
+    // Use the subdomain in the URL when present for clarity
+    const hostname = this._subdomain ? `${this._subdomain}.${this._domain}` : this._domain
     const res = this.router.handle(
-      new Request(`http://localhost${path}`, {
+      new Request(`http://${hostname}${path}`, {
         method,
         headers: merged,
         body: body !== undefined ? JSON.stringify(body) : undefined,