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

package/src/decorator/Decorator.test.ts

@@ -0,0 +1,649 @@
+import { tool, interaction, ToolConfig, InteractionConfig, ParameterConfig, AuthRequirementConfig } from './Decorator';
+import { toolsService } from '../service/Service';
+import { ParameterType } from '../types/Models';
+
+// Mock the toolsService
+jest.mock('../service/Service', () => ({
+  toolsService: {
+    registerTool: jest.fn(),
+    registerInteraction: jest.fn()
+  }
+}));
+describe('Decorators', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('@tool decorator', () => {
+    it('should register a tool with minimal configuration', () => {
+      const config: ToolConfig = {
+        name: 'testTool',
+        description: 'A test tool',
+        parameters: [],
+        endpoint: '/test-tool'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async testMethod(_params: any) {
+          return { result: 'success' };
+        }
+      }
+
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'testTool',
+        'A test tool',
+        expect.any(Function),
+        [],
+        '/test-tool',
+        []
+      );
+
+      // Ensure TestClass is considered "used" by TypeScript
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should register a tool with parameters', () => {
+      const parameterConfig: ParameterConfig = {
+        name: 'inputParam',
+        type: ParameterType.String,
+        description: 'An input parameter',
+        required: true
+      };
+
+      const config: ToolConfig = {
+        name: 'toolWithParams',
+        description: 'A tool with parameters',
+        parameters: [parameterConfig],
+        endpoint: '/tool-with-params'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async toolWithParams(_params: any) {
+          return { result: _params.inputParam };
+        }
+      }
+
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'toolWithParams',
+        'A tool with parameters',
+        expect.any(Function),
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'inputParam',
+            type: ParameterType.String,
+            description: 'An input parameter',
+            required: true
+          })
+        ]),
+        '/tool-with-params',
+        []
+      );
+
+      // Ensure TestClass is considered "used" by TypeScript
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should register a tool with auth requirements', () => {
+      const authRequirementConfig: AuthRequirementConfig = {
+        provider: 'optiId',
+        scopeBundle: 'calendar',
+        required: true
+      };
+
+      const config: ToolConfig = {
+        name: 'toolWithAuth',
+        description: 'A tool with auth requirements',
+        parameters: [],
+        authRequirements: [authRequirementConfig],
+        endpoint: '/tool-with-auth'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async toolWithAuth(_params: any, _authData: any) {
+          return { result: 'authenticated' };
+        }
+      }
+
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'toolWithAuth',
+        'A tool with auth requirements',
+        expect.any(Function),
+        [],
+        '/tool-with-auth',
+        expect.arrayContaining([
+          expect.objectContaining({
+            provider: 'optiId',
+            scopeBundle: 'calendar',
+            required: true
+          })
+        ])
+      );
+
+      // Ensure TestClass is considered "used" by TypeScript
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should register a tool with multiple parameters and auth requirements', () => {
+      const parameterConfigs: ParameterConfig[] = [
+        {
+          name: 'param1',
+          type: ParameterType.String,
+          description: 'First parameter',
+          required: true
+        },
+        {
+          name: 'param2',
+          type: ParameterType.Integer,
+          description: 'Second parameter',
+          required: false
+        }
+      ];
+
+      const authRequirementConfigs: AuthRequirementConfig[] = [
+        {
+          provider: 'optiId',
+          scopeBundle: 'calendar',
+          required: true
+        },
+        {
+          provider: 'Bearer',
+          scopeBundle: 'drive',
+          required: false
+        }
+      ];
+
+      const config: ToolConfig = {
+        name: 'complexTool',
+        description: 'A complex tool with multiple configs',
+        parameters: parameterConfigs,
+        authRequirements: authRequirementConfigs,
+        endpoint: '/complex-tool'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async complexTool(_params: any, _authData: any) {
+          return { result: 'complex operation completed' };
+        }
+      }
+
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'complexTool',
+        'A complex tool with multiple configs',
+        expect.any(Function),
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'param1',
+            type: ParameterType.String,
+            description: 'First parameter',
+            required: true
+          }),
+          expect.objectContaining({
+            name: 'param2',
+            type: ParameterType.Integer,
+            description: 'Second parameter',
+            required: false
+          })
+        ]),
+        '/complex-tool',
+        expect.arrayContaining([
+          expect.objectContaining({
+            provider: 'optiId',
+            scopeBundle: 'calendar',
+            required: true
+          }),
+          expect.objectContaining({
+            provider: 'Bearer',
+            scopeBundle: 'drive',
+            required: false
+          })
+        ])
+      );
+
+      // Ensure TestClass is considered "used" by TypeScript
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should handle empty parameters array', () => {
+      const config: ToolConfig = {
+        name: 'emptyParamsTool',
+        description: 'Tool with empty parameters',
+        parameters: [],
+        endpoint: '/empty-params'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async emptyParamsTool() {
+          return { result: 'no params needed' };
+        }
+      }
+
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'emptyParamsTool',
+        'Tool with empty parameters',
+        expect.any(Function),
+        [],
+        '/empty-params',
+        []
+      );
+
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should handle empty auth requirements array', () => {
+      const config: ToolConfig = {
+        name: 'noAuthTool',
+        description: 'Tool with no auth requirements',
+        parameters: [],
+        authRequirements: [],
+        endpoint: '/no-auth'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async noAuthTool(_params: any) {
+          return { result: 'no auth needed' };
+        }
+      }
+
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'noAuthTool',
+        'Tool with no auth requirements',
+        expect.any(Function),
+        [],
+        '/no-auth',
+        []
+      );
+
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should register the actual method as the handler', () => {
+      const config: ToolConfig = {
+        name: 'handlerTest',
+        description: 'Test handler registration',
+        parameters: [],
+        endpoint: '/handler-test'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async handlerTest(_params: any) {
+          return { result: 'handler called' };
+        }
+      }
+
+      const mockedRegisterTool = jest.mocked(toolsService.registerTool);
+      const registerToolCall = mockedRegisterTool.mock.calls[0];
+      const registeredHandler = registerToolCall[2]; // Third argument is the handler
+
+      expect(typeof registeredHandler).toBe('function');
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should handle different parameter types', () => {
+      const parameterConfigs: ParameterConfig[] = [
+        { name: 'stringParam', type: ParameterType.String, description: 'String param', required: true },
+        { name: 'intParam', type: ParameterType.Integer, description: 'Integer param', required: true },
+        { name: 'numberParam', type: ParameterType.Number, description: 'Number param', required: false },
+        { name: 'boolParam', type: ParameterType.Boolean, description: 'Boolean param', required: false },
+        { name: 'listParam', type: ParameterType.List, description: 'List param', required: false },
+        { name: 'dictParam', type: ParameterType.Dictionary, description: 'Dictionary param', required: false }
+      ];
+
+      const config: ToolConfig = {
+        name: 'multiTypeTool',
+        description: 'Tool with multiple parameter types',
+        parameters: parameterConfigs,
+        endpoint: '/multi-type'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async multiTypeTool(_params: any) {
+          return { result: 'multi-type processing' };
+        }
+      }
+      expect(TestClass).toBeDefined();
+
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'multiTypeTool',
+        'Tool with multiple parameter types',
+        expect.any(Function),
+        expect.arrayContaining([
+          expect.objectContaining({ name: 'stringParam', type: ParameterType.String }),
+          expect.objectContaining({ name: 'intParam', type: ParameterType.Integer }),
+          expect.objectContaining({ name: 'numberParam', type: ParameterType.Number }),
+          expect.objectContaining({ name: 'boolParam', type: ParameterType.Boolean }),
+          expect.objectContaining({ name: 'listParam', type: ParameterType.List }),
+          expect.objectContaining({ name: 'dictParam', type: ParameterType.Dictionary })
+        ]),
+        '/multi-type',
+        []
+      );
+    });
+  });
+
+  describe('@interaction decorator', () => {
+    it('should register an interaction with minimal configuration', () => {
+      const config: InteractionConfig = {
+        name: 'testInteraction',
+        endpoint: '/test-interaction'
+      };
+
+      class TestClass {
+        @interaction(config)
+        public async testInteraction(_data: any) {
+          return { message: 'interaction completed' };
+        }
+      }
+
+      expect(TestClass).toBeDefined();
+
+      expect(toolsService.registerInteraction).toHaveBeenCalledWith(
+        'testInteraction',
+        expect.any(Function),
+        '/test-interaction'
+      );
+    });
+
+    it('should register the actual method as the handler', () => {
+      const config: InteractionConfig = {
+        name: 'handlerInteraction',
+        endpoint: '/handler-interaction'
+      };
+
+      class TestClass {
+        @interaction(config)
+        public async handlerInteraction(_data: any) {
+          return { message: 'handler interaction' };
+        }
+      }
+
+      const mockedRegisterInteraction = jest.mocked(toolsService.registerInteraction);
+      const registerInteractionCall = mockedRegisterInteraction.mock.calls[0];
+      const registeredHandler = registerInteractionCall[1]; // Second argument is the handler
+      expect(TestClass).toBeDefined();
+      expect(typeof registeredHandler).toBe('function');
+    });
+
+    it('should handle multiple interactions in the same class', () => {
+      class TestClass {
+        @interaction({ name: 'interaction1', endpoint: '/interaction1' })
+        public async interaction1(_data: any) {
+          return { message: 'interaction 1' };
+        }
+
+        @interaction({ name: 'interaction2', endpoint: '/interaction2' })
+        public async interaction2(_data: any) {
+          return { message: 'interaction 2' };
+        }
+      }
+      expect(TestClass).toBeDefined();
+      expect(toolsService.registerInteraction).toHaveBeenCalledTimes(2);
+      expect(toolsService.registerInteraction).toHaveBeenNthCalledWith(
+        1,
+        'interaction1',
+        expect.any(Function),
+        '/interaction1'
+      );
+      expect(toolsService.registerInteraction).toHaveBeenNthCalledWith(
+        2,
+        'interaction2',
+        expect.any(Function),
+        '/interaction2'
+      );
+    });
+  });
+
+  describe('mixed decorators', () => {
+    it('should handle both tool and interaction decorators in the same class', () => {
+      const toolConfig: ToolConfig = {
+        name: 'mixedTool',
+        description: 'A tool in mixed class',
+        parameters: [
+          { name: 'param1', type: ParameterType.String, description: 'String param', required: true }
+        ],
+        endpoint: '/mixed-tool'
+      };
+
+      const interactionConfig: InteractionConfig = {
+        name: 'mixedInteraction',
+        endpoint: '/mixed-interaction'
+      };
+
+      class MixedClass {
+        @tool(toolConfig)
+        public async mixedTool(_params: any) {
+          return { result: 'tool result' };
+        }
+
+        @interaction(interactionConfig)
+        public async mixedInteraction(_data: any) {
+          return { message: 'interaction result' };
+        }
+      }
+
+      expect(MixedClass).toBeDefined();
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'mixedTool',
+        'A tool in mixed class',
+        expect.any(Function),
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'param1',
+            type: ParameterType.String,
+            description: 'String param',
+            required: true
+          })
+        ]),
+        '/mixed-tool',
+        []
+      );
+
+      expect(toolsService.registerInteraction).toHaveBeenCalledWith(
+        'mixedInteraction',
+        expect.any(Function),
+        '/mixed-interaction'
+      );
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle auth requirements with default required value', () => {
+      const authRequirementConfig: AuthRequirementConfig = {
+        provider: 'optiId',
+        scopeBundle: 'calendar'
+        // required is not specified, should default to true in AuthRequirement constructor
+      };
+
+      const config: ToolConfig = {
+        name: 'defaultAuthTool',
+        description: 'Tool with default auth requirement',
+        parameters: [],
+        authRequirements: [authRequirementConfig],
+        endpoint: '/default-auth'
+      };
+
+      class TestClass {
+        @tool(config)
+        public async defaultAuthTool(_params: any, _authData: any) {
+          return { result: 'default auth' };
+        }
+      }
+
+      expect(TestClass).toBeDefined();
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'defaultAuthTool',
+        'Tool with default auth requirement',
+        expect.any(Function),
+        [],
+        '/default-auth',
+        expect.arrayContaining([
+          expect.objectContaining({
+            provider: 'optiId',
+            scopeBundle: 'calendar',
+            required: true // Should default to true
+          })
+        ])
+      );
+    });
+
+    it('should handle undefined parameters and authRequirements arrays', () => {
+      const config = {
+        name: 'undefinedArraysTool',
+        description: 'Tool with undefined arrays',
+        endpoint: '/undefined-arrays'
+        // parameters and authRequirements are not defined
+      } as ToolConfig;
+
+      class TestClass {
+        @tool(config)
+        public async undefinedArraysTool(_params: any) {
+          return { result: 'undefined arrays handled' };
+        }
+      }
+
+      expect(TestClass).toBeDefined();
+      expect(toolsService.registerTool).toHaveBeenCalledWith(
+        'undefinedArraysTool',
+        'Tool with undefined arrays',
+        expect.any(Function),
+        [], // Should be empty array when parameters is undefined
+        '/undefined-arrays',
+        [] // Should be empty array when authRequirements is undefined
+      );
+    });
+  });
+
+  describe('handler instance context', () => {
+    it('should allow tool handler to call class methods', async () => {
+      class TestClass {
+        private getValue() {
+          return 'class-method-called';
+        }
+
+        @tool({
+          name: 'instanceMethodTest',
+          description: 'Test calling class methods',
+          parameters: [],
+          endpoint: '/instance-method-test'
+        })
+        public async instanceMethodTest(_params: any) {
+          return { result: this.getValue() };
+        }
+      }
+
+      // Get the registered handler
+      const mockedRegisterTool = jest.mocked(toolsService.registerTool);
+      const registerToolCall = mockedRegisterTool.mock.calls.find((call) => call[0] === 'instanceMethodTest');
+      const registeredHandler = registerToolCall![2];
+
+      // Call the handler
+      const result = await registeredHandler(undefined as any, {}, {});
+
+      // Should be able to call class methods through 'this'
+      expect((result as any).result).toBe('class-method-called');
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should allow interaction handler to call class methods', async () => {
+      class TestClass {
+        private processData() {
+          return 'interaction-processed';
+        }
+
+        @interaction({
+          name: 'instanceInteractionTest',
+          endpoint: '/instance-interaction-test'
+        })
+        public async instanceInteractionTest(_data: any) {
+          return { message: this.processData() };
+        }
+      }
+
+      // Get the registered handler
+      const mockedRegisterInteraction = jest.mocked(toolsService.registerInteraction);
+      const registerInteractionCall = mockedRegisterInteraction.mock.calls.find(
+        (call) => call[0] === 'instanceInteractionTest'
+      );
+      const registeredHandler = registerInteractionCall![1];
+
+      // Call the handler
+      const result = await registeredHandler(undefined as any, {});
+
+      // Should be able to call class methods through 'this'
+      expect((result as any).message).toBe('interaction-processed');
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should handle invalid functionContext gracefully for tool', async () => {
+      class TestClass {
+        private getValue() {
+          return 'class-method-called';
+        }
+
+        @tool({
+          name: 'invalidContextTest',
+          description: 'Test handling invalid context',
+          parameters: [],
+          endpoint: '/invalid-context-test'
+        })
+        public async invalidContextTest(_params: any) {
+          return { result: this.getValue() };
+        }
+      }
+
+      // Get the registered handler
+      const mockedRegisterTool = jest.mocked(toolsService.registerTool);
+      const registerToolCall = mockedRegisterTool.mock.calls.find((call) => call[0] === 'invalidContextTest');
+      const registeredHandler = registerToolCall![2];
+
+      // Call the handler with an invalid functionContext (truthy but wrong type)
+      // This should trigger the instanceof check and create a new instance instead
+      const invalidContext = { notAnInstance: true, someOtherProperty: 'invalid' };
+      const result = await registeredHandler(invalidContext as any, {}, {});
+
+      // Should still work by creating a new instance
+      expect((result as any).result).toBe('class-method-called');
+      expect(TestClass).toBeDefined();
+    });
+
+    it('should handle invalid functionContext gracefully for interaction', async () => {
+      class TestClass {
+        private processData() {
+          return 'interaction-processed';
+        }
+
+        @interaction({
+          name: 'invalidContextInteractionTest',
+          endpoint: '/invalid-context-interaction-test'
+        })
+        public async invalidContextInteractionTest(_data: any) {
+          return { message: this.processData() };
+        }
+      }
+
+      // Get the registered handler
+      const mockedRegisterInteraction = jest.mocked(toolsService.registerInteraction);
+      const registerInteractionCall = mockedRegisterInteraction.mock.calls.find(
+        (call) => call[0] === 'invalidContextInteractionTest'
+      );
+      const registeredHandler = registerInteractionCall![1];
+
+      // Call the handler with an invalid functionContext (truthy but wrong type)
+      // This should trigger the instanceof check and create a new instance instead
+      const invalidContext = { notAnInstance: true, someOtherProperty: 'invalid' };
+      const result = await registeredHandler(invalidContext as any, {});
+
+      // Should still work by creating a new instance
+      expect((result as any).message).toBe('interaction-processed');
+      expect(TestClass).toBeDefined();
+    });
+  });
+});
+