@goodfellow-cms/gitlab 0.1.0 → 0.2.0

package/dist/testing.d.ts

@@ -21,11 +21,108 @@ export interface FakeGitLabOptions {
   };
   /** Simulates a GitLab Pages pipeline that succeeds after being checked this many times. Off by default. */
   deployAfterChecks?: number;
+  /** Groups the users belong to, which new projects can be created in. */
+  groups?: string[];
+  /** Publishes the site with GitLab Pages. Off by default. */
+  pages?: {
+    uniqueDomain?: boolean;
+  };
+  /** Other GitLab accounts that exist, which can be added to the project. Every token's user exists and is a member. */
+  accounts?: string[];
+}
+/** A member of the site's project. */
+export interface FakeMember {
+  id: number;
+  username: string;
+  name?: string;
+  accessLevel: number;
+  /** A member through a group rather than the project itself. */
+  inherited?: boolean;
+}
+/** A custom domain added to the site's GitLab Pages. */
+export interface FakePagesDomain {
+  verified: boolean;
+  verificationCode: string;
+  /** Whether Let's Encrypt has issued the certificate. */
+  certificate: boolean;
+}
+/** The site's GitLab Pages settings, which tests can change. */
+export interface FakeGitLabPages {
+  uniqueDomain: boolean;
+  forceHttps: boolean;
+  primaryDomain: string | null;
+  domains: Map<string, FakePagesDomain>;
+  /** Domains whose TXT record GitLab would find, so verifying them works. */
+  dnsReady: Set<string>;
+}
+/** A project created through the fake's API, as the setup page creates them. */
+export interface FakeCreatedProject {
+  id: number;
+  path: string;
+  visibility: string;
+  description?: string;
+  pagesAccessLevel?: string;
+  repo: FakeRepo;
 }
 export declare function fakeGitLab(options: FakeGitLabOptions): {
+  /** The project's members by user id, invitations by email, and protected branches, which tests can change. */
+  members: Map<number, FakeMember>;
+  invitations: Map<string, number>;
+  protectedBranches: Map<string, {
+    push: number;
+    merge: number;
+    forcePush: boolean;
+  }>;
+  failBuild: (sha: string, failure?: {
+    job?: string;
+    failureReason?: string;
+    trace?: string;
+  }) => void;
+  /** The project's update settings, and the pipelines the update ran in, which tests add with `addUpdateRun()`. */
+  updateSettings: {
+    jobTokenPush: boolean;
+    schedules: Array<{
+      id: number;
+      ref: string;
+      cron: string;
+      active: boolean;
+    }>;
+  };
+  updateRuns: {
+    id: number;
+    source: string;
+    status: string;
+    variables?: Array<{
+      key: string;
+      value: string;
+    }>;
+    trace: string;
+  }[];
+  addUpdateRun: (run: {
+    source?: string;
+    status?: string;
+    trace?: string;
+    variables?: Array<{
+      key: string;
+      value: string;
+    }>;
+  }) => {
+    variables?: Array<{
+      key: string;
+      value: string;
+    }>;
+    id: number;
+    source: string;
+    status: string;
+    trace: string;
+  };
   repo: FakeRepo;
+  /** Projects created through the API, by full path. */
+  created: Map<string, FakeCreatedProject>;
+  /** The site's GitLab Pages, if it has them, which tests can change. */
+  pages: FakeGitLabPages | undefined;
   requests: Request[];
-  commit: (changes: FileChange[], message: string) => string;
+  commit: (changes: FileChange[], message: string, author?: string) => string;
   authorize: (authorizeUrl: string) => string;
   handle: (request: Request) => Promise<Response>;
   fetch: typeof fetch;

package/dist/testing.js

@@ -24,13 +24,314 @@ function fakeGitLab(options) {
 		username: "editor",
 		name: "Test Editor"
 	} }));
