@lullabot/playwright-testing 0.1.0 → 1.0.1

package/src/github/attachments.test.ts

@@ -1,248 +1,309 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import * as fs from 'fs'
-import * as os from 'os'
-import * as path from 'path'
-import { AttachmentUploader, mimeTypeFor, FetchLike } from './attachments'
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { AttachmentUploader, mimeTypeFor, FetchLike } from "./attachments";
 
-let tmpDir: string
+let tmpDir: string;
 
 beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'attachments-test-'))
-})
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "attachments-test-"));
+});
 
 afterEach(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true })
-})
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
 
 /** Write a file of a given size and return its path. */
 function writeFile(name: string, bytes = 16): string {
-  const filePath = path.join(tmpDir, name)
-  fs.writeFileSync(filePath, Buffer.alloc(bytes, 1))
-  return filePath
+  const filePath = path.join(tmpDir, name);
+  fs.writeFileSync(filePath, Buffer.alloc(bytes, 1));
+  return filePath;
 }
 
 /** A fetch stub that records calls and replays canned responses. */
-function stubFetch(responses: Array<{ ok: boolean; status: number; body: string }>) {
-  const calls: string[] = []
-  const headers: Array<Record<string, string>> = []
+function stubFetch(
+  responses: Array<{ ok: boolean; status: number; body: string }>,
+) {
+  const calls: string[] = [];
+  const headers: Array<Record<string, string>> = [];
   const impl: FetchLike = async (url, init) => {
-    calls.push(url)
-    headers.push(init.headers)
-    const next = responses.shift() ?? { ok: true, status: 201, body: '{"url":"https://example.test/a"}' }
+    calls.push(url);
+    headers.push(init.headers);
+    const next = responses.shift() ?? {
+      ok: true,
+      status: 201,
+      body: '{"url":"https://example.test/a"}',
+    };
     return {
       ok: next.ok,
       status: next.status,
       text: async () => next.body,
-    }
-  }
-  return { impl, calls, headers }
+    };
+  };
+  return { impl, calls, headers };
 }
 
-describe('mimeTypeFor', () => {
-  it('maps the image types GitHub renders inline', () => {
-    expect(mimeTypeFor('a/b/diff.png')).toBe('image/png')
-    expect(mimeTypeFor('shot.JPEG')).toBe('image/jpeg')
-    expect(mimeTypeFor('clip.webm')).toBe('video/webm')
-    expect(mimeTypeFor('icon.svg')).toBe('image/svg+xml')
-    expect(mimeTypeFor('clip.MOV')).toBe('video/quicktime')
-  })
-
-  it('falls back to a generic type for anything else', () => {
-    expect(mimeTypeFor('report.txt')).toBe('application/octet-stream')
-  })
-})
-
-describe('AttachmentUploader', () => {
-  it('is off without a token, which is the normal case', async () => {
-    const uploader = new AttachmentUploader({ repositoryId: '1' })
-    expect(uploader.enabled).toBe(false)
-    expect(uploader.disabledReason).toMatch(/no upload token/)
-    expect(await uploader.upload(writeFile('a.png'))).toBeNull()
-  })
-
-  it('is off without a repository ID', () => {
-    const uploader = new AttachmentUploader({ token: 't' })
-    expect(uploader.enabled).toBe(false)
-    expect(uploader.disabledReason).toMatch(/repository ID/)
-  })
-
-  it('returns the asset URL and passes the endpoint what it needs', async () => {
+describe("mimeTypeFor", () => {
+  it("maps the image types GitHub renders inline", () => {
+    expect(mimeTypeFor("a/b/diff.png")).toBe("image/png");
+    expect(mimeTypeFor("shot.JPEG")).toBe("image/jpeg");
+    expect(mimeTypeFor("clip.webm")).toBe("video/webm");
+    expect(mimeTypeFor("icon.svg")).toBe("image/svg+xml");
+    expect(mimeTypeFor("clip.MOV")).toBe("video/quicktime");
+  });
+
+  it("falls back to a generic type for anything else", () => {
+    expect(mimeTypeFor("report.txt")).toBe("application/octet-stream");
+  });
+});
+
+describe("AttachmentUploader", () => {
+  it("is off without a token, which is the normal case", async () => {
+    const uploader = new AttachmentUploader({ repositoryId: "1" });
+    expect(uploader.enabled).toBe(false);
+    expect(uploader.disabledReason).toMatch(/no upload token/);
+    expect(await uploader.upload(writeFile("a.png"))).toBeNull();
+  });
+
+  it("is off without a repository ID", () => {
+    const uploader = new AttachmentUploader({ token: "t" });
+    expect(uploader.enabled).toBe(false);
+    expect(uploader.disabledReason).toMatch(/repository ID/);
+  });
+
+  it("returns the asset URL and passes the endpoint what it needs", async () => {
     const { impl, calls } = stubFetch([
-      { ok: true, status: 201, body: '{"url":"https://github.com/user-attachments/assets/abc"}' },
-    ])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '42', fetchImpl: impl })
+      {
+        ok: true,
+        status: 201,
+        body: '{"url":"https://github.com/user-attachments/assets/abc"}',
+      },
+    ]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "42",
+      fetchImpl: impl,
+    });
 
-    const url = await uploader.upload(writeFile('diff.png'))
+    const url = await uploader.upload(writeFile("diff.png"));
 
-    expect(url).toBe('https://github.com/user-attachments/assets/abc')
-    expect(calls[0]).toContain('repository_id=42')
-    expect(calls[0]).toContain('content_type=image%2Fpng')
-    expect(calls[0]).toContain('name=diff.png')
-    expect(uploader.getStats().uploaded).toBe(1)
-  })
+    expect(url).toBe("https://github.com/user-attachments/assets/abc");
+    expect(calls[0]).toContain("repository_id=42");
+    expect(calls[0]).toContain("content_type=image%2Fpng");
+    expect(calls[0]).toContain("name=diff.png");
+    expect(uploader.getStats().uploaded).toBe(1);
+  });
 
