nestjs-firebase-admin 0.4.5 → 0.5.8

package/dist/modules/admin/admin.service.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/modules/admin/admin.service.spec.js

@@ -1,228 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const testing_1 = require("@nestjs/testing");
-const admin_service_1 = require("./admin.service");
-const node_http_1 = require("node:http");
-const rxjs_1 = require("rxjs");
-const FIREBASE_ADMIN_INSTANCE_TOKEN = 'FIREBASE_ADMIN_INSTANCE_TOKEN';
-jest.mock('firebase-admin/app', () => {
-    return {
-        getApp: jest.fn().mockReturnValue({ name: 'app-name', options: {} }),
-        getApps: jest.fn().mockReturnValue([{ name: 'app-name', options: {} }]),
-        deleteApp: jest.fn().mockResolvedValue(undefined),
-        applicationDefault: jest.fn().mockReturnValue('default-credential'),
-    };
-});
-jest.mock('firebase-admin', () => {
-    return {
-        initializeApp: jest.fn().mockReturnValue({ name: 'app-name', options: {} }),
-        credential: {
-            cert: jest.fn().mockReturnValue('mocked-credential'),
-        },
-    };
-});
-const firebaseAdmin = jest.requireMock('firebase-admin');
-const firebaseAdminApp = jest.requireMock('firebase-admin/app');
-describe('AdminService', () => {
-    let service;
-    const mockOptions = {
-        credential: {
-            projectId: 'mock-project',
-            clientEmail: 'mock@example.com',
-            privateKey: 'mock-key',
-        },
-        databaseURL: 'https://mock-project.firebaseio.com',
-        storageBucket: 'mock-project.appspot.com',
-        projectId: 'mock-project',
-    };
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        jest.clearAllMocks();
-        const mockApp = { name: 'app-name', options: {} };
-        firebaseAdmin.initializeApp.mockReturnValue(mockApp);
-        firebaseAdmin.credential.cert.mockReturnValue('mocked-credential');
-        const module = yield testing_1.Test.createTestingModule({
-            providers: [
-                admin_service_1.AdminService,
-                {
-                    provide: FIREBASE_ADMIN_INSTANCE_TOKEN,
-                    useValue: mockOptions,
-                },
-                {
-                    provide: 'FIREBASE_ADMIN_APP',
-                    useValue: mockApp,
-                },
-            ],
-        }).compile();
-        service = module.get(admin_service_1.AdminService);
-    }));
-    it('must be defined', () => {
-        expect(service).toBeDefined();
-    });
-    describe('constructor', () => {
-        it('must store the injected Firebase Admin app', () => {
-            expect(service.appRef).toEqual({ name: 'app-name', options: {} });
-        });
-    });
-    describe('applicationDefault', () => {
-        it('should return default credentials with no arguments', () => {
-            const result = service.applicationDefault();
-            expect(firebaseAdminApp.applicationDefault).toHaveBeenCalledWith(undefined);
-            expect(result).toBe('default-credential');
-        });
-        it('must pass HTTP agent when provided', () => {
-            const httpAgent = new node_http_1.Agent();
-            const result = service.applicationDefault(httpAgent);
-            expect(firebaseAdminApp.applicationDefault).toHaveBeenCalledWith(httpAgent);
-            expect(result).toBe('default-credential');
-        });
-    });
-    describe('deleteApp', () => {
-        it('should call deleteApp function with the given app', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockApp = { name: 'app-to-delete' };
-            yield service.deleteApp(mockApp);
-            expect(firebaseAdminApp.deleteApp).toHaveBeenCalledWith(mockApp);
-        }));
-        it('should return a resolved promise', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockApp = { name: 'app-to-delete' };
-            yield expect(service.deleteApp(mockApp)).resolves.toBeUndefined();
-        }));
-        it('should propagate errors from deleteApp', () => __awaiter(void 0, void 0, void 0, function* () {
-            firebaseAdminApp.deleteApp.mockRejectedValueOnce(new Error('Delete error'));
-            const mockApp = { name: 'app-with-error' };
-            yield expect(service.deleteApp(mockApp)).rejects.toThrow('Delete error');
-        }));
-    });
-    describe('getApps', () => {
-        it('should return all initialized apps', () => {
-            const mockApps = [{ name: 'app1' }, { name: 'app2' }];
-            firebaseAdminApp.getApps.mockReturnValueOnce(mockApps);
-            const result = service.getApps;
-            expect(firebaseAdminApp.getApps).toHaveBeenCalled();
-            expect(result).toEqual(mockApps);
-        });
-        it('should return an empty array when there are no apps', () => {
-            firebaseAdminApp.getApps.mockReturnValueOnce([]);
-            const result = service.getApps;
-            expect(result).toEqual([]);
-        });
-    });
-    describe('getApp', () => {
-        it('should return the default app', () => {
-            const mockApp = { name: 'default-app' };
-            firebaseAdminApp.getApp.mockReturnValueOnce(mockApp);
-            const result = service.getApp;
-            expect(firebaseAdminApp.getApp).toHaveBeenCalled();
-            expect(result).toEqual(mockApp);
-        });
-        it('must propagate getApp errors', () => {
-            firebaseAdminApp.getApp.mockImplementationOnce(() => {
-                throw new Error('App not found');
-            });
-            expect(() => service.getApp).toThrow('App not found');
-        });
-    });
-    describe('admin', () => {
-        it('should return Firebase Admin SDK instance', () => {
-            const adminModule = service.admin();
-            expect(adminModule).toBeDefined();
-            expect(adminModule.initializeApp).toBe(firebaseAdmin.initializeApp);
-            expect(adminModule.credential.cert).toBe(firebaseAdmin.credential.cert);
-        });
-    });
-    describe('initializeAppObservable', () => {
-        it('must return an Observable with the app instance', () => {
-            return new Promise(done => {
-                const observable = service.initializeAppObservable();
-                expect(observable).toBeInstanceOf(rxjs_1.Observable);
-                observable.subscribe({
-                    next: (app) => {
-                        expect(app).toBeDefined();
-                        expect(app).toEqual({ name: 'app-name', options: {} });
-                    },
-                    complete: () => {
-                        done();
-                    },
-                    error: (_err) => {
-                        done();
-                    },
-                });
-            });
-        });
-        it('must complete the Observable after issuing the app', () => {
-            return new Promise(done => {
-                const completeSpy = jest.fn();
-                service.initializeAppObservable().subscribe({
-                    next: () => { },
-                    complete: () => {
-                        completeSpy();
-                        expect(completeSpy).toHaveBeenCalledTimes(1);
-                        done();
-                    },
-                    error: (_err) => {
-                        done();
-                    },
-                });
-            });
-        });
-        it('must return a valid cleanup function when unsubscribing', () => {
-            const observable = service.initializeAppObservable();
-            const subscription = observable.subscribe(() => { });
-            expect(() => subscription.unsubscribe()).not.toThrow();
-        });
-    });
-    describe('appRef', () => {
-        it('should return the injected app instance', () => {
-            const result = service.appRef;
-            expect(result).toEqual({ name: 'app-name', options: {} });
-        });
-    });
-    describe('initializeApp', () => {
-        it('should return the injected app instance', () => {
-            const result = service.initializeApp();
-            expect(result).toEqual({ name: 'app-name', options: {} });
-        });
-    });
-    describe('complex use cases', () => {
-        it('should allow you to get an app and then delete it', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockApp = { name: 'app-to-manage' };
-            firebaseAdminApp.getApp.mockReturnValueOnce(mockApp);
-            const app = service.getApp;
-            yield service.deleteApp(app);
-            expect(firebaseAdminApp.getApp).toHaveBeenCalled();
-            expect(firebaseAdminApp.deleteApp).toHaveBeenCalledWith(mockApp);
-        }));
-        it('should return the same app when appRef is called multiple times in a row', () => {
-            const firstCall = service.appRef;
-            const secondCall = service.appRef;
-            expect(firstCall).toBe(secondCall);
-            expect(firstCall).toEqual({ name: 'app-name', options: {} });
-        });
-        it('should be defined', () => {
-            expect(service).toBeDefined();
-        });
-        it('should return an array of apps', () => {
-            expect(service.getApps).toBeInstanceOf(Array);
-        });
-        it('should return an app', () => {
-            expect(service.getApp).toBeInstanceOf(Object);
-        });
-        it('should return an app reference', () => {
-            expect(service.appRef).toBeInstanceOf(Object);
-        });
-        it('should return an observable of an app', () => {
-            expect(service.initializeAppObservable()).toBeInstanceOf(Object);
-        });
-        it('should return a credential', () => {
-            expect(service.applicationDefault()).toBe('default-credential');
-        });
-    });
-});