+	let nextUserId = 1;
+	/** Every GitLab account, by username, with its id. */
+	const accounts = /* @__PURE__ */ new Map();
+	for (const name of [...[...tokens.values(), ...options.oauth ? [options.oauth.user] : []].map((user) => user.username), ...options.accounts ?? []]) if (!accounts.has(name)) accounts.set(name, nextUserId++);
+	const members = /* @__PURE__ */ new Map();
+	for (const user of [...tokens.values(), ...options.oauth ? [options.oauth.user] : []]) {
+		const id = accounts.get(user.username) ?? 0;
+		members.set(id, {
+			id,
+			username: user.username,
+			name: user.name,
+			accessLevel: user.accessLevel ?? 40
+		});
+	}
+	const invitations = /* @__PURE__ */ new Map();
+	/** Protected branches and who may push to them: GitLab protects the default branch for Maintainers. */
+	const protectedBranches = /* @__PURE__ */ new Map([[repo.defaultBranch, {
+		push: 40,
+		merge: 40,
+		forcePush: false
+	}]]);
+	/** The project's members and invitations, and its protected branches. */
+	async function handleMembers(request, url, rest, accessLevel) {
+		const forbidden = () => json({ message: "403 Forbidden" }, 403);
+		const list = (items) => {
+			const perPage = Number(url.searchParams.get("per_page") ?? 20);
+			const page = Number(url.searchParams.get("page") ?? 1);
+			return json(items.slice((page - 1) * perPage, page * perPage));
+		};
+		const shown = (member) => ({
+			id: member.id,
+			username: member.username,
+			name: member.name ?? member.username,
+			avatar_url: `https://avatars.example/${member.username}`,
+			access_level: member.accessLevel
+		});
+		if (rest === "/members/all" && request.method === "GET") return list([...members.values()].map(shown));
+		if (rest === "/members" && request.method === "GET") return list([...members.values()].filter((member) => !member.inherited).map(shown));
+		if (rest === "/members" && request.method === "POST") {
+			if (accessLevel < 40) return forbidden();
+			const body = await request.json();
+			const username = [...accounts].find(([, id]) => id === body.user_id)?.[0];
+			if (!username) return json({ message: "404 User Not Found" }, 404);
+			if (members.has(body.user_id)) return json({ message: "Member already exists" }, 409);
+			members.set(body.user_id, {
+				id: body.user_id,
+				username,
+				accessLevel: body.access_level
+			});
+			return json(shown(members.get(body.user_id)), 201);
+		}
+		const member = rest.match(/^\/members\/(\d+)$/);
+		if (member) {
+			if (accessLevel < 40) return forbidden();
+			const found = members.get(Number(member[1]));
+			if (!found || found.inherited) return json({ message: "404 Member Not Found" }, 404);
+			if (request.method === "DELETE") {
+				members.delete(found.id);
+				return new Response(null, { status: 204 });
+			}
+			if (request.method === "PUT") {
+				found.accessLevel = (await request.json()).access_level;
+				return json(shown(found));
+			}
+		}
+		if (rest === "/invitations") {
+			if (accessLevel < 40) return forbidden();
+			if (request.method === "GET") return list([...invitations].map(([email, level]) => ({
+				invite_email: email,
+				access_level: level
+			})));
+			if (request.method === "POST") {
+				const body = await request.json();
+				if (invitations.has(body.email)) return json({
+					status: "error",
+					message: { [body.email]: "Invite email has already been taken" }
+				}, 201);
+				invitations.set(body.email, body.access_level);
+				return json({ status: "success" }, 201);
+			}
+		}
+		const invitation = rest.match(/^\/invitations\/([^/]+)$/);
+		if (invitation) {
+			if (accessLevel < 40) return forbidden();
+			const email = decodeURIComponent(invitation[1] ?? "");
+			if (!invitations.has(email)) return json({ message: "404 Not Found" }, 404);
+			if (request.method === "DELETE") {
+				invitations.delete(email);
+				return new Response(null, { status: 204 });
+			}
+			if (request.method === "PUT") {
+				invitations.set(email, (await request.json()).access_level);
+				return json({ invite_email: email });
+			}
+		}
+		const protection = rest.match(/^\/protected_branches\/([^/]+)$/);
+		if (protection) {
+			const name = decodeURIComponent(protection[1] ?? "");
+			const found = protectedBranches.get(name);
+			if (!found) return json({ message: "404 Not found" }, 404);
+			if (request.method === "GET") return json({
+				name,
+				push_access_levels: [{ access_level: found.push }],
+				merge_access_levels: [{ access_level: found.merge }],
+				allow_force_push: found.forcePush
+			});
+			if (request.method === "DELETE") {
+				if (accessLevel < 40) return forbidden();
+				protectedBranches.delete(name);
+				return new Response(null, { status: 204 });
+			}
+		}
+		if (rest === "/protected_branches" && request.method === "POST") {
+			if (accessLevel < 40) return forbidden();
+			const body = await request.json();
+			if (protectedBranches.has(body.name)) return json({ message: "Protected branch already exists" }, 409);
+			protectedBranches.set(body.name, {
+				push: body.push_access_level ?? 40,
+				merge: body.merge_access_level ?? 40,
+				forcePush: body.allow_force_push ?? false
+			});
+			return json({ name: body.name }, 201);
+		}
+	}
 	const codes = /* @__PURE__ */ new Map();
 	const refreshTokens = /* @__PURE__ */ new Map();
 	const pipelines = /* @__PURE__ */ new Map();
