test: Enhance prayer times service tests with additional parameters and mock responses

Author: F2had

src/prayer-times/controllers/prayer-times.controller.spec.ts

@@ -87,11 +87,8 @@ describe('PrayerTimesController', () => {
       expect(prayerTimesService.getPrayerTimes).toHaveBeenCalledWith(
         51.5074,
         -0.1278,
-        2025,
-        7,
-        2,
         1,
-        { method: 2 },
+        { method: 2, year: 2025, month: 7 },
       );
     });
 

src/prayer-times/dtos/prayer-times.dto.ts

@@ -1,4 +1,4 @@
-import { IsOptional, IsInt, IsNumber, IsNotEmpty } from 'class-validator';
+import { IsOptional, IsInt } from 'class-validator';
 import { LocationDto } from '@/prayer-times/dtos/location.dto';
 import { Type } from 'class-transformer';
 

src/prayer-times/services/aladhan/aladhan.service.spec.ts

@@ -1,20 +1,151 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AladhanService } from './aladhan.service';
-import { HttpModule } from '@nestjs/axios';
+import { HttpService } from '@nestjs/axios';
+import { of } from 'rxjs';
+import { AxiosResponse } from 'axios';
 
 describe('AladhanService', () => {
   let service: AladhanService;
+  let httpService: HttpService;
+
+  const mockAladhanResponseData = {
+    data: {
+      '1': [
+        {
+          date: { timestamp: '01 Jan 2025' },
+          meta: {
+            timezone: 'Asia/Riyadh',
+            location: { latitude: 24.7136, longitude: 46.6753 },
+          },
+          timings: {
+            Fajr: '2025-01-01T05:23:00+03:00',
+            Sunrise: '2025-01-01T06:46:00+03:00',
+            Dhuhr: '2025-01-01T12:04:00+03:00',
+            Asr: '2025-01-01T15:15:00+03:00',
+            Sunset: '2025-01-01T17:23:00+03:00',
+            Maghrib: '2025-01-01T17:23:00+03:00',
+            Isha: '2025-01-01T18:53:00+03:00',
+            Imsak: '2025-01-01T05:13:00+03:00',
+            Midnight: '2025-01-02T00:04:00+03:00',
+            Firstthird: '2025-01-01T21:24:00+03:00',
+            Lastthird: '2025-01-02T02:45:00+03:00',
+          },
+        },
+      ],
+    },
+  };
+
+  const mockAxiosResponse: AxiosResponse = {
+    data: mockAladhanResponseData,
+    status: 200,
+    statusText: 'OK',
+    headers: {},
+    config: {} as any,
+  };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      imports: [HttpModule],
-      providers: [AladhanService],
+      providers: [
+        AladhanService,
+        {
+          provide: HttpService,
+          useValue: {
+            get: jest.fn(),
+          },
+        },
+      ],
     }).compile();
 
     service = module.get<AladhanService>(AladhanService);
