neoris/openvidu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

backend: Add unit test command and update token service to use VideoGrant type

Browse Source
This commit is contained in:
Carlos Santos 2025-05-08 12:10:59 +02:00
parent ae43b582c4
commit 23da76806d
5 changed files with 2 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
backend/package.json
View File

@ -42,6 +42,7 @@
"test:integration-webhooks": "node --experimental-vm-modules node_modules/.bin/jest --runInBand --forceExit --testPathPattern \"tests/integration/webhooks\" --ci --reporters=default --reporters=jest-junit",
"test:integration-security": "node --experimental-vm-modules node_modules/.bin/jest --runInBand --forceExit --testPathPattern \"tests/integration/api/security\" --ci --reporters=default --reporters=jest-junit",
"test:integration-global-preferences": "node --experimental-vm-modules node_modules/.bin/jest --runInBand --forceExit --testPathPattern \"tests/integration/api/global-preferences\" --ci --reporters=default --reporters=jest-junit",
"test:unit": "node --experimental-vm-modules node_modules/.bin/jest --runInBand --forceExit --testPathPattern \"tests/unit\" --ci --reporters=default --reporters=jest-junit",
"lint:fix": "eslint src --fix",
"format:code": "prettier --ignore-path .gitignore --write '**/*.{ts,js,json,md}'"
},

2
backend/src/services/token.service.ts
View File

@ -56,7 +56,7 @@ export class TokenService {
permissions: permissions.openvidu
})
};
return await this.generateJwtToken(tokenOptions, permissions.livekit);
return await this.generateJwtToken(tokenOptions, permissions.livekit as VideoGrant);
}
async generateRecordingToken(

108
backend/tests/unit/services/openvidu-webhook.service.test.ts
View File

@ -1,108 +0,0 @@
import fetchMock from 'jest-fetch-mock';
import { OpenViduWebhookService } from '../../../src/services/openvidu-webhook.service';
import { LoggerService } from '../../../src/services/logger.service';
import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
import { Room } from 'livekit-server-sdk';
import { OpenViduWebhookEvent } from '../../../src/models/webhook.model';
import { MEET_WEBHOOK_URL } from '../../../src/environment';
describe('OpenVidu Webhook Service', () => {
let webhookService: OpenViduWebhookService;
let loggerMock: jest.Mocked<LoggerService>;
beforeEach(() => {
fetchMock.enableMocks();
// Create a new instance of LoggerService before each test
loggerMock = {
verbose: jest.fn(),
error: jest.fn()
} as unknown as jest.Mocked<LoggerService>;
// Create a new instance of OpenViduWebhookService before each test
webhookService = new OpenViduWebhookService(loggerMock);
});
afterEach(() => {
jest.clearAllMocks();
fetchMock.resetMocks();
jest.useRealTimers();
});
it('should not send webhook if webhook is disabled', async () => {
jest.spyOn(webhookService as any, 'isWebhookEnabled').mockReturnValue(false);
const mockRoom = { name: 'TestRoom' } as Room;
await webhookService.sendRoomFinishedWebhook(mockRoom);
expect(fetch).not.toHaveBeenCalled();
expect(loggerMock.verbose).not.toHaveBeenCalled();
});
it('should send webhook when enabled and request is successful', async () => {
jest.spyOn(webhookService as any, 'isWebhookEnabled').mockReturnValue(true);
(fetch as jest.MockedFunction<typeof fetch>).mockResolvedValue(new Response(null, { status: 200 }));
const mockRoom = { name: 'TestRoom' } as Room;
await webhookService.sendRoomFinishedWebhook(mockRoom);
expect(loggerMock.verbose).toHaveBeenCalledWith(`Sending room finished webhook for room ${mockRoom.name}`);
expect(fetch).toHaveBeenCalledWith(MEET_WEBHOOK_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
event: OpenViduWebhookEvent.ROOM_FINISHED,
room: { name: mockRoom.name }
})
});
});
it('should retry sending webhook on failure and eventually succeed', async () => {
jest.spyOn(webhookService as any, 'isWebhookEnabled').mockReturnValue(true);
// Set fetch to fail twice before succeeding
(fetch as jest.MockedFunction<typeof fetch>)
.mockRejectedValueOnce(new Error('Network Error'))
.mockRejectedValueOnce(new Error('Network Error'))
.mockResolvedValue(new Response(null, { status: 200 }));
const mockRoom = { name: 'TestRoom' } as Room;
await webhookService.sendRoomFinishedWebhook(mockRoom);
expect(loggerMock.verbose).toHaveBeenCalledWith(`Sending room finished webhook for room ${mockRoom.name}`);
expect(loggerMock.verbose).toHaveBeenCalledWith('Retrying in 0.3 seconds... (5 retries left)');
expect(loggerMock.verbose).toHaveBeenCalledWith('Retrying in 0.6 seconds... (4 retries left)');
expect(fetch).toHaveBeenCalledTimes(3);
});
it('should throw error after exhausting all retries', async () => {
jest.useFakeTimers({ advanceTimers: true });
jest.spyOn(webhookService as any, 'isWebhookEnabled').mockReturnValue(true);
// Set fetch to always fail
(fetch as jest.MockedFunction<typeof fetch>).mockRejectedValue(new Error('Network Error'));
const mockRoom = { name: 'TestRoom' } as Room;
const sendPromise = webhookService.sendRoomFinishedWebhook(mockRoom);
for (const delay of [300, 600, 1200, 2400, 4800]) {
jest.advanceTimersByTime(delay);
await new Promise(process.nextTick);
}
await expect(sendPromise).rejects.toThrow('Request failed: Error: Network Error');
jest.useRealTimers();
expect(fetch).toHaveBeenCalledTimes(6);
});
});