-  it('sends a Content-Type, which the endpoint rejects the request without', async () => {
+  it("sends a Content-Type, which the endpoint rejects the request without", async () => {
     // Node's fetch sends no Content-Type for a Buffer body, and the endpoint
     // answers 400 "Invalid Content-Type" when it is missing.
-    const { impl, headers } = stubFetch([])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+    const { impl, headers } = stubFetch([]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    await uploader.upload(writeFile('diff.png'))
+    await uploader.upload(writeFile("diff.png"));
 
-    expect(headers[0]['Content-Type']).toBe('image/png')
-  })
+    expect(headers[0]["Content-Type"]).toBe("image/png");
+  });
 
-  it('reports the response body when the endpoint refuses', async () => {
+  it("reports the response body when the endpoint refuses", async () => {
     const { impl } = stubFetch([
       { ok: false, status: 400, body: '{"message":"Invalid Content-Type"}' },
-    ])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+    ]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    await uploader.upload(writeFile('a.png'))
+    await uploader.upload(writeFile("a.png"));
 
-    expect(uploader.disabledReason).toContain('Invalid Content-Type')
-  })
+    expect(uploader.disabledReason).toContain("Invalid Content-Type");
+  });
 
-  it('accepts href as well as url, since write-ups disagree', async () => {
-    const { impl } = stubFetch([{ ok: true, status: 201, body: '{"href":"https://example.test/h"}' }])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+  it("accepts href as well as url, since write-ups disagree", async () => {
+    const { impl } = stubFetch([
+      { ok: true, status: 201, body: '{"href":"https://example.test/h"}' },
+    ]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    expect(await uploader.upload(writeFile('a.png'))).toBe('https://example.test/h')
-  })
+    expect(await uploader.upload(writeFile("a.png"))).toBe(
+      "https://example.test/h",
+    );
+  });
 
-  it('stops for the rest of the run after one failure', async () => {
-    const { impl, calls } = stubFetch([{ ok: false, status: 404, body: '{"message":"Not Found"}' }])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+  it("stops for the rest of the run after one failure", async () => {
+    const { impl, calls } = stubFetch([
+      { ok: false, status: 404, body: '{"message":"Not Found"}' },
+    ]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    expect(await uploader.upload(writeFile('one.png'))).toBeNull()
-    expect(uploader.enabled).toBe(false)
-    expect(uploader.disabledReason).toMatch(/HTTP 404/)
+    expect(await uploader.upload(writeFile("one.png"))).toBeNull();
+    expect(uploader.enabled).toBe(false);
+    expect(uploader.disabledReason).toMatch(/HTTP 404/);
 
     // The second attempt must not reach the endpoint at all.
-    expect(await uploader.upload(writeFile('two.png'))).toBeNull()
-    expect(calls).toHaveLength(1)
-  })
+    expect(await uploader.upload(writeFile("two.png"))).toBeNull();
+    expect(calls).toHaveLength(1);
+  });
 
-  it('stops when the endpoint answers without a URL', async () => {
-    const { impl } = stubFetch([{ ok: true, status: 200, body: 'not json' }])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+  it("stops when the endpoint answers without a URL", async () => {
+    const { impl } = stubFetch([{ ok: true, status: 200, body: "not json" }]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    expect(await uploader.upload(writeFile('a.png'))).toBeNull()
-    expect(uploader.disabledReason).toMatch(/no URL/)
-  })
+    expect(await uploader.upload(writeFile("a.png"))).toBeNull();
+    expect(uploader.disabledReason).toMatch(/no URL/);
+  });
 
-  it('stops rather than throwing when fetch rejects', async () => {
+  it("stops rather than throwing when fetch rejects", async () => {
     const impl: FetchLike = async () => {
-      throw new Error('socket hang up')
-    }
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+      throw new Error("socket hang up");
+    };
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    expect(await uploader.upload(writeFile('a.png'))).toBeNull()
-    expect(uploader.disabledReason).toMatch(/socket hang up/)
-  })
+    expect(await uploader.upload(writeFile("a.png"))).toBeNull();
+    expect(uploader.disabledReason).toMatch(/socket hang up/);
+  });
 
-  it('enforces the upload count budget and says so', async () => {
-    const { impl } = stubFetch([])
+  it("enforces the upload count budget and says so", async () => {
+    const { impl } = stubFetch([]);
     const uploader = new AttachmentUploader({
-      token: 't',
-      repositoryId: '1',
+      token: "t",
+      repositoryId: "1",
       maxUploads: 1,
       fetchImpl: impl,
-    })
+    });
 
-    expect(await uploader.upload(writeFile('one.png'))).not.toBeNull()
-    expect(await uploader.upload(writeFile('two.png'))).toBeNull()
-    expect(uploader.disabledReason).toMatch(/upload limit of 1/)
-  })
+    expect(await uploader.upload(writeFile("one.png"))).not.toBeNull();
+    expect(await uploader.upload(writeFile("two.png"))).toBeNull();
+    expect(uploader.disabledReason).toMatch(/upload limit of 1/);
+  });
 
