Add integration tests for API routes

api/src/repositories/headquartersRepo.ts

@@ -145,8 +145,12 @@ let headquartersRepo: HeadquartersRepository | null = null;
 export async function getHeadquartersRepository(
   isTest: boolean = false,
 ): Promise<HeadquartersRepository> {
+  const isTestEnv = isTest || process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+  if (isTestEnv) {
+    return createHeadquartersRepository(true);
+  }
   if (!headquartersRepo) {
-    headquartersRepo = await createHeadquartersRepository(isTest);
+    headquartersRepo = await createHeadquartersRepository(false);
   }
   return headquartersRepo;
 }

api/src/repositories/orderDetailDeliveriesRepo.ts

@@ -187,8 +187,12 @@ let orderDetailDeliveriesRepo: OrderDetailDeliveriesRepository | null = null;
 export async function getOrderDetailDeliveriesRepository(
   isTest: boolean = false,
 ): Promise<OrderDetailDeliveriesRepository> {
+  const isTestEnv = isTest || process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+  if (isTestEnv) {
+    return createOrderDetailDeliveriesRepository(true);
+  }
   if (!orderDetailDeliveriesRepo) {
-    orderDetailDeliveriesRepo = await createOrderDetailDeliveriesRepository(isTest);
+    orderDetailDeliveriesRepo = await createOrderDetailDeliveriesRepository(false);
   }
   return orderDetailDeliveriesRepo;
 }

api/src/repositories/orderDetailsRepo.ts

@@ -175,8 +175,12 @@ let orderDetailsRepo: OrderDetailsRepository | null = null;
 export async function getOrderDetailsRepository(
   isTest: boolean = false,
 ): Promise<OrderDetailsRepository> {
+  const isTestEnv = isTest || process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+  if (isTestEnv) {
+    return createOrderDetailsRepository(true);
+  }
   if (!orderDetailsRepo) {
-    orderDetailsRepo = await createOrderDetailsRepository(isTest);
+    orderDetailsRepo = await createOrderDetailsRepository(false);
   }
   return orderDetailsRepo;
 }

api/src/repositories/productsRepo.ts