+    httpService = module.get<HttpService>(HttpService);
   });
 
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('getPrayerTimes', () => {
+    it('should fetch prayer times with basic parameters', async () => {
+      jest.spyOn(httpService, 'get').mockReturnValue(of(mockAxiosResponse));
+
+      const result = await service.getPrayerTimes(24.7136, 46.6753, {
+        method: 3,
+      });
+
+      expect(httpService.get).toHaveBeenCalledWith(
+        'https://api.aladhan.com/v1/calendar',
+        {
+          params: {
+            latitude: 24.7136,
+            longitude: 46.6753,
+            iso8601: true,
+            annual: true,
+            method: 3,
+          },
+        },
+      );
+
+      expect(result.timezone).toBe('Asia/Riyadh');
+      expect(result.location).toEqual({
+        latitude: 24.7136,
+        longitude: 46.6753,
+      });
+      expect(result.months['1']).toBeDefined();
+    });
+
+    it('should fetch prayer times with all Aladhan parameters', async () => {
+      jest.spyOn(httpService, 'get').mockReturnValue(of(mockAxiosResponse));
+
+      const params = {
+        method: 3,
+        school: 1,
+        midnightMode: 0,
+        shafaq: 'general',
+        latitudeAdjustment: 1,
+        tune: '0,5,0,0,0,0,0,-2,0',
+        year: 2025,
+        month: 1,
+      };
+
+      await service.getPrayerTimes(24.7136, 46.6753, params);
+
+      expect(httpService.get).toHaveBeenCalledWith(
+        'https://api.aladhan.com/v1/calendar',
+        {
+          params: {
+            latitude: 24.7136,
+            longitude: 46.6753,
+            iso8601: true,
+            annual: true,
+            method: 3,
+            school: 1,
+            midnightMode: 0,
+            shafaq: 'general',
+            latitudeAdjustment: 1,
+            tune: '0,5,0,0,0,0,0,-2,0',
+            year: 2025,
+            month: 1,
+          },
+        },
+      );
+    });
+
+    it('should fetch prayer times with no optional parameters', async () => {
+      jest.spyOn(httpService, 'get').mockReturnValue(of(mockAxiosResponse));
+
+      await service.getPrayerTimes(24.7136, 46.6753);
+
+      expect(httpService.get).toHaveBeenCalledWith(
+        'https://api.aladhan.com/v1/calendar',
+        {
+          params: {
+            latitude: 24.7136,
+            longitude: 46.6753,
+            iso8601: true,
+            annual: true,
+          },
+        },
+      );
+    });
+  });
 });

src/prayer-times/services/prayer-times.service.spec.ts

@@ -5,6 +5,17 @@ import { ProviderService } from '@/prayer-times/services/provider/provider.servi
 
 describe('PrayerTimesService', () => {
   let service: PrayerTimesService;
+  let providerService: ProviderService;
+  let providerRegistry: ProviderRegistryService;
+
+  const mockProvider = {
+    id: 1,
+    name: 'Aladhan',
+    website: 'https://aladhan.com',
+  };
+  const mockProviderService = {
+    getPrayerTimes: jest.fn(),
+  };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -13,23 +24,68 @@ describe('PrayerTimesService', () => {
         {
           provide: ProviderService,
           useValue: {
-            getProviderById: jest.fn(),
-            getProviders: jest.fn(),
+            getProviderById: jest.fn().mockReturnValue(mockProvider),
+            getProviders: jest.fn().mockReturnValue([mockProvider]),
           },
         },
         {
           provide: ProviderRegistryService,
           useValue: {
-            getProviderService: jest.fn(),
+            getProviderService: jest.fn().mockReturnValue(mockProviderService),
           },
         },
       ],
     }).compile();
 
     service = module.get<PrayerTimesService>(PrayerTimesService);
+    providerService = module.get<ProviderService>(ProviderService);
+    providerRegistry = module.get<ProviderRegistryService>(
+      ProviderRegistryService,
+    );
   });
 
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('getPrayerTimes', () => {
+    it('should call provider service with correct parameters', async () => {
+      const mockResponse = {
+        timezone: 'Asia/Riyadh',
+        location: { latitude: 24.7136, longitude: 46.6753 },
+        months: {},
+      };
+
+      mockProviderService.getPrayerTimes.mockResolvedValue(mockResponse);
+
+      const result = await service.getPrayerTimes(24.7136, 46.6753, 1, {
+        method: 3,
+        school: 1,
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(providerRegistry.getProviderService).toHaveBeenCalledWith(1);
+      expect(mockProviderService.getPrayerTimes).toHaveBeenCalledWith(
+        24.7136,
+        46.6753,
+        { method: 3, school: 1 },
+      );
+    });
+
+    it('should use default provider when none specified', async () => {
+      const mockResponse = {
+        timezone: 'Asia/Riyadh',
+        location: { latitude: 24.7136, longitude: 46.6753 },
+        months: {},
+      };
+
+      mockProviderService.getPrayerTimes.mockResolvedValue(mockResponse);
+      (providerService.getProviderById as jest.Mock).mockReturnValue(null);
+
+      await service.getPrayerTimes(24.7136, 46.6753, undefined, { method: 3 });
+
+      expect(providerService.getProviders).toHaveBeenCalled();
+      expect(providerRegistry.getProviderService).toHaveBeenCalledWith(1);
+    });
+  });
 });