first commit

packages/nodes-base/nodes/Google/Firebase/RealtimeDatabase/__test__/GenericFunctions.test.ts

@@ -0,0 +1,242 @@
+import { mock, mockDeep } from 'jest-mock-extended';
+import type { IExecuteFunctions, ILoadOptionsFunctions, INode } from 'n8n-workflow';
+import { NodeApiError } from 'n8n-workflow';
+
+import { googleApiRequest } from '../GenericFunctions';
+
+describe('GoogleFirebaseRealtimeDatabase > GenericFunctions', () => {
+	let mockExecuteFunctions: jest.Mocked<IExecuteFunctions>;
+	let mockLoadOptionsFunctions: jest.Mocked<ILoadOptionsFunctions>;
+	let mockNode: INode;
+
+	beforeEach(() => {
+		mockExecuteFunctions = mockDeep<IExecuteFunctions>();
+		mockLoadOptionsFunctions = mockDeep<ILoadOptionsFunctions>();
+		mockNode = mock<INode>({
+			id: 'test-node',
+			name: 'Test RealtimeDatabase Node',
+			type: 'n8n-nodes-base.googleFirebaseRealtimeDatabase',
+			typeVersion: 1,
+			position: [0, 0],
+			parameters: {},
+		});
+
+		mockExecuteFunctions.getNode.mockReturnValue(mockNode);
+		mockLoadOptionsFunctions.getNode.mockReturnValue(mockNode);
+
+		jest.clearAllMocks();
+	});
+
+	describe('googleApiRequest', () => {
+		const mockRequestOAuth2 = jest.fn();
+
+		beforeEach(() => {
+			mockExecuteFunctions.helpers.requestOAuth2 = mockRequestOAuth2;
+			mockLoadOptionsFunctions.helpers.requestOAuth2 = mockRequestOAuth2;
+		});
+
+		describe('successful requests', () => {
+			beforeEach(() => {
+				mockExecuteFunctions.getCredentials.mockResolvedValue({
+					region: 'firebaseio.com',
+				});
+				mockLoadOptionsFunctions.getCredentials.mockResolvedValue({
+					region: 'firebaseio.com',
+				});
+			});
+
+			it('should make successful API request with default options', async () => {
+				const mockResponse = { data: { test: 'value' } };
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				const result = await googleApiRequest.call(
+					mockExecuteFunctions,
+					'test-project',
+					'GET',
+					'/users',
+				);
+
+				expect(result).toEqual(mockResponse);
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					expect.objectContaining({
+						method: 'GET',
+						url: 'https://test-project.firebaseio.com//users.json',
+						headers: {
+							'Content-Type': 'application/json',
+						},
+						qs: {},
+						json: true,
+					}),
+				);
+			});
+
+			it('should include body for POST requests', async () => {
+				const mockResponse = { success: true };
+				const requestBody = { name: 'John Doe', email: 'john@example.com' };
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				await googleApiRequest.call(
+					mockExecuteFunctions,
+					'test-project',
+					'POST',
+					'/users',
+					requestBody,
+				);
+
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					expect.objectContaining({
+						method: 'POST',
+						body: requestBody,
+					}),
+				);
+			});
+
+			it('should remove empty body for GET requests', async () => {
+				const mockResponse = { data: [] };
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				await googleApiRequest.call(mockExecuteFunctions, 'test-project', 'GET', '/users', {});
+
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+					expect.not.objectContaining({ body: expect.anything() }),
+				);
+			});
+
+			it('should include query parameters', async () => {
+				const mockResponse = { data: [] };
+				const queryParams = { orderBy: '"$key"', limitToFirst: 10 };
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				await googleApiRequest.call(
+					mockExecuteFunctions,
+					'test-project',
+					'GET',
+					'/users',
+					{},
+					queryParams,
+				);
+
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					expect.objectContaining({
+						qs: queryParams,
+					}),
+				);
+			});
+
+			it('should include custom headers', async () => {
+				const mockResponse = { data: [] };
+				const customHeaders = { 'X-Custom-Header': 'custom-value' };
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				await googleApiRequest.call(
+					mockExecuteFunctions,
+					'test-project',
+					'GET',
+					'/users',
+					{},
+					{},
+					customHeaders,
+				);
+
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					expect.objectContaining({
+						headers: {
+							'Content-Type': 'application/json',
+							'X-Custom-Header': 'custom-value',
+						},
+					}),
+				);
+			});
+
+			it('should use custom URI when provided', async () => {
+				const mockResponse = { data: [] };
+				const customUri = 'https://custom-project.firebaseio.com/custom/path.json';
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				await googleApiRequest.call(
+					mockExecuteFunctions,
+					'test-project',
+					'GET',
+					'/users',
+					{},
+					{},
+					{},
+					customUri,
+				);
+
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					expect.objectContaining({
+						url: customUri,
+					}),
+				);
+			});
+
+			it('should use different regions correctly', async () => {
+				mockExecuteFunctions.getCredentials.mockResolvedValue({
+					region: 'europe-west1-firebase.cloudfunctions.net',
+				});
+				const mockResponse = { data: [] };
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				await googleApiRequest.call(mockExecuteFunctions, 'test-project', 'GET', '/users');
+
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					expect.objectContaining({
+						url: 'https://test-project.europe-west1-firebase.cloudfunctions.net//users.json',
+					}),
+				);
+			});
+		});
+
+		describe('error handling', () => {
+			beforeEach(() => {
+				mockExecuteFunctions.getCredentials.mockResolvedValue({
+					region: 'firebaseio.com',
+				});
+			});
+
+			it('should throw NodeApiError on API failure', async () => {
+				const apiError = new Error('API request failed');
+				mockRequestOAuth2.mockRejectedValue(apiError);
+
+				await expect(
+					googleApiRequest.call(mockExecuteFunctions, 'test-project', 'GET', '/users'),
+				).rejects.toThrow(NodeApiError);
+
+				expect(mockExecuteFunctions.getNode).toHaveBeenCalled();
+			});
+
+			it('should handle credential errors', async () => {
+				const credentialError = new Error('Invalid credentials');
+				mockExecuteFunctions.getCredentials.mockRejectedValue(credentialError);
+
+				await expect(
+					googleApiRequest.call(mockExecuteFunctions, 'test-project', 'GET', '/users'),
+				).rejects.toThrow('Invalid credentials');
+			});
+
+			it('should handle missing region in credentials', async () => {
+				mockExecuteFunctions.getCredentials.mockResolvedValue({});
+				const mockResponse = { data: [] };
+				mockRequestOAuth2.mockResolvedValue(mockResponse);
+
+				await googleApiRequest.call(mockExecuteFunctions, 'test-project', 'GET', '/users');
+
+				expect(mockRequestOAuth2).toHaveBeenCalledWith(
+					'googleFirebaseRealtimeDatabaseOAuth2Api',
+					expect.objectContaining({
+						url: 'https://test-project.undefined//users.json',
+					}),
+				);
+			});
+		});
+	});
+});