@accounter/server 0.0.9-alpha-20251210155614-e6e65aaecafef9e8fedd0b933f613ffcf478cecf → 0.0.9-alpha-20251210171954-c9c0e7693ebe08d3643d9ee2c00c03606a53e334

package/src/__tests__/helpers/seed-helpers.business.test.ts

@@ -1,161 +1,159 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
-import pg from 'pg';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { ensureFinancialEntity, ensureBusinessForEntity } from './seed-helpers.js';
-import { testDbConfig, qualifyTable } from './test-db-config.js';
+import { qualifyTable } from './test-db-config.js';
 import { EntityValidationError } from './seed-errors.js';
+import { TestDatabase } from './db-setup.js';
 
 describe('ensureBusinessForEntity', () => {
-  let pool: pg.Pool;
-  let client: pg.PoolClient;
+  let db: TestDatabase;
 
   beforeAll(async () => {
-    pool = new pg.Pool(testDbConfig);
-    client = await pool.connect();
+    db = new TestDatabase();
+    await db.connect();
   });
 
   afterAll(async () => {
-    client.release();
-    await pool.end();
+    await db.close();
   });
 
-  beforeEach(async () => {
-    await client.query('BEGIN');
-  });
-
-  afterEach(async () => {
-    await client.query('ROLLBACK');
-  });
-
-  it('should create a new business for a financial entity', async () => {
-    // Create a financial entity first
-    const { id: entityId } = await ensureFinancialEntity(client, {
-      name: 'Test Business Entity',
-      type: 'business',
-    });
-
-    // Ensure business for this entity
-    await ensureBusinessForEntity(client, entityId);
-
-    // Verify business exists
-    const result = await client.query(
-      `SELECT id, no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
-      [entityId],
-    );
-
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].id).toBe(entityId);
-    expect(result.rows[0].no_invoices_required).toBe(false);
-  });
-
-  it('should be idempotent - repeated calls do not create duplicates', async () => {
-    // Create a financial entity first
-    const { id: entityId } = await ensureFinancialEntity(client, {
-      name: 'Test Business Entity 2',
-      type: 'business',
-    });
-
-    // Call ensureBusinessForEntity multiple times
-    await ensureBusinessForEntity(client, entityId);
-    await ensureBusinessForEntity(client, entityId);
-    await ensureBusinessForEntity(client, entityId);
-
-    // Verify only one business exists
-    const result = await client.query(
-      `SELECT id FROM ${qualifyTable('businesses')} WHERE id = $1`,
-      [entityId],
-    );
-
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].id).toBe(entityId);
-  });
-
-  it('should support noInvoicesRequired option', async () => {
-    // Create a financial entity first
-    const { id: entityId } = await ensureFinancialEntity(client, {
-      name: 'Test Business Entity 3',
-      type: 'business',
-    });
-
-    // Ensure business with noInvoicesRequired set to true
-    await ensureBusinessForEntity(client, entityId, { noInvoicesRequired: true });
-
-    // Verify business has correct option set
-    const result = await client.query(
-      `SELECT id, no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
-      [entityId],
-    );
-
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].id).toBe(entityId);
-    expect(result.rows[0].no_invoices_required).toBe(true);
-  });
-
-  it('should default noInvoicesRequired to false when not specified', async () => {
-    // Create a financial entity first
-    const { id: entityId } = await ensureFinancialEntity(client, {
-      name: 'Test Business Entity 4',
-      type: 'business',
-    });
-
-    // Ensure business without specifying options
-    await ensureBusinessForEntity(client, entityId);
-
-    // Verify business has default value
-    const result = await client.query(
-      `SELECT no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
-      [entityId],
-    );
-
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].no_invoices_required).toBe(false);
-  });
-
-  it('should not modify existing business when called again', async () => {
-    // Create a financial entity first
-    const { id: entityId } = await ensureFinancialEntity(client, {
-      name: 'Test Business Entity 5',
-      type: 'business',
-    });
-
-    // Create business with noInvoicesRequired = true
-    await ensureBusinessForEntity(client, entityId, { noInvoicesRequired: true });
-
-    // Call again with different options (should be no-op)
-    await ensureBusinessForEntity(client, entityId, { noInvoicesRequired: false });
-
-    // Verify original value is preserved
-    const result = await client.query(
-      `SELECT no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
-      [entityId],
-    );
-
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].no_invoices_required).toBe(true); // Original value preserved
-  });
-
-  it('should not leak data between tests', async () => {
-    // This test verifies transactional isolation by checking that data
-    // from previous tests is not visible
-    const result = await client.query(
-      `SELECT COUNT(*) as count FROM ${qualifyTable('businesses')} WHERE id IN (SELECT id FROM ${qualifyTable('financial_entities')} WHERE name LIKE 'Test Business Entity%')`,
-    );
-
-    // Due to ROLLBACK after each test, count should be 0
-    expect(parseInt(result.rows[0].count)).toBe(0);
-  });
+  it('should create a new business for a financial entity', async () =>
+    db.withTransaction(async client => {
+      // Create a financial entity first
+      const { id: entityId } = await ensureFinancialEntity(client, {
+        name: 'Test Business Entity',
+        type: 'business',
+      });
+
+      // Ensure business for this entity
+      await ensureBusinessForEntity(client, entityId);
+
+      // Verify business exists
+      const result = await client.query(
+        `SELECT id, no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
+        [entityId],
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0].id).toBe(entityId);
+      expect(result.rows[0].no_invoices_required).toBe(false);
+    }));
+
+  it('should be idempotent - repeated calls do not create duplicates', async () =>
+    db.withTransaction(async client => {
+      // Create a financial entity first
+      const { id: entityId } = await ensureFinancialEntity(client, {
+        name: 'Test Business Entity 2',
+        type: 'business',
+      });
+
+      // Call ensureBusinessForEntity multiple times
+      await ensureBusinessForEntity(client, entityId);
+      await ensureBusinessForEntity(client, entityId);
+      await ensureBusinessForEntity(client, entityId);
+
+      // Verify only one business exists
+      const result = await client.query(
+        `SELECT id FROM ${qualifyTable('businesses')} WHERE id = $1`,
+        [entityId],
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0].id).toBe(entityId);
+    }));
+
+  it('should support noInvoicesRequired option', async () =>
+    db.withTransaction(async client => {
+      // Create a financial entity first
+      const { id: entityId } = await ensureFinancialEntity(client, {
+        name: 'Test Business Entity 3',
+        type: 'business',
+      });
+
+      // Ensure business with noInvoicesRequired set to true
+      await ensureBusinessForEntity(client, entityId, { noInvoicesRequired: true });
+
+      // Verify business has correct option set
+      const result = await client.query(
+        `SELECT id, no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
+        [entityId],
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0].id).toBe(entityId);
+      expect(result.rows[0].no_invoices_required).toBe(true);
+    }));
+
+  it('should default noInvoicesRequired to false when not specified', async () =>
+    db.withTransaction(async client => {
+      // Create a financial entity first
+      const { id: entityId } = await ensureFinancialEntity(client, {
+        name: 'Test Business Entity 4',
+        type: 'business',
+      });
+
+      // Ensure business without specifying options
+      await ensureBusinessForEntity(client, entityId);
+
+      // Verify business has default value
+      const result = await client.query(
+        `SELECT no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
+        [entityId],
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0].no_invoices_required).toBe(false);
+    }));
+
+  it('should not modify existing business when called again', async () =>
+    db.withTransaction(async client => {
+      // Create a financial entity first
+      const { id: entityId } = await ensureFinancialEntity(client, {
+        name: 'Test Business Entity 5',
+        type: 'business',
+      });
+
+      // Create business with noInvoicesRequired = true
+      await ensureBusinessForEntity(client, entityId, { noInvoicesRequired: true });
+
+      // Call again with different options (should be no-op)
+      await ensureBusinessForEntity(client, entityId, { noInvoicesRequired: false });
+
+      // Verify original value is preserved
+      const result = await client.query(
+        `SELECT no_invoices_required FROM ${qualifyTable('businesses')} WHERE id = $1`,
+        [entityId],
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0].no_invoices_required).toBe(true); // Original value preserved
+    }));
+
+  it('should not leak data between tests', async () =>
+    db.withTransaction(async client => {
+      // This test verifies transactional isolation by checking that data
+      // from previous tests is not visible
+      const result = await client.query(
+        `SELECT COUNT(*) as count FROM ${qualifyTable('businesses')} WHERE id IN (SELECT id FROM ${qualifyTable('financial_entities')} WHERE name LIKE 'Test Business Entity%')`,
+      );
+
+      // Due to ROLLBACK after each test, count should be 0
+      expect(parseInt(result.rows[0].count)).toBe(0);
+    }));
 
   // Validation tests
-  it('should reject invalid UUID format', async () => {
-    await expect(
-      ensureBusinessForEntity(client, 'not-a-valid-uuid'),
-    ).rejects.toThrow(EntityValidationError);
-  });
-
-  it('should reject non-existent financial entity', async () => {
-    const fakeId = '00000000-0000-0000-0000-000000000000';
-
-    await expect(
-      ensureBusinessForEntity(client, fakeId),
-    ).rejects.toThrow(EntityValidationError);
-  });
+  it('should reject invalid UUID format', async () =>
+    db.withTransaction(async client => {
+      await expect(ensureBusinessForEntity(client, 'not-a-valid-uuid')).rejects.toThrow(
+        EntityValidationError,
+      );
+    }));
+
+  it('should reject non-existent financial entity', async () =>
+    db.withTransaction(async client => {
+      const fakeId = '00000000-0000-0000-0000-000000000000';
+
+      await expect(ensureBusinessForEntity(client, fakeId)).rejects.toThrow(
+        EntityValidationError,
+      );
+    }));
 });

package/src/__tests__/helpers/seed-helpers.concurrent.test.ts

@@ -1,18 +1,18 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import pg from 'pg';
 import { ensureFinancialEntity } from './seed-helpers.js';
-import { testDbConfig } from './test-db-config.js';
 import { withConcurrentTransactions } from './test-transaction.js';
+import { TestDatabase } from './db-setup.js';
 
 describe('ensureFinancialEntity - Concurrent Access', () => {
-  let pool: pg.Pool;
+  let db: TestDatabase;
 
   beforeAll(async () => {
-    pool = new pg.Pool(testDbConfig);
+    db = new TestDatabase();
+    await db.connect();
   });
 
   afterAll(async () => {
-    await pool.end();
+    await db.close();
   });
 
   it('should handle concurrent inserts of same entity gracefully', async () => {
@@ -22,7 +22,7 @@ describe('ensureFinancialEntity - Concurrent Access', () => {
     };
 
     // Two separate transactions attempting to create the same entity
-    const [result1, result2] = await withConcurrentTransactions(pool, [
+    const [result1, result2] = await withConcurrentTransactions(db.getPool(), [
       async client => ensureFinancialEntity(client, params),
       async client => ensureFinancialEntity(client, params),
     ]);
@@ -37,7 +37,7 @@ describe('ensureFinancialEntity - Concurrent Access', () => {
   });
 
   it('should handle concurrent inserts of different entities', async () => {
-    const [result1, result2, result3] = await withConcurrentTransactions(pool, [
+    const [result1, result2, result3] = await withConcurrentTransactions(db.getPool(), [
       async client =>
         ensureFinancialEntity(client, {
           name: 'Concurrent Entity A',
@@ -64,8 +64,8 @@ describe('ensureFinancialEntity - Concurrent Access', () => {
   it('should handle concurrent creation with separate namespaces', async () => {
     // Test that concurrent operations in separate transactions don't interfere
     const timestamp = Date.now();
-    
-    const [result1, result2, result3] = await withConcurrentTransactions(pool, [
+
+    const [result1, result2, result3] = await withConcurrentTransactions(db.getPool(), [
       async client =>
         ensureFinancialEntity(client, {
           name: `Namespace A - ${timestamp}`,
@@ -87,7 +87,7 @@ describe('ensureFinancialEntity - Concurrent Access', () => {
     expect(result1.id).toBeDefined();
     expect(result2.id).toBeDefined();
     expect(result3.id).toBeDefined();
-    
+
     // All should have unique IDs
     expect(result1.id).not.toBe(result2.id);
     expect(result2.id).not.toBe(result3.id);