@0xsequence/catapult 1.4.0 → 1.5.0

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

@@ -1,125 +0,0 @@
-// 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

@@ -1,425 +0,0 @@
-import { ExecutionEngine } from '../engine'
-import { ExecutionContext } from '../context'
-import { ValueResolver } from '../resolver'
-import { ContractRepository } from '../../contracts/repository'
-import { Action, Network, ReadJsonValue, SliceBytesValue } 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, { 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')
-    })
-
-    it('should allow numeric network chain IDs to index top-level maps', async () => {
-      const value: ReadJsonValue = {
-        type: 'read-json',
-        arguments: {
-          json: {
-            999: {
-              executeCalldata: '0xfeedface'
-            }
-          },
-          path: '{{Network().chainId}}'
-        }
-      }
-
-      const result = await resolver.resolve(value, context)
-      expect(result).toEqual({ executeCalldata: '0xfeedface' })
-    })
-
-    it('should let value-empty detect missing top-level map entries', async () => {
-      const value = {
-        type: 'value-empty',
-        arguments: {
-          value: {
-            type: 'read-json',
-            arguments: {
-              json: {
-                999: {
-                  executeCalldata: '0xfeedface'
-                }
-              },
-              path: '{{missingChainId}}'
-            }
-          }
-        }
-      } as const
-
-      const scope = new Map<string, any>([['missingChainId', 10]])
-      const result = await resolver.resolve(value, context, scope)
-      expect(result).toBe(true)
-    })
-  })
-
-  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 allow piping read-json output into slice-bytes', async () => {
-      const response = {
-        txs: {
-          data: '0xaabbccddff'
-        }
-      }
-
-      const value: SliceBytesValue = {
-        type: 'slice-bytes',
-        arguments: {
-          value: {
-            type: 'read-json',
-            arguments: {
-              json: response,
-              path: 'txs.data'
-            }
-          },
-          range: ':-1'
-        }
-      }
-
-      const trimmed = await resolver.resolve(value, context)
-      expect(trimmed).toBe('0xaabbccdd')
-    })
-
-    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)
-    })
-  })
-})