405 lines
27 KiB
TypeScript
405 lines
27 KiB
TypeScript
// Three gaps found in real use, against the stateful App Store Connect double (tests/helpers/fake-stores.ts):
|
|
// 1. release type: updates sat in Pending Developer Release because versions were created / submitted as MANUAL
|
|
// (apple.releaseType, apple submit, apple release --after-approval | --manual)
|
|
// 2. device families: an iPhone-only build of an app whose live version runs on iPad is refused AFTER the archive (ITMS-90101)
|
|
// 3. TestFlight: inviting a tester of a group without an installable build is 409 NO_INSTALLABLE_BUILDS
|
|
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, setDefaultTimeout, test } from 'bun:test';
|
|
import { parseArgs } from '../cli/lib/args';
|
|
import { runShipStep } from '../cli/lib/ship-step';
|
|
import { run as appleSubmit } from '../cli/apple/submit';
|
|
import { run as appleRelease } from '../cli/apple/release';
|
|
import { run as appleTestflight } from '../cli/apple/testflight';
|
|
import { run as appleBuild } from '../cli/apple/build';
|
|
import { validateConfig } from '../cli/lib/config';
|
|
import { planVersion } from '../cli/lib/listing-plan';
|
|
import { releaseTypeChanges, validateReleaseType, wantedRelease } from '../cli/lib/release-type';
|
|
import { familyVerdicts, liveFamilies, pbxFamilies, projectFamilies } from '../cli/lib/device-families';
|
|
import { liveDeviceFamilies } from '../cli/apple/device-families';
|
|
import { appleRules } from '../cli/lib/validate-rules';
|
|
import { installableBuild, noInstallableBuildHint, noInstallableBuilds409 } from '../cli/lib/testflight';
|
|
import { ascEnv, BASE, capture, project, restore } from './helpers/store-mock';
|
|
import { installStores, type Stores, uninstallStores, writes } from './helpers/fake-stores';
|
|
|
|
const APP = '6400000101';
|
|
|
|
/** Runs a ship step in-process with stdout / stderr captured. */
|
|
async function ship(key: string, argv: string[], body: (a: ReturnType<typeof parseArgs>) => Promise<void>): Promise<{ code: number; out: string; err: string }> {
|
|
const out: string[] = [], err: string[] = [];
|
|
const o = process.stdout.write, e = process.stderr.write, cl = console.log, ce = console.error, cw = console.warn, ci = console.info;
|
|
process.stdout.write = ((s: string | Uint8Array) => { out.push(typeof s === 'string' ? s : new TextDecoder().decode(s)); return true; }) as typeof process.stdout.write;
|
|
process.stderr.write = ((s: string | Uint8Array) => { err.push(typeof s === 'string' ? s : new TextDecoder().decode(s)); return true; }) as typeof process.stderr.write;
|
|
console.log = (...a: unknown[]) => { out.push(a.map(String).join(' ') + '\n'); };
|
|
console.info = console.log;
|
|
console.error = (...a: unknown[]) => { err.push(a.map(String).join(' ') + '\n'); };
|
|
console.warn = console.error;
|
|
try {
|
|
const code = await runShipStep(key, argv, parseArgs, async a => {
|
|
const keep = console.log;
|
|
if (a.has('json')) console.log = (...x: unknown[]) => console.error(...x);
|
|
try { await body(a); } finally { console.log = keep; }
|
|
});
|
|
return { code, out: out.join(''), err: err.join('') };
|
|
} finally { process.stdout.write = o; process.stderr.write = e; console.log = cl; console.error = ce; console.warn = cw; console.info = ci; }
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------ 1. release type
|
|
|
|
describe('release type (pure)', () => {
|
|
test('config: afterApproval | manual | scheduled (+ date); scheduled needs the date, the date needs scheduled', () => {
|
|
expect(validateReleaseType({ releaseType: 'afterApproval' })).toEqual([]);
|
|
expect(validateReleaseType({ releaseType: 'scheduled', earliestReleaseDate: '2027-03-01T09:00:00Z' })).toEqual([]);
|
|
expect(validateReleaseType({ releaseType: 'soon' }).join()).toContain('afterApproval | manual | scheduled');
|
|
expect(validateReleaseType({ releaseType: 'scheduled' }).join()).toContain('earliestReleaseDate is required');
|
|
expect(validateReleaseType({ releaseType: 'manual', earliestReleaseDate: '2027-03-01T09:00:00Z' }).join()).toContain('only with apple.releaseType "scheduled"');
|
|
expect(validateReleaseType({ releaseType: 'scheduled', earliestReleaseDate: 'tomorrow' }).join()).toContain('ISO 8601');
|
|
expect(validateConfig({ ...BASE, apple: { ...BASE.apple!, releaseType: 'later' as never } }).join()).toContain('apple.releaseType');
|
|
expect(wantedRelease({})).toBeNull();
|
|
expect(wantedRelease({ releaseType: 'afterApproval' })).toEqual({ releaseType: 'AFTER_APPROVAL' });
|
|
});
|
|
test('changes are old -> new; the same instant is not a change', () => {
|
|
expect(releaseTypeChanges({ releaseType: 'MANUAL' }, { releaseType: 'AFTER_APPROVAL' })).toEqual([{ field: 'releaseType', from: 'MANUAL', to: 'AFTER_APPROVAL' }]);
|
|
expect(releaseTypeChanges({ releaseType: 'AFTER_APPROVAL' }, { releaseType: 'AFTER_APPROVAL' })).toEqual([]);
|
|
expect(releaseTypeChanges({ releaseType: 'SCHEDULED', earliestReleaseDate: '2027-03-01T09:00:00+00:00' }, { releaseType: 'SCHEDULED', earliestReleaseDate: '2027-03-01T09:00:00Z' })).toEqual([]);
|
|
expect(releaseTypeChanges({ releaseType: 'MANUAL' }, { releaseType: 'SCHEDULED', earliestReleaseDate: '2027-03-01T09:00:00Z' }).map(c => c.field)).toEqual(['releaseType', 'earliestReleaseDate']);
|
|
});
|
|
test('apple listing: a new version takes the configured type (MANUAL when unset); an existing one keeps its own unless asked', () => {
|
|
const rows = [{ id: 'v1', attributes: { versionString: '1.0.0', appVersionState: 'READY_FOR_SALE', platform: 'IOS' } }];
|
|
expect(planVersion(rows, '1.1.0', { copyright: 'c' }).attributes.releaseType).toBe('MANUAL');
|
|
expect(planVersion(rows, '1.1.0', { copyright: 'c', releaseType: 'AFTER_APPROVAL' }).attributes.releaseType).toBe('AFTER_APPROVAL');
|
|
const sched = planVersion(rows, '1.1.0', { copyright: 'c', releaseType: 'SCHEDULED', earliestReleaseDate: '2027-03-01T09:00:00Z' });
|
|
expect(sched.attributes).toMatchObject({ releaseType: 'SCHEDULED', earliestReleaseDate: '2027-03-01T09:00:00Z' });
|
|
const editable = [...rows, { id: 'v2', attributes: { versionString: '1.1.0', appVersionState: 'PREPARE_FOR_SUBMISSION', platform: 'IOS', copyright: 'c', releaseType: 'AFTER_APPROVAL' } }];
|
|
expect(planVersion(editable, '1.1.0', { copyright: 'c' }).action).toBe('keep');
|
|
expect(planVersion(editable, '1.1.0', { copyright: 'c', releaseType: 'MANUAL' }).changes).toEqual([{ field: 'releaseType', from: 'AFTER_APPROVAL', to: 'MANUAL' }]);
|
|
});
|
|
});
|
|
|
|
describe('release type (fake App Store Connect)', () => {
|
|
setDefaultTimeout(30_000);
|
|
let s: Stores;
|
|
beforeAll(() => { ascEnv(); });
|
|
afterAll(restore);
|
|
beforeEach(() => { s = installStores(); });
|
|
afterEach(() => { uninstallStores(); });
|
|
const version = (id: string, v: string, state: string, releaseType = 'MANUAL'): void => { s.asc.put({ type: 'appStoreVersions', id, attributes: { versionString: v, appVersionState: state, platform: 'IOS', releaseType }, rels: { app: APP } }); };
|
|
const build = (): void => { s.asc.put({ type: 'builds', id: 'b-8', attributes: { version: '8', processingState: 'VALID', usesNonExemptEncryption: false }, rels: { app: APP } }); };
|
|
const typeOf = (id: string): unknown => s.asc.all('appStoreVersions').find(v => v.id === id)!.attributes.releaseType;
|
|
const cfg = (releaseType: 'afterApproval' | 'manual') => ({ ...BASE, apple: { ...BASE.apple!, releaseType } });
|
|
|
|
test('apple submit with apple.releaseType: the dry run shows old -> new, the real run sets it BEFORE the submit, the re-run is exit 7', async () => {
|
|
version('ver-0', '1.0.0', 'READY_FOR_SALE');
|
|
version('ver-1', '1.1.0', 'PREPARE_FOR_SUBMISSION');
|
|
build();
|
|
const p = project(cfg('afterApproval'));
|
|
const dry = await ship('apple submit', ['--json', '--build', '8'], a => appleSubmit({ loaded: p.loaded, args: a }));
|
|
expect(dry.code).toBe(0);
|
|
expect(JSON.parse(dry.out).releaseType).toEqual({ changes: [{ field: 'releaseType', from: 'MANUAL', to: 'AFTER_APPROVAL' }] });
|
|
expect(typeOf('ver-1')).toBe('MANUAL');
|
|
expect(writes(s.calls)).toEqual([]);
|
|
const r = await ship('apple submit', ['--json', '--yes', '--build', '8'], a => appleSubmit({ loaded: p.loaded, args: a }));
|
|
expect(r.err).not.toContain('error:');
|
|
expect(r.code).toBe(0);
|
|
expect(r.err).toContain('release type of 1.1.0: releaseType MANUAL -> AFTER_APPROVAL');
|
|
expect(typeOf('ver-1')).toBe('AFTER_APPROVAL');
|
|
const w = writes(s.calls).map(c => `${c.method} ${c.path}`);
|
|
expect(w.indexOf('PATCH /v1/appStoreVersions/ver-1')).toBeGreaterThanOrEqual(0);
|
|
expect(w.indexOf('PATCH /v1/appStoreVersions/ver-1')).toBeLessThan(w.findIndex(x => /^PATCH \/v1\/reviewSubmissions\//.test(x)));
|
|
const again = await ship('apple submit', ['--json', '--yes', '--build', '8'], a => appleSubmit({ loaded: p.loaded, args: a }));
|
|
expect(again.code).toBe(7);
|
|
});
|
|
|
|
test('apple submit without apple.releaseType leaves the version\'s release type alone', async () => {
|
|
version('ver-0', '1.0.0', 'READY_FOR_SALE');
|
|
version('ver-1', '1.1.0', 'PREPARE_FOR_SUBMISSION');
|
|
build();
|
|
const p = project(BASE);
|
|
const r = await ship('apple submit', ['--json', '--yes', '--build', '8'], a => appleSubmit({ loaded: p.loaded, args: a }));
|
|
expect(r.code).toBe(0);
|
|
expect(typeOf('ver-1')).toBe('MANUAL');
|
|
expect(writes(s.calls).some(c => c.path === '/v1/appStoreVersions/ver-1')).toBe(false);
|
|
});
|
|
|
|
test('apple release --after-approval --yes on an update: set, then exit 7 when it is that type; --manual puts it back', async () => {
|
|
version('ver-0', '1.0.0', 'READY_FOR_SALE');
|
|
version('ver-1', '1.1.0', 'WAITING_FOR_REVIEW');
|
|
const p = project(BASE);
|
|
const run = (argv: string[]) => ship('apple release', ['--json', '--yes', ...argv], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
const r = await run(['--after-approval', '--version', '1.1.0']);
|
|
expect(r.err).not.toContain('error:');
|
|
expect(r.code).toBe(0);
|
|
expect(JSON.parse(r.out)).toMatchObject({ ok: true, step: 'release', version: '1.1.0', releaseType: 'AFTER_APPROVAL', from: 'MANUAL', changed: true, releaseKind: 'update' });
|
|
expect(writes(s.calls).map(c => `${c.method} ${c.path}`)).toEqual(['PATCH /v1/appStoreVersions/ver-1']);
|
|
expect(typeOf('ver-1')).toBe('AFTER_APPROVAL');
|
|
const n = s.calls.length;
|
|
const again = await run(['--after-approval']);
|
|
expect(again.code).toBe(7);
|
|
expect(JSON.parse(again.out)).toMatchObject({ ok: true, alreadyThere: true });
|
|
expect(writes(s.calls.slice(n))).toEqual([]);
|
|
const back = await run(['--manual', '--version', '1.1.0']);
|
|
expect(back.code).toBe(0);
|
|
expect(typeOf('ver-1')).toBe('MANUAL');
|
|
});
|
|
|
|
test('apple release --after-approval --dry changes nothing; --scheduled sets the date; two type flags are a usage error', async () => {
|
|
version('ver-0', '1.0.0', 'READY_FOR_SALE');
|
|
version('ver-1', '1.1.0', 'PREPARE_FOR_SUBMISSION');
|
|
const p = project(BASE);
|
|
const dry = await ship('apple release', ['--json', '--after-approval', '--dry'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(dry.code).toBe(0);
|
|
expect(JSON.parse(dry.out)).toMatchObject({ dryRun: true, changes: [{ field: 'releaseType', from: 'MANUAL', to: 'AFTER_APPROVAL' }] });
|
|
expect(writes(s.calls)).toEqual([]);
|
|
const sch = await ship('apple release', ['--json', '--yes', '--scheduled', '2027-03-01T09:00:00Z'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(sch.code).toBe(0);
|
|
expect(s.asc.all('appStoreVersions').find(v => v.id === 'ver-1')!.attributes).toMatchObject({ releaseType: 'SCHEDULED', earliestReleaseDate: '2027-03-01T09:00:00Z' });
|
|
const both = await ship('apple release', ['--json', '--yes', '--manual', '--after-approval'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(both.code).not.toBe(0);
|
|
expect(both.err).toContain('alternatives');
|
|
});
|
|
|
|
test('an approved version (Pending Developer Release) is refused with the way out; a released one too', async () => {
|
|
version('ver-0', '1.0.0', 'READY_FOR_SALE');
|
|
version('ver-1', '1.1.0', 'PENDING_DEVELOPER_RELEASE');
|
|
const p = project(BASE);
|
|
const r = await ship('apple release', ['--json', '--yes', '--after-approval', '--version', '1.1.0'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(r.code).not.toBe(0);
|
|
expect(r.err).toContain('apple release --manual-release --version 1.1.0');
|
|
expect(writes(s.calls)).toEqual([]);
|
|
// already MANUAL and asked for MANUAL: nothing to do even in that state
|
|
const same = await ship('apple release', ['--json', '--yes', '--manual', '--version', '1.1.0'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(same.code).toBe(7);
|
|
});
|
|
|
|
test('--after-approval on the first version of an app is the owner\'s step (exit 3 OWNER_STEP) unless --first-release', async () => {
|
|
version('ver-1', '1.0.0', 'PREPARE_FOR_SUBMISSION');
|
|
const p = project(BASE);
|
|
const r = await ship('apple release', ['--json', '--yes', '--after-approval'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(r.code).toBe(3);
|
|
expect(JSON.parse(r.out)).toMatchObject({ ok: false, error: { code: 'OWNER_STEP' } });
|
|
expect(writes(s.calls)).toEqual([]);
|
|
const manual = await ship('apple release', ['--json', '--yes', '--manual'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(manual.code).toBe(7);
|
|
const ok = await ship('apple release', ['--json', '--yes', '--after-approval', '--first-release'], a => appleRelease({ loaded: p.loaded, args: a }));
|
|
expect(ok.code).toBe(0);
|
|
expect(typeOf('ver-1')).toBe('AFTER_APPROVAL');
|
|
});
|
|
});
|
|
|
|
// ------------------------------------------------------------------------------------------------ 2. device families
|
|
|
|
const PBX = (family: string, bundle = 'com.example.notes'): string => `// !$*UTF8*$!
|
|
{
|
|
objects = {
|
|
/* Begin XCBuildConfiguration section */
|
|
AA01 /* Debug */ = {
|
|
isa = XCBuildConfiguration;
|
|
buildSettings = {
|
|
PRODUCT_BUNDLE_IDENTIFIER = ${bundle};
|
|
TARGETED_DEVICE_FAMILY = "1,2";
|
|
};
|
|
name = Debug;
|
|
};
|
|
AA02 /* Release */ = {
|
|
isa = XCBuildConfiguration;
|
|
baseConfigurationReference = ZZ01;
|
|
buildSettings = {
|
|
PRODUCT_BUNDLE_IDENTIFIER = ${bundle};
|
|
TARGETED_DEVICE_FAMILY = ${family};
|
|
};
|
|
name = Release;
|
|
};
|
|
AA03 /* Release */ = {
|
|
isa = XCBuildConfiguration;
|
|
buildSettings = {
|
|
PRODUCT_BUNDLE_IDENTIFIER = ${bundle}.Share;
|
|
TARGETED_DEVICE_FAMILY = "1,2";
|
|
WRAPPER_EXTENSION = appex;
|
|
};
|
|
name = Release;
|
|
};
|
|
/* End XCBuildConfiguration section */
|
|
};
|
|
}
|
|
`;
|
|
|
|
describe('device families (pure)', () => {
|
|
test('pbxproj: the Release configuration of the app\'s bundle id, not the extension\'s or Debug', () => {
|
|
expect(pbxFamilies(PBX('1'), 'com.example.notes')).toMatchObject({ list: [1], families: { iphone: true, ipad: false }, configurations: ['1'] });
|
|
expect(pbxFamilies(PBX('"1,2"'), 'com.example.notes')).toMatchObject({ list: [1, 2], families: { iphone: true, ipad: true } });
|
|
expect(pbxFamilies('no project here', 'com.example.notes')).toBeNull();
|
|
});
|
|
test('live signals: any iPad signal means iPad; no signal at all is unknown, never iPhone only', () => {
|
|
expect(liveFamilies('1.0.0', 'READY_FOR_SALE', [{ name: 'screenshot sets', values: ['APP_IPHONE_67', 'APP_IPAD_PRO_3GEN_129'] }])?.families).toEqual({ iphone: true, ipad: true });
|
|
expect(liveFamilies('1.0.0', 'READY_FOR_SALE', [{ name: 'a', values: [] }, { name: 'b', values: ['APP_IPHONE_67'] }])?.families).toEqual({ iphone: true, ipad: false });
|
|
expect(liveFamilies('1.0.0', 'READY_FOR_SALE', [{ name: 'a', values: [] }])).toBeNull();
|
|
});
|
|
test('verdicts: the exact fix; unknown is a warning; iPhone-only live version is fine', () => {
|
|
const live = liveFamilies('1.0.0', 'READY_FOR_SALE', [{ name: 'screenshot sets', values: ['APP_IPAD_PRO_3GEN_129'] }]);
|
|
const project = pbxFamilies(PBX('1'), 'com.example.notes', 'ios/App/App.xcodeproj/project.pbxproj');
|
|
const v = familyVerdicts({ live, project, ipad: false });
|
|
expect(v.map(x => x.level)).toEqual(['blocker', 'blocker']);
|
|
expect(v[0]!.msg).toContain('ITMS-90101');
|
|
expect(v[0]!.fix).toContain('"1,2"');
|
|
expect(v[1]!.fix).toContain('apple.ipad: true');
|
|
expect(familyVerdicts({ live, project: pbxFamilies(PBX('"1,2"'), 'com.example.notes'), ipad: true }).map(x => x.level)).toEqual(['ok']);
|
|
expect(familyVerdicts({ live: null, project, ipad: false })[0]!.level).toBe('warn');
|
|
expect(familyVerdicts({ live: liveFamilies('1.0.0', 'READY_FOR_SALE', [{ name: 'a', values: ['APP_IPHONE_67'] }]), project, ipad: false })[0]!.level).toBe('ok');
|
|
});
|
|
test('validate rules turn the verdicts into findings', () => {
|
|
const f = appleRules({ deviceFamilies: [{ level: 'blocker', msg: 'x ITMS-90101', fix: 'y' }], version: null, build: null, expectedLocales: [], locales: [], requiredDisplayTypes: [], reviewDetail: null, ageRating: null, priceSchedule: true, availability: true, iaps: [], expectedProducts: [], privacyUrl: { url: 'https://example.com', status: 200 } }).filter(x => x.code === 'device-families');
|
|
expect(f).toMatchObject([{ store: 'apple', level: 'blocker', code: 'device-families', fix: 'y' }]);
|
|
});
|
|
});
|
|
|
|
describe('device families (fake App Store Connect + project)', () => {
|
|
setDefaultTimeout(30_000);
|
|
let s: Stores;
|
|
beforeAll(() => { ascEnv(); });
|
|
afterAll(restore);
|
|
beforeEach(() => { s = installStores(); });
|
|
afterEach(() => { uninstallStores(); });
|
|
/** a live version 1.0.0 with a build whose bundle names the families; screenshotSets: display types of its first locale */
|
|
function live(o: { protocols?: string[]; sets?: string[]; models?: string[] }): void {
|
|
s.asc.put({ type: 'appStoreVersions', id: 'ver-live', attributes: { versionString: '1.0.0', appVersionState: 'READY_FOR_SALE', platform: 'IOS' }, rels: { app: APP } });
|
|
s.asc.put({ type: 'builds', id: 'b-live', attributes: { version: '4', processingState: 'VALID' }, rels: { app: APP, appStoreVersion: 'ver-live' } });
|
|
s.asc.put({ type: 'buildBundles', id: 'bb-live', attributes: { bundleId: 'com.example.notes', bundleType: 'APP', deviceProtocols: o.protocols ?? [] }, rels: { build: 'b-live' } });
|
|
for (const [i, m] of (o.models ?? []).entries()) s.asc.put({ type: 'buildBundleFileSizes', id: `fs-${i}`, attributes: { deviceModel: m }, rels: { buildBundle: 'bb-live' } });
|
|
if (o.sets) {
|
|
s.asc.put({ type: 'appStoreVersionLocalizations', id: 'loc-live', attributes: { locale: 'en-US' }, rels: { appStoreVersion: 'ver-live' } });
|
|
for (const [i, t] of o.sets.entries()) s.asc.put({ type: 'appScreenshotSets', id: `set-${i}`, attributes: { screenshotDisplayType: t }, rels: { appStoreVersionLocalization: 'loc-live' } });
|
|
}
|
|
}
|
|
const IPHONE_ONLY = { 'ios/App/App.xcodeproj/project.pbxproj': PBX('1') };
|
|
const cfg = { ...BASE, apple: { ...BASE.apple!, ipad: false, signing: { teamId: 'ABCDE12345' } } };
|
|
|
|
test('the live version\'s families are read from the build bundle, its device models and its screenshot sets', async () => {
|
|
const c = (await import('../cli/apple/asc')).ascClient;
|
|
live({ sets: ['APP_IPHONE_67', 'APP_IPAD_PRO_3GEN_129'] });
|
|
expect((await liveDeviceFamilies(await c('.', 'com.example.notes', APP), APP))?.families).toEqual({ iphone: true, ipad: true });
|
|
uninstallStores(); s = installStores();
|
|
live({ protocols: ['iphone', 'ipad'] });
|
|
expect((await liveDeviceFamilies(await c('.', 'com.example.notes', APP), APP))?.evidence[0]).toContain('deviceProtocols');
|
|
uninstallStores(); s = installStores();
|
|
live({ models: ['iPad_Pro_12_9_6th', 'iPhone15,2'] });
|
|
expect((await liveDeviceFamilies(await c('.', 'com.example.notes', APP), APP))?.families.ipad).toBe(true);
|
|
uninstallStores(); s = installStores();
|
|
expect(await liveDeviceFamilies(await c('.', 'com.example.notes', APP), APP)).toBeNull();
|
|
});
|
|
|
|
test('apple build stops BEFORE the archive when the project drops iPad that the live version has; --allow-device-gap goes on', async () => {
|
|
live({ sets: ['APP_IPHONE_67', 'APP_IPAD_PRO_3GEN_129'] });
|
|
const argv = ['--build-number', '5', '--no-prebuild'];
|
|
const p = project(cfg, IPHONE_ONLY);
|
|
const r = await capture(() => appleBuild(p.ctx(argv))).catch(e => ({ out: '', err: String((e as Error).message ?? e), exit: 1 }));
|
|
expect(r.exit).toBe(1);
|
|
expect(r.err).toContain('stopped before the archive');
|
|
expect(r.err).toContain('ITMS-90101');
|
|
expect(r.err).toContain('TARGETED_DEVICE_FAMILY to "1,2"');
|
|
expect(r.err).toContain('apple.ipad: true');
|
|
expect(r.err).toContain('--allow-device-gap');
|
|
// dry: warns, never throws
|
|
const dry = await capture(() => appleBuild(p.ctx([...argv, '--dry'])));
|
|
expect(dry.err).toContain('ITMS-90101');
|
|
// the escape hatch passes the check (the run then stops later: no Xcode on this machine)
|
|
const gap = await capture(() => appleBuild(p.ctx([...argv, '--allow-device-gap']))).catch(e => ({ out: '', err: String((e as Error).message ?? e), exit: 1 }));
|
|
expect(gap.err).not.toContain('stopped before the archive');
|
|
});
|
|
|
|
test('apple build passes the check with iPad in the project and apple.ipad true; an iPhone-only live version never blocks', async () => {
|
|
live({ sets: ['APP_IPHONE_67', 'APP_IPAD_PRO_3GEN_129'] });
|
|
const ok = project({ ...cfg, apple: { ...cfg.apple, ipad: true } }, { 'ios/App/App.xcodeproj/project.pbxproj': PBX('"1,2"') });
|
|
const r = await capture(() => appleBuild(ok.ctx(['--build-number', '5', '--no-prebuild', '--dry'])));
|
|
expect(r.err).not.toContain('ITMS-90101');
|
|
uninstallStores(); s = installStores();
|
|
live({ sets: ['APP_IPHONE_67'] });
|
|
const iph = project(cfg, IPHONE_ONLY);
|
|
const r2 = await capture(() => appleBuild(iph.ctx(['--build-number', '5', '--no-prebuild', '--dry'])));
|
|
expect(r2.err).not.toContain('ITMS-90101');
|
|
});
|
|
|
|
test('projectFamilies reads the project found under the root (and apple.build.project)', () => {
|
|
const p = project(cfg, IPHONE_ONLY);
|
|
expect(projectFamilies(p.root, 'com.example.notes')).toMatchObject({ file: 'ios/App/App.xcodeproj/project.pbxproj', list: [1] });
|
|
expect(projectFamilies(p.root, 'com.example.notes', 'ios/App/App.xcodeproj')?.list).toEqual([1]);
|
|
expect(projectFamilies(project(cfg).root, 'com.example.notes')).toBeNull();
|
|
});
|
|
});
|
|
|
|
// ------------------------------------------------------------------------------------------------ 3. TestFlight invite
|
|
|
|
describe('TestFlight invite needs an installable build', () => {
|
|
setDefaultTimeout(30_000);
|
|
let s: Stores;
|
|
beforeAll(() => { ascEnv(); });
|
|
afterAll(restore);
|
|
beforeEach(() => { s = installStores(); });
|
|
afterEach(() => { uninstallStores(); });
|
|
const CSV = { '.storebound/testers.csv': 'email,first_name,groups\ntester1@example.com,Ex,Friends\n' };
|
|
const cfg = { ...BASE, apple: { ...BASE.apple!, testflight: { groups: [{ name: 'Friends' }] } } };
|
|
const group = (): void => { s.asc.put({ type: 'betaGroups', id: 'grp-friends', attributes: { name: 'Friends', isInternalGroup: false }, rels: { app: APP } }); };
|
|
const buildIn = (external: string): void => {
|
|
s.asc.put({ type: 'builds', id: 'b-1', attributes: { version: '7', processingState: 'VALID', expired: false }, rels: { app: APP, betaGroups: ['grp-friends'] } });
|
|
s.asc.put({ type: 'buildBetaDetails', id: 'bd-1', attributes: { externalBuildState: external, internalBuildState: 'IN_BETA_TESTING' }, rels: { build: 'b-1' } });
|
|
};
|
|
const invites = (): number => s.asc.all('betaTesterInvitations').length;
|
|
|
|
test('pure: external needs BETA_APPROVED / IN_BETA_TESTING, internal READY_FOR_BETA_TESTING / IN_BETA_TESTING', () => {
|
|
const b = { attributes: { processingState: 'VALID' } };
|
|
expect(installableBuild(b, { externalBuildState: 'READY_FOR_BETA_SUBMISSION' }, false)).toBe(false);
|
|
expect(installableBuild(b, { externalBuildState: 'WAITING_FOR_BETA_REVIEW' }, false)).toBe(false);
|
|
expect(installableBuild(b, { externalBuildState: 'BETA_APPROVED' }, false)).toBe(true);
|
|
expect(installableBuild(b, { externalBuildState: 'IN_BETA_TESTING' }, false)).toBe(true);
|
|
expect(installableBuild(b, { internalBuildState: 'READY_FOR_BETA_TESTING' }, true)).toBe(true);
|
|
expect(installableBuild({ attributes: { processingState: 'VALID', expired: true } }, { externalBuildState: 'BETA_APPROVED' }, false)).toBe(false);
|
|
expect(noInstallableBuildHint(['Friends'])).toBe('tester added; the invite goes out when a build in Friends passes Beta App Review (re-run with --invite then)');
|
|
expect(noInstallableBuilds409(new Error('POST /v1/betaTesterInvitations -> 409 STATE_ERROR.TESTER_INVITE.NO_INSTALLABLE_BUILDS'))).toBe(true);
|
|
expect(noInstallableBuilds409(new Error('-> 409 ALREADY_EXISTS'))).toBe(false);
|
|
});
|
|
|
|
test('a new external group without an approved build: the tester is added, no invitation is sent, exit 0 with the hint', async () => {
|
|
group();
|
|
buildIn('WAITING_FOR_BETA_REVIEW');
|
|
const p = project(cfg, CSV);
|
|
const r = await capture(() => appleTestflight(p.ctx(['testers', '--group', 'Friends', '--invite', '--yes'])));
|
|
expect(r.exit).toBeNull();
|
|
expect(r.err).toContain('tester added; the invite goes out when a build in Friends passes Beta App Review (re-run with --invite then)');
|
|
expect(s.asc.all('betaTesters')).toHaveLength(1);
|
|
expect(invites()).toBe(0);
|
|
expect(writes(s.calls).some(c => c.path === '/v1/betaTesterInvitations')).toBe(false);
|
|
});
|
|
|
|
test('once a build passed Beta App Review, --invite sends the invitation', async () => {
|
|
group();
|
|
const p = project(cfg, CSV);
|
|
await capture(() => appleTestflight(p.ctx(['testers', '--group', 'Friends', '--invite', '--yes'])));
|
|
expect(invites()).toBe(0);
|
|
buildIn('BETA_APPROVED');
|
|
const r = await capture(() => appleTestflight(p.ctx(['testers', '--group', 'Friends', '--invite', '--yes'])));
|
|
expect(r.exit).toBeNull();
|
|
expect(invites()).toBe(1);
|
|
});
|
|
|
|
test('if the 409 still comes back (the build looked installable), it is the same case: warning, no throw, exit 0', async () => {
|
|
group();
|
|
buildIn('BETA_APPROVED');
|
|
const p = project(cfg, CSV);
|
|
// Apple's answer wins over our read: the double refuses the invitation as the live API did
|
|
s.faults.push({ method: 'POST', match: /\/v1\/betaTesterInvitations/, when: 'before', status: 409, code: 'STATE_ERROR.TESTER_INVITE.NO_INSTALLABLE_BUILDS', detail: 'The tester cannot be invited because the groups they belong to have no installable builds.' });
|
|
const r = await capture(() => appleTestflight(p.ctx(['testers', '--group', 'Friends', '--invite', '--yes'])));
|
|
expect(r.exit).toBeNull();
|
|
expect(r.err).toContain('passes Beta App Review');
|
|
expect(s.asc.all('betaTesters')).toHaveLength(1);
|
|
});
|
|
|
|
test('distribute --submit-review prints the hint for testers that are added but not invited', async () => {
|
|
group();
|
|
buildIn('READY_FOR_BETA_SUBMISSION');
|
|
const p = project(cfg, CSV);
|
|
await capture(() => appleTestflight(p.ctx(['testers', '--group', 'Friends', '--yes'])));
|
|
s.asc.all('buildBetaDetails')[0]!.attributes.processingState = 'x';
|
|
s.asc.put({ type: 'preReleaseVersions', id: 'pre-1', attributes: { version: '1.0.0', platform: 'IOS' }, rels: { app: APP } });
|
|
s.asc.all('builds')[0]!.rels.preReleaseVersion = 'pre-1';
|
|
s.asc.all('builds')[0]!.rels.buildBetaDetail = 'bd-1';
|
|
const r = await capture(() => appleTestflight(p.ctx(['distribute', '--build', '7', '--group', 'Friends', '--submit-review', '--yes'])));
|
|
expect(r.out + r.err).toContain('tester added; the invite goes out when a build in Friends passes Beta App Review');
|
|
});
|
|
});
|