|
|
|
@ -1,20 +1,791 @@ |
|
|
|
import { Test, TestingModule } from '@nestjs/testing' |
|
|
|
import { GatewayService } from './gateway.service' |
|
|
|
import { AuthModule } from '../auth/auth.module' |
|
|
|
import { getModelToken } from '@nestjs/mongoose' |
|
|
|
import { Device, DeviceDocument } from './schemas/device.schema' |
|
|
|
import { SMS } from './schemas/sms.schema' |
|
|
|
import { SMSBatch } from './schemas/sms-batch.schema' |
|
|
|
import { AuthService } from '../auth/auth.service' |
|
|
|
import { WebhookService } from '../webhook/webhook.service' |
|
|
|
import { BillingService } from '../billing/billing.service' |
|
|
|
import { SmsQueueService } from './queue/sms-queue.service' |
|
|
|
import { Model } from 'mongoose' |
|
|
|
import { ConfigModule } from '@nestjs/config' |
|
|
|
import { HttpException, HttpStatus } from '@nestjs/common' |
|
|
|
import * as firebaseAdmin from 'firebase-admin' |
|
|
|
import { SMSType } from './sms-type.enum' |
|
|
|
import { WebhookEvent } from '../webhook/webhook-event.enum' |
|
|
|
import { RegisterDeviceInputDTO, SendBulkSMSInputDTO, SendSMSInputDTO } from './gateway.dto' |
|
|
|
import { User } from '../users/schemas/user.schema' |
|
|
|
import { BatchResponse } from 'firebase-admin/messaging' |
|
|
|
|
|
|
|
// Mock firebase-admin
|
|
|
|
jest.mock('firebase-admin', () => ({ |
|
|
|
messaging: jest.fn().mockReturnValue({ |
|
|
|
sendEach: jest.fn(), |
|
|
|
}), |
|
|
|
})) |
|
|
|
|
|
|
|
describe('GatewayService', () => { |
|
|
|
let service: GatewayService |
|
|
|
let deviceModel: Model<DeviceDocument> |
|
|
|
let smsModel: Model<SMS> |
|
|
|
let smsBatchModel: Model<SMSBatch> |
|
|
|
let authService: AuthService |
|
|
|
let webhookService: WebhookService |
|
|
|
let billingService: BillingService |
|
|
|
let smsQueueService: SmsQueueService |
|
|
|
|
|
|
|
const mockDeviceModel = { |
|
|
|
findOne: jest.fn(), |
|
|
|
find: jest.fn(), |
|
|
|
findById: jest.fn(), |
|
|
|
findByIdAndUpdate: jest.fn(), |
|
|
|
findByIdAndDelete: jest.fn(), |
|
|
|
create: jest.fn(), |
|
|
|
exec: jest.fn(), |
|
|
|
countDocuments: jest.fn(), |
|
|
|
} |
|
|
|
|
|
|
|
const mockSmsModel = { |
|
|
|
create: jest.fn(), |
|
|
|
find: jest.fn(), |
|
|
|
updateMany: jest.fn(), |
|
|
|
countDocuments: jest.fn(), |
|
|
|
} |
|
|
|
|
|
|
|
const mockSmsBatchModel = { |
|
|
|
create: jest.fn(), |
|
|
|
findByIdAndUpdate: jest.fn(), |
|
|
|
} |
|
|
|
|
|
|
|
const mockAuthService = { |
|
|
|
getUserApiKeys: jest.fn(), |
|
|
|
} |
|
|
|
|
|
|
|
const mockWebhookService = { |
|
|
|
deliverNotification: jest.fn(), |
|
|
|
} |
|
|
|
|
|
|
|
const mockBillingService = { |
|
|
|
canPerformAction: jest.fn(), |
|
|
|
} |
|
|
|
|
|
|
|
const mockSmsQueueService = { |
|
|
|
isQueueEnabled: jest.fn(), |
|
|
|
addSendSmsJob: jest.fn(), |
|
|
|
} |
|
|
|
|
|
|
|
beforeEach(async () => { |
|
|
|
const module: TestingModule = await Test.createTestingModule({ |
|
|
|
providers: [GatewayService], |
|
|
|
imports: [AuthModule], |
|
|
|
providers: [ |
|
|
|
GatewayService, |
|
|
|
{ |
|
|
|
provide: getModelToken(Device.name), |
|
|
|
useValue: mockDeviceModel, |
|
|
|
}, |
|
|
|
{ |
|
|
|
provide: getModelToken(SMS.name), |
|
|
|
useValue: mockSmsModel, |
|
|
|
}, |
|
|
|
{ |
|
|
|
provide: getModelToken(SMSBatch.name), |
|
|
|
useValue: mockSmsBatchModel, |
|
|
|
}, |
|
|
|
{ |
|
|
|
provide: AuthService, |
|
|
|
useValue: mockAuthService, |
|
|
|
}, |
|
|
|
{ |
|
|
|
provide: WebhookService, |
|
|
|
useValue: mockWebhookService, |
|
|
|
}, |
|
|
|
{ |
|
|
|
provide: BillingService, |
|
|
|
useValue: mockBillingService, |
|
|
|
}, |
|
|
|
{ |
|
|
|
provide: SmsQueueService, |
|
|
|
useValue: mockSmsQueueService, |
|
|
|
}, |
|
|
|
], |
|
|
|
imports: [ConfigModule], |
|
|
|
}).compile() |
|
|
|
|
|
|
|
service = module.get<GatewayService>(GatewayService) |
|
|
|
deviceModel = module.get<Model<DeviceDocument>>(getModelToken(Device.name)) |
|
|
|
smsModel = module.get<Model<SMS>>(getModelToken(SMS.name)) |
|
|
|
smsBatchModel = module.get<Model<SMSBatch>>(getModelToken(SMSBatch.name)) |
|
|
|
authService = module.get<AuthService>(AuthService) |
|
|
|
webhookService = module.get<WebhookService>(WebhookService) |
|
|
|
billingService = module.get<BillingService>(BillingService) |
|
|
|
smsQueueService = module.get<SmsQueueService>(SmsQueueService) |
|
|
|
|
|
|
|
// Reset all mocks
|
|
|
|
jest.clearAllMocks() |
|
|
|
}) |
|
|
|
|
|
|
|
it('should be defined', () => { |
|
|
|
expect(service).toBeDefined() |
|
|
|
}) |
|
|
|
|
|
|
|
describe('registerDevice', () => { |
|
|
|
const mockUser = { |
|
|
|
_id: 'user123', |
|
|
|
name: 'Test User', |
|
|
|
email: 'test@example.com', |
|
|
|
password: 'password', |
|
|
|
role: 'user', |
|
|
|
createdAt: new Date(), |
|
|
|
updatedAt: new Date() |
|
|
|
} as unknown as User; |
|
|
|
|
|
|
|
const mockDeviceInput: RegisterDeviceInputDTO = { |
|
|
|
model: 'Pixel 6', |
|
|
|
buildId: 'build123', |
|
|
|
fcmToken: 'token123', |
|
|
|
enabled: true, |
|
|
|
} |
|
|
|
const mockDevice = { |
|
|
|
_id: 'device123', |
|
|
|
...mockDeviceInput, |
|
|
|
user: mockUser._id, |
|
|
|
} |
|
|
|
|
|
|
|
it('should update device if it already exists', async () => { |
|
|
|
mockDeviceModel.findOne.mockResolvedValue(mockDevice) |
|
|
|
mockDeviceModel.findByIdAndUpdate.mockResolvedValue({ |
|
|
|
...mockDevice, |
|
|
|
fcmToken: 'updatedToken', |
|
|
|
}) |
|
|
|
|
|
|
|
// The implementation internally uses the _id from the found device to update it
|
|
|
|
// So we need to avoid the internal call to updateDevice which is failing in the test
|
|
|
|
// by mocking the service method directly and restoring it after the test
|
|
|
|
const originalUpdateDevice = service.updateDevice; |
|
|
|
service.updateDevice = jest.fn().mockResolvedValue({ |
|
|
|
...mockDevice, |
|
|
|
fcmToken: 'updatedToken', |
|
|
|
}); |
|
|
|
|
|
|
|
const result = await service.registerDevice(mockDeviceInput, mockUser) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findOne).toHaveBeenCalledWith({ |
|
|
|
user: mockUser._id, |
|
|
|
model: mockDeviceInput.model, |
|
|
|
buildId: mockDeviceInput.buildId, |
|
|
|
}) |
|
|
|
expect(service.updateDevice).toHaveBeenCalledWith( |
|
|
|
mockDevice._id.toString(), |
|
|
|
{ ...mockDeviceInput, enabled: true } |
|
|
|
) |
|
|
|
expect(result).toBeDefined() |
|
|
|
|
|
|
|
// Restore the original method
|
|
|
|
service.updateDevice = originalUpdateDevice; |
|
|
|
}) |
|
|
|
|
|
|
|
it('should create a new device if it does not exist', async () => { |
|
|
|
mockDeviceModel.findOne.mockResolvedValue(null) |
|
|
|
mockDeviceModel.create.mockResolvedValue(mockDevice) |
|
|
|
|
|
|
|
const result = await service.registerDevice(mockDeviceInput, mockUser) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findOne).toHaveBeenCalledWith({ |
|
|
|
user: mockUser._id, |
|
|
|
model: mockDeviceInput.model, |
|
|
|
buildId: mockDeviceInput.buildId, |
|
|
|
}) |
|
|
|
expect(mockDeviceModel.create).toHaveBeenCalledWith({ |
|
|
|
...mockDeviceInput, |
|
|
|
user: mockUser, |
|
|
|
}) |
|
|
|
expect(result).toBeDefined() |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('getDevicesForUser', () => { |
|
|
|
const mockUser = { |
|
|
|
_id: 'user123', |
|
|
|
name: 'Test User', |
|
|
|
email: 'test@example.com', |
|
|
|
password: 'password', |
|
|
|
role: 'user', |
|
|
|
createdAt: new Date(), |
|
|
|
updatedAt: new Date() |
|
|
|
} as unknown as User; |
|
|
|
|
|
|
|
const mockDevices = [ |
|
|
|
{ _id: 'device1', model: 'Pixel 6' }, |
|
|
|
{ _id: 'device2', model: 'iPhone 13' }, |
|
|
|
] |
|
|
|
|
|
|
|
it('should return all devices for a user', async () => { |
|
|
|
mockDeviceModel.find.mockResolvedValue(mockDevices) |
|
|
|
|
|
|
|
const result = await service.getDevicesForUser(mockUser) |
|
|
|
|
|
|
|
expect(mockDeviceModel.find).toHaveBeenCalledWith({ user: mockUser._id }) |
|
|
|
expect(result).toEqual(mockDevices) |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('getDeviceById', () => { |
|
|
|
const mockDevice = { _id: 'device123', model: 'Pixel 6' } |
|
|
|
|
|
|
|
it('should return device by id', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
|
|
|
|
const result = await service.getDeviceById('device123') |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith('device123') |
|
|
|
expect(result).toEqual(mockDevice) |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('updateDevice', () => { |
|
|
|
const mockDeviceId = 'device123' |
|
|
|
const mockDeviceInput: RegisterDeviceInputDTO = { |
|
|
|
model: 'Pixel 6', |
|
|
|
buildId: 'build123', |
|
|
|
fcmToken: 'updatedToken', |
|
|
|
enabled: true, |
|
|
|
} |
|
|
|
const mockDevice = { |
|
|
|
_id: mockDeviceId, |
|
|
|
...mockDeviceInput, |
|
|
|
} |
|
|
|
|
|
|
|
it('should update device if it exists', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
mockDeviceModel.findByIdAndUpdate.mockResolvedValue({ |
|
|
|
...mockDevice, |
|
|
|
fcmToken: 'updatedToken', |
|
|
|
}) |
|
|
|
|
|
|
|
const result = await service.updateDevice(mockDeviceId, mockDeviceInput) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockDeviceModel.findByIdAndUpdate).toHaveBeenCalledWith( |
|
|
|
mockDeviceId, |
|
|
|
{ $set: mockDeviceInput }, |
|
|
|
{ new: true }, |
|
|
|
) |
|
|
|
expect(result).toBeDefined() |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw an error if device does not exist', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(null) |
|
|
|
|
|
|
|
await expect( |
|
|
|
service.updateDevice(mockDeviceId, mockDeviceInput), |
|
|
|
).rejects.toThrow(HttpException) |
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockDeviceModel.findByIdAndUpdate).not.toHaveBeenCalled() |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('deleteDevice', () => { |
|
|
|
const mockDeviceId = 'device123' |
|
|
|
const mockDevice = { _id: mockDeviceId, model: 'Pixel 6' } |
|
|
|
|
|
|
|
it('should return empty object when device exists', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
|
|
|
|
const result = await service.deleteDevice(mockDeviceId) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(result).toEqual({}) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw an error if device does not exist', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(null) |
|
|
|
|
|
|
|
await expect(service.deleteDevice(mockDeviceId)).rejects.toThrow( |
|
|
|
HttpException, |
|
|
|
) |
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('sendSMS', () => { |
|
|
|
const mockDeviceId = 'device123' |
|
|
|
const mockDevice = { |
|
|
|
_id: mockDeviceId, |
|
|
|
enabled: true, |
|
|
|
fcmToken: 'fcm-token', |
|
|
|
user: 'user123', |
|
|
|
} |
|
|
|
const mockSmsInput: SendSMSInputDTO = { |
|
|
|
message: 'Hello there', |
|
|
|
recipients: ['+123456789'], |
|
|
|
smsBody: 'Hello there', |
|
|
|
receivers: ['+123456789'], |
|
|
|
} |
|
|
|
const mockSms = { |
|
|
|
_id: 'sms123', |
|
|
|
device: mockDeviceId, |
|
|
|
message: mockSmsInput.message, |
|
|
|
type: SMSType.SENT, |
|
|
|
recipient: mockSmsInput.recipients[0], |
|
|
|
status: 'pending', |
|
|
|
} |
|
|
|
const mockSmsBatch = { |
|
|
|
_id: 'batch123', |
|
|
|
device: mockDeviceId, |
|
|
|
message: mockSmsInput.message, |
|
|
|
recipientCount: 1, |
|
|
|
status: 'pending', |
|
|
|
} |
|
|
|
const mockFcmResponse: BatchResponse = { |
|
|
|
successCount: 1, |
|
|
|
failureCount: 0, |
|
|
|
responses: [], |
|
|
|
} |
|
|
|
|
|
|
|
beforeEach(() => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
mockSmsBatchModel.create.mockResolvedValue(mockSmsBatch) |
|
|
|
mockSmsModel.create.mockResolvedValue(mockSms) |
|
|
|
mockDeviceModel.findByIdAndUpdate.mockImplementation(() => ({ |
|
|
|
exec: jest.fn().mockResolvedValue(true), |
|
|
|
})) |
|
|
|
mockSmsBatchModel.findByIdAndUpdate.mockImplementation(() => ({ |
|
|
|
exec: jest.fn().mockResolvedValue(true), |
|
|
|
})) |
|
|
|
mockBillingService.canPerformAction.mockResolvedValue(true) |
|
|
|
mockSmsQueueService.isQueueEnabled.mockReturnValue(false) |
|
|
|
|
|
|
|
// Fix the mock
|
|
|
|
jest.spyOn(firebaseAdmin.messaging(), 'sendEach').mockResolvedValue(mockFcmResponse) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should send SMS successfully', async () => { |
|
|
|
const result = await service.sendSMS(mockDeviceId, mockSmsInput) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockBillingService.canPerformAction).toHaveBeenCalledWith( |
|
|
|
mockDevice.user.toString(), |
|
|
|
'send_sms', |
|
|
|
mockSmsInput.recipients.length, |
|
|
|
) |
|
|
|
expect(mockSmsBatchModel.create).toHaveBeenCalled() |
|
|
|
expect(mockSmsModel.create).toHaveBeenCalled() |
|
|
|
expect(firebaseAdmin.messaging().sendEach).toHaveBeenCalled() |
|
|
|
expect(result).toEqual(mockFcmResponse) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw error if device is not enabled', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue({ |
|
|
|
...mockDevice, |
|
|
|
enabled: false, |
|
|
|
}) |
|
|
|
|
|
|
|
await expect( |
|
|
|
service.sendSMS(mockDeviceId, mockSmsInput), |
|
|
|
).rejects.toThrow(HttpException) |
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockBillingService.canPerformAction).not.toHaveBeenCalled() |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw error if message is blank', async () => { |
|
|
|
await expect( |
|
|
|
service.sendSMS(mockDeviceId, { ...mockSmsInput, message: '', smsBody: '' }), |
|
|
|
).rejects.toThrow(HttpException) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw error if recipients are invalid', async () => { |
|
|
|
await expect( |
|
|
|
service.sendSMS(mockDeviceId, { ...mockSmsInput, recipients: [] }), |
|
|
|
).rejects.toThrow(HttpException) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should queue SMS if queue is enabled', async () => { |
|
|
|
mockSmsQueueService.isQueueEnabled.mockReturnValue(true) |
|
|
|
mockSmsQueueService.addSendSmsJob.mockResolvedValue(true) |
|
|
|
|
|
|
|
const result = await service.sendSMS(mockDeviceId, mockSmsInput) |
|
|
|
|
|
|
|
expect(mockSmsQueueService.isQueueEnabled).toHaveBeenCalled() |
|
|
|
expect(mockSmsQueueService.addSendSmsJob).toHaveBeenCalled() |
|
|
|
expect(result).toHaveProperty('success', true) |
|
|
|
expect(result).toHaveProperty('smsBatchId', mockSmsBatch._id) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should handle queue error properly', async () => { |
|
|
|
mockSmsQueueService.isQueueEnabled.mockReturnValue(true) |
|
|
|
mockSmsQueueService.addSendSmsJob.mockRejectedValue(new Error('Queue error')) |
|
|
|
|
|
|
|
await expect( |
|
|
|
service.sendSMS(mockDeviceId, mockSmsInput), |
|
|
|
).rejects.toThrow(HttpException) |
|
|
|
|
|
|
|
expect(mockSmsBatchModel.findByIdAndUpdate).toHaveBeenCalled() |
|
|
|
expect(mockSmsModel.updateMany).toHaveBeenCalled() |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('sendBulkSMS', () => { |
|
|
|
const mockDeviceId = 'device123' |
|
|
|
const mockDevice = { |
|
|
|
_id: mockDeviceId, |
|
|
|
enabled: true, |
|
|
|
fcmToken: 'fcm-token', |
|
|
|
user: 'user123', |
|
|
|
} |
|
|
|
const mockBulkSmsInput: SendBulkSMSInputDTO = { |
|
|
|
messageTemplate: 'Hello {name}', |
|
|
|
messages: [ |
|
|
|
{ |
|
|
|
message: 'Hello John', |
|
|
|
recipients: ['+123456789'], |
|
|
|
smsBody: 'Hello John', |
|
|
|
receivers: ['+123456789'], |
|
|
|
}, |
|
|
|
{ |
|
|
|
message: 'Hello Jane', |
|
|
|
recipients: ['+987654321'], |
|
|
|
smsBody: 'Hello Jane', |
|
|
|
receivers: ['+987654321'], |
|
|
|
}, |
|
|
|
], |
|
|
|
} |
|
|
|
const mockSmsBatch = { |
|
|
|
_id: 'batch123', |
|
|
|
device: mockDeviceId, |
|
|
|
message: mockBulkSmsInput.messageTemplate, |
|
|
|
recipientCount: 2, |
|
|
|
status: 'pending', |
|
|
|
} |
|
|
|
const mockSms = { |
|
|
|
_id: 'sms123', |
|
|
|
device: mockDeviceId, |
|
|
|
message: 'Hello John', |
|
|
|
type: SMSType.SENT, |
|
|
|
recipient: '+123456789', |
|
|
|
status: 'pending', |
|
|
|
} |
|
|
|
const mockFcmResponse: BatchResponse = { |
|
|
|
successCount: 1, |
|
|
|
failureCount: 0, |
|
|
|
responses: [], |
|
|
|
} |
|
|
|
|
|
|
|
beforeEach(() => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
mockSmsBatchModel.create.mockResolvedValue(mockSmsBatch) |
|
|
|
mockSmsModel.create.mockResolvedValue(mockSms) |
|
|
|
mockDeviceModel.findByIdAndUpdate.mockImplementation(() => ({ |
|
|
|
exec: jest.fn().mockResolvedValue(true), |
|
|
|
})) |
|
|
|
mockSmsBatchModel.findByIdAndUpdate.mockImplementation(() => ({ |
|
|
|
exec: jest.fn().mockResolvedValue(true), |
|
|
|
})) |
|
|
|
mockBillingService.canPerformAction.mockResolvedValue(true) |
|
|
|
mockSmsQueueService.isQueueEnabled.mockReturnValue(false) |
|
|
|
|
|
|
|
// Fix the mock
|
|
|
|
jest.spyOn(firebaseAdmin.messaging(), 'sendEach').mockResolvedValue(mockFcmResponse) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should send bulk SMS successfully', async () => { |
|
|
|
const result = await service.sendBulkSMS(mockDeviceId, mockBulkSmsInput) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockBillingService.canPerformAction).toHaveBeenCalledWith( |
|
|
|
mockDevice.user.toString(), |
|
|
|
'bulk_send_sms', |
|
|
|
2, |
|
|
|
) |
|
|
|
expect(mockSmsBatchModel.create).toHaveBeenCalled() |
|
|
|
expect(mockSmsModel.create).toHaveBeenCalled() |
|
|
|
expect(firebaseAdmin.messaging().sendEach).toHaveBeenCalled() |
|
|
|
expect(result).toHaveProperty('success', true) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should queue bulk SMS if queue is enabled', async () => { |
|
|
|
mockSmsQueueService.isQueueEnabled.mockReturnValue(true) |
|
|
|
mockSmsQueueService.addSendSmsJob.mockResolvedValue(true) |
|
|
|
|
|
|
|
const result = await service.sendBulkSMS(mockDeviceId, mockBulkSmsInput) |
|
|
|
|
|
|
|
expect(mockSmsQueueService.isQueueEnabled).toHaveBeenCalled() |
|
|
|
expect(mockSmsQueueService.addSendSmsJob).toHaveBeenCalled() |
|
|
|
expect(result).toHaveProperty('success', true) |
|
|
|
expect(result).toHaveProperty('smsBatchId', mockSmsBatch._id) |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('receiveSMS', () => { |
|
|
|
const mockDeviceId = 'device123' |
|
|
|
const mockDevice = { |
|
|
|
_id: mockDeviceId, |
|
|
|
user: 'user123', |
|
|
|
} |
|
|
|
const mockReceivedSmsData = { |
|
|
|
message: 'Hello from test', |
|
|
|
sender: '+123456789', |
|
|
|
receivedAt: new Date(), |
|
|
|
} |
|
|
|
const mockSms = { |
|
|
|
_id: 'sms123', |
|
|
|
...mockReceivedSmsData, |
|
|
|
device: mockDeviceId, |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
} |
|
|
|
|
|
|
|
beforeEach(() => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
mockSmsModel.create.mockResolvedValue(mockSms) |
|
|
|
mockDeviceModel.findByIdAndUpdate.mockImplementation(() => ({ |
|
|
|
exec: jest.fn().mockResolvedValue(true), |
|
|
|
})) |
|
|
|
mockBillingService.canPerformAction.mockResolvedValue(true) |
|
|
|
mockWebhookService.deliverNotification.mockResolvedValue(true) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should receive SMS successfully', async () => { |
|
|
|
const result = await service.receiveSMS(mockDeviceId, mockReceivedSmsData) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockBillingService.canPerformAction).toHaveBeenCalledWith( |
|
|
|
mockDevice.user.toString(), |
|
|
|
'receive_sms', |
|
|
|
1, |
|
|
|
) |
|
|
|
expect(mockSmsModel.create).toHaveBeenCalled() |
|
|
|
expect(mockDeviceModel.findByIdAndUpdate).toHaveBeenCalled() |
|
|
|
expect(mockWebhookService.deliverNotification).toHaveBeenCalledWith({ |
|
|
|
sms: mockSms, |
|
|
|
user: mockDevice.user, |
|
|
|
event: WebhookEvent.MESSAGE_RECEIVED, |
|
|
|
}) |
|
|
|
expect(result).toEqual(mockSms) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw error if device does not exist', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(null) |
|
|
|
|
|
|
|
await expect( |
|
|
|
service.receiveSMS(mockDeviceId, mockReceivedSmsData), |
|
|
|
).rejects.toThrow(HttpException) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw error if SMS data is invalid', async () => { |
|
|
|
await expect( |
|
|
|
service.receiveSMS(mockDeviceId, { ...mockReceivedSmsData, message: '' }), |
|
|
|
).rejects.toThrow(HttpException) |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('getReceivedSMS', () => { |
|
|
|
const mockDeviceId = 'device123' |
|
|
|
const mockDevice = { |
|
|
|
_id: mockDeviceId, |
|
|
|
} |
|
|
|
const mockSmsData = [ |
|
|
|
{ |
|
|
|
_id: 'sms1', |
|
|
|
message: 'Hello 1', |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
sender: '+123456789', |
|
|
|
receivedAt: new Date(), |
|
|
|
}, |
|
|
|
{ |
|
|
|
_id: 'sms2', |
|
|
|
message: 'Hello 2', |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
sender: '+987654321', |
|
|
|
receivedAt: new Date(), |
|
|
|
}, |
|
|
|
] |
|
|
|
|
|
|
|
beforeEach(() => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
mockSmsModel.find.mockReturnValue({ |
|
|
|
populate: jest.fn().mockReturnValue({ |
|
|
|
lean: jest.fn().mockResolvedValue(mockSmsData), |
|
|
|
}), |
|
|
|
}) |
|
|
|
mockSmsModel.countDocuments.mockResolvedValue(2) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should get received SMS with pagination', async () => { |
|
|
|
const result = await service.getReceivedSMS(mockDeviceId, 1, 10) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockSmsModel.countDocuments).toHaveBeenCalledWith({ |
|
|
|
device: mockDevice._id, |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
}) |
|
|
|
expect(mockSmsModel.find).toHaveBeenCalledWith( |
|
|
|
{ |
|
|
|
device: mockDevice._id, |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
}, |
|
|
|
null, |
|
|
|
{ |
|
|
|
sort: { receivedAt: -1 }, |
|
|
|
limit: 10, |
|
|
|
skip: 0, |
|
|
|
}, |
|
|
|
) |
|
|
|
expect(result).toHaveProperty('data', mockSmsData) |
|
|
|
expect(result).toHaveProperty('meta') |
|
|
|
expect(result.meta).toHaveProperty('total', 2) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw error if device does not exist', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(null) |
|
|
|
|
|
|
|
await expect(service.getReceivedSMS(mockDeviceId)).rejects.toThrow( |
|
|
|
HttpException, |
|
|
|
) |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('getMessages', () => { |
|
|
|
const mockDeviceId = 'device123' |
|
|
|
const mockDevice = { |
|
|
|
_id: mockDeviceId, |
|
|
|
} |
|
|
|
const mockSmsData = [ |
|
|
|
{ |
|
|
|
_id: 'sms1', |
|
|
|
message: 'Hello 1', |
|
|
|
type: SMSType.SENT, |
|
|
|
recipient: '+123456789', |
|
|
|
createdAt: new Date(), |
|
|
|
}, |
|
|
|
{ |
|
|
|
_id: 'sms2', |
|
|
|
message: 'Hello 2', |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
sender: '+987654321', |
|
|
|
createdAt: new Date(), |
|
|
|
}, |
|
|
|
] |
|
|
|
|
|
|
|
beforeEach(() => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(mockDevice) |
|
|
|
mockSmsModel.find.mockReturnValue({ |
|
|
|
populate: jest.fn().mockReturnValue({ |
|
|
|
lean: jest.fn().mockResolvedValue(mockSmsData), |
|
|
|
}), |
|
|
|
}) |
|
|
|
mockSmsModel.countDocuments.mockResolvedValue(2) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should get all messages with pagination', async () => { |
|
|
|
const result = await service.getMessages(mockDeviceId, '', 1, 10) |
|
|
|
|
|
|
|
expect(mockDeviceModel.findById).toHaveBeenCalledWith(mockDeviceId) |
|
|
|
expect(mockSmsModel.countDocuments).toHaveBeenCalledWith({ |
|
|
|
device: mockDevice._id, |
|
|
|
}) |
|
|
|
expect(mockSmsModel.find).toHaveBeenCalledWith( |
|
|
|
{ |
|
|
|
device: mockDevice._id, |
|
|
|
}, |
|
|
|
null, |
|
|
|
{ |
|
|
|
sort: { createdAt: -1 }, |
|
|
|
limit: 10, |
|
|
|
skip: 0, |
|
|
|
}, |
|
|
|
) |
|
|
|
expect(result).toHaveProperty('data', mockSmsData) |
|
|
|
expect(result).toHaveProperty('meta') |
|
|
|
expect(result.meta).toHaveProperty('total', 2) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should get sent messages with pagination', async () => { |
|
|
|
const result = await service.getMessages(mockDeviceId, 'sent', 1, 10) |
|
|
|
|
|
|
|
expect(mockSmsModel.countDocuments).toHaveBeenCalledWith({ |
|
|
|
device: mockDevice._id, |
|
|
|
type: SMSType.SENT, |
|
|
|
}) |
|
|
|
expect(mockSmsModel.find).toHaveBeenCalledWith( |
|
|
|
{ |
|
|
|
device: mockDevice._id, |
|
|
|
type: SMSType.SENT, |
|
|
|
}, |
|
|
|
null, |
|
|
|
expect.any(Object), |
|
|
|
) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should get received messages with pagination', async () => { |
|
|
|
const result = await service.getMessages(mockDeviceId, 'received', 1, 10) |
|
|
|
|
|
|
|
expect(mockSmsModel.countDocuments).toHaveBeenCalledWith({ |
|
|
|
device: mockDevice._id, |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
}) |
|
|
|
expect(mockSmsModel.find).toHaveBeenCalledWith( |
|
|
|
{ |
|
|
|
device: mockDevice._id, |
|
|
|
type: SMSType.RECEIVED, |
|
|
|
}, |
|
|
|
null, |
|
|
|
expect.any(Object), |
|
|
|
) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should throw error if device does not exist', async () => { |
|
|
|
mockDeviceModel.findById.mockResolvedValue(null) |
|
|
|
|
|
|
|
await expect(service.getMessages(mockDeviceId)).rejects.toThrow( |
|
|
|
HttpException, |
|
|
|
) |
|
|
|
}) |
|
|
|
}) |
|
|
|
|
|
|
|
describe('getStatsForUser', () => { |
|
|
|
const mockUser = { |
|
|
|
_id: 'user123', |
|
|
|
name: 'Test User', |
|
|
|
email: 'test@example.com', |
|
|
|
password: 'password', |
|
|
|
role: 'user', |
|
|
|
createdAt: new Date(), |
|
|
|
updatedAt: new Date() |
|
|
|
} as unknown as User; |
|
|
|
|
|
|
|
const mockDevices = [ |
|
|
|
{ |
|
|
|
_id: 'device1', |
|
|
|
sentSMSCount: 10, |
|
|
|
receivedSMSCount: 5, |
|
|
|
}, |
|
|
|
{ |
|
|
|
_id: 'device2', |
|
|
|
sentSMSCount: 20, |
|
|
|
receivedSMSCount: 15, |
|
|
|
}, |
|
|
|
] |
|
|
|
const mockApiKeys = [ |
|
|
|
{ _id: 'key1', name: 'API Key 1' }, |
|
|
|
{ _id: 'key2', name: 'API Key 2' }, |
|
|
|
] |
|
|
|
|
|
|
|
beforeEach(() => { |
|
|
|
mockDeviceModel.find.mockResolvedValue(mockDevices) |
|
|
|
mockAuthService.getUserApiKeys.mockResolvedValue(mockApiKeys) |
|
|
|
}) |
|
|
|
|
|
|
|
it('should return stats for user', async () => { |
|
|
|
const result = await service.getStatsForUser(mockUser) |
|
|
|
|
|
|
|
expect(mockDeviceModel.find).toHaveBeenCalledWith({ user: mockUser._id }) |
|
|
|
expect(mockAuthService.getUserApiKeys).toHaveBeenCalledWith(mockUser) |
|
|
|
expect(result).toEqual({ |
|
|
|
totalSentSMSCount: 30, |
|
|
|
totalReceivedSMSCount: 20, |
|
|
|
totalDeviceCount: 2, |
|
|
|
totalApiKeyCount: 2, |
|
|
|
}) |
|
|
|
}) |
|
|
|
}) |
|
|
|
}) |
isra el
11 months ago