Skip to content
Sign up

flagon-io/g1t

public
00

Where people and agents ship software together. The open-source git platform for the whole job: issues, agents, checks and deploys to the edge.

g1t.sh
gitagentscloudflarerustforgemcp
146 linesCodeBlameRaw
1import assert from "node:assert/strict";
2import { test } from "node:test";
3
4import type { FileDiff } from "@g1t/contracts";
5
6import { diffContent, firstScreens, htmlOfFile, linkedFile, withHtml } from "./diff.ts";
7import { highlightFile } from "./shiki.ts";
8
9const FILE: FileDiff = {
10 path: "src/lib.rs",
11 status: "modified",
12 additions: 2,
13 deletions: 1,
14 binary: false,
15 hunks: [
16 {
17 lines: [
18 { kind: "context", old: 1, new: 1, text: "fn main() {" },
19 { kind: "delete", old: 2, new: null, text: ' println!("old");' },
20 { kind: "add", old: null, new: 2, text: ' println!("new");' },
21 { kind: "add", old: null, new: 3, text: "" },
22 { kind: "context", old: 3, new: 4, text: "}" },
23 ],
24 },
25 { lines: [{ kind: "add", old: null, new: 10, text: "// end" }] },
26 ],
27};
28
29test("a highlighted file's HTML, kept apart and given back, is the same highlighted file", async () => {
30 const highlighted = await highlightFile(FILE);
31 assert.ok(highlighted);
32 const html = htmlOfFile(highlighted);
33 assert.equal(html.length, 2);
34 assert.ok(html[0]!.every((row) => row !== null));
35 // Through the data centre's cache it travels as JSON.
36 const kept = JSON.parse(JSON.stringify(html));
37 assert.deepEqual(withHtml(FILE, kept), highlighted);
38});
39
40test("lines without HTML stay without it", () => {
41 const html = [[null, "<b>x</b>", null, "", null], [null]];
42 const file = withHtml(FILE, html);
43 assert.equal("html" in file.hunks[0]!.lines[0]!, false);
44 assert.equal(file.hunks[0]!.lines[1]!.html, "<b>x</b>");
45 // An empty line's HTML is kept: it is not the same as none.
46 assert.equal(file.hunks[0]!.lines[3]!.html, "");
47 assert.equal("html" in file.hunks[1]!.lines[0]!, false);
48 // The diff given in is not changed.
49 assert.equal("html" in FILE.hunks[0]!.lines[1]!, false);
50});
51
52test("what a file's colours depend on: each line's side and text, not its numbers or path", () => {
53 const moved: FileDiff = {
54 ...FILE,
55 path: "other/lib.rs",
56 hunks: FILE.hunks.map((hunk) => ({ lines: hunk.lines.map((line) => ({ ...line, old: 99, new: 99 })) })),
57 };
58 assert.equal(diffContent(moved), diffContent(FILE));
59 const sideChanged: FileDiff = {
60 ...FILE,
61 hunks: [{ lines: FILE.hunks[0]!.lines.map((line, n) => (n === 0 ? { ...line, kind: "add" as const } : line)) }, FILE.hunks[1]!],
62 };
63 assert.notEqual(diffContent(sideChanged), diffContent(FILE));
64 // A line split differently is different content.
65 const one: FileDiff = { ...FILE, hunks: [{ lines: [{ kind: "add", old: null, new: 1, text: "a\nb" }] }] };
66 const two: FileDiff = {
67 ...FILE,
68 hunks: [{ lines: [{ kind: "add", old: null, new: 1, text: "a" }, { kind: "add", old: null, new: 2, text: "b" }] }],
69 };
70 assert.notEqual(diffContent(one), diffContent(two));
71});
72
73/** A file of `lines` added lines. */
74function sized(path: string, lines: number): FileDiff {
75 return {
76 path,
77 status: "added",
78 additions: lines,
79 deletions: 0,
80 binary: false,
81 hunks: [{ lines: Array.from({ length: lines }, (_, n) => ({ kind: "add" as const, old: null, new: n + 1, text: `line ${n}` })) }],
82 };
83}
84
85const comparisonOf = (files: FileDiff[]) => ({ base: "a".repeat(40), head: "b".repeat(40), files, truncated: false });
86
87test("a small change is sent whole", () => {
88 const files = [sized("a", 10), sized("b", 300), FILE];
89 const sent = firstScreens(comparisonOf(files));
90 assert.deepEqual(sent.files, files);
91 assert.ok(sent.files.every((file) => !file.deferred));
92});
93
94test("past the first screens' lines, files are sent with their counts but not their lines", () => {
95 const files = Array.from({ length: 10 }, (_, n) => sized(`f${n}`, 400));
96 const sent = firstScreens(comparisonOf(files), { budget: 2_000 });
97 // 5 × 400 lines fit in 2,000; the rest wait, in order.
98 assert.deepEqual(
99 sent.files.map((file) => file.hunks.length > 0),
100 [true, true, true, true, true, false, false, false, false, false],
101 );
102 const later = sent.files[7]!;
103 assert.deepEqual(later.deferred, { lines: 400, large: false });
104 assert.equal(later.additions, 400);
105 assert.equal(later.path, "f7");
106 // Once one does not fit, a smaller one after it waits too: what is drawn is the top of the change.
107 const mixed = firstScreens(comparisonOf([sized("a", 800), sized("b", 900), sized("c", 10)]), { budget: 1_000 });
108 assert.deepEqual(mixed.files.map((file) => file.deferred?.lines ?? null), [null, 900, 10]);
109});
110
111test("a very large file waits to be asked for, and does not hold back the files after it", () => {
112 const sent = firstScreens(comparisonOf([sized("package-lock.json", 5_000), sized("src/a.ts", 20)]));
113 assert.deepEqual(sent.files[0]!.deferred, { lines: 5_000, large: true });
114 assert.equal(sent.files[0]!.hunks.length, 0);
115 assert.equal(sent.files[1]!.deferred, undefined);
116 assert.equal(sent.files[1]!.hunks.length, 1);
117});
118
119test("files with comments keep their lines wherever they are, however large", () => {
120 const files = [sized("a", 900), sized("b", 400), sized("lock", 3_000), sized("c", 400)];
121 const sent = firstScreens(comparisonOf(files), { budget: 1_000, eager: ["c", "lock"] });
122 assert.deepEqual(
123 sent.files.map((file) => file.deferred ?? null),
124 [null, { lines: 400, large: false }, null, null],
125 );
126});
127
128test("files the comparison left out wait with no counts; binary files are as they were", () => {
129 const omitted: FileDiff = { ...sized("z", 0), hunks: [], additions: 0, omitted: true };
130 const binary: FileDiff = { ...sized("logo.png", 0), hunks: [], binary: true };
131 const sent = firstScreens(comparisonOf([omitted, binary]));
132 assert.deepEqual(sent.files[0]!.deferred, { lines: null, large: false });
133 assert.equal(sent.files[1]!.deferred, undefined);
134 assert.equal(sent.files[1]!.binary, true);
135});
136
137test("a link to a file names it by path, encoded or not, and only a file of the change", () => {
138 const files = [{ path: "src/a b.ts" }, { path: "README.md" }];
139 assert.equal(linkedFile("#file-README.md", files), "README.md");
140 assert.equal(linkedFile("#diff-src/a%20b.ts", files), "src/a b.ts");
141 assert.equal(linkedFile("#file-src/a b.ts", files), "src/a b.ts");
142 assert.equal(linkedFile("#file-missing.ts", files), null);
143 assert.equal(linkedFile("#readme", files), null);
144 assert.equal(linkedFile("", files), null);
145 assert.equal(linkedFile("#file-%E0%A4%A", files), null);
146});