[SSF 162] - Admin Donation Stats

apps/backend/src/pantries/pantries.controller.spec.ts

@@ -110,6 +110,50 @@ describe('PantriesController', () => {
     expect(controller).toBeDefined();
   });
 
+  describe('getAvailableYears', () => {
+    it('should return an array of years', async () => {
+      const mockYears = [2025, 2024];
+      mockPantriesService.getAvailableYears.mockResolvedValueOnce(mockYears);
+
+      const result = await controller.getAvailableYears();
+
+      expect(result).toEqual(mockYears);
+      expect(mockPantriesService.getAvailableYears).toHaveBeenCalled();
+    });
+
+    it('should return an empty array when no approved pantry orders exist', async () => {
+      mockPantriesService.getAvailableYears.mockResolvedValueOnce([]);
+
+      const result = await controller.getAvailableYears();
+
+      expect(result).toEqual([]);
+      expect(mockPantriesService.getAvailableYears).toHaveBeenCalled();
+    });
+  });
+
+  describe('getApprovedPantryNames', () => {
+    it('should return an array of approved pantry names', async () => {
+      const mockNames = ['Pantry A', 'Pantry B'];
+      mockPantriesService.getApprovedPantryNames.mockResolvedValueOnce(
+        mockNames,
+      );
+
+      const result = await controller.getApprovedPantryNames();
+
+      expect(result).toEqual(mockNames);
+      expect(mockPantriesService.getApprovedPantryNames).toHaveBeenCalled();
+    });
+
+    it('should return an empty array if no approved pantries exist', async () => {
+      mockPantriesService.getApprovedPantryNames.mockResolvedValueOnce([]);
+
+      const result = await controller.getApprovedPantryNames();
+
+      expect(result).toEqual([]);
+      expect(mockPantriesService.getApprovedPantryNames).toHaveBeenCalled();
+    });
+  });
+
   describe('getPendingPantries', () => {
     it('should return an array of pending pantries', async () => {
       mockPantriesService.getPendingPantries.mockResolvedValueOnce([
@@ -391,6 +435,7 @@ describe('PantriesController', () => {
       const mockStats: PantryStats[] = [
         {
           pantryId: 1,
+          pantryName: 'Community Food Pantry Downtown',
           totalItems: 100,
           totalOz: 1600,
           totalLbs: 100,

apps/backend/src/pantries/pantries.controller.ts

@@ -76,6 +76,17 @@ export class PantriesController {
   }
 
   @Roles(Role.ADMIN)
+  @Get('/approved-names')
+  async getApprovedPantryNames(): Promise<string[]> {
+    return this.pantriesService.getApprovedPantryNames();
+  }
+
+  @Roles(Role.ADMIN)
+  @Get('/available-years-stats')
+  async getAvailableYears(): Promise<number[]> {
+    return this.pantriesService.getAvailableYears();
+  }
+
   @Get('/approved')
   async getApprovedPantries(): Promise<ApprovedPantryResponse[]> {
     return this.pantriesService.getApprovedPantriesWithVolunteers();

apps/backend/src/pantries/pantries.service.spec.ts

@@ -471,7 +471,9 @@ describe('PantriesService', () => {
     it('throws NotFoundException for non-existent pantry names', async () => {
       await expect(
         service.getPantryStats(['Nonexistent Pantry']),
-      ).rejects.toThrow(NotFoundException);
+      ).rejects.toThrow(
+        new NotFoundException('Pantries not found: Nonexistent Pantry'),
+      );
     });
 
     it('throws NotFoundException when some provided pantry names do not exist', async () => {
@@ -480,7 +482,9 @@ describe('PantriesService', () => {
           'Community Food Pantry Downtown',
           'Fake Pantry',
         ]),
-      ).rejects.toThrow(NotFoundException);
+      ).rejects.toThrow(
+        new NotFoundException('Pantries not found: Fake Pantry'),
+      );
     });
 
     it('error message includes the missing pantry name', async () => {
@@ -506,19 +510,20 @@ describe('PantriesService', () => {
       expect(stats.percentageFoodRescueItems).toBe(0);
     });
 
-    it('returns zeroed stats for a pantry with no orders (Riverside Food Assistance)', async () => {
-      const stats = (
-        await service.getPantryStats(['Riverside Food Assistance'])
-      )[0];
+    it('throws NotFoundException for a non-approved (denied) pantry', async () => {
+      await expect(
+        service.getPantryStats(['Riverside Food Assistance']),
+      ).rejects.toThrow(
+        new NotFoundException('Pantries not found: Riverside Food Assistance'),
+      );
+    });
 
-      expect(stats.pantryId).toBe(4);
-      expect(stats.totalItems).toBe(0);
-      expect(stats.totalOz).toBe(0);
-      expect(stats.totalLbs).toBe(0);
-      expect(stats.totalDonatedFoodValue).toBe(0);
-      expect(stats.totalShippingCost).toBe(0);
-      expect(stats.totalValue).toBe(0);
-      expect(stats.percentageFoodRescueItems).toBe(0);
+    it('throws NotFoundException for a non-approved (pending) pantry', async () => {
+      await expect(
+        service.getPantryStats(['Harbor Community Center']),
+      ).rejects.toThrow(
+        new NotFoundException('Pantries not found: Harbor Community Center'),
+      );
     });
 
     it('respects year filter and returns zeros for a non-matching year', async () => {
@@ -579,6 +584,9 @@ describe('PantriesService', () => {
       for (let i = 0; i < 10; i++) {
         await service.addPantry(makePantryDto(i));
       }
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'approved' WHERE pantry_name LIKE 'BulkTest Pantry%'`,
+      );
 
       const page1 = await service.getPantryStats(undefined, undefined, 1);
       expect(page1.length).toBe(10);
@@ -606,9 +614,13 @@ describe('PantriesService', () => {
       expect(community?.totalDonatedFoodValue).toBeCloseTo(130.0, 2);
     });
 
-    it('returns proper array for no pantryNames given', async () => {
+    it('returns only approved pantries when no names given', async () => {
       const stats = await service.getPantryStats();
-      expect(stats.length).toBe(6);
+      expect(stats.length).toBe(3);
+      const names = stats.map((s) => s.pantryName);
+      expect(names).not.toContain('Riverside Food Assistance');
+      expect(names).not.toContain('Harbor Community Center');
+      expect(names).not.toContain('Southside Pantry Network');
     });
 
     it('returns nothing for an invalid pantry name', async () => {
@@ -628,9 +640,13 @@ describe('PantriesService', () => {
     });
 
     it('validates all names before paginating — throws if any name is invalid regardless of page', async () => {
+      // Create 12 valid approved pantries so we have enough to paginate
       for (let i = 0; i < 12; i++) {
         await service.addPantry(makePantryDto(i));
       }
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'approved' WHERE pantry_name LIKE 'BulkTest Pantry%'`,
+      );
       const validNames = Array.from(
         { length: 12 },
         (_, i) => `BulkTest Pantry ${i}`,
@@ -649,6 +665,9 @@ describe('PantriesService', () => {
       for (let i = 0; i < 12; i++) {
         await service.addPantry(makePantryDto(i));
       }
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'approved' WHERE pantry_name LIKE 'BulkTest Pantry%'`,
+      );
       const names = Array.from(
         { length: 12 },
         (_, i) => `BulkTest Pantry ${i}`,
@@ -662,6 +681,9 @@ describe('PantriesService', () => {
       for (let i = 0; i < 12; i++) {
         await service.addPantry(makePantryDto(i));
       }
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'approved' WHERE pantry_name LIKE 'BulkTest Pantry%'`,
+      );
       const names = Array.from(
         { length: 12 },
         (_, i) => `BulkTest Pantry ${i}`,
@@ -675,6 +697,9 @@ describe('PantriesService', () => {
       for (let i = 0; i < 12; i++) {
         await service.addPantry(makePantryDto(i));
       }
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'approved' WHERE pantry_name LIKE 'BulkTest Pantry%'`,
+      );
       const names = Array.from(
         { length: 12 },
         (_, i) => `BulkTest Pantry ${i}`,
@@ -688,6 +713,9 @@ describe('PantriesService', () => {
       for (let i = 0; i < 12; i++) {
         await service.addPantry(makePantryDto(i));
       }
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'approved' WHERE pantry_name LIKE 'BulkTest Pantry%'`,
+      );
       const names = Array.from(
         { length: 12 },
         (_, i) => `BulkTest Pantry ${i}`,
@@ -704,6 +732,27 @@ describe('PantriesService', () => {
     });
   });
 
+  describe('getApprovedPantryNames', () => {
+    it('returns the 3 approved pantry names from seed data', async () => {
+      const names = await service.getApprovedPantryNames();
+
+      expect(names).toHaveLength(3);
+      expect(names).toContain('Community Food Pantry Downtown');
+      expect(names).toContain('Westside Community Kitchen');
+      expect(names).toContain('North End Food Bank');
+    });
+
+    it('returns an empty array when no pantries are approved', async () => {
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'pending' WHERE status = 'approved'`,
+      );
+
+      const names = await service.getApprovedPantryNames();
+
+      expect(names).toEqual([]);
+    });
+  });
+
   describe('getTotalStats', () => {
     it('aggregates stats across all pantries and matches migration sums', async () => {
       const total = await service.getTotalStats();
@@ -726,6 +775,72 @@ describe('PantriesService', () => {
       expect(totalEmpty.totalValue).toBe(0);
       expect(totalEmpty.percentageFoodRescueItems).toBe(0);
     });
+
+    it('returns all zeros when no approved pantries exist', async () => {
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'pending' WHERE status = 'approved'`,
+      );
+      const total = await service.getTotalStats();
+      expect(total.totalItems).toBe(0);
+      expect(total.totalOz).toBe(0);
+      expect(total.totalLbs).toBe(0);
+      expect(total.totalDonatedFoodValue).toBe(0);
+      expect(total.totalShippingCost).toBe(0);
+      expect(total.totalValue).toBe(0);
+      expect(total.percentageFoodRescueItems).toBe(0);
+    });
+  });
+
+  describe('getAvailableYears', () => {
+    it('returns years from approved pantry orders sorted descending', async () => {
+      await testDataSource.query(
+        `UPDATE public.orders SET created_at = '2024-06-01 00:00:00'`,
+      );
+
+      const years = await service.getAvailableYears();
+
+      expect(years).toEqual([2024]);
+    });
+
+    it('returns multiple years sorted descending', async () => {
+      await testDataSource.query(`
+        UPDATE public.orders
+        SET created_at = '2025-01-01 00:00:00'
+        WHERE order_id = (SELECT order_id FROM public.orders ORDER BY order_id LIMIT 1)
+      `);
+      await testDataSource.query(`
+        UPDATE public.orders
+        SET created_at = '2024-01-01 00:00:00'
+        WHERE order_id != (SELECT order_id FROM public.orders ORDER BY order_id LIMIT 1)
+      `);
+
+      const years = await service.getAvailableYears();
+
+      expect(years).toEqual([2025, 2024]);
+    });
+
+    it('returns empty array when no approved pantries exist', async () => {
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'pending' WHERE status = 'approved'`,
+      );
+
+      const years = await service.getAvailableYears();
+
+      expect(years).toEqual([]);
+    });
+
+    it('excludes years from non-approved pantry orders', async () => {
+      await testDataSource.query(
+        `UPDATE public.orders SET created_at = '2024-06-01 00:00:00'`,
+      );
+      await testDataSource.query(
+        `UPDATE public.pantries SET status = 'pending' WHERE status = 'approved'`,
+      );
+
+      const years = await service.getAvailableYears();
+
+      expect(years).toEqual([]);
+    });
   });
 
   describe('findByIds', () => {
@@ -849,12 +964,12 @@ describe('PantriesService', () => {
       const williamId = Number(await getVolunteerId('william.m@volunteer.org'));
       await expect(
         service.updatePantryVolunteers(9999, [williamId]),
-      ).rejects.toThrow(NotFoundException);
+      ).rejects.toThrow(new NotFoundException('Pantry with ID 9999 not found'));
     });
 
     it('throws NotFoundException when volunteer id does not exist', async () => {
       await expect(service.updatePantryVolunteers(1, [99999])).rejects.toThrow(
-        NotFoundException,
+        new NotFoundException('One or more users not found'),
       );
     });