Add test coverage for remaining API routes

api/src/routes/delivery.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import deliveryRouter, { resetDeliveries } from './delivery';
+import { deliveries as seedDeliveries } from '../seedData';
+
+let app: express.Express;
+
+describe('Delivery API', () => {
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/deliveries', deliveryRouter);
+        resetDeliveries();
+    });
+
+    it('should create a new delivery', async () => {
+        const newDelivery = {
+            deliveryId: 100,
+            supplierId: 1,
+            deliveryDate: new Date().toISOString(),
+            name: "Test Delivery",
+            description: "A test delivery",
+            status: "pending"
+        };
+        const response = await request(app).post('/deliveries').send(newDelivery);
+        expect(response.status).toBe(201);
+        expect(response.body).toEqual(newDelivery);
+    });
+
+    it('should get all deliveries', async () => {
+        const response = await request(app).get('/deliveries');
+        expect(response.status).toBe(200);
+        expect(response.body.length).toBe(seedDeliveries.length);
+        response.body.forEach((delivery: any, index: number) => {
+            expect(delivery).toMatchObject(seedDeliveries[index]);
+        });
+    });
+
+    it('should get a delivery by ID', async () => {
+        const response = await request(app).get('/deliveries/1');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(seedDeliveries[0]);
+    });
+
+    it('should update a delivery by ID', async () => {
+        const updatedDelivery = {
+            ...seedDeliveries[0],
+            status: 'delivered'
+        };
+        const response = await request(app).put('/deliveries/1').send(updatedDelivery);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(updatedDelivery);
+    });
+
+    it('should delete a delivery by ID', async () => {
+        const response = await request(app).delete('/deliveries/1');
+        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);
+    });
+});

api/src/routes/delivery.ts

@@ -108,6 +108,11 @@ const router = express.Router();
 
 let deliveries: Delivery[] = [...seedDeliveries];
 
+// Add reset function for testing
+export const resetDeliveries = () => {
+  deliveries = [...seedDeliveries];
+};
+
 // Create a new delivery
 router.post('/', (req, res) => {
   const newDelivery: Delivery = req.body;

api/src/routes/headquarters.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import headquartersRouter, { resetHeadquarters } from './headquarters';
+import { headquarters as seedHeadquarters } from '../seedData';
+
+let app: express.Express;
+
+describe('Headquarters API', () => {
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/headquarters', headquartersRouter);
+        resetHeadquarters();
+    });
+
+    it('should create a new headquarters', async () => {
+        const newHeadquarters = {
+            headquartersId: 100,
+            name: "Test HQ",
+            description: "A test headquarters",
+            address: "123 Test St",
+            contactPerson: "Test Contact",
+            email: "test@hq.com",
+            phone: "555-8888"
+        };
+        const response = await request(app).post('/headquarters').send(newHeadquarters);
+        expect(response.status).toBe(201);
+        expect(response.body).toEqual(newHeadquarters);
+    });
+
+    it('should get all headquarters', async () => {
+        const response = await request(app).get('/headquarters');
+        expect(response.status).toBe(200);
+        expect(response.body.length).toBe(seedHeadquarters.length);
+        response.body.forEach((hq: any, index: number) => {
+            expect(hq).toMatchObject(seedHeadquarters[index]);
+        });
+    });
+
+    it('should get a headquarters by ID', async () => {
+        const response = await request(app).get('/headquarters/1');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(seedHeadquarters[0]);
+    });
+
+    it('should update a headquarters by ID', async () => {
+        const updatedHeadquarters = {
+            ...seedHeadquarters[0],
+            name: 'Updated CatTech Global HQ'
+        };
+        const response = await request(app).put('/headquarters/1').send(updatedHeadquarters);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(updatedHeadquarters);
+    });
+
+    it('should delete a headquarters by ID', async () => {
+        const response = await request(app).delete('/headquarters/1');
+        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);
+    });
+});

api/src/routes/headquarters.ts

@@ -107,6 +107,11 @@ const router = express.Router();
 
 let headquartersList: Headquarters[] = [...seedHeadquarters];
 
+// Add reset function for testing
+export const resetHeadquarters = () => {
+  headquartersList = [...seedHeadquarters];
+};
+
 // Create a new headquarters
 router.post('/', (req, res) => {
   const newHeadquarters: Headquarters = req.body;

api/src/routes/order.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import orderRouter, { resetOrders } from './order';
+import { orders as seedOrders } from '../seedData';
+
+let app: express.Express;
+
+describe('Order API', () => {
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/orders', orderRouter);
+        resetOrders();
+    });
+
+    it('should create a new order', async () => {
+        const newOrder = {
+            orderId: 100,
+            branchId: 1,
+            orderDate: new Date().toISOString(),
+            name: "Test Order",
+            description: "A test order",
+            status: "pending"
+        };
+        const response = await request(app).post('/orders').send(newOrder);
+        expect(response.status).toBe(201);
+        expect(response.body).toEqual(newOrder);
+    });
+
+    it('should get all orders', async () => {
+        const response = await request(app).get('/orders');
+        expect(response.status).toBe(200);
+        expect(response.body.length).toBe(seedOrders.length);
+        response.body.forEach((order: any, index: number) => {
+            expect(order).toMatchObject(seedOrders[index]);
+        });
+    });
+
+    it('should get an order by ID', async () => {
+        const response = await request(app).get('/orders/1');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(seedOrders[0]);
+    });
+
+    it('should update an order by ID', async () => {
+        const updatedOrder = {
+            ...seedOrders[0],
+            status: 'completed'
+        };
+        const response = await request(app).put('/orders/1').send(updatedOrder);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(updatedOrder);
+    });
+
+    it('should delete an order by ID', async () => {
+        const response = await request(app).delete('/orders/1');
+        expect(response.status).toBe(204);
+    });
+
+    it('should return 404 for non-existing order', async () => {
+        const response = await request(app).get('/orders/999');
+        expect(response.status).toBe(404);
+    });
+});

