Merge pull request #2073 from OneCommunityGlobal/Aditya-feat/Add-Side-by-Side-Comparison-Mode-for-Actual-vs-Planned-Expenditure-Charts

Rithika taking over for Aditya-feat: Side-by-Side Comparison Mode for Actual vs. Planned Expenditure Charts

Author: one-community

src/controllers/bmdashboard/__tests__/bmEquipmentController.test.js

@@ -15,6 +15,7 @@ describe('bmEquipmentController', () => {
       findOneAndUpdate: jest.fn(),
       create: jest.fn(),
       findByIdAndUpdate: jest.fn(),
+      updateOne: jest.fn(),
     };
 
     // Initialize controller with mock model
@@ -130,4 +131,148 @@ describe('bmEquipmentController', () => {
       expect(mockRes.status).toHaveBeenCalledWith(201);
     });
   });
+
+  describe('updateEquipmentById', () => {
+    const validObjectId = '507f1f77bcf86cd799439011';
+
+    it('should return 400 for invalid equipment ID', async () => {
+      mockReq.params.equipmentId = 'invalid-id';
+      mockReq.body = { purchaseStatus: 'Purchased' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith({ message: 'Invalid equipment ID.' });
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid project ID when provided', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { projectId: 'not-valid', purchaseStatus: 'Purchased' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith({ message: 'Invalid project ID.' });
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid purchaseStatus enum', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { purchaseStatus: 'InvalidStatus' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Invalid purchaseStatus'),
+        }),
+      );
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid currentUsage enum', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { currentUsage: 'Broken' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Invalid currentUsage'),
+        }),
+      );
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid condition enum', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { condition: 'Unknown' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Invalid condition'),
+        }),
+      );
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 when no valid fields provided to update', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { unknownField: 'value' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith({
+        message: 'No valid fields provided to update.',
+      });
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 200 with updated equipment on success', async () => {
+      const updatedEquipment = {
+        _id: validObjectId,
+        purchaseStatus: 'Purchased',
+        condition: 'Good',
+      };
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { purchaseStatus: 'Purchased', condition: 'Good' };
+
+      mockBuildingEquipment.updateOne.mockResolvedValue({});
+      const mockPopulate = jest.fn().mockReturnThis();
+      const mockExec = jest.fn().mockResolvedValue(updatedEquipment);
+      mockBuildingEquipment.findById.mockReturnValue({
+        populate: mockPopulate,
+        exec: mockExec,
+      });
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockBuildingEquipment.updateOne).toHaveBeenCalledWith(
+        { _id: validObjectId },
+        { $set: expect.objectContaining({ purchaseStatus: 'Purchased', condition: 'Good' }) },
+      );
+      expect(mockBuildingEquipment.findById).toHaveBeenCalledWith(validObjectId);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.send).toHaveBeenCalledWith(updatedEquipment);
+    });
+
+    it('should return 404 when equipment not found after update', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { condition: 'Good' };
+
+      mockBuildingEquipment.updateOne.mockResolvedValue({});
+      const mockPopulate = jest.fn().mockReturnThis();
+      const mockExec = jest.fn().mockResolvedValue(null);
+      mockBuildingEquipment.findById.mockReturnValue({
+        populate: mockPopulate,
+        exec: mockExec,
+      });
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(404);
+      expect(mockRes.send).toHaveBeenCalledWith({ message: 'Equipment not found.' });
+    });
+
+    it('should return 500 on updateOne error', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { condition: 'Good' };
+
+      mockBuildingEquipment.updateOne.mockRejectedValue(new Error('DB error'));
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(500);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({ message: expect.any(String) }),
+      );
+    });
+  });
 });

src/controllers/bmdashboard/__tests__/expenditureController.test.js