+	/** The project's settings for updates: whether job tokens may push, and its pipeline schedules. */
+	const updateSettings = {
+		jobTokenPush: false,
+		schedules: []
+	};
+	/** Pipelines the update ran in: scheduled, or started through the API, with the pages job's log. */
+	const updateRuns = [];
+	/** Simulates a scheduled (or API) pipeline whose pages job logged `trace`. */
+	function addUpdateRun(run) {
+		const added = {
+			id: 1e3 + updateRuns.length,
+			source: "schedule",
+			status: "success",
+			trace: "",
+			...run
+		};
+		updateRuns.push(added);
+		return added;
+	}
+	/** Failed jobs, by commit, which tests add with `failBuild()`. */
+	const failures = /* @__PURE__ */ new Map();
+	/**
+	* Simulates the pipeline for a commit failing: its `pages` job (or another,
+	* such as `pages:deploy`) fails for a GitLab failure reason, with a log.
+	*/
+	function failBuild(sha, failure = {}) {
+		if (!pipelines.has(sha)) pipelines.set(sha, { checks: 0 });
+		failures.set(sha, {
+			job: failure.job ?? "pages",
+			failureReason: failure.failureReason ?? "script_failure",
+			trace: failure.trace ?? ""
+		});
+	}
+	const pipelineId = (sha) => [...pipelines.keys()].indexOf(sha) + 1;
 	const requests = [];
 	let counter = 0;