-  it('skips a file over GitHub\'s size limit and keeps going', async () => {
+  it("skips a file over GitHub's size limit and keeps going", async () => {
     // GitHub refuses an image over 10 MB, and a rejection would otherwise
     // switch uploading off for every image behind it.
-    const { impl, calls } = stubFetch([])
+    const { impl, calls } = stubFetch([]);
     const uploader = new AttachmentUploader({
-      token: 't',
-      repositoryId: '1',
+      token: "t",
+      repositoryId: "1",
       maxFileBytes: 100,
       fetchImpl: impl,
-    })
+    });
 
-    expect(await uploader.upload(writeFile('huge.png', 200))).toBeNull()
-    expect(uploader.enabled).toBe(true)
-    expect(uploader.lastSkipReason).toBe('too-large')
+    expect(await uploader.upload(writeFile("huge.png", 200))).toBeNull();
+    expect(uploader.enabled).toBe(true);
+    expect(uploader.lastSkipReason).toBe("too-large");
     // Nothing was sent for it: the limit is checked before the request.
-    expect(calls).toHaveLength(0)
+    expect(calls).toHaveLength(0);
 
-    expect(await uploader.upload(writeFile('small.png', 10))).not.toBeNull()
-    expect(uploader.lastSkipReason).toBeNull()
-    expect(uploader.getStats()).toEqual({ uploaded: 1, skipped: 1, bytes: 10 })
-  })
+    expect(await uploader.upload(writeFile("small.png", 10))).not.toBeNull();
+    expect(uploader.lastSkipReason).toBeNull();
+    expect(uploader.getStats()).toEqual({ uploaded: 1, skipped: 1, bytes: 10 });
+  });
 
-  it('skips a file that does not fit the byte budget, rather than stopping', async () => {
-    const { impl } = stubFetch([])
+  it("skips a file that does not fit the byte budget, rather than stopping", async () => {
+    const { impl } = stubFetch([]);
     const uploader = new AttachmentUploader({
-      token: 't',
-      repositoryId: '1',
+      token: "t",
+      repositoryId: "1",
       maxTotalBytes: 100,
       fetchImpl: impl,
-    })
+    });
 
-    expect(await uploader.upload(writeFile('first.png', 60))).not.toBeNull()
-    expect(await uploader.upload(writeFile('big.png', 60))).toBeNull()
-    expect(uploader.lastSkipReason).toBe('budget')
+    expect(await uploader.upload(writeFile("first.png", 60))).not.toBeNull();
+    expect(await uploader.upload(writeFile("big.png", 60))).toBeNull();
+    expect(uploader.lastSkipReason).toBe("budget");
 
     // The budget is a ceiling on the total, not a stop: what still fits goes.
-    expect(await uploader.upload(writeFile('last.png', 30))).not.toBeNull()
-    expect(uploader.enabled).toBe(true)
-    expect(uploader.getStats().bytes).toBe(90)
-  })
+    expect(await uploader.upload(writeFile("last.png", 30))).not.toBeNull();
+    expect(uploader.enabled).toBe(true);
+    expect(uploader.getStats().bytes).toBe(90);
+  });
 
