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

package/src/function/ToolFunction.test.ts

@@ -0,0 +1,224 @@
+import { ToolFunction } from './ToolFunction';
+import { toolsService } from '../service/Service';
+import { Response } from '@zaiusinc/app-sdk';
+
+// Mock the toolsService
+jest.mock('../service/Service', () => ({
+  toolsService: {
+    processRequest: jest.fn(),
+    extractBearerToken: jest.fn(),
+  },
+}));
+
+// Mock the Request and Response classes and Function base class
+jest.mock('@zaiusinc/app-sdk', () => ({
+  Function: class {
+    protected request: any;
+    public constructor(_name?: string) {
+      // Mock constructor that accepts optional name parameter
+      this.request = {};
+    }
+  },
+  Request: jest.fn().mockImplementation(() => ({})),
+  Response: jest.fn().mockImplementation((status, data) => ({
+    status,
+    data,
+    bodyJSON: data,
+    bodyAsU8Array: new Uint8Array()
+  })),
+}));
+
+// Create a concrete implementation for testing
+class TestToolFunction extends ToolFunction {
+  private mockValidateBearerToken: jest.MockedFunction<(token: string) => boolean>;
+
+  public constructor(request?: any) {
+    super(request || {}); // Pass the request parameter properly
+    // Set the request directly without defaulting to empty object
+    (this as any).request = request;
+
+    // Create a mock implementation of the abstract method
+    this.mockValidateBearerToken = jest.fn().mockReturnValue(true);
+  }
+
+  // Implement the abstract method
+  protected validateBearerToken(bearerToken: string): boolean {
+    return this.mockValidateBearerToken(bearerToken);
+  }
+
+  // Expose request and validation mock for testing
+  public getRequest() {
+    return (this as any).request;
+  }
+
+  public getMockValidateBearerToken() {
+    return this.mockValidateBearerToken;
+  }
+}
+
+describe('ToolFunction', () => {
+  let mockRequest: any;
+  let mockResponse: Response;
+  let toolFunction: TestToolFunction;
+  let mockProcessRequest: jest.MockedFunction<typeof toolsService.processRequest>;
+  let mockExtractBearerToken: jest.MockedFunction<typeof toolsService.extractBearerToken>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Create mock instances
+    mockRequest = {
+      headers: new Map(),
+      method: 'POST',
+      path: '/test'
+    };
+    mockResponse = {} as Response;
+
+    // Setup the mocks
+    mockProcessRequest = jest.mocked(toolsService.processRequest);
+    mockExtractBearerToken = jest.mocked(toolsService.extractBearerToken);
+
+    // Create test instance
+    toolFunction = new TestToolFunction(mockRequest);
+  });
+
+  describe('bearer token validation', () => {
+    it('should extract bearer token from headers and validate it', async () => {
+      // Arrange
+      const bearerToken = 'valid-token-123';
+      mockExtractBearerToken.mockReturnValue(bearerToken);
+      toolFunction.getMockValidateBearerToken().mockReturnValue(true);
+      mockProcessRequest.mockResolvedValue(mockResponse);
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith(bearerToken);
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest);
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should return 403 Forbidden when bearer token validation fails', async () => {
+      // Arrange
+      const bearerToken = 'invalid-token-456';
+      mockExtractBearerToken.mockReturnValue(bearerToken);
+      toolFunction.getMockValidateBearerToken().mockReturnValue(false);
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith(bearerToken);
+      expect(mockProcessRequest).not.toHaveBeenCalled();
+      expect(result).toEqual(new Response(403, { error: 'Forbidden' }));
+    });
+
+    it('should handle complex bearer token validation scenarios', async () => {
+      // Arrange - simulate a token that should be valid based on some complex logic
+      const complexToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9l' +
+        'IiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+      mockExtractBearerToken.mockReturnValue(complexToken);
+      toolFunction.getMockValidateBearerToken().mockReturnValue(true);
+      mockProcessRequest.mockResolvedValue(mockResponse);
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith(complexToken);
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest);
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should handle bearer token validation throwing an error', async () => {
+      // Arrange
+      const bearerToken = 'malformed-token';
+      mockExtractBearerToken.mockReturnValue(bearerToken);
+      toolFunction.getMockValidateBearerToken().mockImplementation(() => {
+        throw new Error('Token validation error');
+      });
+
+      // Act & Assert
+      await expect(toolFunction.perform()).rejects.toThrow('Token validation error');
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith(bearerToken);
+      expect(mockProcessRequest).not.toHaveBeenCalled();
+    });
+
+    it('should call validateBearerToken only once per request', async () => {
+      // Arrange
+      const bearerToken = 'test-token';
+      mockExtractBearerToken.mockReturnValue(bearerToken);
+      toolFunction.getMockValidateBearerToken().mockReturnValue(true);
+      mockProcessRequest.mockResolvedValue(mockResponse);
+
+      // Act
+      await toolFunction.perform();
+
+      // Assert
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledTimes(1);
+      expect(toolFunction.getMockValidateBearerToken()).toHaveBeenCalledWith(bearerToken);
+    });
+
+    it('should extract bearer token only once per request', async () => {
+      // Arrange
+      const bearerToken = 'test-token';
+      mockExtractBearerToken.mockReturnValue(bearerToken);
+      toolFunction.getMockValidateBearerToken().mockReturnValue(true);
+      mockProcessRequest.mockResolvedValue(mockResponse);
+
+      // Act
+      await toolFunction.perform();
+
+      // Assert
+      expect(mockExtractBearerToken).toHaveBeenCalledTimes(1);
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
+    });
+
+    it('should skip validation when bearer token is undefined', async () => {
+      // Arrange
+      mockExtractBearerToken.mockReturnValue(undefined);
+      mockProcessRequest.mockResolvedValue(mockResponse);
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
+      expect(toolFunction.getMockValidateBearerToken()).not.toHaveBeenCalled();
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest);
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should skip validation when bearer token is empty string', async () => {
+      // Arrange
+      mockExtractBearerToken.mockReturnValue('');
+      mockProcessRequest.mockResolvedValue(mockResponse);
+
+      // Act
+      const result = await toolFunction.perform();
+
+      // Assert
+      expect(mockExtractBearerToken).toHaveBeenCalledWith(mockRequest.headers);
+      expect(toolFunction.getMockValidateBearerToken()).not.toHaveBeenCalled();
+      expect(mockProcessRequest).toHaveBeenCalledWith(mockRequest);
+      expect(result).toBe(mockResponse);
+    });
+  });
+
+  describe('inheritance', () => {
+    it('should be an instance of Function', () => {
+      // Assert
+      expect(toolFunction).toBeInstanceOf(ToolFunction);
+    });
+
+    it('should have access to the request property', () => {
+      // Assert
+      expect(toolFunction.getRequest()).toBe(mockRequest);
+    });
+  });
+});

package/src/function/ToolFunction.ts

@@ -0,0 +1,25 @@
+import { Function, Response } from '@zaiusinc/app-sdk';
+import { toolsService } from '../service/Service';
+
+/**
+ * Abstract base class for tool-based function execution
+ * Provides a standard interface for processing requests through registered tools
+ */
+export abstract class ToolFunction extends Function {
+
+  /**
+   * Process the incoming request using the tools service
+   *
+   * @returns Response as the HTTP response
+   */
+  public async perform(): Promise<Response> {
+    const bearerToken = toolsService.extractBearerToken(this.request.headers);
+    if (bearerToken && !this.validateBearerToken(bearerToken)) {
+      return new Response(403, { error: 'Forbidden' });
+    }
+
+    return toolsService.processRequest(this.request);
+  }
+
+  protected abstract validateBearerToken(bearerToken: string): boolean;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './function/ToolFunction';
+export * from './types/Models';
+export * from './decorator/Decorator';
+export { Tool, Interaction, InteractionResult } from './service/Service';