@elevasis/core 0.1.0

package/src/execution/engine/tools/platform/resource-invocation/__tests__/edge-cases.test.ts

@@ -0,0 +1,507 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { z } from 'zod'
+import { ResourceInvocationService, createResourceInvocationService } from '../resource-invocation-service'
+import type { ResourceRegistry } from '../../../../../../platform/registry/resource-registry'
+import type { WorkflowDefinition } from '../../../../workflow/types'
+import type { AgentDefinition } from '../../../../agent/core/types'
+import type { ExecuteResourceCallback } from '../types'
+import { createMockExecutionContext } from '../../../../test-utils/mocks'
+
+describe('ResourceInvocationService Edge Cases', () => {
+  let mockRegistry: ResourceRegistry
+  let mockExecuteResource: ReturnType<typeof vi.fn>
+  let service: ResourceInvocationService
+
+  const mockWorkflowDefinition: WorkflowDefinition = {
+    config: {
+      resourceId: 'test-workflow',
+      name: 'Test Workflow',
+      description: 'Test workflow for edge cases',
+      version: '1.0.0',
+      type: 'workflow',
+      status: 'dev'
+    },
+    contract: {
+      inputSchema: z.object({
+        value: z.string()
+      }),
+      outputSchema: z.object({
+        result: z.string()
+      })
+    },
+    entryPoint: 'start',
+    steps: {}
+  }
+
+  const mockAgentDefinition: AgentDefinition = {
+    config: {
+      resourceId: 'test-agent',
+      name: 'Test Agent',
+      description: 'Test agent for edge cases',
+      version: '1.0.0',
+      type: 'agent',
+      status: 'dev'
+    },
+    contract: {
+      inputSchema: z.object({
+        query: z.string()
+      }),
+      outputSchema: z.object({
+        answer: z.string()
+      })
+    },
+    modelConfig: {
+      provider: 'openai',
+      model: 'gpt-4o',
+      temperature: 0.7
+    },
+    systemPrompt: 'You are a test agent',
+    tools: []
+  }
+
+  beforeEach(() => {
+    mockRegistry = {
+      getResourceDefinition: vi.fn(),
+      getRelationships: vi.fn().mockReturnValue(undefined)
+    } as unknown as ResourceRegistry
+
+    mockExecuteResource = vi.fn()
+
+    service = new ResourceInvocationService(mockRegistry, mockExecuteResource)
+  })
+
+  describe('concurrent invocations', () => {
+    it('handles concurrent invocations without state mixing', async () => {
+      // Setup: All invocations use the same resource definition
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockWorkflowDefinition)
+
+      // Mock executor that returns different results based on input
+      mockExecuteResource.mockImplementation(async (request) => {
+        // Simulate async delay
+        await new Promise(resolve => setTimeout(resolve, 10))
+
+        return {
+          success: true,
+          output: { result: `processed-${request.input.value}` },
+          executionId: `exec-${request.input.value}`,
+          resourceType: 'workflow'
+        }
+      })
+
+      const mockContext = createMockExecutionContext({
+        organizationId: 'org-123',
+        organizationName: 'test-org'
+      })
+
+      // Launch 3 parallel calls with different inputs
+      const results = await Promise.all([
+        service.executeSync('test-workflow', { value: 'input-1' }, 'test-org', mockContext),
+        service.executeSync('test-workflow', { value: 'input-2' }, 'test-org', mockContext),
+        service.executeSync('test-workflow', { value: 'input-3' }, 'test-org', mockContext)
+      ])
+
+      // Verify each returns its own result without interference
+      expect(results[0].success).toBe(true)
+      expect(results[0].output).toEqual({ result: 'processed-input-1' })
+      expect(results[0].executionId).toBe('exec-input-1')
+
+      expect(results[1].success).toBe(true)
+      expect(results[1].output).toEqual({ result: 'processed-input-2' })
+      expect(results[1].executionId).toBe('exec-input-2')
+
+      expect(results[2].success).toBe(true)
+      expect(results[2].output).toEqual({ result: 'processed-input-3' })
+      expect(results[2].executionId).toBe('exec-input-3')
+
+      // Verify all three calls were made
+      expect(mockExecuteResource).toHaveBeenCalledTimes(3)
+    })
+  })
+
+  describe('empty input validation', () => {
+    it('handles empty object input for resources with z.object({})', async () => {
+      // Create resource with z.object({}) schema (accepts any object)
+      const emptySchemaWorkflow: WorkflowDefinition = {
+        ...mockWorkflowDefinition,
+        contract: {
+          inputSchema: z.object({}),
+          outputSchema: z.object({ status: z.string() })
+        }
+      }
+
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(emptySchemaWorkflow)
+
+      mockExecuteResource.mockResolvedValue({
+        success: true,
+        output: { status: 'completed' },
+        executionId: 'exec-empty',
+        resourceType: 'workflow'
+      })
+
+      const mockContext = createMockExecutionContext({
+        organizationName: 'test-org'
+      })
+
+      // Verify empty {} input is valid
+      const result = await service.executeSync(
+        'empty-schema-workflow',
+        {},
+        'test-org',
+        mockContext
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.output).toEqual({ status: 'completed' })
+      expect(mockExecuteResource).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: {}
+        }),
+        mockContext
+      )
+    })
+  })
+
+  describe('execution depth limits', () => {
+    it('allows execution at depth 4 (one below limit)', async () => {
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockWorkflowDefinition)
+
+      mockExecuteResource.mockResolvedValue({
+        success: true,
+        output: { result: 'depth-4-success' },
+        executionId: 'exec-depth-4',
+        resourceType: 'workflow'
+      })
+
+      // Context with executionDepth: 4
+      const contextDepth4 = createMockExecutionContext({
+        organizationName: 'test-org',
+        executionDepth: 4
+      })
+
+      const result = await service.executeSync(
+        'test-workflow',
+        { value: 'test' },
+        'test-org',
+        contextDepth4
+      )
+
+      // Should succeed (limit is 5)
+      expect(result.success).toBe(true)
+      expect(result.output).toEqual({ result: 'depth-4-success' })
+      expect(mockExecuteResource).toHaveBeenCalledWith(
+        expect.anything(),
+        contextDepth4
+      )
+    })
+
+    it('blocks execution at depth 5 (at limit)', async () => {
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockWorkflowDefinition)
+
+      // Mock executor to reject at depth 5
+      mockExecuteResource.mockResolvedValue({
+        success: false,
+        output: null,
+        executionId: '',
+        resourceType: 'workflow',
+        error: 'Maximum execution depth exceeded'
+      })
+
+      // Context with executionDepth: 5
+      const contextDepth5 = createMockExecutionContext({
+        organizationName: 'test-org',
+        executionDepth: 5
+      })
+
+      const result = await service.executeSync(
+        'test-workflow',
+        { value: 'test' },
+        'test-org',
+        contextDepth5
+      )
+
+      // Should fail with depth exceeded error
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('Maximum execution depth exceeded')
+    })
+  })
+
+  describe('null vs undefined output semantics', () => {
+    it('distinguishes null output (fire-and-forget) from undefined', async () => {
+      // Resource with outputSchema: null (fire-and-forget pattern)
+      const fireAndForgetWorkflow: WorkflowDefinition = {
+        ...mockWorkflowDefinition,
+        contract: {
+          inputSchema: z.object({ data: z.string() }),
+          outputSchema: null
+        }
+      }
+
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(fireAndForgetWorkflow)
+
+      // Resource should return null (not undefined)
+      mockExecuteResource.mockResolvedValue({
+        success: true,
+        output: null,
+        executionId: 'exec-null',
+        resourceType: 'workflow'
+      })
+
+      const mockContext = createMockExecutionContext({
+        organizationName: 'test-org'
+      })
+
+      const result = await service.executeSync(
+        'fire-and-forget',
+        { data: 'test' },
+        'test-org',
+        mockContext
+      )
+
+      // Verify output is explicitly null, not undefined
+      expect(result.success).toBe(true)
+      expect(result.output).toBeNull()
+      expect(result.output).not.toBeUndefined()
+    })
+  })
+
+  describe('complex nested schema validation', () => {
+    it('validates deeply nested input schemas', async () => {
+      // Resource with deeply nested schema
+      const nestedSchemaWorkflow: WorkflowDefinition = {
+        ...mockWorkflowDefinition,
+        contract: {
+          inputSchema: z.object({
+            nested: z.object({
+              deep: z.object({
+                value: z.string().min(1)
+              })
+            })
+          }),
+          outputSchema: z.object({ result: z.string() })
+        }
+      }
+
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(nestedSchemaWorkflow)
+
+      mockExecuteResource.mockResolvedValue({
+        success: true,
+        output: { result: 'nested-success' },
+        executionId: 'exec-nested',
+        resourceType: 'workflow'
+      })
+
+      const mockContext = createMockExecutionContext({
+        organizationName: 'test-org'
+      })
+
+      // Test valid deeply nested input
+      const validResult = await service.executeSync(
+        'nested-schema-workflow',
+        {
+          nested: {
+            deep: {
+              value: 'valid-value'
+            }
+          }
+        },
+        'test-org',
+        mockContext
+      )
+
+      expect(validResult.success).toBe(true)
+      expect(validResult.output).toEqual({ result: 'nested-success' })
+
+      // Test invalid deeply nested input (empty string violates min(1))
+      const invalidResult = await service.executeSync(
+        'nested-schema-workflow',
+        {
+          nested: {
+            deep: {
+              value: '' // Violates min(1)
+            }
+          }
+        },
+        'test-org',
+        mockContext
+      )
+
+      expect(invalidResult.success).toBe(false)
+      expect(invalidResult.error).toContain('Input validation failed')
+
+      // Test missing nested field
+      const missingFieldResult = await service.executeSync(
+        'nested-schema-workflow',
+        {
+          nested: {
+            // Missing 'deep' field
+          }
+        },
+        'test-org',
+        mockContext
+      )
+
+      expect(missingFieldResult.success).toBe(false)
+      expect(missingFieldResult.error).toContain('Input validation failed')
+    })
+  })
+
+  describe('error preservation through chain', () => {
+    it('preserves error context through invocation chain', async () => {
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockAgentDefinition)
+
+      // Executor returns error with specific message
+      const specificErrorMessage = 'Agent execution failed: Model API rate limit exceeded (429)'
+      mockExecuteResource.mockResolvedValue({
+        success: false,
+        output: null,
+        executionId: 'exec-error',
+        resourceType: 'agent',
+        error: specificErrorMessage
+      })
+
+      const mockContext = createMockExecutionContext({
+        organizationName: 'test-org'
+      })
+
+      const result = await service.executeSync(
+        'test-agent',
+        { query: 'test query' },
+        'test-org',
+        mockContext
+      )
+
+      // Verify error message preserved in result
+      expect(result.success).toBe(false)
+      expect(result.error).toBe(specificErrorMessage)
+      expect(result.error).toContain('Model API rate limit exceeded')
+      expect(result.error).toContain('429')
+    })
+  })
+
+  describe('self-invocation prevention', () => {
+    it('handles invocation of same resourceId (no infinite loop)', async () => {
+      vi.mocked(mockRegistry.getResourceDefinition).mockReturnValue(mockAgentDefinition)
+
+      // Mock executor that checks for recursion depth
+      let invocationCount = 0
+      mockExecuteResource.mockImplementation(async (request, context) => {
+        invocationCount++
+
+        // Simulate depth limit enforcement in coordinator
+        if (context.executionDepth >= 5) {
+          return {
+            success: false,
+            output: null,
+            executionId: '',
+            resourceType: 'agent',
+            error: 'Maximum execution depth exceeded'
+          }
+        }
+
+        return {
+          success: true,
+          output: { answer: `invocation-${invocationCount}` },
+          executionId: `exec-${invocationCount}`,
+          resourceType: 'agent'
+        }
+      })
+
+      // Parent agent trying to invoke itself
+      const parentContext = createMockExecutionContext({
+        organizationName: 'test-org',
+        resourceId: 'test-agent',
+        executionDepth: 5 // At depth limit
+      })
+
+      const result = await service.executeSync(
+        'test-agent', // Same as parent resourceId
+        { query: 'recursive query' },
+        'test-org',
+        parentContext
+      )
+
+      // Depth limit should prevent infinite recursion
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('Maximum execution depth exceeded')
+      expect(invocationCount).toBe(1) // Only one attempt made
+    })
+  })
+
+  describe('multiple organizations isolation', () => {
+    it('prevents cross-organization resource access', async () => {
+      // Setup: Registry returns resource for org-a, nothing for org-b
+      vi.mocked(mockRegistry.getResourceDefinition).mockImplementation((orgName, resourceId) => {
+        if (orgName === 'org-a' && resourceId === 'private-workflow') {
+          return mockWorkflowDefinition
+        }
+        return null
+      })
+
+      const contextOrgA = createMockExecutionContext({
+        organizationId: 'org-a-id',
+        organizationName: 'org-a'
+      })
+
+      const contextOrgB = createMockExecutionContext({
+        organizationId: 'org-b-id',
+        organizationName: 'org-b'
+      })
+
+      mockExecuteResource.mockResolvedValue({
+        success: true,
+        output: { result: 'success' },
+        executionId: 'exec-org-a',
+        resourceType: 'workflow'
+      })
+
+      // org-a should succeed
+      const resultOrgA = await service.executeSync(
+        'private-workflow',
+        { value: 'test' },
+        'org-a',
+        contextOrgA
+      )
+
+      expect(resultOrgA.success).toBe(true)
+      expect(mockRegistry.getResourceDefinition).toHaveBeenCalledWith('org-a', 'private-workflow')
+
+      // org-b should fail (resource not found)
+      const resultOrgB = await service.executeSync(
+        'private-workflow',
+        { value: 'test' },
+        'org-b',
+        contextOrgB
+      )
+
+      expect(resultOrgB.success).toBe(false)
+      expect(resultOrgB.error).toContain('Resource not found')
+      expect(mockRegistry.getResourceDefinition).toHaveBeenCalledWith('org-b', 'private-workflow')
+    })
+  })
+
+  describe('factory function edge cases', () => {
+    it('throws with null registry', () => {
+      expect(() => {
+        createResourceInvocationService(null as unknown as ResourceRegistry, mockExecuteResource)
+      }).toThrow('ResourceRegistry required')
+    })
+
+    it('throws with undefined registry', () => {
+      expect(() => {
+        createResourceInvocationService(undefined as unknown as ResourceRegistry, mockExecuteResource)
+      }).toThrow('ResourceRegistry required')
+    })
+
+    it('throws with null executeResource callback', () => {
+      expect(() => {
+        createResourceInvocationService(mockRegistry, null as unknown as ExecuteResourceCallback)
+      }).toThrow('executeResource callback required')
+    })
+
+    it('throws with undefined executeResource callback', () => {
+      expect(() => {
+        createResourceInvocationService(mockRegistry, undefined as unknown as ExecuteResourceCallback)
+      }).toThrow('executeResource callback required')
+    })
+  })
+})