@@ -0,0 +1,148 @@
+jest.mock('../../../models/bmdashboard/expenditure', () => ({
+  distinct: jest.fn(),
+  aggregate: jest.fn(),
+}));
+
+jest.mock('../../../startup/logger', () => ({
+  logException: jest.fn(),
+  logInfo: jest.fn(),
+}));
+
+const Expenditure = require('../../../models/bmdashboard/expenditure');
+const logger = require('../../../startup/logger');
+const { getProjectExpensesPie, getProjectIdsWithExpenditure } = require('../expenditureController');
+
+const VALID_ID = '507f1f77bcf86cd799439011';
+const INVALID_ID = 'not-a-valid-id';
+
+const makeRes = () => {
+  const res = {};
+  res.status = jest.fn().mockReturnThis();
+  res.json = jest.fn().mockReturnThis();
+  return res;
+};
+
+describe('expenditureController', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // ---------------------------------------------------------------------------
+  describe('getProjectIdsWithExpenditure', () => {
+    it('returns 200 with the array of project IDs on success', async () => {
+      const ids = [VALID_ID, '507f1f77bcf86cd799439012'];
+      Expenditure.distinct.mockResolvedValue(ids);
+
+      const res = makeRes();
+      await getProjectIdsWithExpenditure({}, res);
+
+      expect(Expenditure.distinct).toHaveBeenCalledWith('projectId');
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(ids);
+    });
+
+    it('returns 200 with an empty array when no expenditure records exist', async () => {
+      Expenditure.distinct.mockResolvedValue([]);
+
+      const res = makeRes();
+      await getProjectIdsWithExpenditure({}, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith([]);
+    });
+
+    it('returns 500 and calls logger on DB error', async () => {
+      const error = new Error('DB failure');
+      Expenditure.distinct.mockRejectedValue(error);
+
+      const res = makeRes();
+      await getProjectIdsWithExpenditure({}, res);
+
+      expect(res.status).toHaveBeenCalledWith(500);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Failed to retrieve project IDs' });
+      expect(logger.logException).toHaveBeenCalledWith(
+        error,
+        'expenditureController.getProjectIdsWithExpenditure',
+      );
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  describe('getProjectExpensesPie', () => {
+    it('returns 400 for an invalid projectId without calling aggregate', async () => {
+      const req = { params: { projectId: INVALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Invalid project ID' });
+      expect(Expenditure.aggregate).not.toHaveBeenCalled();
+    });
+
+    it('returns 400 for a short non-hex string without calling aggregate', async () => {
+      const req = { params: { projectId: '12345' } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(Expenditure.aggregate).not.toHaveBeenCalled();
+    });
+
+    it('returns 200 with { actual, planned } shape on success', async () => {
+      Expenditure.aggregate.mockResolvedValue([
+        { _id: { type: 'actual', category: 'Labor' }, amount: 1000 },
+        { _id: { type: 'actual', category: 'Materials' }, amount: 500 },
+        { _id: { type: 'planned', category: 'Equipment' }, amount: 2000 },
+      ]);
+
+      const req = { params: { projectId: VALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(Expenditure.aggregate).toHaveBeenCalledTimes(1);
+      expect(res.json).toHaveBeenCalledWith({
+        actual: [
+          { category: 'Labor', amount: 1000 },
+          { category: 'Materials', amount: 500 },
+        ],
+        planned: [{ category: 'Equipment', amount: 2000 }],
+      });
+      // status should NOT be explicitly set to 200 (res.json implies 200)
+      expect(res.status).not.toHaveBeenCalled();
+    });
+
+    it('returns { actual: [], planned: [] } when no matching records exist', async () => {
+      Expenditure.aggregate.mockResolvedValue([]);
+
+      const req = { params: { projectId: VALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.json).toHaveBeenCalledWith({ actual: [], planned: [] });
+    });
+
+    it('returns 500 and calls logger with projectId on DB error', async () => {
+      const error = new Error('Aggregate failed');
+      Expenditure.aggregate.mockRejectedValue(error);
+
+      const req = { params: { projectId: VALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(500);
+      expect(res.json).toHaveBeenCalledWith({
+        message: 'Server error retrieving expenses pie data.',
+      });
+      expect(logger.logException).toHaveBeenCalledWith(
+        error,
+        'expenditureController.getProjectExpensesPie',
+        { projectId: VALID_ID },
+      );
+    });
+  });
+});

src/controllers/bmdashboard/expenditureController.js

@@ -1,12 +1,17 @@
 const mongoose = require('mongoose');
 const Expenditure = require('../../models/bmdashboard/expenditure');
+const logger = require('../../startup/logger');
 
 exports.getProjectExpensesPie = async (req, res) => {
   try {
     const { projectId } = req.params;
 
+    if (!mongoose.Types.ObjectId.isValid(projectId)) {
+      return res.status(400).json({ message: 'Invalid project ID' });
+    }
+
     const data = await Expenditure.aggregate([
-      { $match: { projectId: mongoose.Types.ObjectId(projectId) } },
+      { $match: { projectId: new mongoose.Types.ObjectId(projectId) } },
       {
         $group: {
           _id: { type: '$type', category: '$category' },
@@ -22,18 +27,21 @@ exports.getProjectExpensesPie = async (req, res) => {
       result[type].push({ category, amount: item.amount });
     });
 
-    res.json(result);
+    return res.json(result);
   } catch (error) {
-    console.error(error);
-    res.status(500).json({ message: 'Server error retrieving expenses pie data.' });
+    logger.logException(error, 'expenditureController.getProjectExpensesPie', {
+      projectId: req.params.projectId,
+    });
+    return res.status(500).json({ message: 'Server error retrieving expenses pie data.' });
   }
 };
-exports.getProjectIdsWithExpenditure = async (req, res) => {
+
+exports.getProjectIdsWithExpenditure = async (_req, res) => {
   try {
     const projectIds = await Expenditure.distinct('projectId');
-    res.status(200).json(projectIds);
+    return res.status(200).json(projectIds);
   } catch (error) {
-    console.error('Error fetching project IDs:', error);
-    res.status(500).json({ message: 'Failed to retrieve project IDs' });
+    logger.logException(error, 'expenditureController.getProjectIdsWithExpenditure');
+    return res.status(500).json({ message: 'Failed to retrieve project IDs' });
   }
 };