package/dist/modules/admin/database.service.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/modules/admin/database.service.spec.js

@@ -1,235 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const testing_1 = require("@nestjs/testing");
-const database_service_1 = require("./database.service");
-const DatabaseService_mock_1 = require("../../tests/mocks/DatabaseService.mock");
-describe('DatabaseService', () => {
-    let service;
-    let mockService;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        const module = yield testing_1.Test.createTestingModule({
-            providers: [
-                {
-                    provide: database_service_1.DatabaseService,
-                    useClass: DatabaseService_mock_1.DatabaseServiceMock,
-                },
-            ],
-        }).compile();
-        service = module.get(database_service_1.DatabaseService);
-        mockService = service;
-    }));
-    afterEach(() => {
-        if (mockService.resetMocks) {
-            mockService.resetMocks();
-        }
-    });
-    it('should be defined', () => {
-        expect(service).toBeDefined();
-    });
-    describe('ref', () => {
-        it('should return a database reference', () => {
-            const ref = service.ref('test-path');
-            expect(ref).toBeDefined();
-            expect(ref.get).toBeDefined();
-            expect(ref.set).toBeDefined();
-            expect(ref.update).toBeDefined();
-            expect(ref.remove).toBeDefined();
-            expect(ref.push).toBeDefined();
-        });
-        it('should handle different path formats', () => {
-            const ref1 = service.ref('users/123/profile');
-            expect(ref1).toBeDefined();
-            const ref2 = service.ref('');
-            expect(ref2).toBeDefined();
-            const ref3 = service.ref('users/user.name@example.com');
-            expect(ref3).toBeDefined();
-        });
-    });
-    describe('get', () => {
-        it('should get data from a path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const data = yield service.get('test-path');
-            expect(data).toBe('mock-data');
-        }));
-        it('should handle non-existent paths', () => __awaiter(void 0, void 0, void 0, function* () {
-            const data = yield service.get('non-existent-path');
-            expect(data).toBe('mock-data');
-        }));
-        it('should handle error during data retrieval', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockRef = service.ref('error-path');
-            mockRef.get = jest.fn().mockRejectedValue(new Error('Database error'));
-            yield expect(service.get('error-path')).rejects.toThrow('Database error');
-        }));
-        it('should call get method with correct path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const path = 'test/specific/path';
-            const spyRef = jest.spyOn(service, 'ref');
-            yield service.get(path);
-            expect(spyRef).toHaveBeenCalledWith(path);
-        }));
-        it('should handle null value response', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockRef = service.ref('null-path');
-            mockRef.get = jest.fn().mockResolvedValue({ val: () => null });
-            const result = yield service.get('null-path');
-            expect(result).toBeNull();
-        }));
-    });
-    describe('set', () => {
-        it('should set data at a path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testData = { name: 'test' };
-            yield expect(service.set('test-path', testData)).resolves.not.toThrow();
-        }));
-        it('should handle complex data structures', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testData = {
-                name: 'test',
-                nested: {
-                    field: 'value',
-                    array: [1, 2, 3],
-                },
-            };
-            yield expect(service.set('test-path', testData)).resolves.not.toThrow();
-        }));
-        it('should handle error during set operation', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockRef = service.ref('error-path');
-            mockRef.set = jest.fn().mockRejectedValue(new Error('Permission denied'));
-            yield expect(service.set('error-path', { test: 'data' })).rejects.toThrow('Permission denied');
-        }));
-        it('should call set method with correct parameters', () => __awaiter(void 0, void 0, void 0, function* () {
-            const path = 'users/123';
-            const data = { name: 'John Doe', age: 30 };
-            const refSpy = jest.spyOn(service, 'ref');
-            const setSpy = jest.spyOn(service.ref(path), 'set');
-            yield service.set(path, data);
-            expect(refSpy).toHaveBeenCalledWith(path);
-            expect(setSpy).toHaveBeenCalledWith(data);
-        }));
-        it('should set primitive data types', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(service.set('string-path', 'test-string')).resolves.not.toThrow();
-            yield expect(service.set('number-path', 42)).resolves.not.toThrow();
-            yield expect(service.set('bool-path', true)).resolves.not.toThrow();
-            yield expect(service.set('null-path', null)).resolves.not.toThrow();
-        }));
-    });
-    describe('update', () => {
-        it('should update data at a path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testData = { name: 'updated' };
-            yield expect(service.update('test-path', testData)).resolves.not.toThrow();
-        }));
-        it('should handle partial updates', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testData = { 'nested.field': 'new-value' };
-            yield expect(service.update('test-path', testData)).resolves.not.toThrow();
-        }));
-        it('should handle error during update operation', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockRef = service.ref('error-path');
-            mockRef.update = jest.fn().mockRejectedValue(new Error('Update failed'));
-            yield expect(service.update('error-path', { name: 'test' })).rejects.toThrow('Update failed');
-        }));
-        it('should call update method with correct parameters', () => __awaiter(void 0, void 0, void 0, function* () {
-            const path = 'users/profile';
-            const data = { lastActive: Date.now(), status: 'online' };
-            const refSpy = jest.spyOn(service, 'ref');
-            const updateSpy = jest.spyOn(service.ref(path), 'update');
-            yield service.update(path, data);
-            expect(refSpy).toHaveBeenCalledWith(path);
-            expect(updateSpy).toHaveBeenCalledWith(data);
-        }));
-        it('should update with empty object', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(service.update('test-path', {})).resolves.not.toThrow();
-        }));
-    });
-    describe('remove', () => {
-        it('should remove data at a path', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(service.remove('test-path')).resolves.not.toThrow();
-        }));
-        it('should handle non-existent paths', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(service.remove('non-existent-path')).resolves.not.toThrow();
-        }));
-        it('should handle error during remove operation', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockRef = service.ref('error-path');
-            mockRef.remove = jest.fn().mockRejectedValue(new Error('Delete failed'));
-            yield expect(service.remove('error-path')).rejects.toThrow('Delete failed');
-        }));
-        it('should call remove method with correct path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const path = 'users/123/sessions';
-            const refSpy = jest.spyOn(service, 'ref');
-            const removeSpy = jest.spyOn(service.ref(path), 'remove');
-            yield service.remove(path);
-            expect(refSpy).toHaveBeenCalledWith(path);
-            expect(removeSpy).toHaveBeenCalled();
-        }));
-    });
-    describe('push', () => {
-        it('should push data to a path and return a key', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testData = { name: 'new-item' };
-            const key = yield service.push('test-path', testData);
-            expect(key).toBe('mock-key');
-        }));
-        it('should handle empty key case', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockRef = service.ref('test-path');
-            mockRef.push = jest.fn().mockResolvedValue({ key: null });
-            const testData = { name: 'new-item' };
-            const key = yield service.push('test-path', testData);
-            expect(key).toBe('');
-        }));
-        it('should handle error during push operation', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockRef = service.ref('error-path');
-            mockRef.push = jest.fn().mockRejectedValue(new Error('Push failed'));
-            yield expect(service.push('error-path', { name: 'test' })).rejects.toThrow('Push failed');
-        }));
-        it('should call push method with correct parameters', () => __awaiter(void 0, void 0, void 0, function* () {
-            const path = 'messages';
-            const data = { text: 'Hello world', timestamp: Date.now() };
-            const refSpy = jest.spyOn(service, 'ref');
-            const pushSpy = jest.spyOn(service.ref(path), 'push');
-            yield service.push(path, data);
-            expect(refSpy).toHaveBeenCalledWith(path);
-            expect(pushSpy).toHaveBeenCalledWith(data);
-        }));
-        it('should push different data types', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(service.push('list/objects', { id: 1 })).resolves.toBe('mock-key');
-            yield expect(service.push('list/arrays', [1, 2, 3])).resolves.toBe('mock-key');
-            yield expect(service.push('list/strings', 'test string')).resolves.toBe('mock-key');
-            yield expect(service.push('list/numbers', 42)).resolves.toBe('mock-key');
-        }));
-    });
-    describe('combined operations', () => {
-        it('should perform get and update operations sequentially', () => __awaiter(void 0, void 0, void 0, function* () {
-            const path = 'users/profile';
-            const getSpy = jest.spyOn(service, 'get');
-            const updateSpy = jest.spyOn(service, 'update');
-            const data = yield service.get(path);
-            yield service.update(path, { lastAccess: Date.now() });
-            expect(getSpy).toHaveBeenCalledWith(path);
-            expect(updateSpy).toHaveBeenCalled();
-        }));
-        it('should perform push and then get the pushed data', () => __awaiter(void 0, void 0, void 0, function* () {
-            const basePath = 'posts';
-            const postData = { title: 'Test Post', content: 'Content' };
-            const key = yield service.push(basePath, postData);
-            expect(key).toBe('mock-key');
-            const path = `${basePath}/${key}`;
-            const getSpy = jest.spyOn(service, 'get');
-            yield service.get(path);
-            expect(getSpy).toHaveBeenCalledWith(path);
-        }));
-        it('should handle transaction-like operations', () => __awaiter(void 0, void 0, void 0, function* () {
-            const itemPath = 'items/123';
-            const itemData = { name: 'Updated Item', updated: true };
-            const refPath = 'users/456/items/123';
-            const refData = { updated: true, timestamp: Date.now() };
-            const setSpy = jest.spyOn(service, 'set');
-            const updateSpy = jest.spyOn(service, 'update');
-            yield service.set(itemPath, itemData);
-            yield service.update(refPath, refData);
-            expect(setSpy).toHaveBeenCalledWith(itemPath, itemData);
-            expect(updateSpy).toHaveBeenCalledWith(refPath, refData);
-        }));
-    });
-});

