183 lines
8.0 KiB
JavaScript
183 lines
8.0 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { execFileSync } from 'node:child_process';
|
|
import { mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join, resolve } from 'node:path';
|
|
import { checkCommits, createPlan, git, releaseType, validCommit } from '../lib.mjs';
|
|
import { acquireLock, lockRef } from '../lock.mjs';
|
|
|
|
function fixture(t) {
|
|
const cwd = mkdtempSync(join(tmpdir(), 'fedeo-release-test-'));
|
|
t.after(() => rmSync(cwd, { recursive: true, force: true }));
|
|
symlinkSync(resolve('node_modules'), join(cwd, 'node_modules'), 'dir');
|
|
const run = args => git(args, cwd, { stdio: ['pipe', 'pipe', 'pipe'] });
|
|
run(['init', '-b', 'main']);
|
|
run(['config', 'user.name', 'Release Test']);
|
|
run(['config', 'user.email', 'release@example.test']);
|
|
run(['commit', '--allow-empty', '-m', 'historic baseline']);
|
|
const config = { bootstrapCommit: run(['rev-parse', 'HEAD']), initialVersion: '1.0.0', repositoryUrl: 'https://git.example.test/owner/fedeo' };
|
|
let count = 0;
|
|
const commit = (message, file = 'file') => {
|
|
writeFileSync(join(cwd, file), `${++count}\n`);
|
|
run(['add', file]);
|
|
run(['commit', '-m', message]);
|
|
return run(['rev-parse', 'HEAD']);
|
|
};
|
|
return { cwd, config, commit, run, plan: () => createPlan({ cwd, config }) };
|
|
}
|
|
|
|
test('commit types, scopes and breaking headers are enforced', () => {
|
|
for (const message of ['fix: repair', 'feat(stock): add transfers', 'feat(api)!: replace auth', 'ci: build', 'revert: restore']) assert.ok(validCommit(message));
|
|
for (const message of ['changes', 'Feat: uppercase', 'fix:', 'fix(x) missing colon', 'fix: ']) assert.equal(validCommit(message), false);
|
|
assert.throws(() => checkCommits([{ hash: 'abc123', message: 'misc changes' }]), /Conventional Commits/);
|
|
});
|
|
|
|
test('semantic-release determines the highest required bump and handles maintenance', async () => {
|
|
const commit = message => ({ hash: 'a'.repeat(40), message });
|
|
assert.equal(await releaseType([commit('fix: repair')]), 'patch');
|
|
assert.equal(await releaseType([commit('perf: reduce latency')]), 'patch');
|
|
assert.equal(await releaseType([commit('fix: repair'), commit('feat: add export')]), 'minor');
|
|
assert.equal(await releaseType([commit('feat(api)!: replace auth')]), 'major');
|
|
assert.equal(await releaseType([commit('refactor: change API\n\nBREAKING CHANGE: remove old API')]), 'major');
|
|
assert.equal(await releaseType([commit('docs: improve guide'), commit('ci: check build')]), null);
|
|
});
|
|
|
|
test('first release uses explicit baseline and excludes legacy history', async t => {
|
|
const f = fixture(t);
|
|
f.commit('feat: export');
|
|
const plan = await f.plan();
|
|
assert.equal(plan.version, '1.0.0');
|
|
assert.equal(plan.tag, 'v1.0.0');
|
|
assert.match(plan.notes, /export/);
|
|
assert.doesNotMatch(plan.notes, /historic baseline|compare\/\.\.\./);
|
|
});
|
|
|
|
function divergentHistory(t) {
|
|
const f = fixture(t);
|
|
f.run(['branch', 'legacy-main']);
|
|
f.config.bootstrapCommit = f.commit('chore: versioning baseline');
|
|
f.commit('feat: current export');
|
|
f.run(['checkout', 'legacy-main']);
|
|
f.commit('.gitea/ISSUE_TEMPLATE/bug_report.md aktualisiert', 'legacy-template');
|
|
const legacyHead = f.commit('feat: historic main feature', 'legacy-feature');
|
|
f.config.legacyHistoryHeads = [legacyHead];
|
|
return f;
|
|
}
|
|
|
|
test('the first main merge excludes pinned legacy branch history from validation and notes', async t => {
|
|
const f = divergentHistory(t);
|
|
f.run(['checkout', 'main']);
|
|
f.run(['merge', '--no-ff', 'legacy-main', '-m', 'Merge historic main']);
|
|
const plan = await f.plan();
|
|
assert.equal(plan.version, '1.0.0');
|
|
assert.match(plan.notes, /current export/);
|
|
assert.doesNotMatch(plan.notes, /historic main feature|ISSUE_TEMPLATE/);
|
|
writeFileSync(join(f.cwd, 'release.config.json'), JSON.stringify(f.config));
|
|
const output = execFileSync(process.execPath, [resolve('scripts/release/cli.mjs'), 'check'], { cwd: f.cwd, encoding: 'utf8' });
|
|
assert.match(output, /1 Commit-Nachrichten geprüft/);
|
|
});
|
|
|
|
test('new commits on a legacy branch still affect versions and must use Conventional Commits', async t => {
|
|
const f = divergentHistory(t);
|
|
f.run(['checkout', 'main']);
|
|
f.run(['tag', 'v1.0.0']);
|
|
f.run(['checkout', 'legacy-main']);
|
|
f.commit('feat(api)!: replace exported API', 'new-api');
|
|
f.run(['checkout', 'main']);
|
|
f.run(['merge', '--no-ff', 'legacy-main', '-m', 'Merge new API']);
|
|
const plan = await f.plan();
|
|
assert.equal(plan.version, '2.0.0');
|
|
assert.match(plan.notes, /replace exported API/);
|
|
assert.doesNotMatch(plan.notes, /historic main feature/);
|
|
|
|
f.run(['checkout', 'legacy-main']);
|
|
f.commit('Unclassified new change', 'another-change');
|
|
f.run(['checkout', 'main']);
|
|
f.run(['merge', '--no-ff', 'legacy-main', '-m', 'Merge another change']);
|
|
await assert.rejects(f.plan(), /Conventional Commits fehlen:[\s\S]*Unclassified new change/);
|
|
});
|
|
|
|
test('patch/minor/major releases, multi-digit tags and unrelated component tags', async t => {
|
|
const f = fixture(t);
|
|
f.run(['tag', 'v1.9.0']);
|
|
f.run(['tag', 'v1.10.0']);
|
|
f.run(['tag', 'mobile-v99.0.0']);
|
|
f.commit('fix: repair');
|
|
assert.equal((await f.plan()).version, '1.10.1');
|
|
f.commit('feat: add transfer');
|
|
assert.equal((await f.plan()).version, '1.11.0');
|
|
f.commit('fix(api)!: remove field');
|
|
assert.equal((await f.plan()).version, '2.0.0');
|
|
});
|
|
|
|
test('maintenance does not release; same tagged commit resumes the same version', async t => {
|
|
const f = fixture(t);
|
|
f.run(['tag', 'v1.0.0']);
|
|
f.commit('docs: guide');
|
|
assert.equal((await f.plan()).version, null);
|
|
f.commit('feat: export');
|
|
f.run(['tag', 'v1.1.0']);
|
|
const plan = await f.plan();
|
|
assert.equal(plan.version, '1.1.0');
|
|
assert.equal(plan.resume, true);
|
|
assert.equal(plan.previousTag, 'v1.0.0');
|
|
assert.match(plan.notes, /export/);
|
|
});
|
|
|
|
test('reverted changes cancel out within the same release range', async t => {
|
|
const f = fixture(t);
|
|
f.run(['tag', 'v1.0.0']);
|
|
const sha = f.commit('feat: temporary feature');
|
|
f.run(['revert', '--no-edit', sha]);
|
|
assert.equal((await f.plan()).version, null);
|
|
});
|
|
|
|
test('real merge commits do not replace the feature commits in release notes', async t => {
|
|
const f = fixture(t);
|
|
f.run(['checkout', '-b', 'feature']);
|
|
f.commit('feat: new feature');
|
|
f.run(['checkout', 'main']);
|
|
f.run(['merge', '--no-ff', 'feature', '-m', 'Merge feature']);
|
|
const plan = await f.plan();
|
|
assert.match(plan.notes, /new feature/);
|
|
assert.doesNotMatch(plan.notes, /Merge feature/);
|
|
});
|
|
|
|
test('an unknown baseline fails instead of releasing unrelated history', async t => {
|
|
const f = fixture(t);
|
|
f.config.bootstrapCommit = 'f'.repeat(40);
|
|
await assert.rejects(f.plan(), /Ausgangscommit/);
|
|
});
|
|
|
|
test('missing or mutable legacy history heads fail instead of silently skipping validation', async t => {
|
|
const f = fixture(t);
|
|
f.config.legacyHistoryHeads = ['f'.repeat(40)];
|
|
await assert.rejects(f.plan(), /alte Release-Historie .* fehlt/);
|
|
f.config.legacyHistoryHeads = ['main'];
|
|
await assert.rejects(f.plan(), /feste vollständige Commit-IDs/);
|
|
});
|
|
|
|
test('Git lease lock excludes concurrent runners and cannot remove another owner', async t => {
|
|
const f = fixture(t);
|
|
const remote = join(f.cwd, 'remote.git');
|
|
f.run(['init', '--bare', remote]);
|
|
f.run(['remote', 'add', 'origin', remote]);
|
|
const unlock = await acquireLock({ runGit: f.run, wait: async () => {}, attempts: 1 });
|
|
await assert.rejects(acquireLock({ runGit: f.run, wait: async () => {}, attempts: 1 }), /belegt/);
|
|
const replacement = f.commit('chore: other lock owner');
|
|
f.run(['push', '--force', 'origin', `${replacement}:${lockRef}`]);
|
|
assert.throws(unlock);
|
|
assert.match(f.run(['ls-remote', 'origin', lockRef]), new RegExp(replacement));
|
|
});
|
|
|
|
test('Git lease lock is released after a successful run', async t => {
|
|
const f = fixture(t);
|
|
const remote = join(f.cwd, 'remote.git');
|
|
f.run(['init', '--bare', remote]);
|
|
f.run(['remote', 'add', 'origin', remote]);
|
|
const unlock = await acquireLock({ runGit: f.run, attempts: 1 });
|
|
unlock();
|
|
assert.equal(f.run(['ls-remote', 'origin', lockRef]), '');
|
|
});
|