@0xsequence/catapult 1.1.0

package/src/lib/core/__tests__/graph.spec.ts

@@ -0,0 +1,125 @@
+// src/lib/core/__tests__/graph.spec.ts
+import * as path from 'path'
+import { ProjectLoader } from '../loader'
+import { DependencyGraph } from '../graph'
+import { Job, Template } from '../../types'
+
+describe('DependencyGraph', () => {
+  let loader: ProjectLoader
+
+  beforeAll(async () => {
+    // Load the real project structure from the examples directory
+    const projectRoot = path.resolve(__dirname, '../../../../examples')
+    loader = new ProjectLoader(projectRoot)
+    await loader.load()
+  })
+
+  it('should be created without errors for a valid project', () => {
+    expect(() => new DependencyGraph(loader.jobs, loader.templates)).not.toThrow()
+  })
+
+  it('should identify direct dependencies from `depends_on` field', () => {
+    const graph = new DependencyGraph(loader.jobs, loader.templates)
+    // guards-v1.yaml has `depends_on: ["sequence-v1"]`
+    const guardsDeps = graph.getDependencies('guards-v1')
+    expect(guardsDeps.has('sequence-v1')).toBe(true)
+  })
+
+  it('should identify dependencies from a template setup block (`job-completed`)', () => {
+    const jobs = new Map<string, Job>()
+    const templates = new Map<string, Template>()
+
+    templates.set('template-with-setup', {
+      name: 'template-with-setup',
+      actions: [],
+      setup: { skip_condition: [{ type: 'job-completed', arguments: { job: 'dependency-job' } }] },
+    })
+
+    jobs.set('job-A', { name: 'job-A', version: '1', actions: [{ name: 'a1', template: 'template-with-setup', arguments: {} }] })
+    jobs.set('dependency-job', { name: 'dependency-job', version: '1', actions: [] })
+
+    const graph = new DependencyGraph(jobs, templates)
+    const jobADeps = graph.getDependencies('job-A')
+    expect(jobADeps.has('dependency-job')).toBe(true)
+  })
+  
+  it('should identify nested dependencies from templates calling templates in setup', () => {
+    // In our examples:
+    // job `sequence-v1` uses `sequence-universal-deployer-2`
+    // `sequence-universal-deployer-2`'s setup uses `nano-universal-deployer`
+    // `nano-universal-deployer`'s setup uses `min-balance` and `send-signed-transaction` (primitives)
+    // This test confirms the graph builder doesn't crash on this complexity.
+    // A more specific test would require mocking a deeper chain.
+    const graph = new DependencyGraph(loader.jobs, loader.templates);
+    const seqV1Deps = graph.getDependencies('sequence-v1');
+
+    // sequence-v1 itself has no job dependencies defined in its YAMLs, so this should be empty.
+    // This confirms our logic correctly distinguishes between template-setup-actions and job dependencies.
+    expect(seqV1Deps.size).toBe(0);
+  });
+
+  it('should correctly identify transitive dependencies', () => {
+    const graph = new DependencyGraph(loader.jobs, loader.templates)
+    // "sequence-v1-seq-0001-patch" -> "guards-v1" -> "sequence-v1"
+    const patchDeps = graph.getDependencies('sequence-v1-seq-0001-patch')
+    expect(patchDeps.has('guards-v1')).toBe(true)
+    expect(patchDeps.has('sequence-v1')).toBe(true) // Transitive dependency
+    expect(patchDeps.size).toBe(2) // depends on sequence-v1, and guards-v1
+  })
+
+  it('should produce a valid topological sort order', () => {
+    const graph = new DependencyGraph(loader.jobs, loader.templates)
+    const order = graph.getExecutionOrder()
+
+    // We can't know the exact order due to parallel possibilities,
+    // but we can verify that dependencies always come before their dependents.
+    const patchIndex = order.indexOf('sequence-v1-seq-0001-patch')
+    const guardsIndex = order.indexOf('guards-v1')
+    const seqV1Index = order.indexOf('sequence-v1')
+
+    expect(patchIndex).toBeGreaterThan(guardsIndex)
+    expect(patchIndex).toBeGreaterThan(seqV1Index)
+    expect(guardsIndex).toBeGreaterThan(seqV1Index)
+  })
+
+  describe('Cycle Detection', () => {
+    it('should throw an error for a simple (A -> B -> A) cycle', () => {
+      const jobs = new Map<string, Job>()
+      jobs.set('job-A', { name: 'job-A', version: '1', actions: [], depends_on: ['job-B'] })
+      jobs.set('job-B', { name: 'job-B', version: '1', actions: [], depends_on: ['job-A'] })
+
+      expect(() => new DependencyGraph(jobs, new Map())).toThrow(
+        /Circular dependency detected: job-A -> job-B -> job-A/
+      )
+    })
+
+    it('should throw an error for a longer (A -> B -> C -> A) cycle', () => {
+        const jobs = new Map<string, Job>()
+        jobs.set('job-A', { name: 'job-A', version: '1', actions: [], depends_on: ['job-B'] })
+        jobs.set('job-B', { name: 'job-B', version: '1', actions: [], depends_on: ['job-C'] })
+        jobs.set('job-C', { name: 'job-C', version: '1', actions: [], depends_on: ['job-A'] })
+  
+        expect(() => new DependencyGraph(jobs, new Map())).toThrow(
+          /Circular dependency detected: job-A -> job-B -> job-C -> job-A/
+        )
+      })
+
+    it('should throw an error for a self-referencing cycle', () => {
+      const jobs = new Map<string, Job>()
+      jobs.set('job-A', { name: 'job-A', version: '1', actions: [], depends_on: ['job-A'] })
+
+      expect(() => new DependencyGraph(jobs, new Map())).toThrow(
+        /Circular dependency detected: job-A -> job-A/
+      )
+    })
+  })
+
+  it('should throw an error for a dependency on a non-existent job', () => {
+    const jobs = new Map<string, Job>()
+    jobs.set('job-A', { name: 'job-A', version: '1', actions: [], depends_on: ['job-non-existent'] })
+
+    expect(() => new DependencyGraph(jobs, new Map())).toThrow(
+      'Invalid dependency: Job "job-A" depends on "job-non-existent", which does not exist.'
+    )
+  })
+})

