mirror of https://github.com/garrytan/gstack.git
97 lines
3.5 KiB
TypeScript
97 lines
3.5 KiB
TypeScript
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
|
|
import { execFileSync } from 'child_process';
|
|
import * as fs from 'fs';
|
|
import * as path from 'path';
|
|
import * as os from 'os';
|
|
|
|
const ROOT = path.resolve(import.meta.dir, '..');
|
|
const DRIVER = path.join(ROOT, 'bin', 'gstack-jsonl-merge');
|
|
|
|
let tmpDir: string;
|
|
|
|
beforeEach(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-jsonl-merge-'));
|
|
});
|
|
|
|
afterEach(() => {
|
|
fs.rmSync(tmpDir, { recursive: true, force: true });
|
|
});
|
|
|
|
/**
|
|
* Run the merge driver the way git does: `driver <base> <ours> <theirs>`.
|
|
* The driver writes the merged result back to the <ours> file. Returns that
|
|
* file's content. `base`/`ours`/`theirs` are arrays of JSONL lines (the file
|
|
* is created from them); pass `null` to omit a file entirely (git passes an
|
|
* absent path for an added file, which the driver must tolerate).
|
|
*/
|
|
function runMerge(
|
|
base: string[] | null,
|
|
ours: string[] | null,
|
|
theirs: string[] | null,
|
|
): string {
|
|
const write = (name: string, lines: string[] | null): string => {
|
|
const p = path.join(tmpDir, name);
|
|
if (lines === null) return path.join(tmpDir, `${name}.absent`);
|
|
fs.writeFileSync(p, lines.length ? lines.join('\n') + '\n' : '');
|
|
return p;
|
|
};
|
|
const basePath = write('base', base);
|
|
const oursPath = write('ours', ours);
|
|
const theirsPath = write('theirs', theirs);
|
|
execFileSync(DRIVER, [basePath, oursPath, theirsPath], {
|
|
encoding: 'utf-8',
|
|
timeout: 15000,
|
|
});
|
|
return fs.readFileSync(oursPath, 'utf-8');
|
|
}
|
|
|
|
describe('gstack-jsonl-merge', () => {
|
|
test('equal-ts entries resolve identically regardless of side (convergence)', () => {
|
|
// Two machines append a different event in the same second, then each
|
|
// merges the other's push. Machine A sees its own line as "ours"; machine
|
|
// B sees the same line as "theirs". The merge must produce the same file
|
|
// on both, or the repos diverge and never reconcile.
|
|
const a = '{"ts":"2026-05-28T10:00:00Z","event":"a"}';
|
|
const b = '{"ts":"2026-05-28T10:00:00Z","event":"b"}';
|
|
|
|
const machineA = runMerge([], [a], [b]); // a = ours, b = theirs
|
|
const machineB = runMerge([], [b], [a]); // b = ours, a = theirs
|
|
|
|
expect(machineA).toBe(machineB);
|
|
// Both lines survive.
|
|
expect(machineA).toContain('"event":"a"');
|
|
expect(machineA).toContain('"event":"b"');
|
|
});
|
|
|
|
test('non-timestamped lines also resolve identically regardless of side', () => {
|
|
const a = '{"event":"a"}'; // no ts -> hash-ordered
|
|
const b = '{"event":"b"}';
|
|
expect(runMerge([], [a], [b])).toBe(runMerge([], [b], [a]));
|
|
});
|
|
|
|
test('plain (non-JSON) lines resolve identically regardless of side', () => {
|
|
expect(runMerge([], ['zebra'], ['apple'])).toBe(
|
|
runMerge([], ['apple'], ['zebra']),
|
|
);
|
|
});
|
|
|
|
test('exact-duplicate lines are deduped', () => {
|
|
const line = '{"ts":"2026-05-28T10:00:00Z","event":"a"}';
|
|
const out = runMerge([line], [line], [line]);
|
|
expect(out.trimEnd().split('\n')).toEqual([line]);
|
|
});
|
|
|
|
test('timestamped entries sort ascending by ts', () => {
|
|
const early = '{"ts":"2026-05-28T09:00:00Z","event":"early"}';
|
|
const late = '{"ts":"2026-05-28T11:00:00Z","event":"late"}';
|
|
const out = runMerge([], [late], [early]).trimEnd().split('\n');
|
|
expect(out).toEqual([early, late]);
|
|
});
|
|
|
|
test('absent ours/theirs files are tolerated (added-file merge)', () => {
|
|
const a = '{"ts":"2026-05-28T10:00:00Z","event":"a"}';
|
|
const out = runMerge(null, [a], null);
|
|
expect(out.trimEnd()).toBe(a);
|
|
});
|
|
});
|