@optimizely-opal/opal-tool-ocp-sdk 0.0.0-dev.1

package/src/service/Service.test.ts

@@ -0,0 +1,550 @@
+import { toolsService, Tool, Interaction } from './Service';
+import { Parameter, ParameterType, AuthRequirement, OptiIdAuthDataCredentials, OptiIdAuthData } from '../types/Models';
+import { logger } from '@zaiusinc/app-sdk';
+
+// Mock the logger
+jest.mock('@zaiusinc/app-sdk', () => ({
+  logger: {
+    error: jest.fn()
+  },
+  Response: jest.fn().mockImplementation((status, data) => ({
+    status,
+    data,
+    bodyJSON: data,
+    bodyAsU8Array: new Uint8Array()
+  }))
+}));
+
+describe('ToolsService', () => {
+  let mockTool: Tool<unknown>;
+  let mockInteraction: Interaction<unknown>;
+
+  beforeEach(() => {
+    // Clear registered functions and interactions before each test
+    (toolsService as any).functions = new Map();
+    (toolsService as any).interactions = new Map();
+
+    // Reset all mocks
+    jest.clearAllMocks();
+
+    // Create mock tool handler
+    const mockToolHandler = jest.fn().mockResolvedValue({ result: 'success' });
+
+    // Create mock interaction handler
+    const mockInteractionHandler = jest.fn().mockResolvedValue({ message: 'interaction success' });
+
+    // Create mock tool
+    mockTool = new Tool(
+      'testTool',
+      'Test tool description',
+      [new Parameter('param1', ParameterType.String, 'Test parameter', true)],
+      '/test-tool',
+      mockToolHandler
+    );
+
+    // Create mock interaction
+    mockInteraction = new Interaction(
+      'testInteraction',
+      '/test-interaction',
+      mockInteractionHandler
+    );
+  });
+
+  const createMockRequest = (overrides: any = {}): any => {
+    // Create a mock headers object with get method
+    const createHeadersMap = (headersObj: any = {}) => {
+      const map = new Map();
+      Object.entries(headersObj).forEach(([key, value]) => {
+        map.set(key, value);
+      });
+      return map;
+    };
+
+    const baseRequest = {
+      path: '/test-tool',
+      method: 'POST',
+      bodyJSON: { parameters: { param1: 'test-value' } },
+      body: JSON.stringify({ parameters: { param1: 'test-value' } }),
+      bodyData: Buffer.from(''),
+      headers: createHeadersMap(),
+      params: {},
+      contentType: 'application/json'
+    };
+
+    return {
+      ...baseRequest,
+      ...overrides,
+      headers: createHeadersMap(overrides.headers)
+    };
+  };
+
+  describe('processRequest', () => {
+    describe('discovery endpoint', () => {
+      it('should return registered functions for discovery endpoint', async () => {
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+
+        const discoveryRequest = createMockRequest({ path: '/discovery' });
+        const response = await toolsService.processRequest(discoveryRequest);
+
+        expect(response.status).toBe(200);
+        expect(response).toHaveProperty('bodyJSON');
+        expect(response.bodyAsU8Array).toBeDefined();
+
+        // Test the actual response structure
+        const responseData = response.bodyJSON as { functions: unknown[] };
+        expect(responseData).toHaveProperty('functions');
+        expect(Array.isArray(responseData.functions)).toBe(true);
+        expect(responseData.functions).toHaveLength(1);
+
+        // Test the registered function structure
+        const registeredFunction = responseData.functions[0];
+        expect(registeredFunction).toEqual({
+          name: mockTool.name,
+          description: mockTool.description,
+          parameters: mockTool.parameters.map((p: Parameter) => p.toJSON()),
+          endpoint: mockTool.endpoint,
+          http_method: 'POST'
+        });
+      });
+
+      it('should return empty functions array when no tools are registered', async () => {
+        const discoveryRequest = createMockRequest({ path: '/discovery' });
+        const response = await toolsService.processRequest(discoveryRequest);
+
+        expect(response.status).toBe(200);
+        expect(response.bodyAsU8Array).toBeDefined();
+
+        // Test the actual response structure
+        const responseData = response.bodyJSON as { functions: unknown[] };
+        expect(responseData).toHaveProperty('functions');
+        expect(Array.isArray(responseData.functions)).toBe(true);
+        expect(responseData.functions).toHaveLength(0);
+      });
+
+      it('should return multiple registered functions in discovery endpoint', async () => {
+        // Register first tool
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+
+        // Register second tool with auth requirements
+        const authRequirements = [new AuthRequirement('oauth2', 'calendar', true)];
+        toolsService.registerTool(
+          'second_tool',
+          'Second test tool',
+          jest.fn(),
+          [],
+          '/second-tool',
+          authRequirements
+        );
+
+        const discoveryRequest = createMockRequest({ path: '/discovery' });
+        const response = await toolsService.processRequest(discoveryRequest);
+
+        expect(response.status).toBe(200);
+
+        // Test the actual response structure
+        const responseData = response.bodyJSON as { functions: unknown[] };
+        expect(responseData).toHaveProperty('functions');
+        expect(Array.isArray(responseData.functions)).toBe(true);
+        expect(responseData.functions).toHaveLength(2);
+
+        // Find and test both functions
+        const firstFunction = responseData.functions.find((f: any) => f.name === mockTool.name);
+        const secondFunction = responseData.functions.find((f: any) => f.name === 'second_tool');
+
+        expect(firstFunction).toEqual({
+          name: mockTool.name,
+          description: mockTool.description,
+          parameters: mockTool.parameters.map((p: Parameter) => p.toJSON()),
+          endpoint: mockTool.endpoint,
+          http_method: 'POST'
+        });
+
+        expect(secondFunction).toEqual({
+          name: 'second_tool',
+          description: 'Second test tool',
+          parameters: [],
+          endpoint: '/second-tool',
+          http_method: 'POST',
+          auth_requirements: authRequirements.map((auth) => auth.toJSON())
+        });
+      });
+    });
+
+    describe('tool execution', () => {
+      beforeEach(() => {
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+      });
+
+      it('should execute tool successfully with parameters', async () => {
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          { param1: 'test-value' },
+          undefined
+        );
+      });
+
+      it('should execute tool with OptiID auth data when provided', async () => {
+        const authData = new OptiIdAuthData(
+          'optiId',
+          new OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123')
+        );
+
+        const requestWithAuth = createMockRequest({
+          bodyJSON: {
+            parameters: { param1: 'test-value' },
+            auth: authData
+          },
+          body: JSON.stringify({
+            parameters: { param1: 'test-value' },
+            auth: authData
+          })
+        });
+
+        const response = await toolsService.processRequest(requestWithAuth);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          { param1: 'test-value' },
+          authData
+        );
+      });
+
+      it('should handle request body without parameters wrapper', async () => {
+        const requestWithoutWrapper = createMockRequest({
+          bodyJSON: { param1: 'test-value' },
+          body: JSON.stringify({ param1: 'test-value' })
+        });
+
+        const response = await toolsService.processRequest(requestWithoutWrapper);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          { param1: 'test-value' },
+          undefined
+        );
+      });
+
+      it('should return 500 error when tool handler throws an error', async () => {
+        const errorMessage = 'Tool execution failed';
+        jest.mocked(mockTool.handler).mockRejectedValueOnce(new Error(errorMessage));
+
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest);
+
+        expect(response.status).toBe(500);
+        expect(logger.error).toHaveBeenCalledWith(
+          `Error in function ${mockTool.name}:`,
+          expect.any(Error)
+        );
+      });
+
+      it('should return 500 error with generic message when error has no message', async () => {
+        jest.mocked(mockTool.handler).mockRejectedValueOnce({});
+
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest);
+
+        expect(response.status).toBe(500);
+      });
+    });
+
+    describe('interaction execution', () => {
+      beforeEach(() => {
+        toolsService.registerInteraction(
+          mockInteraction.name,
+          mockInteraction.handler,
+          mockInteraction.endpoint
+        );
+      });
+
+      it('should execute interaction successfully with data', async () => {
+        const interactionRequest = createMockRequest({
+          path: '/test-interaction',
+          bodyJSON: { data: { param1: 'test-value' } },
+          body: JSON.stringify({ data: { param1: 'test-value' } })
+        });
+
+        const response = await toolsService.processRequest(interactionRequest);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith({ param1: 'test-value' }, undefined);
+      });
+
+      it('should handle interaction request body without data wrapper', async () => {
+        const interactionRequest = createMockRequest({
+          path: '/test-interaction',
+          bodyJSON: { param1: 'test-value' },
+          body: JSON.stringify({ param1: 'test-value' })
+        });
+
+        const response = await toolsService.processRequest(interactionRequest);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith({ param1: 'test-value' }, undefined);
+      });
+
+      it('should execute interaction with OptiID auth data when provided', async () => {
+        const authData = new OptiIdAuthData(
+          'optiId',
+          new OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123')
+        );
+
+        const interactionRequest = createMockRequest({
+          path: '/test-interaction',
+          bodyJSON: {
+            data: { param1: 'test-value' },
+            auth: authData
+          },
+          body: JSON.stringify({
+            data: { param1: 'test-value' },
+            auth: authData
+          })
+        });
+
+        const response = await toolsService.processRequest(interactionRequest);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(
+          { param1: 'test-value' },
+          authData
+        );
+      });
+
+      it('should handle interaction request without data wrapper but with auth data', async () => {
+        const authData = new OptiIdAuthData(
+          'optiId',
+          new OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123')
+        );
+
+        const interactionRequest = createMockRequest({
+          path: '/test-interaction',
+          bodyJSON: {
+            param1: 'test-value',
+            auth: authData
+          },
+          body: JSON.stringify({
+            param1: 'test-value',
+            auth: authData
+          })
+        });
+
+        const response = await toolsService.processRequest(interactionRequest);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(
+          {
+            param1: 'test-value',
+            auth: authData
+          },
+          authData
+        );
+      });
+
+      it('should return 500 error when interaction handler throws an error', async () => {
+        const errorMessage = 'Interaction execution failed';
+        jest.mocked(mockInteraction.handler).mockRejectedValueOnce(new Error(errorMessage));
+
+        const interactionRequest = createMockRequest({
+          path: '/test-interaction',
+          bodyJSON: { data: { param1: 'test-value' } }
+        });
+
+        const response = await toolsService.processRequest(interactionRequest);
+
+        expect(response.status).toBe(500);
+        expect(logger.error).toHaveBeenCalledWith(
+          `Error in function ${mockInteraction.name}:`,
+          expect.any(Error)
+        );
+      });
+    });
+
+    describe('error cases', () => {
+      it('should return 404 when no matching tool or interaction is found', async () => {
+        const unknownRequest = createMockRequest({ path: '/unknown-endpoint' });
+        const response = await toolsService.processRequest(unknownRequest);
+
+        expect(response.status).toBe(404);
+      });
+
+      it('should handle tool with OptiID auth requirements', async () => {
+        const authRequirements = [
+          new AuthRequirement('OptiID', 'calendar', true)
+        ];
+
+        toolsService.registerTool(
+          'optiIdAuthTool',
+          'Tool with OptiID auth',
+          mockTool.handler,
+          mockTool.parameters,
+          '/optid-auth-tool',
+          authRequirements
+        );
+
+        const authRequest = createMockRequest({
+          path: '/optid-auth-tool'
+        });
+
+        const response = await toolsService.processRequest(authRequest);
+
+        expect(response.status).toBe(200);
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle request with null bodyJSON', async () => {
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+
+        const requestWithNullBody = createMockRequest({
+          bodyJSON: null,
+          body: null
+        });
+
+        const response = await toolsService.processRequest(requestWithNullBody);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(null, undefined);
+      });
+
+      it('should handle request with undefined bodyJSON', async () => {
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+
+        const requestWithUndefinedBody = createMockRequest({
+          bodyJSON: undefined,
+          body: undefined
+        });
+
+        const response = await toolsService.processRequest(requestWithUndefinedBody);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(undefined, undefined);
+      });
+
+      it('should extract auth data from bodyJSON when body exists', async () => {
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+
+        const authData = new OptiIdAuthData(
+          'optiId',
+          new OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123')
+        );
+
+        const requestWithAuth = createMockRequest({
+          bodyJSON: {
+            parameters: { param1: 'test-value' },
+            auth: authData
+          },
+          body: JSON.stringify({
+            parameters: { param1: 'test-value' },
+            auth: authData
+          })
+        });
+
+        const response = await toolsService.processRequest(requestWithAuth);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          { param1: 'test-value' },
+          authData
+        );
+      });
+
+      it('should handle missing auth data gracefully', async () => {
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+
+        const requestWithoutAuth = createMockRequest({
+          bodyJSON: {
+            parameters: { param1: 'test-value' }
+            // No auth property
+          },
+          body: JSON.stringify({
+            parameters: { param1: 'test-value' }
+          })
+        });
+
+        const response = await toolsService.processRequest(requestWithoutAuth);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          { param1: 'test-value' },
+          undefined
+        );
+      });
+
+      it('should handle auth extraction when body is falsy but bodyJSON has auth', async () => {
+        toolsService.registerTool(
+          mockTool.name,
+          mockTool.description,
+          mockTool.handler,
+          mockTool.parameters,
+          mockTool.endpoint
+        );
+
+        const authData = new OptiIdAuthData(
+          'optiId',
+          new OptiIdAuthDataCredentials('customer123', 'instance123', 'token123', 'sku123')
+        );
+
+        const requestWithAuthButNoBody = createMockRequest({
+          bodyJSON: {
+            parameters: { param1: 'test-value' },
+            auth: authData
+          },
+          body: ''
+        });
+
+        const response = await toolsService.processRequest(requestWithAuthButNoBody);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          { param1: 'test-value' },
+          authData
+        );
+      });
+    });
+  });
+});