@accounter/server 0.0.9-alpha-20251210173458-9f3d75bb8729ec6038c777f7dbf9a1b5fa727888 → 0.0.9-alpha-20251210173721-a5bb944d9abd3f354daf897072b78bea4d8269c9

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

@@ -1,159 +1,161 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import pg from 'pg';
 import { ensureFinancialEntity, ensureBusinessForEntity } from './seed-helpers.js';
-import { qualifyTable } from './test-db-config.js';
+import { testDbConfig, qualifyTable } from './test-db-config.js';
 import { EntityValidationError } from './seed-errors.js';
-import { TestDatabase } from './db-setup.js';
 
 describe('ensureBusinessForEntity', () => {
-  let db: TestDatabase;
+  let pool: pg.Pool;
+  let client: pg.PoolClient;
 
   beforeAll(async () => {
-    db = new TestDatabase();
-    await db.connect();
+    pool = new pg.Pool(testDbConfig);
+    client = await pool.connect();
   });
 
   afterAll(async () => {
-    await db.close();
+    client.release();
+    await pool.end();
   });
 
-  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);
-    }));
+  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);
+  });
 
   // Validation tests
-  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,
-      );
-    }));
+  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);
+  });
 });

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 db: TestDatabase;
+  let pool: pg.Pool;
 
   beforeAll(async () => {
-    db = new TestDatabase();
-    await db.connect();
+    pool = new pg.Pool(testDbConfig);
   });
 
   afterAll(async () => {
-    await db.close();
+    await pool.end();
   });
 
   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(db.getPool(), [
+    const [result1, result2] = await withConcurrentTransactions(pool, [
       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(db.getPool(), [
+    const [result1, result2, result3] = await withConcurrentTransactions(pool, [
       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(db.getPool(), [
+    
+    const [result1, result2, result3] = await withConcurrentTransactions(pool, [
       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);