package/src/lib/core/__tests__/json-integration.spec.ts

@@ -0,0 +1,360 @@
+import { ExecutionEngine } from '../engine'
+import { ExecutionContext } from '../context'
+import { ValueResolver } from '../resolver'
+import { ContractRepository } from '../../contracts/repository'
+import { Action, Network, ReadJsonValue } from '../../types'
+import { VerificationPlatformRegistry } from '../../verification/etherscan'
+
+describe('JSON Integration Tests', () => {
+  let engine: ExecutionEngine
+  let context: ExecutionContext
+  let resolver: ValueResolver
+  let mockNetwork: Network
+  let mockRegistry: ContractRepository
+  let templates: Map<string, any>
+
+  beforeEach(() => {
+    mockNetwork = { name: 'testnet', chainId: 999, rpcUrl: 'http://localhost:8545' }
+    mockRegistry = new ContractRepository()
+    
+    // Create a mock context that doesn't require a real connection
+    context = {
+      getNetwork: () => mockNetwork,
+      setOutput: jest.fn(),
+      getOutput: jest.fn(),
+      setContextPath: jest.fn(),
+      getContextPath: jest.fn(),
+      dispose: jest.fn(),
+      provider: {} as any,
+      contractRepository: mockRegistry
+    } as any
+
+    templates = new Map()
+    const verificationRegistry = new VerificationPlatformRegistry()
+    engine = new ExecutionEngine(templates, undefined, verificationRegistry)
+    resolver = new ValueResolver()
+  })
+
+  describe('ReadJsonValue resolver', () => {
+    it('should extract nested values from JSON objects', async () => {
+      const testJson = {
+        txs: {
+          to: '0x596aF90CecdBF9A768886E771178fd5561dD27Ab',
+          data: '0x1234'
+        }
+      }
+
+      const value: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: testJson,
+          path: 'txs.data'
+        }
+      }
+
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0x1234')
+    })
+
+    it('should extract nested address values', async () => {
+      const testJson = {
+        txs: {
+          to: '0x596aF90CecdBF9A768886E771178fd5561dD27Ab',
+          data: '0x1234'
+        }
+      }
+
+      const value: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: testJson,
+          path: 'txs.to'
+        }
+      }
+
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0x596aF90CecdBF9A768886E771178fd5561dD27Ab')
+    })
+
+    it('should handle array access', async () => {
+      const testJson = {
+        transactions: [
+          { hash: '0xabc123', value: '1000' },
+          { hash: '0xdef456', value: '2000' }
+        ]
+      }
+
+      const value: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: testJson,
+          path: 'transactions.1.hash'
+        }
+      }
+
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0xdef456')
+    })
+
+    it('should handle deeply nested objects', async () => {
+      const testJson = {
+        response: {
+          data: {
+            blockchain: {
+              ethereum: {
+                contracts: {
+                  token: {
+                    address: '0x123456789',
+                    symbol: 'TEST'
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      const value: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: testJson,
+          path: 'response.data.blockchain.ethereum.contracts.token.symbol'
+        }
+      }
+
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('TEST')
+    })
+
+    it('should return entire object when path is empty', async () => {
+      const testJson = { name: 'test', value: 42 }
+
+      const value: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: testJson,
+          path: ''
+        }
+      }
+
+      const result = await resolver.resolve(value, context)
+      expect(result).toEqual(testJson)
+    })
+
+    it('should throw error for invalid paths', async () => {
+      const testJson = { name: 'test' }
+
+      const value: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: testJson,
+          path: 'nonexistent.field'
+        }
+      }
+
+      await expect(resolver.resolve(value, context)).rejects.toThrow(
+        'read-json: Failed to access path "nonexistent.field"'
+      )
+    })
+
+    it('should handle null and undefined values gracefully', async () => {
+      const testJson = {
+        data: {
+          value: null,
+          missing: undefined
+        }
+      }
+
+      const nullValue: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: testJson,
+          path: 'data.value'
+        }
+      }
+
+      const result = await resolver.resolve(nullValue, context)
+      expect(result).toBeNull()
+    })
+
+    it('should work with template variables', async () => {
+      // Mock context to return a JSON object when resolving a template variable
+      const mockJson = {
+        api: {
+          response: {
+            status: 'success',
+            data: '0xabcdef'
+          }
+        }
+      }
+
+      // Mock the resolver to handle template variable resolution
+      const originalResolve = resolver.resolve.bind(resolver)
+      jest.spyOn(resolver, 'resolve').mockImplementation(async (value, ctx, scope) => {
+        if (value === '{{apiResponse}}') {
+          return mockJson
+        }
+        if (value === '{{extractPath}}') {
+          return 'api.response.data'
+        }
+        return originalResolve(value, ctx, scope)
+      })
+
+      const value: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: '{{apiResponse}}',
+          path: '{{extractPath}}'
+        }
+      }
+
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0xabcdef')
+    })
+  })
+
+  describe('JsonRequestAction integration', () => {
+    it('should handle json-request action type validation', () => {
+      const action: Action = {
+        type: 'json-request',
+        name: 'test-request',
+        arguments: {
+          url: 'https://api.example.com/data',
+          method: 'GET'
+        }
+      }
+
+      expect(action.type).toBe('json-request')
+      expect(action.arguments.url).toBe('https://api.example.com/data')
+      expect(action.arguments.method).toBe('GET')
+    })
+
+    it('should validate required url parameter', async () => {
+      const action: Action = {
+        type: 'json-request',
+        name: 'test-request',
+        arguments: {
+          url: null as any
+        }
+      }
+
+      // Mock the engine's executePrimitive method to test validation
+      const mockEngine = {
+        resolver: {
+          resolve: jest.fn().mockResolvedValue(null)
+        }
+      }
+
+      // The engine should validate that url is a string
+      expect(mockEngine.resolver.resolve).toBeDefined()
+    })
+  })
+
+  describe('End-to-end workflow simulation', () => {
+    it('should simulate the Guard API example workflow', async () => {
+      // Simulate the API response from Guard
+      const mockApiResponse = {
+        txs: {
+          to: '0x596aF90CecdBF9A768886E771178fd5561dD27Ab',
+          data: '0x1234'
+        }
+      }
+
+      // Step 1: Simulate storing the API response in context
+      context.setOutput('guard-patch-request.response', mockApiResponse)
+
+      // Step 2: Extract the data using read-json
+      const extractDataValue: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: mockApiResponse,
+          path: 'txs.data'
+        }
+      }
+
+      const extractedData = await resolver.resolve(extractDataValue, context)
+      expect(extractedData).toBe('0x1234')
+
+      // Step 3: Extract the to address using read-json
+      const extractToValue: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: mockApiResponse,
+          path: 'txs.to'
+        }
+      }
+
+      const extractedTo = await resolver.resolve(extractToValue, context)
+      expect(extractedTo).toBe('0x596aF90CecdBF9A768886E771178fd5561dD27Ab')
+
+      // Verify both values are correctly extracted
+      expect(extractedData).toBe('0x1234')
+      expect(extractedTo).toBe('0x596aF90CecdBF9A768886E771178fd5561dD27Ab')
+    })
+
+    it('should handle complex nested API responses', async () => {
+      const complexApiResponse = {
+        status: 'success',
+        data: {
+          blockchain: 'ethereum',
+          network: 'mainnet',
+          transactions: [
+            {
+              hash: '0xabc123',
+              to: '0x111111',
+              data: '0xfirst'
+            },
+            {
+              hash: '0xdef456',
+              to: '0x222222',
+              data: '0xsecond'
+            }
+          ],
+          metadata: {
+            timestamp: 1234567890,
+            source: 'guard-api'
+          }
+        }
+      }
+
+      // Extract various nested values
+      const statusValue: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: complexApiResponse,
+          path: 'status'
+        }
+      }
+
+      const firstTxData: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: complexApiResponse,
+          path: 'data.transactions.0.data'
+        }
+      }
+
+      const secondTxTo: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: complexApiResponse,
+          path: 'data.transactions.1.to'
+        }
+      }
+
+      const timestamp: ReadJsonValue = {
+        type: 'read-json',
+        arguments: {
+          json: complexApiResponse,
+          path: 'data.metadata.timestamp'
+        }
+      }
+
+      // Test all extractions
+      expect(await resolver.resolve(statusValue, context)).toBe('success')
+      expect(await resolver.resolve(firstTxData, context)).toBe('0xfirst')
+      expect(await resolver.resolve(secondTxTo, context)).toBe('0x222222')
+      expect(await resolver.resolve(timestamp, context)).toBe(1234567890)
+    })
+  })
+})