edsger 0.35.3 → 0.36.0

package/dist/commands/build/__tests__/run-build.test.js

@@ -0,0 +1,303 @@
+/**
+ * Integration tests for the runBuild orchestration function.
+ * Uses dependency injection (BuildDeps) to mock external calls
+ * while testing the full decision-making pipeline.
+ */
+import assert from 'node:assert';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { runBuild } from '../index.js';
+// ── Helpers ────────────────────────────────────────────────────────
+function createTmpDir() {
+    const dir = join(tmpdir(), `edsger-run-build-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function makeAppleConfig(overrides = {}) {
+    return {
+        id: 'config-1',
+        product_id: 'prod-1',
+        store_type: 'apple_app_store',
+        credentials: {
+            key_id: 'KEY123',
+            issuer_id: 'ISSUER456',
+            private_key: '-----BEGIN PRIVATE KEY-----\ntest\n-----END PRIVATE KEY-----',
+        },
+        app_identifier: 'com.example.app',
+        listings: {},
+        screenshots: {},
+        build_config: {},
+        current_version: null,
+        submission_status: 'none',
+        submitted_at: null,
+        released_at: null,
+        rejection_reason: null,
+        is_active: true,
+        created_by: 'user-1',
+        created_at: '2024-01-01',
+        updated_at: '2024-01-01',
+        ...overrides,
+    };
+}
+function makeOptions(overrides = {}) {
+    return {
+        buildProductId: 'prod-1',
+        verbose: false,
+        ...overrides,
+    };
+}
+function createMockDeps(overrides = {}) {
+    const calls = [];
+    const savedConfigs = [];
+    const tmpDir = overrides.tmpDir ?? createTmpDir();
+    // Create a fake .ipa in the export directory so the build flow completes
+    const exportDir = join(tmpDir, 'build', 'export');
+    mkdirSync(exportDir, { recursive: true });
+    writeFileSync(join(exportDir, 'MyApp.ipa'), 'fake-ipa-data');
+    const deps = {
+        fetchConfigs: overrides.fetchConfigs ??
+            (async () => overrides.configs ?? [makeAppleConfig()]),
+        fetchGitHub: overrides.fetchGitHub ??
+            (async () => ({
+                configured: true,
+                token: 'ghp_test',
+                owner: 'org',
+                repo: 'app',
+            })),
+        cloneRepo: overrides.cloneRepo ?? (() => ({ repoPath: tmpDir })),
+        getWorkspaceRoot: overrides.getWorkspaceRoot ?? (() => tmpDir),
+        saveBuildConfig: overrides.saveBuildConfig ??
+            (async (_id, bc) => {
+                savedConfigs.push(bc);
+                return null;
+            }),
+        checkoutDefaultBranch: overrides.checkoutDefaultBranch ?? (() => { }),
+        findProjects: overrides.findProjects ??
+            (() => overrides.projects ?? [
+                { path: 'MyApp.xcworkspace', type: 'workspace' },
+            ]),
+        findSchemes: overrides.findSchemes ?? (() => overrides.schemes ?? ['MyApp']),
+        runCommand: overrides.runCommand ??
+            (async (cmd, args, opts) => {
+                calls.push({ cmd, args, opts });
+            }),
+        isXcodeAvailable: overrides.isXcodeAvailable ?? (() => true),
+    };
+    return { deps, calls, savedConfigs };
+}
+// ── Tests ──────────────────────────────────────────────────────────
+describe('runBuild orchestration', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = createTmpDir();
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    // -- Error paths --
+    it('throws when xcodebuild is not available', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            isXcodeAvailable: () => false,
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('xcodebuild is not available'));
+            return true;
+        });
+    });
+    it('throws when no Apple App Store config exists', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            configs: [],
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('No Apple App Store configuration'));
+            return true;
+        });
+    });
+    it('throws when GitHub is not configured', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            fetchGitHub: async () => ({
+                configured: false,
+                message: 'No repo connected',
+            }),
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('GitHub not configured'));
+            return true;
+        });
+    });
+    it('throws when no Xcode projects found', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            projects: [],
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('No Xcode projects found'));
+            return true;
+        });
+    });
+    it('throws when no schemes found', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            schemes: [],
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('No schemes found'));
+            return true;
+        });
+    });
+    // -- Happy paths --
+    it('runs full archive + export pipeline', async () => {
+        const config = makeAppleConfig({
+            build_config: { team_id: 'TEAM1', export_method: 'app-store' },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions(), deps);
+        // Should have called xcodebuild twice: archive + exportArchive
+        const xcodeCalls = calls.filter((c) => c.cmd === 'xcodebuild');
+        assert.strictEqual(xcodeCalls.length, 2);
+        assert.ok(xcodeCalls[0].args.includes('archive'));
+        assert.ok(xcodeCalls[1].args.includes('-exportArchive'));
+    });
+    it('uses scheme from options over saved config', async () => {
+        const config = makeAppleConfig({
+            build_config: { scheme: 'SavedScheme', project_path: 'A.xcworkspace' },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions({ scheme: 'OverrideScheme' }), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        const schemeIdx = archiveCall.args.indexOf('-scheme');
+        assert.strictEqual(archiveCall.args[schemeIdx + 1], 'OverrideScheme');
+    });
+    it('uses project path from saved build_config', async () => {
+        const config = makeAppleConfig({
+            build_config: { project_path: 'ios/App.xcworkspace', scheme: 'App' },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions(), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        assert.ok(archiveCall.args.some((a) => a.includes('ios/App.xcworkspace')));
+    });
+    it('persists discovered build config to DB', async () => {
+        const { deps, savedConfigs } = createMockDeps({ tmpDir });
+        await runBuild(makeOptions(), deps);
+        assert.strictEqual(savedConfigs.length, 1);
+        assert.strictEqual(savedConfigs[0].project_path, 'MyApp.xcworkspace');
+        assert.strictEqual(savedConfigs[0].scheme, 'MyApp');
+        assert.strictEqual(savedConfigs[0].configuration, 'Release');
+    });
+    it('does not re-save config when nothing changed', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'MyApp.xcworkspace',
+                scheme: 'MyApp',
+                configuration: 'Release',
+            },
+        });
+        const { deps, savedConfigs } = createMockDeps({
+            tmpDir,
+            configs: [config],
+        });
+        await runBuild(makeOptions(), deps);
+        assert.strictEqual(savedConfigs.length, 0);
+    });
+    it('passes --upload to trigger upload after build', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'A.xcworkspace',
+                scheme: 'A',
+                configuration: 'Release',
+                team_id: 'TEAM1',
+                export_method: 'app-store',
+            },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions({ upload: true }), deps);
+        // Should have xcrun altool call for upload
+        const uploadCall = calls.find((c) => c.cmd === 'xcrun' && c.args.includes('altool'));
+        assert.ok(uploadCall, 'Expected xcrun altool upload call');
+        assert.ok(uploadCall.args.includes('--upload-app'));
+    });
+    it('uses notarytool for macOS platform upload', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'A.xcworkspace',
+                scheme: 'A',
+                configuration: 'Release',
+                team_id: 'TEAM1',
+                export_method: 'app-store',
+            },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions({ upload: true, platform: 'macos' }), deps);
+        const uploadCall = calls.find((c) => c.cmd === 'xcrun' && c.args.includes('notarytool'));
+        assert.ok(uploadCall, 'Expected xcrun notarytool call for macOS');
+    });
+    it('passes platform destination to xcodebuild', async () => {
+        const { deps, calls } = createMockDeps({ tmpDir });
+        await runBuild(makeOptions({ platform: 'macos' }), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        const destIdx = archiveCall.args.indexOf('-destination');
+        assert.strictEqual(archiveCall.args[destIdx + 1], 'generic/platform=macOS');
+    });
+    it('auto-selects first workspace when multiple projects exist', async () => {
+        const { deps, calls } = createMockDeps({
+            tmpDir,
+            projects: [
+                { path: 'ios/App.xcworkspace', type: 'workspace' },
+                { path: 'App.xcodeproj', type: 'project' },
+            ],
+        });
+        await runBuild(makeOptions(), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        assert.ok(archiveCall.args.some((a) => a.includes('ios/App.xcworkspace')));
+    });
+    it('skips archive when --skipArchive is set', async () => {
+        const { deps, calls } = createMockDeps({ tmpDir });
+        await runBuild(makeOptions({ skipArchive: true }), deps);
+        const xcodeCalls = calls.filter((c) => c.cmd === 'xcodebuild');
+        assert.strictEqual(xcodeCalls.length, 0);
+    });
+    it('adds DEVELOPMENT_TEAM when team_id is set', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'A.xcworkspace',
+                scheme: 'A',
+                configuration: 'Release',
+                team_id: 'TEAM123',
+            },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions(), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        assert.ok(archiveCall.args.some((a) => a === 'DEVELOPMENT_TEAM=TEAM123'));
+    });
+    it('re-discovers project on --reselect even with saved config', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'old/Old.xcworkspace',
+                scheme: 'OldScheme',
+                configuration: 'Release',
+            },
+        });
+        const { deps, savedConfigs } = createMockDeps({
+            tmpDir,
+            configs: [config],
+            projects: [{ path: 'new/New.xcworkspace', type: 'workspace' }],
+            schemes: ['NewScheme'],
+        });
+        await runBuild(makeOptions({ reselect: true }), deps);
+        assert.strictEqual(savedConfigs.length, 1);
+        assert.strictEqual(savedConfigs[0].project_path, 'new/New.xcworkspace');
+        assert.strictEqual(savedConfigs[0].scheme, 'NewScheme');
+    });
+});

package/dist/commands/build/index.d.ts

@@ -0,0 +1,59 @@
+import { type AppStoreConfig, type BuildConfig } from '../../api/app-store.js';
+import { type CliOptions } from '../../types/index.js';
+export interface BuildOptions extends CliOptions {
+    buildProductId: string;
+    scheme?: string;
+    project?: string;
+    configuration?: string;
+    platform?: string;
+    upload?: boolean;
+    reselect?: boolean;
+    skipArchive?: boolean;
+    ipa?: string;
+}
+export interface XcodeProject {
+    path: string;
+    type: 'workspace' | 'project';
+}
+export type Platform = 'ios' | 'macos';
+/**
+ * Injectable dependencies for runBuild — enables unit testing
+ * without real MCP, GitHub, git, or xcodebuild calls.
+ */
+export interface BuildDeps {
+    fetchConfigs: (productId: string, verbose?: boolean) => Promise<AppStoreConfig[]>;
+    fetchGitHub: (productId: string, verbose?: boolean) => Promise<{
+        configured: boolean;
+        token?: string;
+        owner?: string;
+        repo?: string;
+        message?: string;
+    }>;
+    cloneRepo: (workspaceRoot: string, dirName: string, owner: string, repo: string, token: string) => {
+        repoPath: string;
+    };
+    getWorkspaceRoot: () => string;
+    saveBuildConfig: (configId: string, buildConfig: BuildConfig, verbose?: boolean) => Promise<AppStoreConfig | null>;
+    checkoutDefaultBranch: (repoPath: string) => void;
+    findProjects: (rootDir: string) => XcodeProject[];
+    findSchemes: (repoPath: string, projectPath: string, projectType: 'workspace' | 'project') => string[];
+    runCommand: (cmd: string, args: string[], opts?: {
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
+        timeout?: number;
+    }) => Promise<void>;
+    isXcodeAvailable: () => boolean;
+}
+/** Default (real) implementations of all dependencies. */
+export declare function createDefaultDeps(): BuildDeps;
+export declare function findXcodeProjects(rootDir: string): XcodeProject[];
+export declare function discoverSchemes(repoPath: string, projectPath: string, projectType: 'workspace' | 'project'): string[];
+export declare function generateExportOptionsPlist(teamId: string, exportMethod: string): string;
+export declare function writeApiKeyFile(keyId: string, privateKey: string): string;
+export declare function cleanupApiKeyFile(keyId: string): void;
+export declare function destinationForPlatform(platform: Platform): string;
+/**
+ * Run the full build pipeline. Accepts an optional `deps` parameter
+ * for dependency injection in tests; falls back to real implementations.
+ */
+export declare function runBuild(options: BuildOptions, deps?: BuildDeps): Promise<void>;