@goodfellow-cms/gitlab 0.0.0-stage → 0.2.0

package/dist/testing.js

@@ -0,0 +1,642 @@
+import { decodeBase64 } from "@goodfellow-cms/core";
+import { FakeRepo, fakeFileBytes } from "@goodfellow-cms/core/testing";
+//#region src/testing.ts
+/**
+* A fake of the parts of GitLab's API that `@goodfellow-cms/gitlab` uses, backed by
+* an in-memory repository, including OAuth with PKCE. For tests only.
+*/
+function json(body, status = 200) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+async function sha256Base64Url(text) {
+	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text)));
+	let binary = "";
+	for (const byte of digest) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fakeGitLab(options) {
+	const webUrl = options.url ?? "https://gitlab.com";
+	const repo = new FakeRepo(options.files);
+	const tokens = new Map(Object.entries(options.tokens ?? { "test-token": {
+		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;
+	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;
+	}
+	function issueTokens(user) {
+		counter += 1;
+		const access = `oauth-access-${counter}`;
+		const refresh = `oauth-refresh-${counter}`;
+		tokens.set(access, user);
+		refreshTokens.set(refresh, user);
+		return {
+			access_token: access,
+			refresh_token: refresh,
+			expires_in: options.oauth?.expiresIn ?? 7200,
+			token_type: "Bearer"
+		};
+	}
+	/**
+	* What GitLab's sign-in page does once the person approves: returns the
+	* address the browser is sent back to, with a one-time code.
+	*/
+	function authorize(authorizeUrl) {
+		const params = new URL(authorizeUrl).searchParams;
+		if (params.get("client_id") !== options.oauth?.clientId) throw new Error("Unknown OAuth application");
+		if (params.get("code_challenge_method") !== "S256") throw new Error("PKCE with S256 is required");
+		counter += 1;
+		const code = `code-${counter}`;
+		codes.set(code, {
+			challenge: params.get("code_challenge") ?? "",
+			redirectUri: params.get("redirect_uri") ?? ""
+		});
+		const back = new URL(params.get("redirect_uri") ?? "");
+		back.searchParams.set("code", code);
+		back.searchParams.set("state", params.get("state") ?? "");
+		return back.toString();
+	}
+	async function handle(request) {
+		requests.push(request.clone());
+		const url = new URL(request.url);
+		if (url.pathname === "/oauth/token" && request.method === "POST") {
+			const body = new URLSearchParams(await request.text());
+			if (body.get("client_id") !== options.oauth?.clientId || !options.oauth) return json({ error: "invalid_client" }, 401);
+			if (body.get("grant_type") === "authorization_code") {
+				const issued = codes.get(body.get("code") ?? "");
+				codes.delete(body.get("code") ?? "");
+				if (!issued || issued.redirectUri !== body.get("redirect_uri")) return json({ error: "invalid_grant" }, 400);
+				if (await sha256Base64Url(body.get("code_verifier") ?? "") !== issued.challenge) return json({
+					error: "invalid_grant",
+					error_description: "PKCE verification failed"
+				}, 400);
+				return json(issueTokens(options.oauth.user));
+			}
+			if (body.get("grant_type") === "refresh_token") {
+				const user = refreshTokens.get(body.get("refresh_token") ?? "");
+				refreshTokens.delete(body.get("refresh_token") ?? "");
+				return user ? json(issueTokens(user)) : json({ error: "invalid_grant" }, 400);
+			}
+			return json({ error: "unsupported_grant_type" }, 400);
+		}
+		if (!url.pathname.startsWith("/api/v4/")) return json({ message: "404 Not Found" }, 404);
+		const user = tokens.get(request.headers.get("authorization")?.replace(/^Bearer /, "") ?? "");
+		if (!user) return json({ message: "401 Unauthorized" }, 401);
+		const path = url.pathname.slice(7);
+		if (path === "/user") return json({
+			username: user.username,
+			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 = 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) {
+			const sha = repo.branches.get(decodeURIComponent(branch[1] ?? ""));
+			return sha ? json({ commit: { id: sha } }) : json({ message: "404 Branch Not Found" }, 404);
+		}
+		if (rest === "/repository/tree") {
+			const ref = url.searchParams.get("ref") ?? repo.defaultBranch;
+			const dir = url.searchParams.get("path") ?? "";
+			const perPage = Number(url.searchParams.get("per_page") ?? 20);
+			const page = Number(url.searchParams.get("page") ?? 1);
+			const entries = [...repo.files(ref)].filter(([file]) => file.startsWith(`${dir}/`)).map(([file, content]) => ({
+				id: repo.blobSha(content),
+				type: "blob",
+				path: file,
+				name: file.split("/").at(-1)
+			}));
+			if (entries.length === 0) return json({ message: "404 Tree Not Found" }, 404);
+			return json(entries.slice((page - 1) * perPage, page * perPage));
+		}
+		const blob = rest.match(/^\/repository\/blobs\/([0-9a-f]{40})\/raw$/);
+		if (blob) {
+			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] ?? "");
+			const ref = url.searchParams.get("ref") ?? repo.defaultBranch;
+			const lastCommit = repo.files(ref).has(filePath) ? repo.lastCommitFor(filePath, ref) : void 0;
+			return lastCommit ? json({
+				file_path: filePath,
+				last_commit_id: lastCommit
+			}) : json({ message: "404 File Not Found" }, 404);
+		}
+		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) {
+				if (action.action === "create" && files.has(action.file_path)) return json({ message: "A file with this name already exists" }, 400);
+				if ((action.action === "update" || action.action === "delete") && !files.has(action.file_path)) return json({ message: "A file with this name doesn't exist" }, 400);
+				if (action.last_commit_id && repo.lastCommitFor(action.file_path, body.branch) !== action.last_commit_id) return json({ message: "You are attempting to update a file that has changed since you started editing it." }, 400);
+			}
+			return json({
+				id: commit(body.actions.map((action) => action.action === "delete" ? {
+					path: action.file_path,
+					delete: true
+				} : action.encoding === "base64" ? {
+					path: action.file_path,
+					bytes: decodeBase64(action.content ?? "")
+				} : {
+					path: action.file_path,
+					content: action.content ?? ""
+				}), 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
+		})) });
+		const statuses = rest.match(/^\/repository\/commits\/([0-9a-f]{40})\/statuses$/);
+		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",
+				status: pipeline.checks > (options.deployAfterChecks ?? 0) ? "success" : "running",
+				target_url: `${webUrl}/${options.project}/-/jobs/1`
+			}]);
+		}
+		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,
+		handle,
+		fetch: ((input, init) => handle(new Request(input, init)))
+	};
+}
+//#endregion
+export { fakeGitLab };