Open History to see the last commit
1import { assert, describe, it } from "@effect/vitest";
2
3import {
4 gitHubApiHostForRemote,
5 resolveGitHubRepository,
6 parseGitHubRepositorySelector,
7 selectGitHubBaseRepository,
8} from "./gitHubRepositoryResolution.ts";
9
10describe("selectGitHubBaseRepository", () => {
11 const remotes = (...entries: ReadonlyArray<readonly [string, string]>) =>
12 entries
13 .flatMap(([name, url]) => [`${name}\t${url} (fetch)`, `${name}\t${url} (push)`])
14 .join("\n");
15 const select = (input: { remotes: string; resolved?: string }) =>
16 selectGitHubBaseRepository({ resolved: "", host: "github.com", ...input });
17
18 it("picks the repository gh reads without a prompt", () => {
19 assert.deepStrictEqual(select({ remotes: remotes(["fork", "git@github.com:me/web.git"]) }), {
20 owner: "me",
21 name: "web",
22 });
23 const fork = remotes(
24 ["origin", "git@github.com:me/web.git"],
25 ["upstream", "https://github.com/Acme/Web.git"],
26 );
27 assert.deepStrictEqual(select({ remotes: fork }), { owner: "acme", name: "web" });
28 assert.deepStrictEqual(select({ remotes: fork, resolved: "remote.origin.gh-resolved base" }), {
29 owner: "me",
30 name: "web",
31 });
32 assert.deepStrictEqual(
33 select({ remotes: fork, resolved: "remote.origin.gh-resolved acme/other" }),
34 { owner: "acme", name: "other" },
35 );
36 const partialClone = fork.replaceAll("(fetch)", "(fetch) [blob:none]");
37 assert.deepStrictEqual(
38 select({ remotes: partialClone, resolved: "remote.origin.gh-resolved base" }),
39 { owner: "me", name: "web" },
40 );
41 assert.deepStrictEqual(
42 select({
43 remotes: remotes(
44 ["origin", "git@github.com:me/web.git"],
45 ["Upstream", "git@github.com:acme/web.git"],
46 ),
47 }),
48 { owner: "acme", name: "web" },
49 );
50 });
51
52 it("honors a marked SSH alias origin over upstream", () => {
53 for (const url of [
54 "git@github.com-scale:me/web.git",
55 "ssh://git@github.com-scale:22/me/web.git",
56 "git@github-work:me/web.git",
57 ]) {
58 const input = {
59 remotes: remotes(["origin", url], ["upstream", "https://github.com/acme/web.git"]),
60 resolved: "remote.origin.gh-resolved base",
61 };
62 assert.deepStrictEqual(select(input), { owner: "me", name: "web" }, url);
63 assert.deepStrictEqual(
64 resolveGitHubRepository({ ...input, hostHint: undefined, defaultHost: "github.com" }),
65 { host: "github.com", locator: { host: "github.com", owner: "me", name: "web" } },
66 url,
67 );
68 }
69 });
70
71 it("does not honor a github.com mark on a different or unrecognized host", () => {
72 for (const url of [
73 "git@github.com-evil.example:me/web.git",
74 "git@github.com.evil.example:me/web.git",
75 "git@evil-github.com:me/web.git",
76 "https://github.com-scale/me/web.git",
77 "git@work:me/web.git",
78 ]) {
79 const input = {
80 remotes: remotes(["origin", url], ["upstream", "https://github.com/acme/web.git"]),
81 resolved: "remote.origin.gh-resolved base",
82 };
83 assert.strictEqual(select(input), null, url);
84 assert.deepStrictEqual(
85 resolveGitHubRepository({ ...input, hostHint: "github.com", defaultHost: "github.com" }),
86 { host: "github.com", locator: { host: "github.com", owner: "acme", name: "web" } },
87 url,
88 );
89 }
90 });
91
92 it("preserves selection behavior for real hosts with explicit ports", () => {
93 const input = {
94 remotes: remotes(["origin", "https://github.example.com:8443/me/web.git"]),
95 resolved: "remote.origin.gh-resolved acme/other",
96 };
97 assert.strictEqual(
98 selectGitHubBaseRepository({ ...input, host: "github.example.com:8443" }),
99 null,
100 );
101 assert.deepStrictEqual(
102 resolveGitHubRepository({ ...input, hostHint: undefined, defaultHost: "github.com" }),
103 {
104 host: "github.example.com:8443",
105 locator: { host: "github.example.com:8443", owner: "me", name: "web" },
106 },
107 );
108 });
109
110 it("leaves gh to choose when it might weigh the remotes differently", () => {
111 for (const input of [
112 { remotes: "" },
113 {
114 remotes: remotes(["a", "git@github.com:me/web.git"], ["b", "git@github.com:acme/web.git"]),
115 },
116 {
117 remotes: remotes(
118 ["origin", "git@github.com:me/web.git"],
119 ["mirror", "git@gitlab.com:me/web.git"],
120 ),
121 },
122 { remotes: remotes(["origin", "git@work:me/web.git"]) },
123 {
124 remotes: remotes(
125 ["origin", "git@github.com:me/web.git"],
126 ["Origin", "git@github.com:acme/web.git"],
127 ),
128 },
129 {
130 remotes: remotes(
131 ["origin", "git@github.com:me/web.git"],
132 ["upstream", "git@github.com:acme/web.git"],
133 ),
134 resolved: "remote.origin.gh-resolved base\nremote.upstream.gh-resolved base",
135 },
136 ]) {
137 assert.strictEqual(select(input), null);
138 }
139 });
140});
141
142describe("parseGitHubRepositorySelector", () => {
143 it("drops a clone URL's .git suffix wherever the selector ends", () => {
144 for (const [selector, host, name] of [
145 ["https://github.com/acme/web.git", "github.com", "web"],
146 ["https://github.com/acme/web.git/", "github.com", "web"],
147 ["https://github.com/acme/web.git?tab=readme", "github.com", "web"],
148 ["https://github.com/acme/web.git.git", "github.com", "web.git"],
149 ["https://github.com/acme/web.git.git/", "github.com", "web.git"],
150 ["acme/web.git/", "github.com", "web"],
151 ["ghe.example.com/acme/web.git/", "ghe.example.com", "web"],
152 ] as const) {
153 assert.deepStrictEqual(parseGitHubRepositorySelector(selector, "github.com"), {
154 host,
155 owner: "acme",
156 name,
157 });
158 }
159 });
160});
161
162describe("gitHubApiHostForRemote", () => {
163 it("reads an SSH alias through github.com and a real host as itself", () => {
164 assert.strictEqual(gitHubApiHostForRemote("git@github:acme/web.git"), "github.com");
165 assert.strictEqual(
166 gitHubApiHostForRemote("git@github.example.com:a/b.git"),
167 "github.example.com",
168 );
169 assert.strictEqual(gitHubApiHostForRemote("git@gitlab.com:a/b.git"), null);
170 });
171});
172
173describe("github.com-<name> SSH aliases", () => {
174 it("reads a per-account alias through github.com", () => {
175 for (const url of [
176 "git@github.com-scale:scalable-so/scalablev2.git",
177 "git@GitHub.com-Work:acme/web.git",
178 "ssh://git@github.com-personal/acme/web.git",
179 "ssh://git@github.com-scale:22/acme/web.git",
180 ]) {
181 assert.strictEqual(gitHubApiHostForRemote(url), "github.com", url);
182 }
183 });
184
185 it("never maps a hostile or real DNS host onto github.com", () => {
186 for (const [url, host] of [
187 ["git@github.com-evil.example:acme/web.git", "github.com-evil.example"],
188 ["ssh://git@github.com-evil.example/acme/web.git", "github.com-evil.example"],
189 ["git@github.com.evil.example:acme/web.git", "github.com.evil.example"],
190 ["git@evil-github.com:acme/web.git", null],
191 ["https://github.com-scale/acme/web.git", "github.com-scale"],
192 ] as const) {
193 assert.strictEqual(gitHubApiHostForRemote(url), host, url);
194 }
195 });
196
197 it("resolves the API host and repository from an alias remote and its host hint", () => {
198 const remotes = [
199 "origin\tgit@github.com-scale:scalable-so/scalablev2.git (fetch)",
200 "origin\tgit@github.com-scale:scalable-so/scalablev2.git (push)",
201 ].join("\n");
202 const expected = {
203 host: "github.com",
204 locator: { host: "github.com", owner: "scalable-so", name: "scalablev2" },
205 };
206 for (const hostHint of ["github.com-scale", undefined]) {
207 assert.deepStrictEqual(
208 resolveGitHubRepository({ remotes, resolved: "", hostHint, defaultHost: "github.com" }),
209 expected,
210 );
211 }
212 });
213
214 it.each([false, true])("preserves an HTTPS alias-shaped host hint (upstream: %s)", (upstream) => {
215 const remotes = [
216 "origin\thttps://github.com-scale/me/web.git (fetch)",
217 ...(upstream ? ["upstream\thttps://github.com/acme/web.git (fetch)"] : []),
218 ].join("\n");
219 assert.deepStrictEqual(
220 resolveGitHubRepository({
221 remotes,
222 resolved: "",
223 hostHint: "github.com-scale",
224 defaultHost: "github.com",
225 }),
226 {
227 host: "github.com-scale",
228 locator: { host: "github.com-scale", owner: "me", name: "web" },
229 },
230 );
231 });
232
233 it("requires matching SSH evidence to normalize a dotted hint", () => {
234 for (const remotes of [
235 "",
236 "origin\tgit@github.com-work:me/web.git (fetch)",
237 "origin\tgit@github.com-scale:me/web.git (push)",
238 ]) {
239 assert.deepStrictEqual(
240 resolveGitHubRepository({
241 remotes,
242 resolved: "",
243 hostHint: "GitHub.com-Scale",
244 defaultHost: "github.com",
245 }),
246 { host: "github.com-scale", locator: null },
247 );
248 }
249 });
250
251 it("preserves a dotted hint when matching remotes use both transports", () => {
252 const entries = [
253 "origin\thttps://github.com-scale/me/web.git (fetch)",
254 "upstream\tgit@github.com-scale:acme/web.git (fetch)",
255 ];
256 for (const [remotes, hostHint, resolved] of [
257 [entries.join("\n"), "github.com-scale", "remote.origin.gh-resolved base"],
258 [entries.join("\n"), "github.com-scale", ""],
259 [entries.toReversed().join("\n"), undefined, "remote.origin.gh-resolved base"],
260 [entries.toReversed().join("\n"), undefined, ""],
261 ] as const) {
262 assert.deepStrictEqual(
263 resolveGitHubRepository({
264 remotes,
265 resolved,
266 hostHint,
267 defaultHost: "github.com",
268 }),
269 {
270 host: "github.com-scale",
271 locator: { host: "github.com-scale", owner: "me", name: "web" },
272 },
273 );
274 }
275 });
276
277 it("retains dotless hint compatibility without remote evidence", () => {
278 for (const hostHint of ["github", "github-work", "workgithub"]) {
279 assert.deepStrictEqual(
280 resolveGitHubRepository({ remotes: "", resolved: "", hostHint, defaultHost: hostHint }),
281 { host: "github.com", locator: null },
282 );
283 }
284 });
285
286 it("keeps a hostile host hint and its remote off github.com", () => {
287 const remotes = "origin\tgit@github.com-evil.example:acme/web.git (fetch)";
288 assert.deepStrictEqual(
289 resolveGitHubRepository({
290 remotes,
291 resolved: "",
292 hostHint: "github.com-evil.example",
293 defaultHost: "github.com-evil.example",
294 }),
295 {
296 host: "github.com-evil.example",
297 locator: { host: "github.com-evil.example", owner: "acme", name: "web" },
298 },
299 );
300 });
301});
302
303describe("parseGitHubRepositorySelector", () => {
304 it("reads host/owner/name only when the host is a plain hostname", () => {
305 assert.deepStrictEqual(parseGitHubRepositorySelector("GHE.corp:8443/acme/web", "github.com"), {
306 host: "ghe.corp:8443",
307 owner: "acme",
308 name: "web",
309 });
310 for (const selector of [
311 "evil.com#.ghe.com/acme/web",
312 "evil.com?.ghe.com/acme/web",
313 "token@evil.com/acme/web",
314 "evil.com\\.ghe.com/acme/web",
315 "-evil.com/acme/web",
316 ]) {
317 assert.strictEqual(parseGitHubRepositorySelector(selector, "github.com"), null, selector);
318 }
319 });
320});