-	function commit(changes, message) {
-		const sha = repo.commit(changes, message);
+	const created = /* @__PURE__ */ new Map();
+	const pages = options.pages ? {
+		uniqueDomain: options.pages.uniqueDomain ?? true,
+		forceHttps: true,
+		primaryDomain: null,
+		domains: /* @__PURE__ */ new Map(),
+		dnsReady: /* @__PURE__ */ new Set()
+	} : void 0;
+	function pagesUrl() {
+		const [namespace = "", ...rest] = options.project.split("/");
+		return pages?.uniqueDomain ? `https://${rest.join("-")}-1a2b3c.gitlab.io` : `https://${namespace}.gitlab.io/${rest.join("/")}`;
+	}
+	/** GitLab Pages' settings and custom domains, for the site's own project. */
+	async function handlePages(request, rest, accessLevel) {
+		if (!rest.startsWith("/pages")) return void 0;
+		if (!pages) return json({ message: "404 Not Found" }, 404);
+		if (accessLevel < 40) return json({ message: "403 Forbidden" }, 403);
+		const method = request.method;
+		const domainJson = (name, domain) => ({
+			domain: name,
+			url: `https://${name}`,
+			verified: domain.verified,
+			verification_code: domain.verificationCode,
+			auto_ssl_enabled: true,
+			certificate: domain.certificate ? {
+				subject: `/CN=${name}`,
+				expired: false
+			} : null
+		});
+		if (rest === "/pages" && method === "GET") return json({
+			url: pagesUrl(),
+			is_unique_domain_enabled: pages.uniqueDomain,
+			force_https: pages.forceHttps,
+			primary_domain: pages.primaryDomain
+		});
+		if (rest === "/pages" && method === "PATCH") {
+			const body = await request.json();
+			if (body.pages_primary_domain !== void 0 && !pages.domains.has(body.pages_primary_domain)) return json({ message: "Primary domain must be one of the project's domains" }, 400);
+			if (body.pages_unique_domain_enabled !== void 0) pages.uniqueDomain = body.pages_unique_domain_enabled;
+			if (body.pages_https_only !== void 0) pages.forceHttps = body.pages_https_only;
+			if (body.pages_primary_domain !== void 0) pages.primaryDomain = body.pages_primary_domain;
+			return json({
+				url: pagesUrl(),
+				is_unique_domain_enabled: pages.uniqueDomain,
+				force_https: pages.forceHttps
+			});
+		}
+		if (rest === "/pages/domains" && method === "GET") return json([...pages.domains].map(([name, domain]) => domainJson(name, domain)));
+		if (rest === "/pages/domains" && method === "POST") {
+			const body = await request.json();
+			if (pages.domains.has(body.domain)) return json({ message: { domain: ["has already been taken"] } }, 400);
+			if (!/^[a-z0-9.-]+\.[a-z]+$/.test(body.domain)) return json({ message: { domain: ["is invalid"] } }, 400);
+			counter += 1;
+			const domain = {
+				verified: false,
+				verificationCode: `code-${counter}`,
+				certificate: false
+			};
+			pages.domains.set(body.domain, domain);
+			return json(domainJson(body.domain, domain), 201);
+		}
+		const one = rest.match(/^\/pages\/domains\/([^/]+)(\/verify)?$/);
+		const name = decodeURIComponent(one?.[1] ?? "");
+		const domain = pages.domains.get(name);
+		if (!one || !domain) return json({ message: "404 Not Found" }, 404);
+		if (one[2] && method === "PUT") {
+			if (!pages.dnsReady.has(name)) return json({ message: "Failed to verify domain ownership" }, 400);
+			domain.verified = true;
+			return json(domainJson(name, domain));
+		}
+		if (method === "GET") return json(domainJson(name, domain));
+		if (method === "DELETE") {
+			pages.domains.delete(name);
+			if (pages.primaryDomain === name) pages.primaryDomain = null;
+			return new Response(null, { status: 204 });
+		}
+		return json({ message: "404 Not Found" }, 404);
+	}
+	const groups = (options.groups ?? []).map((group, index) => ({
+		id: 100 + index,
+		path: group
+	}));
+	/** Creating projects, and committing to the projects created, as the setup page does. */
+	async function handleCreated(request, path, user) {
+		if (path === "/namespaces") return json([{
+			id: 1,
+			kind: "user",
+			full_path: user.username,
+			name: user.name ?? user.username
+		}, ...groups.map((group) => ({
+			id: group.id,
+			kind: "group",
+			full_path: group.path,
+			name: group.path
+		}))]);
+		if (path === "/projects" && request.method === "POST") {
+			const body = await request.json();
+			const namespace = body.namespace_id === void 0 || body.namespace_id === 1 ? user.username : groups.find((group) => group.id === body.namespace_id)?.path;
+			if (!namespace) return json({ message: "404 Namespace Not Found" }, 404);
+			if (!/^[\w.-]+$/.test(body.path)) return json({ message: { path: ["is invalid"] } }, 400);
+			const fullPath = `${namespace}/${body.path}`;
+			if (created.has(fullPath) || fullPath === options.project) return json({ message: { name: ["has already been taken"] } }, 400);
+			counter += 1;
+			const project = {
+				id: 1e3 + counter,
+				path: fullPath,
+				visibility: body.visibility,
+				description: body.description,
+				pagesAccessLevel: body.pages_access_level,
+				repo: new FakeRepo({})
+			};
+			created.set(fullPath, project);
+			return json({
+				id: project.id,
+				path_with_namespace: fullPath,
+				web_url: `${webUrl}/${fullPath}`
+			}, 201);
+		}
+		const match = path.match(/^\/projects\/([^/]+)(\/.*)?$/);
+		const key = decodeURIComponent(match?.[1] ?? "");
+		const project = created.get(key) ?? [...created.values()].find((candidate) => String(candidate.id) === key);
+		if (!match || !project) return void 0;
+		const rest = match[2] ?? "";
+		if (rest === "") return json({
+			id: project.id,
+			path_with_namespace: project.path,
+			default_branch: "main"
+		});
+		if (rest === "/repository/commits" && request.method === "POST") {
+			const body = await request.json();
+			return json({
+				id: project.repo.commit(body.actions.map((action) => action.encoding === "base64" ? {
+					path: action.file_path,
+					bytes: decodeBase64(action.content ?? "")
+				} : {
+					path: action.file_path,
+					content: action.content ?? ""
+				}), body.commit_message, { branch: body.branch }),
+				message: body.commit_message
+			}, 201);
+		}
+		return json({ message: "404 Not Found" }, 404);
+	}
+	function commit(changes, message, author) {
+		const sha = repo.commit(changes, message, { author });
 		if (options.deployAfterChecks !== void 0) pipelines.set(sha, { checks: 0 });
 		return sha;
 	}
@@ -98,16 +399,31 @@ function fakeGitLab(options) {
 			name: user.name,
 			avatar_url: `https://avatars.example/${user.username}`
 		});
