@optimizely-opal/opal-tool-ocp-sdk 0.0.0-OCP-1487.1

package/src/service/Service.test.ts

@@ -0,0 +1,661 @@
+import { toolsService, Tool, Interaction } from './Service';
+import { Parameter, ParameterType, AuthRequirement, OptiIdAuthDataCredentials, OptiIdAuthData } from '../types/Models';
+import { ToolFunction } from '../function/ToolFunction';
+import { logger } from '@zaiusinc/app-sdk';
+
+// Mock the logger and other app-sdk exports
+jest.mock('@zaiusinc/app-sdk', () => ({
+  logger: {
+    error: jest.fn()
+  },
+  Function: class {
+    public constructor(public request: any) {}
+  },
+  Response: jest.fn().mockImplementation((status, data) => ({
+    status,
+    data,
+    bodyJSON: data,
+    bodyAsU8Array: new Uint8Array()
+  }))
+}));
+
+describe('ToolsService', () => {
+  let mockTool: Tool<unknown>;
+  let mockInteraction: Interaction<unknown>;
+  let mockToolFunction: ToolFunction;
+
+  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 ToolFunction
+    mockToolFunction = {
+      ready: jest.fn().mockResolvedValue(true),
+      perform: jest.fn(),
+      validateBearerToken: jest.fn().mockReturnValue(true),
+      request: {} as any
+    } as any;
+
+    // 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, mockToolFunction);
+
+        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',
+          auth_requirements: [{ provider: 'OptiID', scope_bundle: 'default', required: true }]
+        });
+      });
+
+      it('should return empty functions array when no tools are registered', async () => {
+        const discoveryRequest = createMockRequest({ path: '/discovery' });
+        const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
+
+        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, mockToolFunction);
+
+        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',
+          auth_requirements: [{ provider: 'OptiID', scope_bundle: 'default', required: true }]
+        });
+
+        expect(secondFunction).toEqual({
+          name: 'second_tool',
+          description: 'Second test tool',
+          parameters: [],
+          endpoint: '/second-tool',
+          http_method: 'POST',
+          auth_requirements: [
+            { provider: 'oauth2', scope_bundle: 'calendar', required: true },
+            { provider: 'OptiID', scope_bundle: 'default', required: true }
+          ]
+        });
+      });
+    });
+
+    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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          { param1: 'test-value' },
+          undefined
+        );
+      });
+
+      it('should execute tool with existing ToolFunction instance context', async () => {
+        // Create a mock ToolFunction instance
+        const mockToolFunctionInstance = {
+          someProperty: 'test-value',
+          someMethod: jest.fn(),
+          ready: jest.fn().mockResolvedValue(true),
+          perform: jest.fn(),
+          validateBearerToken: jest.fn().mockReturnValue(true),
+          request: {} as any
+        } as any;
+
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest, mockToolFunctionInstance);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunctionInstance, // functionContext - existing instance
+          { param1: 'test-value' },
+          undefined
+        );
+      });
+
+      it('should allow handler in ToolFunction subclass to access request object', async () => {
+        // Create a mock class that extends ToolFunction
+        class MockToolFunction extends ToolFunction {
+          public testMethod() {
+            return `path: ${this.request.path}`;
+          }
+
+          public getRequestPath() {
+            return this.request.path;
+          }
+        }
+
+        // Create an instance with a mock request
+        const mockRequest = createMockRequest({ path: '/test-path' });
+        const mockToolFunctionInstance = new MockToolFunction(mockRequest);
+
+        // Create a handler that will use the ToolFunction instance's methods and properties
+        const handlerThatAccessesRequest = jest.fn().mockImplementation((
+          functionContext: any,
+          params: any,
+          _authData: any
+        ) => {
+          // This simulates what would happen in a decorated method of a ToolFunction subclass
+          if (functionContext && functionContext instanceof MockToolFunction) {
+            return Promise.resolve({
+              success: true,
+              requestPath: functionContext.getRequestPath(), // Use public method to access request
+              testMethodResult: functionContext.testMethod(),
+              receivedParams: params
+            });
+          }
+          return Promise.resolve({ success: false, error: 'No valid function context' });
+        });
+
+        // Register a tool with our custom handler
+        toolsService.registerTool(
+          'test-toolfunction-access',
+          'Test handler access to ToolFunction instance',
+          handlerThatAccessesRequest,
+          [],
+          '/test-toolfunction-access'
+        );
+
+        const testRequest = createMockRequest({
+          path: '/test-toolfunction-access',
+          bodyJSON: { action: 'test' }
+        });
+
+        const response = await toolsService.processRequest(testRequest, mockToolFunctionInstance);
+
+        expect(response.status).toBe(200);
+        expect((response as any).data).toBeDefined();
+        expect((response as any).data.success).toBe(true);
+        expect((response as any).data.requestPath).toBe('/test-path');
+        expect((response as any).data.testMethodResult).toBe('path: /test-path');
+        expect((response as any).data.receivedParams).toEqual({ action: 'test' });
+        expect(handlerThatAccessesRequest).toHaveBeenCalledWith(
+          mockToolFunctionInstance, // functionContext is the ToolFunction instance
+          { action: 'test' },
+          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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          { 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          { 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, mockToolFunction);
+
+        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, mockToolFunction);
+
+        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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          { 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          {
+            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, mockToolFunction);
+
+        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, mockToolFunction);
+
+        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, mockToolFunction);
+
+        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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          { 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          { 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, mockToolFunction);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunction, // functionContext
+          { param1: 'test-value' },
+          authData
+        );
+      });
+    });
+  });
+});