@0xsequence/catapult 1.3.16 → 1.4.0

package/src/lib/core/__tests__/assert-action.spec.ts

@@ -0,0 +1,474 @@
+import { ExecutionEngine } from '../engine'
+import { ExecutionContext } from '../context'
+import { ContractRepository } from '../../contracts/repository'
+import { Action, Network } from '../../types'
+import { VerificationPlatformRegistry } from '../../verification/etherscan'
+
+describe('Assert Action', () => {
+  let engine: ExecutionEngine
+  let context: ExecutionContext
+  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()
+    } as any
+
+    templates = new Map()
+    const verificationRegistry = new VerificationPlatformRegistry()
+    engine = new ExecutionEngine(templates, { verificationRegistry })
+  })
+
+  describe('assert primitive action', () => {
+    it('should pass when eq comparison is true', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-eq',
+        arguments: {
+          actual: '42',
+          eq: '42'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-eq.actual', '42')
+    })
+
+    it('should fail when eq comparison is false', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-fail',
+        arguments: {
+          actual: '42',
+          eq: '99'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed.*actual=42.*expected=99.*op=eq/)
+    })
+
+    it('should include custom message on failure', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-msg',
+        arguments: {
+          actual: '10',
+          eq: '20',
+          message: 'balance mismatch'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed: balance mismatch.*actual=10.*expected=20.*op=eq/)
+    })
+
+    it('should pass neq comparison', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-neq',
+        arguments: {
+          actual: '10',
+          neq: '20'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-neq.actual', '10')
+    })
+
+    it('should fail neq comparison when values are equal', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-neq-fail',
+        arguments: {
+          actual: '10',
+          neq: '10'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed.*op=neq/)
+    })
+
+    it('should pass gte comparison', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-gte',
+        arguments: {
+          actual: '100',
+          gte: '50'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-gte.actual', '100')
+    })
+
+    it('should pass gte when equal', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-gte-equal',
+        arguments: {
+          actual: '50',
+          gte: '50'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+    })
+
+    it('should fail gte when less', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-gte-fail',
+        arguments: {
+          actual: '10',
+          gte: '100'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed.*op=gte/)
+    })
+
+    it('should pass lt comparison', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-lt',
+        arguments: {
+          actual: '10',
+          lt: '100'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+    })
+
+    it('should fail lt when greater', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-lt-fail',
+        arguments: {
+          actual: '100',
+          lt: '10'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed.*op=lt/)
+    })
+
+    it('should pass lte comparison', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-lte',
+        arguments: {
+          actual: '10',
+          lte: '100'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+    })
+
+    it('should pass lte when equal', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-lte-equal',
+        arguments: {
+          actual: '100',
+          lte: '100'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+    })
+
+    it('should fail lte when greater', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-lte-fail',
+        arguments: {
+          actual: '100',
+          lte: '10'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed.*op=lte/)
+    })
+
+    it('should pass gt comparison', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-gt',
+        arguments: {
+          actual: '100',
+          gt: '10'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+    })
+
+    it('should fail gt when less', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-gt-fail',
+        arguments: {
+          actual: '10',
+          gt: '100'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed.*op=gt/)
+    })
+
+    it('should use `to` + `signature` form (call resolver)', async () => {
+      // Mock the resolver to simulate a call returning a value
+      const mockResolver = {
+        resolve: jest.fn(async (value: any, ctx: any, scope: any) => {
+          if (value.type === 'call') {
+            return '0xDepositManagerAddress'
+          }
+          if (value.type === 'basic-arithmetic') {
+            const [a, b] = value.arguments.values
+            if (value.arguments.operation === 'eq') {
+              return a === b
+            }
+          }
+          return value
+        })
+      }
+      ;(engine as any).resolver = mockResolver
+
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-call',
+        arguments: {
+          to: '0xSomeProxyAddress',
+          signature: 'depositManager() returns (address)',
+          eq: '0xDepositManagerAddress'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(mockResolver.resolve).toHaveBeenCalledWith(
+        { type: 'call', arguments: { to: '0xSomeProxyAddress', signature: 'depositManager() returns (address)', values: [] } },
+        context,
+        new Map()
+      )
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-call.actual', '0xDepositManagerAddress')
+    })
+
+    it('should use `actual` form with read-balance resolver', async () => {
+      // Mock the resolver to simulate a read-balance returning a value
+      const mockResolver = {
+        resolve: jest.fn(async (value: any, ctx: any, scope: any) => {
+          if (value.type === 'read-balance') {
+            return '1000000000000000000' // 1 ETH
+          }
+          if (value.type === 'basic-arithmetic') {
+            const [a, b] = value.arguments.values
+            if (value.arguments.operation === 'gte') {
+              return BigInt(a) >= BigInt(b)
+            }
+          }
+          return value
+        })
+      }
+      ;(engine as any).resolver = mockResolver
+
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-read-balance',
+        arguments: {
+          actual: { type: 'read-balance', arguments: { address: '0xDeployer' } },
+          gte: '1000000000000000000',
+          message: 'deployer underfunded'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(mockResolver.resolve).toHaveBeenCalledWith(
+        { type: 'read-balance', arguments: { address: '0xDeployer' } },
+        context,
+        new Map()
+      )
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-read-balance.actual', '1000000000000000000')
+    })
+
+    it('should not store outputs when action has no name', async () => {
+      const action: Action = {
+        type: 'assert',
+        arguments: {
+          actual: '42',
+          eq: '42'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(context.setOutput).not.toHaveBeenCalled()
+    })
+
+    it('should not store outputs when action has custom output', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-custom',
+        arguments: {
+          actual: '42',
+          eq: '42'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map(), true)
+
+      // With hasCustomOutput=true, the .actual output should not be stored by the assert case
+      // (the custom output handling is done elsewhere in executeAction)
+      const setOutputCalls = (context.setOutput as jest.Mock).mock.calls
+      const actualOutputs = setOutputCalls.filter((c: any[]) => c[0].includes('.actual'))
+      expect(actualOutputs.length).toBe(0)
+    })
+
+    it('should fail when no comparator key is provided', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-no-comparator',
+        arguments: {
+          actual: '42'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert must have exactly one of/)
+    })
+
+    it('should fail when more than one comparator key is provided', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-multi-comparator',
+        arguments: {
+          actual: '42',
+          eq: '42',
+          gte: '1'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert must have exactly one comparator, but got: eq, gte/)
+    })
+
+    it('should resolve values from context variables', async () => {
+      // Mock the resolver to simulate template variable resolution
+      // returning the same value for both actual and expected
+      const mockResolver = {
+        resolve: jest.fn(async (value: any, ctx: any, scope: any) => {
+          if (typeof value === 'string' && value.startsWith('{{') && value.endsWith('}}')) {
+            return 'resolved-value'
+          }
+          if (value.type === 'basic-arithmetic') {
+            const [a, b] = value.arguments.values
+            if (value.arguments.operation === 'eq') {
+              return a === b
+            }
+          }
+          return value
+        })
+      }
+      ;(engine as any).resolver = mockResolver
+
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-context',
+        arguments: {
+          actual: '{{myValue}}',
+          eq: '{{myExpected}}'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      // Both {{myValue}} and {{myExpected}} resolve to 'resolved-value', so eq returns true
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-context.actual', 'resolved-value')
+    })
+
+    it('should handle boolean values in eq comparison', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-bool',
+        arguments: {
+          actual: true,
+          eq: true
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-bool.actual', true)
+    })
+
+    it('should handle large number comparisons', async () => {
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-large',
+        arguments: {
+          actual: '115792089237316195423570985008687907853269984665640564039457584007913129639935',
+          gte: '10000000000000000000000000000000000000000000000000000000000000000000000000000'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+      expect(context.setOutput).toHaveBeenCalledWith('test-assert-large.actual', '115792089237316195423570985008687907853269984665640564039457584007913129639935')
+    })
+
+    it('should describe call form as signature in error message', async () => {
+      const mockResolver = {
+        resolve: jest.fn(async (value: any, ctx: any, scope: any) => {
+          if (value.type === 'call') return 'wrong-address'
+          if (value.type === 'basic-arithmetic') return false
+          return value
+        })
+      }
+      ;(engine as any).resolver = mockResolver
+
+      const action: Action = {
+        type: 'assert',
+        name: 'test-assert-call-desc',
+        arguments: {
+          to: '0xProxy',
+          signature: 'getOwner() returns (address)',
+          eq: '0xCorrectOwner'
+        }
+      }
+
+      await expect(
+        (engine as any).executePrimitive(action, context, new Map())
+      ).rejects.toThrow(/assert failed.*getOwner\(\) returns \(address\)/)
+    })
+  })
+})

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