api/src/routes/order.ts

@@ -107,6 +107,11 @@ const router = express.Router();
 
 let orders: Order[] = [...seedOrders];
 
+// Add reset function for testing
+export const resetOrders = () => {
+  orders = [...seedOrders];
+};
+
 // Create a new order
 router.post('/', (req, res) => {
   const newOrder: Order = req.body;

api/src/routes/orderDetail.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import orderDetailRouter, { resetOrderDetails } from './orderDetail';
+import { orderDetails as seedOrderDetails } from '../seedData';
+
+let app: express.Express;
+
+describe('OrderDetail API', () => {
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/order-details', orderDetailRouter);
+        resetOrderDetails();
+    });
+
+    it('should create a new order detail', async () => {
+        const newOrderDetail = {
+            orderDetailId: 100,
+            orderId: 1,
+            productId: 1,
+            quantity: 10,
+            unitPrice: 99.99,
+            notes: "Test order detail"
+        };
+        const response = await request(app).post('/order-details').send(newOrderDetail);
+        expect(response.status).toBe(201);
+        expect(response.body).toEqual(newOrderDetail);
+    });
+
+    it('should get all order details', async () => {
+        const response = await request(app).get('/order-details');
+        expect(response.status).toBe(200);
+        expect(response.body.length).toBe(seedOrderDetails.length);
+        response.body.forEach((orderDetail: any, index: number) => {
+            expect(orderDetail).toMatchObject(seedOrderDetails[index]);
+        });
+    });
+
+    it('should get an order detail by ID', async () => {
+        const response = await request(app).get('/order-details/1');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(seedOrderDetails[0]);
+    });
+
+    it('should update an order detail by ID', async () => {
+        const updatedOrderDetail = {
+            ...seedOrderDetails[0],
+            quantity: 10
+        };
+        const response = await request(app).put('/order-details/1').send(updatedOrderDetail);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(updatedOrderDetail);
+    });
+
+    it('should delete an order detail by ID', async () => {
+        const response = await request(app).delete('/order-details/1');
+        expect(response.status).toBe(204);
+    });
+
+    it('should return 404 for non-existing order detail', async () => {
+        const response = await request(app).get('/order-details/999');
+        expect(response.status).toBe(404);
+    });
+});

api/src/routes/orderDetail.ts

@@ -107,6 +107,11 @@ const router = express.Router();
 
 let orderDetails: OrderDetail[] = [...seedOrderDetails];
 
+// Add reset function for testing
+export const resetOrderDetails = () => {
+  orderDetails = [...seedOrderDetails];
+};
+
 // Create a new order detail
 router.post('/', (req, res) => {
   const newOrderDetail: OrderDetail = req.body;

api/src/routes/orderDetailDelivery.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import orderDetailDeliveryRouter, { resetOrderDetailDeliveries } from './orderDetailDelivery';
+import { orderDetailDeliveries as seedOrderDetailDeliveries } from '../seedData';
+
+let app: express.Express;
+
+describe('OrderDetailDelivery API', () => {
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/order-detail-deliveries', orderDetailDeliveryRouter);
+        resetOrderDetailDeliveries();
+    });
+
+    it('should create a new order detail delivery', async () => {
+        const newOrderDetailDelivery = {
+            orderDetailDeliveryId: 100,
+            orderDetailId: 1,
+            deliveryId: 1,
+            quantity: 5,
+            notes: "Test delivery"
+        };
+        const response = await request(app).post('/order-detail-deliveries').send(newOrderDetailDelivery);
+        expect(response.status).toBe(201);
+        expect(response.body).toEqual(newOrderDetailDelivery);
+    });
+
+    it('should get all order detail deliveries', async () => {
+        const response = await request(app).get('/order-detail-deliveries');
+        expect(response.status).toBe(200);
+        expect(response.body.length).toBe(seedOrderDetailDeliveries.length);
+        response.body.forEach((orderDetailDelivery: any, index: number) => {
+            expect(orderDetailDelivery).toMatchObject(seedOrderDetailDeliveries[index]);
+        });
+    });
+
+    it('should get an order detail delivery by ID', async () => {
+        const response = await request(app).get('/order-detail-deliveries/1');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(seedOrderDetailDeliveries[0]);
+    });
+
+    it('should update an order detail delivery by ID', async () => {
+        const updatedOrderDetailDelivery = {
+            ...seedOrderDetailDeliveries[0],
+            quantity: 10
+        };
+        const response = await request(app).put('/order-detail-deliveries/1').send(updatedOrderDetailDelivery);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(updatedOrderDetailDelivery);
+    });
+
+    it('should delete an order detail delivery by ID', async () => {
+        const response = await request(app).delete('/order-detail-deliveries/1');
+        expect(response.status).toBe(204);
+    });
+
+    it('should return 404 for non-existing order detail delivery', async () => {
+        const response = await request(app).get('/order-detail-deliveries/999');
+        expect(response.status).toBe(404);
+    });
+});

api/src/routes/orderDetailDelivery.ts

@@ -107,6 +107,11 @@ const router = express.Router();
 
 let orderDetailDeliveries: OrderDetailDelivery[] = [...seedOrderDetailDeliveries];
 
+// Add reset function for testing
+export const resetOrderDetailDeliveries = () => {
+  orderDetailDeliveries = [...seedOrderDetailDeliveries];
+};
+
 // Create a new order detail delivery
 router.post('/', (req, res) => {
   const newOrderDetailDelivery: OrderDetailDelivery = req.body;