Open History to see the last commit
1import { describe, expect, it } from "@effect/vitest";
2import * as Effect from "effect/Effect";
3import * as Layer from "effect/Layer";
4import * as Redacted from "effect/Redacted";
5import * as TestClock from "effect/testing/TestClock";
6import { HttpClient, HttpClientResponse } from "effect/http";
7
8import * as GitHubCredentials from "./GitHubCredentials.ts";
9import * as GitHubMediaFetch from "./gitHubMediaFetch.ts";
10import * as GitHubRest from "./GitHubRest.ts";
11
12const PR_REPOSITORY = "enterprise/private";
13
14/** An SSO organization: the upload URL answers with a sign-in page, a rendered signed URL with bytes. */
15const makeSsoFixture = (uploadUrl: string) => {
16 const state = { account: "account-a", expired: new Set<string>() };
17 const rendered: Array<GitHubRest.GitHubRestInput> = [];
18 const signedUrls: Array<string> = [];
19 const requests: Array<{ url: string; authorization?: string; range?: string }> = [];
20 const credential = (host: string) =>
21 Effect.sync(() => ({
22 host,
23 token: Redacted.make(state.account),
24 fingerprint: state.account,
25 source: "gh" as const,
26 }));
27 const layer = Layer.mergeAll(
28 Layer.mock(GitHubCredentials.GitHubCredentials)({ get: credential }),
29 Layer.mock(GitHubRest.GitHubRest)({
30 rest: (input) =>
31 Effect.sync(() => {
32 rendered.push(input);
33 const signed = `https://private-user-images.githubusercontent.com/1/upload.mp4?jwt=${state.account}-${rendered.length}&x=1`;
34 const inRepository =
35 (input.body as { readonly context?: string } | undefined)?.context === PR_REPOSITORY;
36 if (inRepository) signedUrls.push(signed);
37 return {
38 status: 200,
39 headers: {},
40 body: `<p><img src="${inRepository ? signed.replaceAll("&", "&") : uploadUrl}" alt=""></p>`,
41 truncated: false,
42 invalidUtf8: false,
43 };
44 }),
45 }),
46 Layer.succeed(
47 HttpClient.HttpClient,
48 HttpClient.make((request) =>
49 Effect.sync(() => {
50 requests.push({
51 url: request.url,
52 ...(request.headers.authorization
53 ? { authorization: request.headers.authorization }
54 : {}),
55 ...(request.headers.range ? { range: request.headers.range } : {}),
56 });
57 if (request.url === uploadUrl) {
58 return HttpClientResponse.fromWeb(
59 request,
60 new Response("<html>Sign in with SSO</html>", {
61 headers: { "content-type": "text/html; charset=utf-8" },
62 }),
63 );
64 }
65 expect(signedUrls).toContain(request.url);
66 const status = state.expired.has(request.url) ? 403 : request.headers.range ? 206 : 200;
67 return HttpClientResponse.fromWeb(
68 request,
69 new Response(null, { status, headers: { "content-type": "video/mp4" } }),
70 );
71 }),
72 ),
73 ),
74 );
75 return { layer, state, rendered, signedUrls, requests };
76};
77
78describe("GitHubMediaFetch", () => {
79 it.effect("loads private media immediately after login with the GitHub credential", () => {
80 let lookups = 0;
81 const authorizations: Array<string | undefined> = [];
82 return Effect.gen(function* () {
83 const fetchMedia = yield* GitHubMediaFetch.make;
84 const request = {
85 url: "https://raw.githubusercontent.com/owner/repo/main/shot.png",
86 headers: {},
87 };
88 expect((yield* fetchMedia(request))?.status).toBe(404);
89 expect((yield* fetchMedia(request))?.status).toBe(200);
90 expect((yield* fetchMedia(request))?.status).toBe(200);
91 expect(lookups).toBe(3);
92 expect(authorizations).toEqual([undefined, "Bearer signed-in", "Bearer signed-in"]);
93 }).pipe(
94 Effect.provide(
95 Layer.merge(
96 Layer.mock(GitHubRest.GitHubRest)({}),
97 Layer.mock(GitHubCredentials.GitHubCredentials)({
98 get: (host) =>
99 ++lookups === 1
100 ? Effect.fail(new GitHubCredentials.GitHubNotSignedInError({ host }))
101 : Effect.succeed({
102 host,
103 token: Redacted.make("signed-in"),
104 source: "gh" as const,
105 fingerprint: "fingerprint",
106 }),
107 }),
108 ),
109 ),
110 Effect.provideService(
111 HttpClient.HttpClient,
112 HttpClient.make((request) => {
113 authorizations.push(request.headers.authorization);
114 return Effect.succeed(
115 HttpClientResponse.fromWeb(
116 request,
117 new Response(null, {
118 status: request.headers.authorization ? 200 : 404,
119 headers: { "content-type": "image/png" },
120 }),
121 ),
122 );
123 }),
124 ),
125 Effect.scoped,
126 );
127 });
128
129 it.effect("keeps the credential off the object store a redirect hands the media to", () => {
130 const authorizations: Array<[string, string | undefined]> = [];
131 return Effect.gen(function* () {
132 const fetchMedia = yield* GitHubMediaFetch.make;
133 const response = yield* fetchMedia({
134 url: "https://github.com/user-attachments/assets/1a1842fb",
135 headers: { range: "bytes=0-1" },
136 });
137 expect(response?.status).toBe(200);
138 expect(authorizations).toEqual([
139 ["github.com", "Bearer signed-in"],
140 ["objects.example.com", undefined],
141 ]);
142 }).pipe(
143 Effect.provide(
144 Layer.merge(
145 Layer.mock(GitHubRest.GitHubRest)({}),
146 Layer.mock(GitHubCredentials.GitHubCredentials)({
147 get: (host) =>
148 Effect.succeed({
149 host,
150 token: Redacted.make("signed-in"),
151 source: "gh" as const,
152 fingerprint: "fingerprint",
153 }),
154 }),
155 ),
156 ),
157 Effect.provideService(
158 HttpClient.HttpClient,
159 HttpClient.make((request) => {
160 const url = new URL(request.url);
161 authorizations.push([url.hostname, request.headers.authorization]);
162 return Effect.succeed(
163 HttpClientResponse.fromWeb(
164 request,
165 url.hostname === "github.com"
166 ? new Response(null, {
167 status: 302,
168 headers: { location: "https://objects.example.com/signed" },
169 })
170 : new Response(null, { status: 200 }),
171 ),
172 );
173 }),
174 ),
175 Effect.scoped,
176 );
177 });
178
179 it.effect(
180 "renders SSO uploads in the PR repository and reuses the signed URL for a range",
181 () => {
182 const url = "https://github.com/user-attachments/assets/explicit-pr-context";
183 const fixture = makeSsoFixture(url);
184 return Effect.gen(function* () {
185 const fetchMedia = yield* GitHubMediaFetch.make;
186 const request = { url, headers: {}, repository: PR_REPOSITORY };
187 expect((yield* fetchMedia(request))?.status).toBe(200);
188 expect((yield* fetchMedia({ ...request, headers: { range: "bytes=2-5" } }))?.status).toBe(
189 206,
190 );
191 expect(fixture.rendered).toHaveLength(1);
192 expect(fixture.rendered[0]).toMatchObject({
193 host: "github.com",
194 method: "POST",
195 path: "markdown",
196 accept: "text/html",
197 body: { text: ``, mode: "gfm", context: PR_REPOSITORY },
198 });
199 expect(fixture.requests).toEqual([
200 { url, authorization: "Bearer account-a" },
201 { url: fixture.signedUrls[0] },
202 { url: fixture.signedUrls[0], range: "bytes=2-5" },
203 ]);
204 }).pipe(Effect.provide(fixture.layer), Effect.scoped);
205 },
206 );
207
208 it.effect("renders a legacy upload in the repository its path names", () => {
209 const url = `https://github.com/${PR_REPOSITORY}/assets/123/legacy`;
210 const fixture = makeSsoFixture(url);
211 return Effect.gen(function* () {
212 const fetchMedia = yield* GitHubMediaFetch.make;
213 const response = yield* fetchMedia({ url, headers: {}, repository: "personal/unrelated" });
214 expect(response?.status).toBe(200);
215 expect(fixture.rendered.map((input) => input.body)).toEqual([
216 { text: ``, mode: "gfm", context: PR_REPOSITORY },
217 ]);
218 }).pipe(Effect.provide(fixture.layer), Effect.scoped);
219 });
220
221 it.effect("renders a fresh signed URL after an account switch, early expiry, or its TTL", () => {
222 const url = "https://github.com/user-attachments/assets/cache-lifecycle";
223 const fixture = makeSsoFixture(url);
224 const request = { url, headers: {}, repository: PR_REPOSITORY };
225 return Effect.gen(function* () {
226 const fetchMedia = yield* GitHubMediaFetch.make;
227 yield* fetchMedia(request);
228 fixture.state.account = "account-b";
229 yield* fetchMedia(request);
230 expect(fixture.rendered).toHaveLength(2);
231
232 fixture.state.expired.add(fixture.signedUrls.at(-1)!);
233 expect((yield* fetchMedia(request))?.status).toBe(200);
234 expect(fixture.rendered).toHaveLength(3);
235
236 yield* TestClock.adjust("6 minutes");
237 yield* fetchMedia(request);
238 expect(fixture.rendered).toHaveLength(4);
239 expect(fixture.requests.at(-1)?.url).toBe(fixture.signedUrls.at(-1));
240 }).pipe(Effect.provide(fixture.layer), Effect.scoped);
241 });
242});