@invarn/cibuild 2.9.5 → 2.9.7

package/dist/src/yaml/converter.test.js

@@ -1,548 +0,0 @@
-/**
- * Unit tests for YAML to PipelineDef conversion with warning system
- */
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
-import { convertYAMLToPipelineDef, YAMLConversionError } from './converter.js';
-import { clearRegistry, registerStep } from './steps/registry.js';
-import { ScriptStepExecutor } from './steps/script.js';
-import { CocoapodsInstallStepExecutor } from './steps/ios-deps.js';
-import { CachePullStepExecutor, CachePushStepExecutor } from './steps/cache.js';
-describe('convertYAMLToPipelineDef - Warning System', () => {
-    let mockConfig;
-    beforeEach(() => {
-        // Clear registry before each test
-        clearRegistry();
-        // Register steps used in tests
-        registerStep('script', new ScriptStepExecutor());
-        registerStep('cocoapods-install', new CocoapodsInstallStepExecutor());
-        // Mock config
-        mockConfig = {
-            artifactsDir: '/test/artifacts',
-            maxConcurrentJobs: 1,
-            paths: {
-                buildsDir: '/test/builds',
-                cacheDir: '/test/cache',
-                derivedDataDir: '/test/derived-data',
-            },
-            interpreters: {
-                bash: '/bin/bash',
-                python: 'python3',
-                ruby: 'ruby',
-                node: 'node',
-            },
-        };
-    });
-    afterEach(() => {
-        // Clean up registry
-        clearRegistry();
-    });
-    describe('Unsupported step handling', () => {
-        test('should collect warnings for unsupported steps', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'script@1.0.0': {
-                                    title: 'Valid step',
-                                    inputs: { content: 'echo "test"' },
-                                },
-                            },
-                            {
-                                'unsupported-step@1.0.0': {
-                                    title: 'This step does not exist',
-                                    inputs: {},
-                                },
-                            },
-                            {
-                                'another-unsupported@2.0.0': {
-                                    inputs: {},
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            // Should have warnings
-            expect(result.warnings).toBeDefined();
-            expect(result.warnings.length).toBe(2);
-            // Should include step names with versions
-            expect(result.warnings[0]).toContain('unsupported-step@1.0.0');
-            expect(result.warnings[1]).toContain('another-unsupported@2.0.0');
-            // Should have warning symbol
-            expect(result.warnings[0]).toContain('⚠️');
-            expect(result.warnings[1]).toContain('⚠️');
-            // Should indicate skipping
-            expect(result.warnings[0]).toContain('skipping');
-            expect(result.warnings[1]).toContain('skipping');
-            // Should track skipped steps count
-            expect(result.skippedSteps).toBe(2);
-            // Pipeline should only contain the valid step
-            expect(result.pipeline.steps.length).toBe(1);
-            expect(result.pipeline.steps[0].name).toBe('Valid step');
-        });
-        test('should handle unsupported step without version', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'unknown-step': {
-                                    title: 'No version specified',
-                                    inputs: {},
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            expect(result.warnings.length).toBe(1);
-            expect(result.warnings[0]).toContain('unknown-step');
-            expect(result.warnings[0]).not.toContain('@');
-            expect(result.skippedSteps).toBe(1);
-            expect(result.pipeline.steps.length).toBe(0);
-        });
-        test('should return empty warnings for fully supported pipeline', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'script@1.0.0': {
-                                    title: 'Step 1',
-                                    inputs: { content: 'echo "1"' },
-                                },
-                            },
-                            {
-                                'script@1.0.0': {
-                                    title: 'Step 2',
-                                    inputs: { content: 'echo "2"' },
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            expect(result.warnings).toBeDefined();
-            expect(result.warnings.length).toBe(0);
-            expect(result.skippedSteps).toBe(0);
-            expect(result.pipeline.steps.length).toBe(2);
-        });
-    });
-    describe('Step suggestions', () => {
-        test('should include suggestions for known unsupported steps', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'npm@1.0.0': {
-                                    title: 'NPM step',
-                                    inputs: { command: 'install' },
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            expect(result.warnings.length).toBe(1);
-            expect(result.warnings[0]).toContain('npm@1.0.0');
-            expect(result.warnings[0]).toContain('💡 Suggestion');
-            expect(result.warnings[0]).toContain('script step with npm commands');
-        });
-        test('should convert cocoapods-install as a supported step', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'cocoapods-install@2.0.0': {
-                                    inputs: {},
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            expect(result.warnings.length).toBe(0);
-            expect(result.skippedSteps).toBe(0);
-            expect(result.pipeline.steps.length).toBe(1);
-        });
-        test('should not include suggestions for unknown steps', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'completely-unknown-step@1.0.0': {
-                                    inputs: {},
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            expect(result.warnings.length).toBe(1);
-            expect(result.warnings[0]).toContain('completely-unknown-step@1.0.0');
-            expect(result.warnings[0]).not.toContain('💡 Suggestion');
-        });
-    });
-    describe('Mixed supported and unsupported steps', () => {
-        test('should process supported steps and warn about unsupported ones', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'script@1.0.0': {
-                                    title: 'Step 1',
-                                    inputs: { content: 'echo "1"' },
-                                },
-                            },
-                            {
-                                'unsupported-1@1.0.0': {
-                                    title: 'Unsupported 1',
-                                    inputs: {},
-                                },
-                            },
-                            {
-                                'script@1.0.0': {
-                                    title: 'Step 2',
-                                    inputs: { content: 'echo "2"' },
-                                },
-                            },
-                            {
-                                'unsupported-2@2.0.0': {
-                                    title: 'Unsupported 2',
-                                    inputs: {},
-                                },
-                            },
-                            {
-                                'script@1.0.0': {
-                                    title: 'Step 3',
-                                    inputs: { content: 'echo "3"' },
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            // Should have 2 warnings
-            expect(result.warnings.length).toBe(2);
-            expect(result.skippedSteps).toBe(2);
-            // Should have 3 valid steps
-            expect(result.pipeline.steps.length).toBe(3);
-            expect(result.pipeline.steps[0].name).toBe('Step 1');
-            expect(result.pipeline.steps[1].name).toBe('Step 2');
-            expect(result.pipeline.steps[2].name).toBe('Step 3');
-            // Step order should be preserved
-            expect(result.pipeline.stepsOrder.length).toBe(3);
-        });
-        test('should handle all unsupported steps', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'unsupported-1@1.0.0': {
-                                    inputs: {},
-                                },
-                            },
-                            {
-                                'unsupported-2@1.0.0': {
-                                    inputs: {},
-                                },
-                            },
-                            {
-                                'unsupported-3@1.0.0': {
-                                    inputs: {},
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            expect(result.warnings.length).toBe(3);
-            expect(result.skippedSteps).toBe(3);
-            expect(result.pipeline.steps.length).toBe(0);
-        });
-    });
-    describe('ConversionResult structure', () => {
-        test('should return valid ConversionResult structure', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'script@1.0.0': {
-                                    inputs: { content: 'echo "test"' },
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            // Should have all required properties
-            expect(result).toHaveProperty('pipeline');
-            expect(result).toHaveProperty('warnings');
-            expect(result).toHaveProperty('skippedSteps');
-            // Types should be correct
-            expect(Array.isArray(result.warnings)).toBe(true);
-            expect(typeof result.skippedSteps).toBe('number');
-            expect(result.pipeline).toHaveProperty('name');
-            expect(result.pipeline).toHaveProperty('steps');
-            expect(result.pipeline).toHaveProperty('stepsOrder');
-        });
-    });
-    describe('Error handling', () => {
-        test('should throw YAMLConversionError for invalid workflow name', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [],
-                    },
-                },
-            };
-            await expect(convertYAMLToPipelineDef(pipeline, mockConfig, 'nonexistent')).rejects.toThrow(YAMLConversionError);
-        });
-        test('should not throw for unsupported steps (should warn instead)', async () => {
-            const pipeline = {
-                format_version: '4',
-                workflows: {
-                    primary: {
-                        steps: [
-                            {
-                                'unsupported-step@1.0.0': {
-                                    inputs: {},
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            // Should not throw, should return warnings instead
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
-            expect(result.warnings.length).toBeGreaterThan(0);
-            expect(result.skippedSteps).toBeGreaterThan(0);
-        });
-    });
-    describe('cachedBuild auto-injection', () => {
-        beforeEach(() => {
-            registerStep('cache-pull', new CachePullStepExecutor());
-            registerStep('cache-push', new CachePushStepExecutor());
-        });
-        test('should inject cache-pull and cache-push when cachedBuild is true', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    'cibuild.io': {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'kmm',
-                        cachedBuild: true,
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            expect(result.pipeline.steps.length).toBe(3);
-            expect(result.pipeline.steps[0].name).toBe('cache-pull');
-            expect(result.pipeline.steps[0].script).toContain('kmm-');
-            expect(result.pipeline.steps[1].name).toBe('script');
-            expect(result.pipeline.steps[2].name).toBe('cache-push');
-            expect(result.pipeline.steps[2].script).toContain('kmm-');
-        });
-        test('should not inject cache steps when cachedBuild is false', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    'cibuild.io': {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'kmm',
-                        cachedBuild: false,
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            expect(result.pipeline.steps.length).toBe(1);
-            expect(result.pipeline.steps[0].name).toBe('script');
-        });
-        test('should not inject cache steps when cachedBuild is absent', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    'cibuild.io': {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'kmm',
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            expect(result.pipeline.steps.length).toBe(1);
-        });
-        test('should use correct technology for android platform', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    'cibuild.io': {
-                        stack: 'linux-docker-android-22.04',
-                        platform: 'android',
-                        cachedBuild: true,
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            expect(result.pipeline.steps[0].script).toContain('gradle-');
-            expect(result.pipeline.steps[2].script).toContain('gradle-');
-        });
-        test('should use cocoapods technology for ios platform', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    'cibuild.io': {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'ios',
-                        cachedBuild: true,
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            expect(result.pipeline.steps[0].script).toContain('pods-');
-            expect(result.pipeline.steps[2].script).toContain('pods-');
-        });
-        test('should strip manual cache steps when cachedBuild is true', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    'cibuild.io': {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'kmm',
-                        cachedBuild: true,
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'cache-pull@1.0.0': { inputs: { technology: 'gradle' } } },
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                            { 'cache-push@1.0.0': { inputs: { technology: 'gradle' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            // Should have 3 steps: auto-injected pull, script, auto-injected push
-            // The manual cache steps should be replaced, not duplicated
-            expect(result.pipeline.steps.length).toBe(3);
-            expect(result.pipeline.steps[0].name).toBe('cache-pull');
-            expect(result.pipeline.steps[0].script).toContain('kmm-'); // auto uses kmm, not gradle
-            expect(result.pipeline.steps[1].name).toBe('script');
-            expect(result.pipeline.steps[2].name).toBe('cache-push');
-            expect(result.pipeline.steps[2].script).toContain('kmm-');
-        });
-        test('should inject cache steps when cachedBuild + platform live under meta.invarn', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    invarn: {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'kmm',
-                        cachedBuild: true,
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            expect(result.pipeline.steps.length).toBe(3);
-            expect(result.pipeline.steps[0].name).toBe('cache-pull');
-            expect(result.pipeline.steps[1].name).toBe('script');
-            expect(result.pipeline.steps[2].name).toBe('cache-push');
-        });
-        test('should prefer meta.invarn cachedBuild over meta.cibuild.io when both are present', async () => {
-            const pipeline = {
-                format_version: '1',
-                meta: {
-                    invarn: {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'kmm',
-                        cachedBuild: true,
-                    },
-                    'cibuild.io': {
-                        stack: 'macos-xcode-26.4',
-                        platform: 'kmm',
-                        cachedBuild: false,
-                    },
-                },
-                workflows: {
-                    build: {
-                        steps: [
-                            { 'script@1.0.0': { inputs: { content: 'echo "building"' } } },
-                        ],
-                    },
-                },
-            };
-            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'build');
-            expect(result.pipeline.steps.length).toBe(3);
-            expect(result.pipeline.steps[0].name).toBe('cache-pull');
-        });
-    });
-});
-//# sourceMappingURL=converter.test.js.map

package/dist/src/yaml/e2e.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * End-to-end integration tests for YAML pipelines
- * Tests complete YAML pipeline loading and execution through CLI components
- */
-import './steps/index.js';
-//# sourceMappingURL=e2e.test.d.ts.map

package/dist/src/yaml/e2e.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"e2e.test.d.ts","sourceRoot":"","sources":["../../../src/yaml/e2e.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,kBAAkB,CAAC"}