+		const setup = await handleCreated(request, path, user);
+		if (setup) return setup;
+		if (path === "/users") {
+			const name = url.searchParams.get("username") ?? "";
+			const id = [...accounts].find(([username]) => username.toLowerCase() === name.toLowerCase())?.[1];
+			return json(id === void 0 ? [] : [{
+				id,
+				username: name
+			}]);
+		}
 		const projectMatch = path.match(/^\/projects\/([^/]+)(\/.*)?$/);
 		if (!projectMatch || decodeURIComponent(projectMatch[1] ?? "") !== options.project) return json({ message: "404 Project Not Found" }, 404);
 		const rest = projectMatch[2] ?? "";
-		const accessLevel = user.accessLevel ?? 40;
-		if (rest === "") return json({
+		const accessLevel = members.get(accounts.get(user.username) ?? 0)?.accessLevel ?? 0;
+		const pagesResponse = await handlePages(request, rest, accessLevel);
+		if (pagesResponse) return pagesResponse;
+		const membersResponse = await handleMembers(request, url, rest, accessLevel);
+		if (membersResponse) return membersResponse;
+		if (rest === "" && request.method !== "PUT") return json({
 			default_branch: repo.defaultBranch,
 			permissions: {
 				project_access: { access_level: accessLevel },
 				group_access: null
-			}
+			},
+			ci_push_repository_for_job_token_allowed: updateSettings.jobTokenPush
 		});
 		const branch = rest.match(/^\/repository\/branches\/(.+)$/);
 		if (branch) {
@@ -133,6 +449,13 @@ function fakeGitLab(options) {
 			const content = repo.blobs.get(blob[1] ?? "");
 			return content === void 0 ? json({ message: "404 Blob Not Found" }, 404) : new Response(fakeFileBytes(content));
 		}
+		const raw = rest.match(/^\/repository\/files\/([^/]+)\/raw$/);
+		if (raw) {
+			const ref = url.searchParams.get("ref") ?? repo.defaultBranch;
+			if (!repo.commitAt(repo.branches.get(ref) ?? ref)) return json({ message: "404 Commit Not Found" }, 404);
+			const content = repo.files(ref).get(decodeURIComponent(raw[1] ?? ""));
+			return content === void 0 ? json({ message: "404 File Not Found" }, 404) : new Response(fakeFileBytes(content));
+		}
 		const file = rest.match(/^\/repository\/files\/([^/]+)$/);
 		if (file) {
 			const filePath = decodeURIComponent(file[1] ?? "");
@@ -145,6 +468,8 @@ function fakeGitLab(options) {
 		}
 		if (rest === "/repository/commits" && request.method === "POST") {
 			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const pushTo = await request.clone().json();
+			if (accessLevel < (protectedBranches.get(pushTo.branch)?.push ?? 0)) return json({ message: "You are not allowed to push into this branch" }, 403);
 			const body = await request.json();
 			const files = repo.files(body.branch);
 			for (const action of body.actions) {
@@ -162,10 +487,25 @@ function fakeGitLab(options) {
 				} : {
 					path: action.file_path,
 					content: action.content ?? ""
-				}), body.commit_message),
+				}), body.commit_message, user.name ?? user.username),
 				message: body.commit_message
 			}, 201);
 		}