@@ -152,8 +152,12 @@ export async function createProductsRepository(
 let productsRepo: ProductsRepository | null = null;
 
 export async function getProductsRepository(isTest: boolean = false): Promise<ProductsRepository> {
+  const isTestEnv = isTest || process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+  if (isTestEnv) {
+    return createProductsRepository(true);
+  }
   if (!productsRepo) {
-    productsRepo = await createProductsRepository(isTest);
+    productsRepo = await createProductsRepository(false);
   }
   return productsRepo;
 }

api/src/routes/delivery.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import deliveryRouter from './delivery';
+import { runMigrations } from '../db/migrate';
+import { closeDatabase, getDatabase } from '../db/sqlite';
+import { errorHandler } from '../utils/errors';
+
+let app: express.Express;
+
+describe('Delivery API', () => {
+  beforeEach(async () => {
+    // Ensure a fresh in-memory database for each test
+    await closeDatabase();
+    await getDatabase(true);
+    await runMigrations(true);
+
+    // Seed required foreign key: supplier
+    const db = await getDatabase();
+    await db.run(
+      'INSERT INTO suppliers (supplier_id, name, description, contact_person, email, phone) VALUES (?, ?, ?, ?, ?, ?)',
+      [1, 'Test Supplier', 'Test supplier desc', 'Supplier Contact', 'supplier@test.com', '555-0000'],
+    );
+
+    // Set up express app
+    app = express();
+    app.use(express.json());
+    app.use('/deliveries', deliveryRouter);
+    // Attach error handler to translate repo errors
+    app.use(errorHandler);
+  });
+
+  afterEach(async () => {
+    await closeDatabase();
+  });
+
+  it('should create a new delivery', async () => {
+    const newDelivery = {
+      supplierId: 1,
+      deliveryDate: '2024-02-01T14:00:00Z',
+      name: 'Test Delivery',
+      description: 'Test delivery description',
+      status: 'pending',
+    };
+    const response = await request(app).post('/deliveries').send(newDelivery);
+    expect(response.status).toBe(201);
+    expect(response.body).toMatchObject(newDelivery);
+    expect(response.body.deliveryId).toBeDefined();
+  });
+
+  it('should get all deliveries', async () => {
+    const response = await request(app).get('/deliveries');
+    expect(response.status).toBe(200);
+    expect(Array.isArray(response.body)).toBe(true);
+  });
+
+  it('should get a delivery by ID', async () => {
+    // First create a delivery to test getting it
+    const newDelivery = {
+      supplierId: 1,
+      deliveryDate: '2024-02-02T14:00:00Z',
+      name: 'Delivery To Get',
+      description: 'Test delivery',
+      status: 'in-transit',
+    };
+    const createResponse = await request(app).post('/deliveries').send(newDelivery);
+    const deliveryId = createResponse.body.deliveryId;
+
+    const response = await request(app).get(`/deliveries/${deliveryId}`);
+    expect(response.status).toBe(200);
+    expect(response.body.deliveryId).toBe(deliveryId);
+  });
+
+  it('should update a delivery by ID', async () => {
+    // First create a delivery to test updating it
+    const newDelivery = {
+      supplierId: 1,
+      deliveryDate: '2024-02-03T14:00:00Z',
+      name: 'Original Delivery',
+      description: 'Original description',
+      status: 'pending',
+    };
+    const createResponse = await request(app).post('/deliveries').send(newDelivery);
+    const deliveryId = createResponse.body.deliveryId;
+
+    const updatedDelivery = {
+      ...newDelivery,
+      status: 'delivered',
+      description: 'Updated description',
+    };
+    const response = await request(app).put(`/deliveries/${deliveryId}`).send(updatedDelivery);
+    expect(response.status).toBe(200);
+    expect(response.body.status).toBe('delivered');
+    expect(response.body.description).toBe('Updated description');
+  });
+
+  it('should update delivery status', async () => {
+    // First create a delivery to test updating status
+    const newDelivery = {
+      supplierId: 1,
+      deliveryDate: '2024-02-04T14:00:00Z',
+      name: 'Delivery Status Update',
+      description: 'Test delivery status update',
+      status: 'pending',
+    };
+    const createResponse = await request(app).post('/deliveries').send(newDelivery);
+    const deliveryId = createResponse.body.deliveryId;
+
+    const response = await request(app)
+      .put(`/deliveries/${deliveryId}/status`)
+      .send({ status: 'delivered' });
+    expect(response.status).toBe(200);
+    expect(response.body.status).toBe('delivered');
+  });
+
+  it('should delete a delivery by ID', async () => {
+    // First create a delivery to test deleting it
+    const newDelivery = {
+      supplierId: 1,
+      deliveryDate: '2024-02-05T14:00:00Z',
+      name: 'Delivery To Delete',
+      description: 'This delivery will be deleted',
+      status: 'failed',
+    };
+    const createResponse = await request(app).post('/deliveries').send(newDelivery);
+    const deliveryId = createResponse.body.deliveryId;
+
+    const response = await request(app).delete(`/deliveries/${deliveryId}`);
+    expect(response.status).toBe(204);
+  });
+
+  it('should return 404 for non-existing delivery', async () => {
+    const response = await request(app).get('/deliveries/999');
+    expect(response.status).toBe(404);
+  });
+
+  it('should return 404 when updating status of non-existing delivery', async () => {
+    const response = await request(app).put('/deliveries/999/status').send({ status: 'delivered' });
+    expect(response.status).toBe(404);
+  });
+});

api/src/routes/headquarters.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import headquartersRouter from './headquarters';
+import { runMigrations } from '../db/migrate';
+import { closeDatabase, getDatabase } from '../db/sqlite';
+import { errorHandler } from '../utils/errors';
+
+let app: express.Express;
+
+describe('Headquarters API', () => {
+  beforeEach(async () => {
+    // Ensure a fresh in-memory database for each test
+    await closeDatabase();
+    await getDatabase(true);
+    await runMigrations(true);
+
+    // Set up express app
+    app = express();
+    app.use(express.json());
+    app.use('/headquarters', headquartersRouter);
+    // Attach error handler to translate repo errors
+    app.use(errorHandler);
+  });
+
+  afterEach(async () => {
+    await closeDatabase();
+  });
+
+  it('should create a new headquarters', async () => {
+    const newHeadquarters = {
+      name: 'Main Headquarters',
+      description: 'Central office location',
+      address: '100 Main Street',
+      contactPerson: 'Alice Johnson',
+      email: 'alice@hq.com',
+      phone: '555-1000',
+    };
+    const response = await request(app).post('/headquarters').send(newHeadquarters);
+    expect(response.status).toBe(201);
+    expect(response.body).toMatchObject(newHeadquarters);
+    expect(response.body.headquartersId).toBeDefined();
+  });
+
+  it('should get all headquarters', async () => {
+    const response = await request(app).get('/headquarters');
+    expect(response.status).toBe(200);
+    expect(Array.isArray(response.body)).toBe(true);
+  });
+
+  it('should get a headquarters by ID', async () => {
+    // First create a headquarters to test getting it
+    const newHeadquarters = {
+      name: 'Regional HQ',
+      description: 'Regional office',
+      address: '200 Regional Ave',
+      contactPerson: 'Charlie Brown',
+      email: 'charlie@regionalhq.com',
+      phone: '555-2000',
+    };
+    const createResponse = await request(app).post('/headquarters').send(newHeadquarters);
+    const headquartersId = createResponse.body.headquartersId;
+
+    const response = await request(app).get(`/headquarters/${headquartersId}`);
+    expect(response.status).toBe(200);
+    expect(response.body.headquartersId).toBe(headquartersId);
+  });
+
+  it('should update a headquarters by ID', async () => {
+    // First create a headquarters to test updating it
+    const newHeadquarters = {
+      name: 'Original HQ',
+      description: 'Original description',
+      address: '300 Original St',
+      contactPerson: 'Diana Ross',
+      email: 'diana@original.com',
+      phone: '555-3000',
+    };
+    const createResponse = await request(app).post('/headquarters').send(newHeadquarters);
+    const headquartersId = createResponse.body.headquartersId;
+
+    const updatedHeadquarters = {
+      ...newHeadquarters,
+      name: 'Updated Headquarters Name',
+    };
+    const response = await request(app)
+      .put(`/headquarters/${headquartersId}`)
+      .send(updatedHeadquarters);
+    expect(response.status).toBe(200);
+    expect(response.body.name).toBe('Updated Headquarters Name');
+  });
+
+  it('should delete a headquarters by ID', async () => {
+    // First create a headquarters to test deleting it
+    const newHeadquarters = {
+      name: 'HQ To Delete',
+      description: 'This headquarters will be deleted',
+      address: '400 Delete Ave',
+      contactPerson: 'Delete Person',
+      email: 'delete@hq.com',
+      phone: '555-4000',
+    };
+    const createResponse = await request(app).post('/headquarters').send(newHeadquarters);
+    const headquartersId = createResponse.body.headquartersId;
+
+    const response = await request(app).delete(`/headquarters/${headquartersId}`);
+    expect(response.status).toBe(204);
+  });
+
+  it('should return 404 for non-existing headquarters', async () => {
+    const response = await request(app).get('/headquarters/999');
+    expect(response.status).toBe(404);
+  });
+});