package/dist/modules/admin/messaging.service.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/modules/admin/messaging.service.spec.js

@@ -1,148 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const testing_1 = require("@nestjs/testing");
-const messaging_service_1 = require("./messaging.service");
-const admin_constants_1 = require("./admin.constants");
-jest.mock('firebase-admin/messaging', () => {
-    return {
-        Messaging: jest.fn().mockImplementation(() => ({
-            send: jest.fn().mockResolvedValue('message-id'),
-            sendMulticast: jest.fn().mockResolvedValue({
-                successCount: 1,
-                failureCount: 0,
-                responses: [{ messageId: 'message-id' }],
-            }),
-            subscribeToTopic: jest.fn().mockResolvedValue({
-                successCount: 1,
-                failureCount: 0,
-                errors: [],
-            }),
-            unsubscribeFromTopic: jest.fn().mockResolvedValue({
-                successCount: 1,
-                failureCount: 0,
-                errors: [],
-            }),
-        })),
-    };
-});
-describe('MessagingService', () => {
-    let service;
-    let mockMessaging;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        const mockApp = {
-            messaging: jest.fn().mockReturnValue({
-                send: jest.fn().mockResolvedValue('message-id'),
-                sendMulticast: jest.fn().mockResolvedValue({
-                    successCount: 1,
-                    failureCount: 0,
-                    responses: [{ messageId: 'message-id' }],
-                }),
-                subscribeToTopic: jest.fn().mockResolvedValue({
-                    successCount: 1,
-                    failureCount: 0,
-                    errors: [],
-                }),
-                unsubscribeFromTopic: jest.fn().mockResolvedValue({
-                    successCount: 1,
-                    failureCount: 0,
-                    errors: [],
-                }),
-            }),
-        };
-        const module = yield testing_1.Test.createTestingModule({
-            providers: [
-                messaging_service_1.MessagingService,
-                {
-                    provide: admin_constants_1.FIREBASE_ADMIN_APP,
-                    useValue: mockApp,
-                },
-            ],
-        }).compile();
-        service = module.get(messaging_service_1.MessagingService);
-        mockMessaging = mockApp.messaging();
-    }));
-    it('should be defined', () => {
-        expect(service).toBeDefined();
-    });
-    describe('sendToDevice', () => {
-        it('should send a message to a single device', () => __awaiter(void 0, void 0, void 0, function* () {
-            const token = 'device-token';
-            const payload = {
-                notification: {
-                    title: 'Test Title',
-                    body: 'Test Body',
-                },
-            };
-            const result = yield service.sendToDevice(token, payload);
-            expect(result).toBe('message-id');
-            expect(mockMessaging.send).toHaveBeenCalledWith(Object.assign({ token }, payload));
-        }));
-    });
-    describe('sendToDevices', () => {
-        it('should send a message to multiple devices', () => __awaiter(void 0, void 0, void 0, function* () {
-            const tokens = ['token1', 'token2'];
-            const payload = {
-                notification: {
-                    title: 'Test Title',
-                    body: 'Test Body',
-                },
-            };
-            const result = yield service.sendToDevices(tokens, payload);
-            expect(result).toEqual({
-                successCount: 1,
-                failureCount: 0,
-                responses: [{ messageId: 'message-id' }],
-            });
-            expect(mockMessaging.sendMulticast).toHaveBeenCalledWith(Object.assign({ tokens }, payload));
-        }));
-    });
-    describe('sendToTopic', () => {
-        it('should send a message to a topic', () => __awaiter(void 0, void 0, void 0, function* () {
-            const topic = 'test-topic';
-            const payload = {
-                notification: {
-                    title: 'Test Title',
-                    body: 'Test Body',
-                },
-            };
-            const result = yield service.sendToTopic(topic, payload);
-            expect(result).toBe('message-id');
-            expect(mockMessaging.send).toHaveBeenCalledWith(Object.assign({ topic }, payload));
-        }));
-    });
-    describe('subscribeToTopic', () => {
-        it('should subscribe devices to a topic', () => __awaiter(void 0, void 0, void 0, function* () {
-            const tokens = ['token1', 'token2'];
-            const topic = 'test-topic';
-            const result = yield service.subscribeToTopic(tokens, topic);
-            expect(result).toEqual({
-                successCount: 1,
-                failureCount: 0,
-                errors: [],
-            });
-            expect(mockMessaging.subscribeToTopic).toHaveBeenCalledWith(tokens, topic);
-        }));
-    });
-    describe('unsubscribeFromTopic', () => {
-        it('should unsubscribe devices from a topic', () => __awaiter(void 0, void 0, void 0, function* () {
-            const tokens = ['token1', 'token2'];
-            const topic = 'test-topic';
-            const result = yield service.unsubscribeFromTopic(tokens, topic);
-            expect(result).toEqual({
-                successCount: 1,
-                failureCount: 0,
-                errors: [],
-            });
-            expect(mockMessaging.unsubscribeFromTopic).toHaveBeenCalledWith(tokens, topic);
-        }));
-    });
-});