diff --git a/api/src/routes/delivery.test.ts b/api/src/routes/delivery.test.ts
new file mode 100644
index 0000000..45d09b5
--- /dev/null
+++ b/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);
+    });
+});
diff --git a/api/src/routes/delivery.ts b/api/src/routes/delivery.ts
index 1408c46..ffd0567 100644
--- a/api/src/routes/delivery.ts
+++ b/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;
diff --git a/api/src/routes/headquarters.test.ts b/api/src/routes/headquarters.test.ts
new file mode 100644
index 0000000..dead103
--- /dev/null
+++ b/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);
+    });
+});
diff --git a/api/src/routes/headquarters.ts b/api/src/routes/headquarters.ts
index 901f90a..172b3be 100644
--- a/api/src/routes/headquarters.ts
+++ b/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;
diff --git a/api/src/routes/order.test.ts b/api/src/routes/order.test.ts
new file mode 100644
index 0000000..98ec994
--- /dev/null
+++ b/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);
+    });
+});
diff --git a/api/src/routes/order.ts b/api/src/routes/order.ts
index b47e12c..9b015ac 100644
--- a/api/src/routes/order.ts
+++ b/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;
diff --git a/api/src/routes/orderDetail.test.ts b/api/src/routes/orderDetail.test.ts
new file mode 100644
index 0000000..16d1bca
--- /dev/null
+++ b/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);
+    });
+});
diff --git a/api/src/routes/orderDetail.ts b/api/src/routes/orderDetail.ts
index 443278a..9730f9c 100644
--- a/api/src/routes/orderDetail.ts
+++ b/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;
diff --git a/api/src/routes/orderDetailDelivery.test.ts b/api/src/routes/orderDetailDelivery.test.ts
new file mode 100644
index 0000000..0ce07dd
--- /dev/null
+++ b/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);
+    });
+});
diff --git a/api/src/routes/orderDetailDelivery.ts b/api/src/routes/orderDetailDelivery.ts
index 501cb24..dd00bcd 100644
--- a/api/src/routes/orderDetailDelivery.ts
+++ b/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;
diff --git a/api/src/routes/product.test.ts b/api/src/routes/product.test.ts
new file mode 100644
index 0000000..da88389
--- /dev/null
+++ b/api/src/routes/product.test.ts
@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import productRouter, { resetProducts } from './product';
+import { products as seedProducts } from '../seedData';
+
+let app: express.Express;
+
+describe('Product API', () => {
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/products', productRouter);
+        resetProducts();
+    });
+
+    it('should create a new product', async () => {
+        const newProduct = {
+            productId: 100,
+            supplierId: 1,
+            name: "Test Product",
+            description: "A test product for testing",
+            price: 99.99,
+            sku: "TEST-001",
+            unit: "piece",
+            imgName: "test.png"
+        };
+        const response = await request(app).post('/products').send(newProduct);
+        expect(response.status).toBe(201);
+        expect(response.body).toEqual(newProduct);
+    });
+
+    it('should get all products', async () => {
+        const response = await request(app).get('/products');
+        expect(response.status).toBe(200);
+        expect(response.body.length).toBe(seedProducts.length);
+        response.body.forEach((product: any, index: number) => {
+            expect(product).toMatchObject(seedProducts[index]);
+        });
+    });
+
+    it('should get a product by ID', async () => {
+        const response = await request(app).get('/products/1');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(seedProducts[0]);
+    });
+
+    it('should update a product by ID', async () => {
+        const updatedProduct = {
+            ...seedProducts[0],
+            name: 'Updated SmartFeeder'
+        };
+        const response = await request(app).put('/products/1').send(updatedProduct);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(updatedProduct);
+    });
+
+    it('should delete a product by ID', async () => {
+        const response = await request(app).delete('/products/1');
+        expect(response.status).toBe(204);
+    });
+
+    it('should return 404 for non-existing product', async () => {
+        const response = await request(app).get('/products/999');
+        expect(response.status).toBe(404);
+    });
+});
diff --git a/api/src/routes/product.ts b/api/src/routes/product.ts
index 0c3b8bf..703a8a0 100644
--- a/api/src/routes/product.ts
+++ b/api/src/routes/product.ts
@@ -107,6 +107,11 @@ const router = express.Router();
 
 let products: Product[] = [...seedProducts];
 
+// Add reset function for testing
+export const resetProducts = () => {
+  products = [...seedProducts];
+};
+
 // Create a new product
 router.post('/', (req, res) => {
   const newProduct: Product = req.body;
diff --git a/api/src/routes/supplier.test.ts b/api/src/routes/supplier.test.ts
new file mode 100644
index 0000000..1f9a227
--- /dev/null
+++ b/api/src/routes/supplier.test.ts
@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import supplierRouter, { resetSuppliers } from './supplier';
+import { suppliers as seedSuppliers } from '../seedData';
+
+let app: express.Express;
+
+describe('Supplier API', () => {
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/suppliers', supplierRouter);
+        resetSuppliers();
+    });
+
+    it('should create a new supplier', async () => {
+        const newSupplier = {
+            supplierId: 100,
+            name: "Test Supplier Co.",
+            description: "A test supplier for testing",
+            contactPerson: "Test Person",
+            email: "test@supplier.com",
+            phone: "555-9999"
+        };
+        const response = await request(app).post('/suppliers').send(newSupplier);
+        expect(response.status).toBe(201);
+        expect(response.body).toEqual(newSupplier);
+    });
+
+    it('should get all suppliers', async () => {
+        const response = await request(app).get('/suppliers');
+        expect(response.status).toBe(200);
+        expect(response.body.length).toBe(seedSuppliers.length);
+        response.body.forEach((supplier: any, index: number) => {
+            expect(supplier).toMatchObject(seedSuppliers[index]);
+        });
+    });
+
+    it('should get a supplier by ID', async () => {
+        const response = await request(app).get('/suppliers/1');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(seedSuppliers[0]);
+    });
+
+    it('should update a supplier by ID', async () => {
+        const updatedSupplier = {
+            ...seedSuppliers[0],
+            name: 'Updated PurrTech Innovations'
+        };
+        const response = await request(app).put('/suppliers/1').send(updatedSupplier);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(updatedSupplier);
+    });
+
+    it('should delete a supplier by ID', async () => {
+        const response = await request(app).delete('/suppliers/1');
+        expect(response.status).toBe(204);
+    });
+
+    it('should return 404 for non-existing supplier', async () => {
+        const response = await request(app).get('/suppliers/999');
+        expect(response.status).toBe(404);
+    });
+});
diff --git a/api/src/routes/supplier.ts b/api/src/routes/supplier.ts
index 905466e..550fd8c 100644
--- a/api/src/routes/supplier.ts
+++ b/api/src/routes/supplier.ts
@@ -107,6 +107,11 @@ const router = express.Router();
 
 let suppliers: Supplier[] = [...seedSuppliers];
 
+// Add reset function for testing
+export const resetSuppliers = () => {
+    suppliers = [...seedSuppliers];
+};
+
 // Create a new supplier
 router.post('/', (req, res) => {
     const newSupplier = req.body as Supplier;