@@ -1886,4 +1886,120 @@ describe('ExecutionEngine', () => {
       )
     })
   })
+
+  describe('skip_if behavior', () => {
+    it('should NOT post-check skip_if after job execution', async () => {
+      // This is the key semantic difference: skip_if is ONLY a pre-skip gate
+      // The pre-skip check for skip_if happens in the deployer, not in executeJob
+      // So executeJob runs normally without any post-check for skip_if
+      const jobWithSkipIf: Job = {
+        name: 'skip-if-job',
+        version: '1.0.0',
+        skip_if: [
+          { type: 'basic-arithmetic', arguments: { operation: 'eq', values: ['{{should_skip}}', 1] } }
+        ],
+        actions: [
+          {
+            name: 'generate-payload',
+            type: 'static',
+            arguments: { value: 'payload-data' }
+          }
+        ]
+      }
+
+      // Set context so skip_if would evaluate to false if checked
+      context.setOutput('should_skip', 0)
+
+      // This should succeed because skip_if is NOT post-checked in executeJob
+      // The job has no skip_condition, so no post-check happens
+      await expect(engine.executeJob(jobWithSkipIf, context)).resolves.not.toThrow()
+
+      // Action should have been executed
+      expect(context.getOutput('generate-payload.value')).toBe('payload-data')
+    })
+
+    it('should post-check skip_condition but NOT skip_if', async () => {
+      // Job with skip_condition - should post-check and fail
+      const jobWithSkipCondition: Job = {
+        name: 'skip-condition-job',
+        version: '1.0.0',
+        skip_condition: [
+          { type: 'basic-arithmetic', arguments: { operation: 'eq', values: ['{{converged}}', 1] } }
+        ],
+        actions: [
+          {
+            name: 'do-work',
+            type: 'static',
+            arguments: { value: 'work-done' }
+          }
+        ]
+      }
+
+      // Pre-execution: skip_condition is false (0) -> job runs
+      context.setOutput('converged', 0)
+
+      // Post-execution: skip_condition is STILL false -> should FAIL
+      // The post-check re-evaluates skip_condition and throws if not true
+      await expect(engine.executeJob(jobWithSkipCondition, context)).rejects.toThrow('failed post-execution check')
+    })
+
+    it('should not post-check skip_if (only skip_condition is post-checked)', async () => {
+      // Job with only skip_if - no post-check should happen
+      const jobWithOnlySkipIf: Job = {
+        name: 'skip-if-only-job',
+        version: '1.0.0',
+        skip_if: [
+          { type: 'basic-arithmetic', arguments: { operation: 'eq', values: ['{{should_skip}}', 1] } }
+        ],
+        actions: [
+          {
+            name: 'generate-artifact',
+            type: 'static',
+            arguments: { value: 'artifact-data' }
+          }
+        ]
+      }
+
+      // Set context so skip_if would be true if checked post-execution
+      context.setOutput('should_skip', 1)
+
+      // But since skip_if is NOT post-checked (only skip_condition is),
+      // and the job has no skip_condition, no post-check happens
+      await expect(engine.executeJob(jobWithOnlySkipIf, context)).resolves.not.toThrow()
+
+      // Action should have been executed
+      expect(context.getOutput('generate-artifact.value')).toBe('artifact-data')
+    })
+
+    it('should post-check skip_condition when both skip_if and skip_condition are present', async () => {
+      // Job with BOTH skip_if and skip_condition
+      // skip_if is only pre-checked (in deployer)
+      // skip_condition is both pre-checked and post-checked
+      const jobWithBoth: Job = {
+        name: 'both-conditions-job',
+        version: '1.0.0',
+        skip_condition: [
+          { type: 'basic-arithmetic', arguments: { operation: 'eq', values: ['{{converged}}', 1] } }
+        ],
+        skip_if: [
+          { type: 'basic-arithmetic', arguments: { operation: 'eq', values: ['{{should_skip}}', 1] } }
+        ],
+        actions: [
+          {
+            name: 'do-work',
+            type: 'static',
+            arguments: { value: 'work-done' }
+          }
+        ]
+      }
+
+      // Pre-execution: both conditions are false -> job runs
+      context.setOutput('should_skip', 0)
+      context.setOutput('converged', 0)
+
+      // Post-execution: skip_condition is STILL false -> should FAIL
+      // skip_if is NOT post-checked
+      await expect(engine.executeJob(jobWithBoth, context)).rejects.toThrow('failed post-execution check')
+    })
+  })
 }) 

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