-  it('tells an unreadable file apart from one the limits refused', async () => {
-    const { impl } = stubFetch([{ ok: false, status: 404, body: '{"message":"Not Found"}' }])
+  it("tells an unreadable file apart from one the limits refused", async () => {
+    const { impl } = stubFetch([
+      { ok: false, status: 404, body: '{"message":"Not Found"}' },
+    ]);
     const uploader = new AttachmentUploader({
-      token: 't',
-      repositoryId: '1',
+      token: "t",
+      repositoryId: "1",
       maxFileBytes: 100,
       fetchImpl: impl,
-    })
+    });
 
-    await uploader.upload(path.join(tmpDir, 'missing.png'))
-    expect(uploader.lastSkipReason).toBe('unreadable')
+    await uploader.upload(path.join(tmpDir, "missing.png"));
+    expect(uploader.lastSkipReason).toBe("unreadable");
 
-    await uploader.upload(writeFile('huge.png', 200))
-    expect(uploader.lastSkipReason).toBe('too-large')
+    await uploader.upload(writeFile("huge.png", 200));
+    expect(uploader.lastSkipReason).toBe("too-large");
 
     // A dead endpoint is the run's problem rather than any one file's.
-    await uploader.upload(writeFile('fine.png', 10))
-    expect(uploader.lastSkipReason).toBe('disabled')
-    expect(uploader.enabled).toBe(false)
-  })
+    await uploader.upload(writeFile("fine.png", 10));
+    expect(uploader.lastSkipReason).toBe("disabled");
+    expect(uploader.enabled).toBe(false);
+  });
 
-  it('skips an unreadable file without giving up on the rest', async () => {
-    const { impl } = stubFetch([])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+  it("skips an unreadable file without giving up on the rest", async () => {
+    const { impl } = stubFetch([]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    expect(await uploader.upload(path.join(tmpDir, 'missing.png'))).toBeNull()
-    expect(uploader.enabled).toBe(true)
-    expect(await uploader.upload(writeFile('present.png'))).not.toBeNull()
-  })
+    expect(await uploader.upload(path.join(tmpDir, "missing.png"))).toBeNull();
+    expect(uploader.enabled).toBe(true);
+    expect(await uploader.upload(writeFile("present.png"))).not.toBeNull();
+  });
 
-  it('reduces a name of nothing but dashes to a usable one', async () => {
+  it("reduces a name of nothing but dashes to a usable one", async () => {
     // Trimming these with /^-+|-+$/ backtracks quadratically, so the trim is an
     // index scan instead. Long runs of dashes are the shape that provokes it.
-    const { impl, calls } = stubFetch([])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+    const { impl, calls } = stubFetch([]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    await uploader.upload(writeFile('a.png'), `${'-'.repeat(50000)}b.png`)
+    await uploader.upload(writeFile("a.png"), `${"-".repeat(50000)}b.png`);
 
-    expect(calls[0]).toContain('name=attachment')
-  })
+    expect(calls[0]).toContain("name=attachment");
+  });
 
-  it('reduces awkward file names to something a query string can carry', async () => {
-    const { impl, calls } = stubFetch([])
-    const uploader = new AttachmentUploader({ token: 't', repositoryId: '1', fetchImpl: impl })
+  it("reduces awkward file names to something a query string can carry", async () => {
+    const { impl, calls } = stubFetch([]);
+    const uploader = new AttachmentUploader({
+      token: "t",
+      repositoryId: "1",
+      fetchImpl: impl,
+    });
 
-    await uploader.upload(writeFile('weird.png'), 'homepage renders "correctly" & fast.png')
+    await uploader.upload(
+      writeFile("weird.png"),
+      'homepage renders "correctly" & fast.png',
+    );
 
-    expect(calls[0]).toContain('name=homepage-renders-correctly-fast.png')
-  })
-})
+    expect(calls[0]).toContain("name=homepage-renders-correctly-fast.png");
+  });
+});