0
backend/tests/unit/services/room.service.test.ts
View File

74
backend/tests/unit/services/system-event.service.test.ts
View File

@ -1,74 +0,0 @@
// tests/integration/services/system-event.service.test.ts
import 'reflect-metadata';
import { Container } from 'inversify';
import { SystemEventService } from '../../../src/services/system-event.service';
import { RedisService } from '../../../src/services/redis.service';
import { LoggerService } from '../../../src/services/logger.service';
import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
describe('SystemEventService', () => {
let container: Container;
let systemEventService: SystemEventService;
let redisServiceMock: jest.Mocked<RedisService>;
let loggerMock: jest.Mocked<LoggerService>;
beforeEach(() => {
// Crear mocks para RedisService y LoggerService
redisServiceMock = {
onReady: jest.fn()
// Añadir otros métodos de RedisService si existen
} as unknown as jest.Mocked<RedisService>;
loggerMock = {
verbose: jest.fn(),
error: jest.fn()
// Añadir otros métodos de LoggerService si existen
} as unknown as jest.Mocked<LoggerService>;
// Configurar el contenedor
container = new Container();
container.bind<LoggerService>(LoggerService).toConstantValue(loggerMock);
container.bind<RedisService>(RedisService).toConstantValue(redisServiceMock);
container.bind<SystemEventService>(SystemEventService).toSelf();
// Obtener instancia del servicio
systemEventService = container.get(SystemEventService);
});
afterEach(() => {
jest.clearAllMocks();
});
it('debería registrar el callback en RedisService.onReady', () => {
const callback = jest.fn();
systemEventService.onRedisReady(callback);
expect(redisServiceMock.onReady).toHaveBeenCalledWith(callback);
});
it('puede registrar múltiples callbacks en RedisService.onReady', () => {
const callback1 = jest.fn();
const callback2 = jest.fn();
systemEventService.onRedisReady(callback1);
systemEventService.onRedisReady(callback2);
expect(redisServiceMock.onReady).toHaveBeenCalledTimes(2);
expect(redisServiceMock.onReady).toHaveBeenCalledWith(callback1);
expect(redisServiceMock.onReady).toHaveBeenCalledWith(callback2);
});
it('debería manejar errores al registrar callbacks', () => {
const callback = jest.fn();
const error = new Error('Error al registrar el callback');
redisServiceMock.onReady.mockImplementationOnce(() => {
throw error;
});
expect(() => systemEventService.onRedisReady(callback)).toThrow(error);
expect(redisServiceMock.onReady).toHaveBeenCalledWith(callback);
});
});