Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

gitHubMediaFetch.test.ts

240 lines9.1 KB

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("&", "&amp;") : 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 );
126 });
127​
128 it.effect("keeps the credential off the object store a redirect hands the media to", () => {
129 const authorizations: Array<[string, string | undefined]> = [];
130 return Effect.gen(function* () {
131 const fetchMedia = yield* GitHubMediaFetch.make;
132 const response = yield* fetchMedia({
133 url: "https://github.com/user-attachments/assets/1a1842fb",
134 headers: { range: "bytes=0-1" },
135 });
136 expect(response?.status).toBe(200);
137 expect(authorizations).toEqual([
138 ["github.com", "Bearer signed-in"],
139 ["objects.example.com", undefined],
140 ]);
141 }).pipe(
142 Effect.provide(
143 Layer.merge(
144 Layer.mock(GitHubRest.GitHubRest)({}),
145 Layer.mock(GitHubCredentials.GitHubCredentials)({
146 get: (host) =>
147 Effect.succeed({
148 host,
149 token: Redacted.make("signed-in"),
150 source: "gh" as const,
151 fingerprint: "fingerprint",
152 }),
153 }),
154 ),
155 ),
156 Effect.provideService(
157 HttpClient.HttpClient,
158 HttpClient.make((request) => {
159 const url = new URL(request.url);
160 authorizations.push([url.hostname, request.headers.authorization]);
161 return Effect.succeed(
162 HttpClientResponse.fromWeb(
163 request,
164 url.hostname === "github.com"
165 ? new Response(null, {
166 status: 302,
167 headers: { location: "https://objects.example.com/signed" },
168 })
169 : new Response(null, { status: 200 }),
170 ),
171 );
172 }),
173 ),
174 );
175 });
176​
177 it.effect(
178 "renders SSO uploads in the PR repository and reuses the signed URL for a range",
179 () => {
180 const url = "https://github.com/user-attachments/assets/explicit-pr-context";
181 const fixture = makeSsoFixture(url);
182 return Effect.gen(function* () {
183 const fetchMedia = yield* GitHubMediaFetch.make;
184 const request = { url, headers: {}, repository: PR_REPOSITORY };
185 expect((yield* fetchMedia(request))?.status).toBe(200);
186 expect((yield* fetchMedia({ ...request, headers: { range: "bytes=2-5" } }))?.status).toBe(
187 206,
188 );
189 expect(fixture.rendered).toHaveLength(1);
190 expect(fixture.rendered[0]).toMatchObject({
191 host: "github.com",
192 method: "POST",
193 path: "markdown",
194 accept: "text/html",
195 body: { text: `![](${url})`, mode: "gfm", context: PR_REPOSITORY },
196 });
197 expect(fixture.requests).toEqual([
198 { url, authorization: "Bearer account-a" },
199 { url: fixture.signedUrls[0] },
200 { url: fixture.signedUrls[0], range: "bytes=2-5" },
201 ]);
202 }).pipe(Effect.provide(fixture.layer));
203 },
204 );
205​
206 it.effect("renders a legacy upload in the repository its path names", () => {
207 const url = `https://github.com/${PR_REPOSITORY}/assets/123/legacy`;
208 const fixture = makeSsoFixture(url);
209 return Effect.gen(function* () {
210 const fetchMedia = yield* GitHubMediaFetch.make;
211 const response = yield* fetchMedia({ url, headers: {}, repository: "personal/unrelated" });
212 expect(response?.status).toBe(200);
213 expect(fixture.rendered.map((input) => input.body)).toEqual([
214 { text: `![](${url})`, mode: "gfm", context: PR_REPOSITORY },
215 ]);
216 }).pipe(Effect.provide(fixture.layer));
217 });
218​
219 it.effect("renders a fresh signed URL after an account switch, early expiry, or its TTL", () => {
220 const url = "https://github.com/user-attachments/assets/cache-lifecycle";
221 const fixture = makeSsoFixture(url);
222 const request = { url, headers: {}, repository: PR_REPOSITORY };
223 return Effect.gen(function* () {
224 const fetchMedia = yield* GitHubMediaFetch.make;
225 yield* fetchMedia(request);
226 fixture.state.account = "account-b";
227 yield* fetchMedia(request);
228 expect(fixture.rendered).toHaveLength(2);
229​
230 fixture.state.expired.add(fixture.signedUrls.at(-1)!);
231 expect((yield* fetchMedia(request))?.status).toBe(200);
232 expect(fixture.rendered).toHaveLength(3);
233​
234 yield* TestClock.adjust("6 minutes");
235 yield* fetchMedia(request);
236 expect(fixture.rendered).toHaveLength(4);
237 expect(fixture.requests.at(-1)?.url).toBe(fixture.signedUrls.at(-1));
238 }).pipe(Effect.provide(fixture.layer));
239 });
240});