@@ -154,6 +154,39 @@ actions: []`
       expect(loader.jobs.size).toBe(1)
       expect(loader.jobs.has('valid-job')).toBe(true)
     })
+
+    it('should skip known non-job YAML documents under jobs without warning', async () => {
+      const jobsDir = path.join(tempDir, 'jobs')
+      const buildInfoDir = path.join(jobsDir, 'stack', 'build-info', 'rc-5')
+      await fs.mkdir(buildInfoDir, { recursive: true })
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+      const validJobYaml = `name: "valid-job"
+version: "1"
+actions: []`
+
+      await fs.writeFile(path.join(jobsDir, 'valid-job.yaml'), validJobYaml)
+      await fs.writeFile(path.join(buildInfoDir, 'source.yaml'), `
+type: source
+build_info: {}
+`)
+      await fs.writeFile(path.join(jobsDir, 'constants.yaml'), `
+type: constants
+constants:
+  value: 1
+`)
+
+      try {
+        const loader = new ProjectLoader(tempDir)
+        await loader.load()
+
+        expect(loader.jobs.size).toBe(1)
+        expect(loader.jobs.has('valid-job')).toBe(true)
+        expect(warnSpy).not.toHaveBeenCalled()
+      } finally {
+        warnSpy.mockRestore()
+      }
+    })
   })
 
   describe('template loading', () => {
@@ -331,4 +364,4 @@ actions:
       expect(job.description).toBe('Deploy a test contract')
     })
   })
-}) 
+})