+		if (rest === "/repository/commits" && request.method === "GET") {
+			const ref = url.searchParams.get("ref_name") ?? repo.defaultBranch;
+			const file = url.searchParams.get("path");
+			if (!repo.commitAt(repo.branches.get(ref) ?? ref)) return json({ message: "404 Reference Not Found" }, 404);
+			const perPage = Number(url.searchParams.get("per_page") ?? 20);
+			const page = Number(url.searchParams.get("page") ?? 1);
+			return json((file ? repo.history(file, ref) : []).slice((page - 1) * perPage, page * perPage).map((commit) => ({
+				id: commit.sha,
+				title: commit.message.split("\n")[0],
+				message: commit.message,
+				author_name: commit.author ?? "GitLab",
+				authored_date: commit.date,
+				committed_date: commit.date
+			})));
+		}
 		if (rest === "/repository/compare") return json({ diffs: repo.changedPaths(url.searchParams.get("from") ?? "", url.searchParams.get("to") ?? "").map((changedPath) => ({
 			old_path: changedPath,
 			new_path: changedPath
@@ -174,6 +514,15 @@ function fakeGitLab(options) {
 		if (statuses) {
 			const pipeline = pipelines.get(statuses[1] ?? "");
 			if (!pipeline) return json([]);
+			const failure = failures.get(statuses[1] ?? "");
+			if (failure) {
+				const id = pipelineId(statuses[1] ?? "");
+				return json([{
+					name: failure.job,
+					status: "failed",
+					target_url: `${webUrl}/${options.project}/-/jobs/${id}`
+				}]);
+			}
 			pipeline.checks += 1;
 			return json([{
 				name: "pages",
@@ -181,14 +530,107 @@ function fakeGitLab(options) {
 				target_url: `${webUrl}/${options.project}/-/jobs/1`
 			}]);
 		}
-		if (rest === "/pipelines") return json([...pipelines.keys()].map((sha, index) => ({
-			id: index + 1,
-			sha
+		if (rest === "/pipelines" && url.searchParams.has("ref")) return json([...updateRuns].reverse().map((run) => ({
+			id: run.id,
+			source: run.source,
+			status: run.status,
+			created_at: "2026-01-05T04:17:00Z",
+			web_url: `${webUrl}/${options.project}/-/pipelines/${run.id}`
 		})));
+		if (rest === "/pipeline" && request.method === "POST") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const run = addUpdateRun({
+				source: "api",
+				status: "created",
+				variables: (await request.json()).variables
+			});
+			return json({
+				id: run.id,
+				status: run.status
+			}, 201);
+		}
+		if (rest === "/pipeline_schedules") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			if (request.method === "POST") {
+				const body = await request.json();
+				const schedule = {
+					id: updateSettings.schedules.length + 1,
+					ref: body.ref,
+					cron: body.cron,
+					active: body.active ?? true
+				};
+				updateSettings.schedules.push(schedule);
+				return json(schedule, 201);
+			}
+			return json(updateSettings.schedules);
+		}
+		if (rest === "" && request.method === "PUT") {
+			if (accessLevel < 40) return json({ message: "403 Forbidden" }, 403);
+			const body = await request.json();
+			if (body.ci_push_repository_for_job_token_allowed !== void 0) updateSettings.jobTokenPush = body.ci_push_repository_for_job_token_allowed;
+			return json({ ci_push_repository_for_job_token_allowed: updateSettings.jobTokenPush });
+		}
+		const updateJobs = rest.match(/^\/pipelines\/(\d{4,})\/jobs$/);
+		if (updateJobs) {
+			const run = updateRuns.find((candidate) => candidate.id === Number(updateJobs[1]));
+			return run ? json([{
+				id: run.id,
+				name: "pages",
+				status: run.status
+			}]) : json({ message: "404 Not Found" }, 404);
+		}
+		const updateTrace = rest.match(/^\/jobs\/(\d{4,})\/trace$/);
+		if (updateTrace) {
+			const run = updateRuns.find((candidate) => candidate.id === Number(updateTrace[1]));
+			return run ? new Response(run.trace) : json({ message: "404 Not Found" }, 404);
+		}
+		if (rest === "/pipelines") {
+			const sha = url.searchParams.get("sha");
+			return json([...pipelines.keys()].map((pipelineSha, index) => ({
+				id: index + 1,
+				sha: pipelineSha
+			})).filter((pipeline) => !sha || pipeline.sha === sha));
+		}
+		const pipelineJobs = rest.match(/^\/pipelines\/(\d+)\/jobs$/);
+		if (pipelineJobs) {
+			const id = Number(pipelineJobs[1]);
+			const sha = [...pipelines.keys()][id - 1];
+			if (!sha) return json({ message: "404 Not Found" }, 404);
+			const failure = failures.get(sha);
+			return json([failure ? {
+				id,
+				name: failure.job,
+				status: "failed",
+				failure_reason: failure.failureReason
+			} : {
+				id,
+				name: "pages",
+				status: "success"
+			}]);
+		}
+		const trace = rest.match(/^\/jobs\/(\d+)\/trace$/);
+		if (trace) {
+			const sha = [...pipelines.keys()][Number(trace[1]) - 1];
+			const failure = sha ? failures.get(sha) : void 0;
+			return failure ? new Response(failure.trace) : json({ message: "404 Not Found" }, 404);
+		}
 		return json({ message: "404 Not Found" }, 404);
 	}
 	return {
+		/** The project's members by user id, invitations by email, and protected branches, which tests can change. */
+		members,
+		invitations,
+		protectedBranches,
+		failBuild,
+		/** The project's update settings, and the pipelines the update ran in, which tests add with `addUpdateRun()`. */
+		updateSettings,
+		updateRuns,
+		addUpdateRun,
 		repo,
+		/** Projects created through the API, by full path. */
+		created,
+		/** The site's GitLab Pages, if it has them, which tests can change. */
+		pages,
 		requests,
 		commit,
 		authorize,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfellow-cms/gitlab",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Edit a Goodfellow site stored on GitLab, straight from the browser.",
   "keywords": [
     "goodfellow",
@@ -10,12 +10,12 @@
     "gitlab",
     "git-based-cms"
   ],
-  "homepage": "https://chartung17.github.io/goodfellow-cms/docs/hosts",
-  "bugs": "https://github.com/chartung17/goodfellow-cms/issues",
+  "homepage": "https://goodfellow-cms.github.io/goodfellow-cms/docs/hosts",
+  "bugs": "https://github.com/goodfellow-cms/goodfellow-cms/issues",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/chartung17/goodfellow-cms.git",
+    "url": "git+https://github.com/goodfellow-cms/goodfellow-cms.git",
     "directory": "packages/gitlab"
   },
   "type": "module",
@@ -35,7 +35,7 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/core": "0.1.0"
+    "@goodfellow-cms/core": "0.2.0"
   },
   "devDependencies": {
     "@puckeditor/core": "0.23.0"