@0xsequence/catapult 1.3.6 → 1.3.8

package/dist/lib/__tests__/deployer.spec.js

@@ -950,5 +950,577 @@ describe('Deployer', () => {
             }));
         });
     });
+    describe('job dependency failure handling', () => {
+        const TEST_BYTECODES = {
+            SIMPLE_CONTRACT: '0x6080604052348015600e575f5ffd5b5060c180601a5f395ff3fe6080604052348015600e575f5ffd5b50600436106030575f3560e01c806390c52443146034578063d09de08a14604d575b5f5ffd5b603b5f5481565b60405190815260200160405180910390f35b60536055565b005b5f805490806061836068565b9190505550565b5f60018201608457634e487b7160e01b5f52601160045260245ffd5b506001019056fea264697066735822122061c8cc43c72d6b23b16f7a7337dd15b93d71eb94a9d5247911e39f486e1f94f964736f6c634300081e0033',
+            BROKEN_BYTECODE: '0xff'
+        };
+        it('should fail job B when job A fails due to dependency failure', async () => {
+            const jobA = {
+                name: 'job-a',
+                version: '1',
+                description: 'Deploy a contract with broken bytecode (will fail)',
+                actions: [
+                    {
+                        name: 'failing-deploy',
+                        type: 'create-contract',
+                        arguments: {
+                            bytecode: TEST_BYTECODES.BROKEN_BYTECODE,
+                            value: '0'
+                        },
+                        output: true
+                    }
+                ]
+            };
+            const jobB = {
+                name: 'job-b',
+                version: '1',
+                description: 'Use output from failed job A',
+                depends_on: ['job-a'],
+                actions: [
+                    {
+                        name: 'use-failed-output',
+                        type: 'send-transaction',
+                        arguments: {
+                            to: '{{job-a.failing-deploy.address}}',
+                            data: '0x',
+                            value: '0'
+                        }
+                    }
+                ]
+            };
+            const mockJobs = new Map();
+            mockJobs.set('job-a', jobA);
+            mockJobs.set('job-b', jobB);
+            const mockTemplates = new Map();
+            MockProjectLoader.mockImplementation(() => ({
+                load: jest.fn().mockResolvedValue(undefined),
+                jobs: mockJobs,
+                templates: mockTemplates
+            }));
+            MockDependencyGraph.mockImplementation(() => ({
+                getExecutionOrder: jest.fn().mockReturnValue(['job-a', 'job-b']),
+                getDependencies: jest.fn().mockReturnValue(new Set())
+            }));
+            MockExecutionEngine.mockImplementation(() => ({
+                executeJob: jest.fn().mockImplementation(async (job) => {
+                    if (job.name === 'job-a') {
+                        throw new Error('Contract deployment failed: invalid bytecode');
+                    }
+                })
+            }));
+            MockExecutionContext.mockImplementation(() => ({
+                dispose: jest.fn().mockResolvedValue(undefined),
+                getNetwork: jest.fn().mockReturnValue(mockNetwork1)
+            }));
+            const deployer = new deployer_1.Deployer(deployerOptions);
+            await expect(deployer.run()).rejects.toThrow('One or more jobs failed during execution');
+            const results = deployer.results;
+            const jobAResult = results.get('job-a');
+            expect(jobAResult).toBeDefined();
+            expect(jobAResult.outputs.get(mockNetwork1.chainId).status).toBe('error');
+            const jobBResult = results.get('job-b');
+            expect(jobBResult).toBeDefined();
+            const jobBError = jobBResult.outputs.get(mockNetwork1.chainId);
+            expect(jobBError.status).toBe('error');
+            expect(jobBError.data).toContain('depends on "job-a", but "job-a" failed');
+        });
+        it('should fail job B when referencing non-existent job outputs', async () => {
+            const jobB = {
+                name: 'job-b',
+                version: '1',
+                description: 'Reference non-existent job outputs',
+                actions: [
+                    {
+                        name: 'use-output-step',
+                        type: 'send-transaction',
+                        arguments: {
+                            to: '{{non-existent-job.deploy-step.address}}',
+                            data: '0x',
+                            value: '0'
+                        }
+                    }
+                ]
+            };
+            const mockJobs = new Map();
+            mockJobs.set('job-b', jobB);
+            const mockTemplates = new Map();
+            MockProjectLoader.mockImplementation(() => ({
+                load: jest.fn().mockResolvedValue(undefined),
+                jobs: mockJobs,
+                templates: mockTemplates
+            }));
+            MockDependencyGraph.mockImplementation(() => ({
+                getExecutionOrder: jest.fn().mockReturnValue(['job-b']),
+                getDependencies: jest.fn().mockReturnValue(new Set())
+            }));
+            MockExecutionEngine.mockImplementation(() => ({
+                executeJob: jest.fn().mockRejectedValue(new Error('Output for key "non-existent-job.deploy-step.address" not found in context'))
+            }));
+            MockExecutionContext.mockImplementation(() => ({
+                dispose: jest.fn().mockResolvedValue(undefined),
+                getNetwork: jest.fn().mockReturnValue(mockNetwork1)
+            }));
+            const deployer = new deployer_1.Deployer(deployerOptions);
+            await expect(deployer.run()).rejects.toThrow('One or more jobs failed during execution');
+            const results = deployer.results;
+            const jobBResult = results.get('job-b');
+            expect(jobBResult).toBeDefined();
+            expect(jobBResult.outputs.get(mockNetwork1.chainId).status).toBe('error');
+        });
+        it('should handle job B with no dependency on job A but references job A outputs', async () => {
+            const jobA = {
+                name: 'job-a',
+                version: '1',
+                description: 'Deploy a contract successfully',
+                actions: [
+                    {
+                        name: 'deploy-step',
+                        type: 'create-contract',
+                        arguments: {
+                            bytecode: TEST_BYTECODES.SIMPLE_CONTRACT,
+                            value: '0'
+                        },
+                        output: true
+                    }
+                ]
+            };
+            const jobB = {
+                name: 'job-b',
+                version: '1',
+                description: 'Reference job A outputs without explicit dependency',
+                actions: [
+                    {
+                        name: 'use-output-step',
+                        type: 'send-transaction',
+                        arguments: {
+                            to: '{{job-a.deploy-step.address}}',
+                            data: '0x',
+                            value: '0'
+                        }
+                    }
+                ]
+            };
+            const mockJobs = new Map();
+            mockJobs.set('job-a', jobA);
+            mockJobs.set('job-b', jobB);
+            const mockTemplates = new Map();
+            MockProjectLoader.mockImplementation(() => ({
+                load: jest.fn().mockResolvedValue(undefined),
+                jobs: mockJobs,
+                templates: mockTemplates
+            }));
+            MockDependencyGraph.mockImplementation(() => ({
+                getExecutionOrder: jest.fn().mockReturnValue(['job-a', 'job-b']),
+                getDependencies: jest.fn().mockReturnValue(new Set())
+            }));
+            MockExecutionEngine.mockImplementation(() => ({
+                executeJob: jest.fn().mockImplementation(async (job) => {
+                    if (job.name === 'job-a') {
+                        return Promise.resolve();
+                    }
+                    else if (job.name === 'job-b') {
+                        return Promise.resolve();
+                    }
+                })
+            }));
+            MockExecutionContext.mockImplementation(() => ({
+                dispose: jest.fn().mockResolvedValue(undefined),
+                getNetwork: jest.fn().mockReturnValue(mockNetwork1),
+                getOutputs: jest.fn().mockReturnValue(new Map([
+                    ['deploy-step.address', '0x5FbDB2315678afecb367f032d93F642f64180aa3'],
+                    ['deploy-step.hash', '0xmockdeployhash123']
+                ]))
+            }));
+            const deployer = new deployer_1.Deployer(deployerOptions);
+            await expect(deployer.run()).resolves.not.toThrow();
+            const results = deployer.results;
+            const jobAResult = results.get('job-a');
+            const jobBResult = results.get('job-b');
+            expect(jobAResult).toBeDefined();
+            expect(jobAResult.outputs.get(mockNetwork1.chainId).status).toBe('success');
+            expect(jobBResult).toBeDefined();
+            expect(jobBResult.outputs.get(mockNetwork1.chainId).status).toBe('success');
+        });
+        it('should allow job B to run when job A is skipped', async () => {
+            const jobA = {
+                name: 'job-a',
+                version: '1',
+                description: 'Job A that will be skipped',
+                skip_condition: [true],
+                actions: [
+                    {
+                        name: 'deploy-step',
+                        type: 'create-contract',
+                        arguments: {
+                            bytecode: TEST_BYTECODES.SIMPLE_CONTRACT,
+                            value: '0'
+                        },
+                        output: true
+                    }
+                ]
+            };
+            const jobB = {
+                name: 'job-b',
+                version: '1',
+                description: 'Job B that should run even if job A is skipped',
+                depends_on: ['job-a'],
+                actions: [
+                    {
+                        name: 'independent-action',
+                        type: 'send-transaction',
+                        arguments: {
+                            to: '0x1234567890123456789012345678901234567890',
+                            data: '0x',
+                            value: '0'
+                        }
+                    }
+                ]
+            };
+            const mockJobs = new Map();
+            mockJobs.set('job-a', jobA);
+            mockJobs.set('job-b', jobB);
+            const mockTemplates = new Map();
+            MockProjectLoader.mockImplementation(() => ({
+                load: jest.fn().mockResolvedValue(undefined),
+                jobs: mockJobs,
+                templates: mockTemplates
+            }));
+            MockDependencyGraph.mockImplementation(() => ({
+                getExecutionOrder: jest.fn().mockReturnValue(['job-a', 'job-b']),
+                getDependencies: jest.fn().mockReturnValue(new Set())
+            }));
+            MockExecutionEngine.mockImplementation(() => ({
+                executeJob: jest.fn().mockImplementation(async (job) => {
+                    if (job.name === 'job-a') {
+                        throw new Error('Job "job-a" skipped due to skip condition');
+                    }
+                    else if (job.name === 'job-b') {
+                        return Promise.resolve();
+                    }
+                }),
+                evaluateSkipConditions: jest.fn().mockImplementation(async (conditions, context, scope) => {
+                    return conditions && conditions.length > 0 && conditions[0] === true;
+                })
+            }));
+            MockExecutionContext.mockImplementation(() => ({
+                dispose: jest.fn().mockResolvedValue(undefined),
+                getNetwork: jest.fn().mockReturnValue(mockNetwork1),
+                getOutputs: jest.fn().mockReturnValue(new Map([
+                    ['independent-action.hash', '0xmocktransactionhash']
+                ]))
+            }));
+            const deployer = new deployer_1.Deployer(deployerOptions);
+            await expect(deployer.run()).resolves.not.toThrow();
+            const results = deployer.results;
+            const jobAResult = results.get('job-a');
+            expect(jobAResult).toBeDefined();
+            expect(jobAResult.outputs.get(mockNetwork1.chainId).status).toBe('skipped');
+            expect(jobAResult.outputs.get(mockNetwork1.chainId).data).toContain('skipped due to skip condition');
+            const jobBResult = results.get('job-b');
+            expect(jobBResult).toBeDefined();
+            expect(jobBResult.outputs.get(mockNetwork1.chainId).status).toBe('success');
+        });
+        it('should fail job B when job A fails, even with complex output references', async () => {
+            const jobA = {
+                name: 'job-a',
+                version: '1',
+                description: 'Deploy a contract with broken bytecode (will fail)',
+                actions: [
+                    {
+                        name: 'failing-deploy',
+                        type: 'create-contract',
+                        arguments: {
+                            bytecode: TEST_BYTECODES.BROKEN_BYTECODE,
+                            value: '0'
+                        },
+                        output: true
+                    }
+                ]
+            };
+            const jobB = {
+                name: 'job-b',
+                version: '1',
+                description: 'Use multiple outputs from failed job A',
+                depends_on: ['job-a'],
+                actions: [
+                    {
+                        name: 'use-multiple-outputs',
+                        type: 'send-transaction',
+                        arguments: {
+                            to: '{{job-a.failing-deploy.address}}',
+                            data: '0x',
+                            value: '0'
+                        }
+                    }
+                ]
+            };
+            const mockJobs = new Map();
+            mockJobs.set('job-a', jobA);
+            mockJobs.set('job-b', jobB);
+            const mockTemplates = new Map();
+            MockProjectLoader.mockImplementation(() => ({
+                load: jest.fn().mockResolvedValue(undefined),
+                jobs: mockJobs,
+                templates: mockTemplates
+            }));
+            MockDependencyGraph.mockImplementation(() => ({
+                getExecutionOrder: jest.fn().mockReturnValue(['job-a', 'job-b']),
+                getDependencies: jest.fn().mockReturnValue(new Set())
+            }));
+            MockExecutionEngine.mockImplementation(() => ({
+                executeJob: jest.fn().mockImplementation(async (job) => {
+                    if (job.name === 'job-a') {
+                        throw new Error('Contract deployment failed: invalid bytecode');
+                    }
+                })
+            }));
+            MockExecutionContext.mockImplementation(() => ({
+                dispose: jest.fn().mockResolvedValue(undefined),
+                getNetwork: jest.fn().mockReturnValue(mockNetwork1)
+            }));
+            const deployer = new deployer_1.Deployer(deployerOptions);
+            await expect(deployer.run()).rejects.toThrow('One or more jobs failed during execution');
+            const results = deployer.results;
+            const jobAResult = results.get('job-a');
+            expect(jobAResult).toBeDefined();
+            expect(jobAResult.outputs.get(mockNetwork1.chainId).status).toBe('error');
+            const jobBResult = results.get('job-b');
+            expect(jobBResult).toBeDefined();
+            const jobBError = jobBResult.outputs.get(mockNetwork1.chainId);
+            expect(jobBError.status).toBe('error');
+            expect(jobBError.data).toContain('depends on "job-a", but "job-a" failed');
+        });
+    });
+    describe('run summary functionality', () => {
+        let mockEventEmitter;
+        let deployer;
+        beforeEach(() => {
+            mockEventEmitter = {
+                emitEvent: jest.fn()
+            };
+            deployer = new deployer_1.Deployer({
+                ...deployerOptions,
+                eventEmitter: mockEventEmitter
+            });
+        });
+        it('should emit run summary with success counts when all jobs succeed', () => {
+            const mockResults = new Map();
+            mockResults.set('job1', {
+                job: mockJob1,
+                outputs: new Map([
+                    [1, { status: 'success', data: new Map([['action1.hash', '0xhash1'], ['action1.address', '0x1234567890123456789012345678901234567890']]) }],
+                    [137, { status: 'success', data: new Map([['action1.hash', '0xhash1'], ['action1.address', '0x1234567890123456789012345678901234567890']]) }]
+                ])
+            });
+            mockResults.set('job2', {
+                job: mockJob2,
+                outputs: new Map([
+                    [1, { status: 'success', data: new Map([['action2.hash', '0xhash2'], ['action2.address', '0x9876543210987654321098765432109876543210']]) }],
+                    [137, { status: 'success', data: new Map([['action2.hash', '0xhash2'], ['action2.address', '0x9876543210987654321098765432109876543210']]) }]
+                ])
+            });
+            mockResults.set('job3', {
+                job: mockJob3,
+                outputs: new Map([
+                    [1, { status: 'success', data: new Map([['action3.hash', '0xhash3']]) }]
+                ])
+            });
+            deployer.results = mockResults;
+            deployer.emitRunSummary(false);
+            expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'run_summary',
+                level: 'info',
+                data: expect.objectContaining({
+                    networkCount: 2,
+                    jobCount: 3,
+                    successCount: 5,
+                    failedCount: 0,
+                    skippedCount: 0,
+                    keyContracts: expect.arrayContaining([
+                        { job: 'job1', action: 'action1', address: '0x1234567890123456789012345678901234567890' },
+                        { job: 'job2', action: 'action2', address: '0x9876543210987654321098765432109876543210' }
+                    ])
+                })
+            }));
+        });
+        it('should emit run summary with failure counts when some jobs fail', () => {
+            const mockResults = new Map();
+            mockResults.set('job1', {
+                job: mockJob1,
+                outputs: new Map([
+                    [1, { status: 'error', data: 'Job1 failed' }],
+                    [137, { status: 'error', data: 'Job1 failed' }]
+                ])
+            });
+            mockResults.set('job2', {
+                job: mockJob2,
+                outputs: new Map([
+                    [1, { status: 'success', data: new Map([['action2.hash', '0xhash2'], ['action2.address', '0x9876543210987654321098765432109876543210']]) }],
+                    [137, { status: 'success', data: new Map([['action2.hash', '0xhash2'], ['action2.address', '0x9876543210987654321098765432109876543210']]) }]
+                ])
+            });
+            mockResults.set('job3', {
+                job: mockJob3,
+                outputs: new Map([
+                    [1, { status: 'success', data: new Map([['action3.hash', '0xhash3']]) }]
+                ])
+            });
+            deployer.results = mockResults;
+            deployer.emitRunSummary(true);
+            expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'run_summary',
+                level: 'warn',
+                data: expect.objectContaining({
+                    networkCount: 2,
+                    jobCount: 3,
+                    successCount: 3,
+                    failedCount: 2,
+                    skippedCount: 0,
+                    keyContracts: expect.arrayContaining([
+                        { job: 'job2', action: 'action2', address: '0x9876543210987654321098765432109876543210' }
+                    ])
+                })
+            }));
+        });
+        it('should emit run summary with skipped counts when jobs are skipped', () => {
+            const mockResults = new Map();
+            mockResults.set('job1', {
+                job: mockJob1,
+                outputs: new Map([
+                    [1, { status: 'skipped', data: 'Job skipped due to network filter' }],
+                    [137, { status: 'skipped', data: 'Job skipped due to network filter' }]
+                ])
+            });
+            deployer.results = mockResults;
+            deployer.emitRunSummary(false);
+            expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'run_summary',
+                level: 'info',
+                data: expect.objectContaining({
+                    networkCount: 2,
+                    jobCount: 1,
+                    successCount: 0,
+                    failedCount: 0,
+                    skippedCount: 2,
+                    keyContracts: []
+                })
+            }));
+        });
+        it('should limit key contracts to 10 entries', () => {
+            const manyContractsJob = {
+                name: 'many-contracts-job',
+                version: '1.0.0',
+                actions: Array.from({ length: 15 }, (_, i) => ({
+                    name: `action${i}`,
+                    template: 'template1',
+                    arguments: {}
+                }))
+            };
+            const mockResults = new Map();
+            const manyOutputs = new Map();
+            for (let i = 0; i < 15; i++) {
+                manyOutputs.set(`action${i}.address`, `0x${i.toString().padStart(40, '0')}`);
+                manyOutputs.set(`action${i}.hash`, `0xhash${i}`);
+            }
+            mockResults.set('many-contracts-job', {
+                job: manyContractsJob,
+                outputs: new Map([
+                    [1, { status: 'success', data: manyOutputs }]
+                ])
+            });
+            deployer.results = mockResults;
+            deployer.emitRunSummary(false);
+            expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'run_summary',
+                data: expect.objectContaining({
+                    keyContracts: expect.arrayContaining([
+                        { job: 'many-contracts-job', action: 'action0', address: '0x0000000000000000000000000000000000000000' },
+                        { job: 'many-contracts-job', action: 'action1', address: '0x0000000000000000000000000000000000000001' },
+                        { job: 'many-contracts-job', action: 'action9', address: '0x0000000000000000000000000000000000000009' }
+                    ])
+                })
+            }));
+            const summaryCall = mockEventEmitter.emitEvent.mock.calls.find((call) => call[0].type === 'run_summary');
+            expect(summaryCall[0].data.keyContracts).toHaveLength(10);
+        });
+        it('should not emit run summary when showSummary is false', () => {
+            const deployerWithoutSummary = new deployer_1.Deployer({
+                ...deployerOptions,
+                eventEmitter: mockEventEmitter,
+                showSummary: false
+            });
+            expect(deployerWithoutSummary.showSummary).toBe(false);
+            const mockResults = new Map();
+            mockResults.set('job1', {
+                job: mockJob1,
+                outputs: new Map([
+                    [1, { status: 'success', data: new Map([['action1.hash', '0xhash1']]) }]
+                ])
+            });
+            deployerWithoutSummary.results = mockResults;
+            deployerWithoutSummary.emitRunSummary(false);
+            expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'run_summary'
+            }));
+        });
+        it('should emit run summary with mixed success/failure/skipped counts', () => {
+            const mockResults = new Map();
+            mockResults.set('success-job', {
+                job: { name: 'success-job', version: '1.0.0', actions: [{ name: 'success-action', template: 'template1', arguments: {} }] },
+                outputs: new Map([
+                    [1, { status: 'success', data: new Map([['success-action.hash', '0xsuccess'], ['success-action.address', '0x1234567890123456789012345678901234567890']]) }],
+                    [137, { status: 'success', data: new Map([['success-action.hash', '0xsuccess'], ['success-action.address', '0x1234567890123456789012345678901234567890']]) }]
+                ])
+            });
+            mockResults.set('fail-job', {
+                job: { name: 'fail-job', version: '1.0.0', actions: [{ name: 'fail-action', template: 'template1', arguments: {} }] },
+                outputs: new Map([
+                    [1, { status: 'error', data: 'Fail job failed' }],
+                    [137, { status: 'error', data: 'Fail job failed' }]
+                ])
+            });
+            mockResults.set('skipped-job', {
+                job: { name: 'skipped-job', version: '1.0.0', actions: [{ name: 'skipped-action', template: 'template1', arguments: {} }] },
+                outputs: new Map([
+                    [1, { status: 'skipped', data: 'Job skipped' }],
+                    [137, { status: 'skipped', data: 'Job skipped' }]
+                ])
+            });
+            deployer.results = mockResults;
+            deployer.emitRunSummary(true);
+            expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'run_summary',
+                level: 'warn',
+                data: expect.objectContaining({
+                    networkCount: 2,
+                    jobCount: 3,
+                    successCount: 2,
+                    failedCount: 2,
+                    skippedCount: 2,
+                    keyContracts: expect.arrayContaining([
+                        { job: 'success-job', action: 'success-action', address: '0x1234567890123456789012345678901234567890' }
+                    ])
+                })
+            }));
+        });
+        it('should handle empty results gracefully', () => {
+            ;
+            deployer.results = new Map();
+            deployer.emitRunSummary(false);
+            expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'run_summary',
+                level: 'info',
+                data: expect.objectContaining({
+                    networkCount: 2,
+                    jobCount: 0,
+                    successCount: 0,
+                    failedCount: 0,
+                    skippedCount: 0,
+                    keyContracts: []
+                })
+            }));
+        });
+    });
 });
 //# sourceMappingURL=deployer.spec.js.map