@invarn/cibuild 1.3.15 → 1.3.17

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

@@ -0,0 +1,474 @@
+/**
+ * Integration tests for step implementations
+ * Tests each step executor with sample inputs
+ */
+import { describe, test, expect } from '@jest/globals';
+import { GitCloneStepExecutor } from './git-clone.js';
+import { ScriptStepExecutor } from './script.js';
+import { CachePullStepExecutor, CachePushStepExecutor } from './cache.js';
+import { testConfig } from './test-config.js';
+import { XcodeBuildStepExecutor, XcodeTestStepExecutor } from './xcode.js';
+import { SetJavaVersionStepExecutor, GradleBuildStepExecutor, AndroidLintStepExecutor, AndroidUnitTestStepExecutor, } from './android.js';
+describe('Step Implementations', () => {
+    describe('GitCloneStepExecutor', () => {
+        test('should generate local checkout script', async () => {
+            const executor = new GitCloneStepExecutor();
+            const result = await executor.execute({}, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('git-clone');
+            expect(result.script).toContain('git rev-parse --show-toplevel');
+            expect(result.script).toContain('CIBUILD_SOURCE_DIR');
+            expect(result.script).toContain('COMMIT_HASH');
+        });
+        test('should export commit metadata via envman', async () => {
+            const executor = new GitCloneStepExecutor();
+            const result = await executor.execute({}, {}, testConfig);
+            expect(result.script).toContain('envman add --key CIBUILD_SOURCE_DIR');
+            expect(result.script).toContain('envman add --key GIT_CLONE_COMMIT_HASH');
+            expect(result.script).toContain('envman add --key CIBUILD_GIT_COMMIT');
+            expect(result.script).toContain('envman add --key GIT_CLONE_COMMIT_AUTHOR_NAME');
+            expect(result.script).toContain('envman add --key GIT_CLONE_COMMIT_MESSAGE_SUBJECT');
+        });
+        test('should export CIBUILD variables', async () => {
+            const executor = new GitCloneStepExecutor();
+            const result = await executor.execute({}, {}, testConfig);
+            expect(result.script).toContain('envman add --key CIBUILD_SOURCE_DIR');
+            expect(result.script).toContain('envman add --key CIBUILD_GIT_COMMIT');
+        });
+        test('should fail if not in a git repository', async () => {
+            const executor = new GitCloneStepExecutor();
+            const result = await executor.execute({}, {}, testConfig);
+            expect(result.script).toContain('Not inside a git repository');
+            expect(result.script).toContain('exit 1');
+        });
+    });
+    describe('ScriptStepExecutor', () => {
+        test('should generate bash script', async () => {
+            const executor = new ScriptStepExecutor();
+            const inputs = {
+                content: 'echo "Hello World"',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('script');
+            expect(result.script).toContain('echo "Hello World"');
+        });
+        test('should require content input', async () => {
+            const executor = new ScriptStepExecutor();
+            const inputs = {};
+            await expect(executor.execute(inputs, {}, testConfig)).rejects.toThrow("Missing required input 'content'");
+        });
+        test('should support working directory', async () => {
+            const executor = new ScriptStepExecutor();
+            const inputs = {
+                content: 'pwd',
+                working_dir: '/tmp/test',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('cd');
+            expect(result.script).toContain('/tmp/test');
+        });
+        test('should support python runner', async () => {
+            const executor = new ScriptStepExecutor();
+            const inputs = {
+                content: 'print("Hello from Python")',
+                runner_bin: 'python3',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('python');
+            expect(result.script).toBe('print("Hello from Python")');
+        });
+        test('should support node runner', async () => {
+            const executor = new ScriptStepExecutor();
+            const inputs = {
+                content: 'console.log("Hello from Node")',
+                runner_bin: 'node',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('node');
+            expect(result.script).toBe('console.log("Hello from Node")');
+        });
+        test('should support ruby runner', async () => {
+            const executor = new ScriptStepExecutor();
+            const inputs = {
+                content: 'puts "Hello from Ruby"',
+                runner_bin: 'ruby',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('ruby');
+            expect(result.script).toBe('puts "Hello from Ruby"');
+        });
+    });
+    describe('CachePullStepExecutor', () => {
+        test('should generate cache pull script', async () => {
+            const executor = new CachePullStepExecutor();
+            const inputs = {
+                cache_key: 'node-modules-v1',
+                cache_paths: ['node_modules'],
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('cache-pull');
+            expect(result.script).toContain('cache-pull');
+            expect(result.script).toContain('node-modules-v1');
+            expect(result.script).toContain('.ci-cache');
+        });
+        test('should skip gracefully when cache_key is missing', async () => {
+            const executor = new CachePullStepExecutor();
+            const inputs = {};
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('skipped');
+        });
+        test('should support debug mode', async () => {
+            const executor = new CachePullStepExecutor();
+            const inputs = {
+                cache_key: 'test-cache',
+                is_debug_mode: true,
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('Debug mode enabled');
+        });
+        test('should auto-configure for cocoapods technology', async () => {
+            const executor = new CachePullStepExecutor();
+            const result = await executor.execute({ technology: 'cocoapods' }, {}, testConfig);
+            expect(result.script).toContain('Podfile.lock');
+            expect(result.script).toContain('pods-');
+            expect(result.script).toContain('shasum -a 256');
+        });
+        test('should auto-configure for gradle technology', async () => {
+            const executor = new CachePullStepExecutor();
+            const result = await executor.execute({ technology: 'gradle' }, {}, testConfig);
+            expect(result.script).toContain('gradle/wrapper/gradle-wrapper.properties');
+            expect(result.script).toContain('gradle-');
+        });
+        test('should auto-configure for npm technology', async () => {
+            const executor = new CachePullStepExecutor();
+            const result = await executor.execute({ technology: 'npm' }, {}, testConfig);
+            expect(result.script).toContain('package-lock.json');
+            expect(result.script).toContain('npm-');
+        });
+        test('should auto-configure for dart technology', async () => {
+            const executor = new CachePullStepExecutor();
+            const result = await executor.execute({ technology: 'dart' }, {}, testConfig);
+            expect(result.script).toContain('pubspec.lock');
+            expect(result.script).toContain('dart-');
+        });
+        test('should auto-configure for carthage technology', async () => {
+            const executor = new CachePullStepExecutor();
+            const result = await executor.execute({ technology: 'carthage' }, {}, testConfig);
+            expect(result.script).toContain('Cartfile.resolved');
+            expect(result.script).toContain('carthage-');
+        });
+        test('should auto-configure for spm technology', async () => {
+            const executor = new CachePullStepExecutor();
+            const result = await executor.execute({ technology: 'spm' }, {}, testConfig);
+            expect(result.script).toContain('Package.resolved');
+            expect(result.script).toContain('spm-');
+        });
+        test('should auto-configure for yarn technology', async () => {
+            const executor = new CachePullStepExecutor();
+            const result = await executor.execute({ technology: 'yarn' }, {}, testConfig);
+            expect(result.script).toContain('yarn.lock');
+            expect(result.script).toContain('yarn-');
+        });
+        test('should throw on unknown technology', async () => {
+            const executor = new CachePullStepExecutor();
+            await expect(executor.execute({ technology: 'unknown' }, {}, testConfig)).rejects.toThrow("Unknown cache technology 'unknown'");
+        });
+    });
+    describe('CachePushStepExecutor', () => {
+        test('should generate cache push script', async () => {
+            const executor = new CachePushStepExecutor();
+            const inputs = {
+                cache_key: 'node-modules-v1',
+                cache_paths: ['node_modules', '.gradle'],
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('cache-push');
+            expect(result.script).toContain('cache-push');
+            expect(result.script).toContain('node-modules-v1');
+            expect(result.script).toContain('.ci-cache');
+        });
+        test('should skip gracefully when cache_key is missing', async () => {
+            const executor = new CachePushStepExecutor();
+            const inputs = {
+                cache_paths: ['node_modules'],
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('skipped');
+        });
+        test('should require cache_paths', async () => {
+            const executor = new CachePushStepExecutor();
+            const inputs = {
+                cache_key: 'test-cache',
+                cache_paths: [],
+            };
+            await expect(executor.execute(inputs, {}, testConfig)).rejects.toThrow("Missing or empty 'cache_paths'");
+        });
+        test('should support debug mode', async () => {
+            const executor = new CachePushStepExecutor();
+            const inputs = {
+                cache_key: 'test-cache',
+                cache_paths: ['build'],
+                is_debug_mode: true,
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('Debug mode enabled');
+        });
+        test('should auto-configure for cocoapods technology', async () => {
+            const executor = new CachePushStepExecutor();
+            const result = await executor.execute({ technology: 'cocoapods' }, {}, testConfig);
+            expect(result.script).toContain('Podfile.lock');
+            expect(result.script).toContain('pods-');
+            expect(result.script).toContain('Pods');
+            expect(result.script).toContain('tar -czf');
+        });
+        test('should auto-configure for gradle technology', async () => {
+            const executor = new CachePushStepExecutor();
+            const result = await executor.execute({ technology: 'gradle' }, {}, testConfig);
+            expect(result.script).toContain('gradle/wrapper/gradle-wrapper.properties');
+            expect(result.script).toContain('~/.gradle/caches');
+        });
+        test('should auto-configure for npm technology', async () => {
+            const executor = new CachePushStepExecutor();
+            const result = await executor.execute({ technology: 'npm' }, {}, testConfig);
+            expect(result.script).toContain('package-lock.json');
+            expect(result.script).toContain('node_modules');
+        });
+        test('should auto-configure for dart technology', async () => {
+            const executor = new CachePushStepExecutor();
+            const result = await executor.execute({ technology: 'dart' }, {}, testConfig);
+            expect(result.script).toContain('pubspec.lock');
+            expect(result.script).toContain('.dart_tool');
+            expect(result.script).toContain('.pub-cache');
+        });
+        test('should throw on unknown technology', async () => {
+            const executor = new CachePushStepExecutor();
+            await expect(executor.execute({ technology: 'unknown' }, {}, testConfig)).rejects.toThrow("Unknown cache technology 'unknown'");
+        });
+    });
+    describe('XcodeBuildStepExecutor', () => {
+        test('should generate xcodebuild script', async () => {
+            const executor = new XcodeBuildStepExecutor();
+            const inputs = {
+                project_path: 'MyApp.xcodeproj',
+                scheme: 'MyApp',
+                configuration: 'Release',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('xcodebuild');
+            expect(result.script).toContain('xcodebuild');
+            expect(result.script).toContain('MyApp.xcodeproj');
+            expect(result.script).toContain('-scheme');
+            expect(result.script).toContain('MyApp');
+            expect(result.script).toContain('-configuration');
+            expect(result.script).toContain('Release');
+        });
+        test('should require project_path', async () => {
+            const executor = new XcodeBuildStepExecutor();
+            const inputs = {
+                scheme: 'MyApp',
+            };
+            await expect(executor.execute(inputs, {}, testConfig)).rejects.toThrow("Missing required input 'project_path'");
+        });
+        test('should require scheme', async () => {
+            const executor = new XcodeBuildStepExecutor();
+            const inputs = {
+                project_path: 'MyApp.xcodeproj',
+            };
+            await expect(executor.execute(inputs, {}, testConfig)).rejects.toThrow("Missing required input 'scheme'");
+        });
+        test('should support workspace files', async () => {
+            const executor = new XcodeBuildStepExecutor();
+            const inputs = {
+                project_path: 'MyApp.xcworkspace',
+                scheme: 'MyApp',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('xcworkspace');
+        });
+        test('should support clean build', async () => {
+            const executor = new XcodeBuildStepExecutor();
+            const inputs = {
+                project_path: 'MyApp.xcodeproj',
+                scheme: 'MyApp',
+                is_clean_build: true,
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('clean');
+        });
+    });
+    describe('XcodeTestStepExecutor', () => {
+        test('should generate xcode test script', async () => {
+            const executor = new XcodeTestStepExecutor();
+            const inputs = {
+                project_path: 'MyApp.xcodeproj',
+                scheme: 'MyApp',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('xcode-test');
+            expect(result.script).toContain('xcodebuild test');
+            expect(result.script).toContain('MyApp.xcodeproj');
+        });
+        test('should support code coverage', async () => {
+            const executor = new XcodeTestStepExecutor();
+            const inputs = {
+                project_path: 'MyApp.xcodeproj',
+                scheme: 'MyApp',
+                is_code_coverage_enabled: true,
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('enableCodeCoverage YES');
+        });
+        test('should support test plan', async () => {
+            const executor = new XcodeTestStepExecutor();
+            const inputs = {
+                project_path: 'MyApp.xcodeproj',
+                scheme: 'MyApp',
+                test_plan: 'MyTestPlan',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('-testPlan');
+            expect(result.script).toContain('MyTestPlan');
+        });
+    });
+    describe('SetJavaVersionStepExecutor', () => {
+        test('should generate java version script', async () => {
+            const executor = new SetJavaVersionStepExecutor();
+            const inputs = {
+                java_version: '17',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('set-java-version');
+            expect(result.script).toContain('JAVA_HOME');
+            expect(result.script).toContain('17');
+        });
+        test('should default to Java 17', async () => {
+            const executor = new SetJavaVersionStepExecutor();
+            const inputs = {};
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('17');
+        });
+        test('should support different Java versions', async () => {
+            const executor = new SetJavaVersionStepExecutor();
+            const inputs = {
+                java_version: '11',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('11');
+        });
+    });
+    describe('GradleBuildStepExecutor', () => {
+        test('should generate gradle build script', async () => {
+            const executor = new GradleBuildStepExecutor();
+            const inputs = {
+                project_location: '.',
+                build_type: 'Release',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('gradle-build');
+            expect(result.script).toContain('Gradle Build');
+            expect(result.script).toContain('assembleRelease');
+        });
+        test('should support debug build', async () => {
+            const executor = new GradleBuildStepExecutor();
+            const inputs = {
+                build_type: 'Debug',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('assembleDebug');
+        });
+        test('should support custom gradle task', async () => {
+            const executor = new GradleBuildStepExecutor();
+            const inputs = {
+                gradle_task: 'bundleRelease',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('bundleRelease');
+        });
+        test('should support custom project location', async () => {
+            const executor = new GradleBuildStepExecutor();
+            const inputs = {
+                project_location: 'android',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('cd');
+            expect(result.script).toContain('android');
+        });
+        test('should support gradle options', async () => {
+            const executor = new GradleBuildStepExecutor();
+            const inputs = {
+                gradle_options: '--stacktrace --no-daemon',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('--stacktrace --no-daemon');
+        });
+    });
+    describe('AndroidLintStepExecutor', () => {
+        test('should generate lint script', async () => {
+            const executor = new AndroidLintStepExecutor();
+            const inputs = {
+                module: 'app',
+                variant: 'debug',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('android-lint');
+            expect(result.script).toContain('lint');
+            expect(result.script).toContain(':app:lintDebug');
+        });
+        test('should support custom module', async () => {
+            const executor = new AndroidLintStepExecutor();
+            const inputs = {
+                module: 'library',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain(':library:');
+        });
+        test('should capitalize variant correctly', async () => {
+            const executor = new AndroidLintStepExecutor();
+            const inputs = {
+                variant: 'release',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('lintRelease');
+        });
+    });
+    describe('AndroidUnitTestStepExecutor', () => {
+        test('should generate unit test script', async () => {
+            const executor = new AndroidUnitTestStepExecutor();
+            const inputs = {
+                module: 'app',
+                variant: 'debug',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('android-unit-test');
+            expect(result.script).toContain('test');
+            expect(result.script).toContain(':app:testDebugUnitTest');
+        });
+        test('should support test filter', async () => {
+            const executor = new AndroidUnitTestStepExecutor();
+            const inputs = {
+                test_filter: 'com.example.MyTest',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('--tests');
+            expect(result.script).toContain('com.example.MyTest');
+        });
+        test('should support custom variant', async () => {
+            const executor = new AndroidUnitTestStepExecutor();
+            const inputs = {
+                variant: 'staging',
+            };
+            const result = await executor.execute(inputs, {}, testConfig);
+            expect(result.script).toContain('testStagingUnitTest');
+        });
+    });
+});
+//# sourceMappingURL=steps.test.js.map

package/dist/src/yaml/steps/test-config.d.ts

@@ -0,0 +1,3 @@
+import type { CIConfig } from '../../types.js';
+export declare const testConfig: CIConfig;
+//# sourceMappingURL=test-config.d.ts.map

package/dist/src/yaml/steps/test-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-config.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/test-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,eAAO,MAAM,UAAU,EAAE,QAcxB,CAAC"}

package/dist/src/yaml/steps/test-config.js

@@ -0,0 +1,16 @@
+export const testConfig = {
+    artifactsDir: './artifacts',
+    interpreters: {
+        python: 'python3',
+        ruby: 'ruby',
+        node: 'node',
+        bash: '/bin/bash',
+    },
+    maxConcurrentJobs: 1,
+    paths: {
+        buildsDir: '.ci-builds',
+        cacheDir: '.ci-cache',
+        derivedDataDir: '~/Library/Developer/Xcode/DerivedData',
+    },
+};
+//# sourceMappingURL=test-config.js.map

package/dist/src/yaml/steps/xcode-new.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for new Xcode steps: xcode-build-for-test, xcode-test-without-building, xcode-build-for-simulator
+ */
+export {};
+//# sourceMappingURL=xcode-new.test.d.ts.map

package/dist/src/yaml/steps/xcode-new.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcode-new.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/xcode-new.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}