From 999a04f8466f75b705b9de879d6d6bcb19927121 Mon Sep 17 00:00:00 2001
From: Kir_Antipov <kp.antipov@gmail.com>
Date: Mon, 8 Jan 2024 06:15:39 +0000
Subject: [PATCH] Added tests for `modrinth-api-client`
---
.../modrinth/modrinth-api-client.spec.ts | 656 ++++++++++++++++++
1 file changed, 656 insertions(+)
create mode 100644 tests/unit/platforms/modrinth/modrinth-api-client.spec.ts
diff --git a/tests/unit/platforms/modrinth/modrinth-api-client.spec.ts b/tests/unit/platforms/modrinth/modrinth-api-client.spec.ts
new file mode 100644
index 0000000..e4b3337
--- /dev/null
+++ b/tests/unit/platforms/modrinth/modrinth-api-client.spec.ts
@@ -0,0 +1,656 @@
+import mockFs from "mock-fs";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createFakeFetch } from "../../../utils/fetch-utils";
+import { FormData } from "@/utils/net/form-data";
+import { HttpResponse } from "@/utils/net/http-response";
+import { ModrinthGameVersion } from "@/platforms/modrinth/modrinth-game-version";
+import { ModrinthLoader } from "@/platforms/modrinth/modrinth-loader";
+import { ModrinthUnfeatureMode } from "@/platforms/modrinth/modrinth-unfeature-mode";
+import { ModrinthVersion, ModrinthVersionInit, ModrinthVersionPatch } from "@/platforms/modrinth/modrinth-version";
+import { ModrinthProject, ModrinthProjectPatch } from "@/platforms/modrinth/modrinth-project";
+import { MODRINTH_API_URL, ModrinthApiClient } from "@/platforms/modrinth/modrinth-api-client";
+
+const DB = Object.freeze({
+ loaders: Object.freeze(JSON.parse(
+ readFileSync(resolve(__dirname, "../../../content/modrinth/loader.json"), "utf8")
+ )) as ModrinthLoader[],
+
+ gameVersions: Object.freeze(JSON.parse(
+ readFileSync(resolve(__dirname, "../../../content/modrinth/game_version.json"), "utf8")
+ )) as ModrinthGameVersion[],
+
+ projects: Object.freeze(JSON.parse(
+ readFileSync(resolve(__dirname, "../../../content/modrinth/projects.json"), "utf8")
+ )) as ModrinthProject[],
+
+ versions: Object.freeze(JSON.parse(
+ readFileSync(resolve(__dirname, "../../../content/modrinth/versions.json"), "utf8")
+ )) as ModrinthVersion[],
+});
+
+const MODRINTH_FETCH = createFakeFetch({
+ baseUrl: MODRINTH_API_URL,
+ requiredHeaders: ["Authorization"],
+
+ GET: {
+ "^\\/tag\\/loader": () => DB.loaders,
+
+ "^\\/tag\\/game_version": () => DB.gameVersions,
+
+ "^\\/project\\/([^/]+)(\\/check)?$": ([idOrSlug, isCheck]) => {
+ const project = DB.projects.find(x => x.id === idOrSlug || x.slug === idOrSlug);
+ if (!project) {
+ return HttpResponse.text("Not found", { status: 404 });
+ }
+
+ return isCheck ? { id: project.id } : project;
+ },
+
+ "^\\/projects\\?ids=(.+)": ([ids]) => {
+ const idOrSlugs = JSON.parse(decodeURIComponent(ids)) as string[];
+ const projects = DB.projects.filter(x => idOrSlugs.includes(x.id) || idOrSlugs.includes(x.slug));
+ return projects;
+ },
+
+ "^\\/version\\/([^/]+)$": ([id]) => {
+ const version = DB.versions.find(x => x.id === id);
+ return version || HttpResponse.text("Not found", { status: 404 });
+ },
+
+ "^\\/versions\\?ids=(.+)": ([ids]) => {
+ const versionIds = JSON.parse(decodeURIComponent(ids)) as string[];
+ const versions = DB.versions.filter(x => versionIds.includes(x.id));
+ return versions;
+ },
+
+ "^\\/project\\/([^/]+)\\/version(\\?.+)?": ([idOrSlug, params]) => {
+ const project = DB.projects.find(x => x.id === idOrSlug || x.slug === idOrSlug);
+ if (!project) {
+ return HttpResponse.text("Not found", { status: 404 });
+ }
+
+ const urlParams = new URLSearchParams(decodeURIComponent(params));
+ const loaders = JSON.parse(urlParams.get("loaders")) as string[];
+ const gameVersions = JSON.parse(urlParams.get("game_versions")) as string[];
+ const featured = JSON.parse(urlParams.get("featured")) as boolean;
+ const topFeatured = !DB.versions.some(x => x.project_id === project.id && x.featured);
+
+ const versions = DB.versions
+ .filter(x => x.project_id === project.id)
+ .filter(x => loaders === null || x.loaders.some(y => loaders.includes(y)))
+ .filter(x => gameVersions === null || x.game_versions.some(y => gameVersions.includes(y)))
+ .filter((x, i) => featured === null || x.featured === featured || topFeatured && i < 10);
+
+ return versions;
+ },
+ },
+
+ POST: {
+ "^\\/version$": (_, { body }) => {
+ const formData = body as FormData;
+ const data = JSON.parse(formData.get("data") as string) as ModrinthVersionInit;
+ const project = DB.projects.find(x => x.id === data.project_id);
+ if (!project) {
+ return HttpResponse.text("Not found", { status: 404 });
+ }
+
+ const primaryFilePart = data["primary_file"] as string;
+ const fileParts = data["file_parts"] as string[];
+ const primaryFileName = formData.get(primaryFilePart)?.["name"] as string;
+ const fileNames = fileParts.map(x => formData.get(x)?.["name"] as string);
+
+ const version = DB.versions.find(x => x.project_id === data.project_id && x.name === data.name);
+ expect(version).toBeDefined();
+
+ expect(version.name).toBe(data.name);
+ expect(version.version_number).toBe(data.version_number);
+ expect(version.project_id).toBe(data.project_id);
+ expect(version.changelog).toBe(data.changelog);
+ expect(version.dependencies).toEqual(data.dependencies);
+ expect(version.game_versions).toEqual(data.game_versions);
+ expect(version.version_type).toBe(data.version_type);
+ expect(version.loaders).toEqual(data.loaders);
+ expect(version.featured).toBe(data.featured);
+ expect(version.status).toBe(data.status);
+ expect(version.requested_status).toBe(data.requested_status);
+
+ expect(version.files.map(x => x.filename)).toEqual(fileNames);
+ expect((version.files.find(x => x.primary) || version.files[0]).filename).toBe(primaryFileName);
+
+ return version;
+ },
+ },
+
+ PATCH: {
+ "^\\/project\\/([^/]+)$": ([idOrSlug], { body }) => {
+ const project = DB.projects.find(x => x.id === idOrSlug || x.slug === idOrSlug);
+ if (!project) {
+ return HttpResponse.text("Not found", { status: 404 });
+ }
+
+ const patch = JSON.parse(body as string) as ModrinthProjectPatch;
+
+ expect(patch.id).toBe(idOrSlug);
+ expect(patch.slug).toBe(project.slug);
+ expect(patch.title).toBe(project.title);
+ expect(patch.description).toBe(project.description);
+ expect(patch.categories).toEqual(project.categories);
+ expect(patch.client_side).toBe(project.client_side);
+ expect(patch.server_side).toBe(project.server_side);
+ expect(patch.body).toBe(project.body);
+ expect(patch.additional_categories).toEqual(project.additional_categories);
+ expect(patch.issues_url).toBe(project.issues_url);
+ expect(patch.source_url).toBe(project.source_url);
+ expect(patch.wiki_url).toBe(project.wiki_url);
+ expect(patch.discord_url).toBe(project.discord_url);
+ expect(patch.donation_urls).toEqual(project.donation_urls);
+ expect(patch.status).toBe(project.status);
+ expect(patch.license_id).toBe(project.license.id);
+ expect(patch.license_url).toBe(project.license.url);
+
+ return HttpResponse.text("Success", { status: 204 });
+ },
+
+ "^\\/version\\/([^/]+)$": ([id], { body }) => {
+ const version = DB.versions.find(x => x.id === id);
+ if (!version) {
+ return HttpResponse.text("Not found", { status: 404 });
+ }
+
+ const patch = JSON.parse(body as string) as ModrinthVersionPatch;
+
+ expect(patch.id).toBe(id);
+ if (Object.keys(patch).length > 2 || patch.featured === undefined) {
+ expect(patch.name).toBe(version.name);
+ expect(patch.version_number).toBe(version.version_number);
+ expect(patch.changelog).toBe(version.changelog);
+ expect(patch.dependencies).toEqual(version.dependencies);
+ expect(patch.game_versions).toEqual(version.game_versions);
+ expect(patch.version_type).toBe(version.version_type);
+ expect(patch.loaders).toEqual(version.loaders);
+ expect(patch.featured).toBe(version.featured);
+ expect(patch.status).toBe(version.status);
+ expect(patch.requested_status).toBe(version.requested_status);
+ expect(patch.primary_file).toEqual(version.files.filter(x => x.primary).map(x => ["sha1", x.hashes.sha1])[0]);
+ }
+
+ return HttpResponse.text("Success", { status: 204 });
+ },
+ },
+
+ DELETE: {
+ "^\\/project\\/([^/]+)$": ([idOrSlug]) => {
+ const project = DB.projects.find(x => x.id === idOrSlug || x.slug === idOrSlug);
+ return project ? HttpResponse.text("Success", { status: 204 }) : HttpResponse.text("Not found", { status: 404 });
+ },
+
+ "^\\/version\\/([^/]+)$": ([id]) => {
+ const version = DB.versions.find(x => x.id === id);
+ return version ? HttpResponse.text("Success", { status: 204 }) : HttpResponse.text("Not found", { status: 404 });
+ },
+ },
+});
+
+beforeEach(() => {
+ const fileNames = DB.versions.flatMap(x => x.files).map(x => x.filename);
+ const fakeFiles = fileNames.reduce((a, b) => ({ ...a, [b]: "" }), {});
+
+ mockFs(fakeFiles);
+});
+
+afterEach(() => {
+ mockFs.restore();
+});
+
+describe("ModrinthApiClient", () => {
+ describe("getLoaders", () => {
+ test("returns loaders", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const loaders = await api.getLoaders();
+
+ expect(loaders).toBeDefined();
+ expect(loaders.map(x => x.name)).toContain("fabric");
+ });
+ });
+
+ describe("getGameVersions", () => {
+ test("returns game versions", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const gameVersions = await api.getGameVersions();
+
+ expect(gameVersions).toBeDefined();
+ expect(gameVersions.map(x => x.version)).toContain("1.18.2");
+ });
+ });
+
+ describe("getProject", () => {
+ test("returns a project by its id", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const project = await api.getProject("gvQqBUqZ");
+
+ expect(project).toBeDefined();
+ expect(project.slug).toBe("lithium");
+ });
+
+ test("returns a project by its slug", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const project = await api.getProject("lithium");
+
+ expect(project).toBeDefined();
+ expect(project.id).toBe("gvQqBUqZ");
+ });
+
+ test("returns undefined if a project with the given id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const project = await api.getProject("QQQQQQQQ");
+
+ expect(project).toBeUndefined();
+ });
+
+ test("returns undefined if a project with the given slug doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const project = await api.getProject("not-a-real-slug");
+
+ expect(project).toBeUndefined();
+ });
+ });
+
+ describe("getProjectId", () => {
+ test("returns a project's id by its id (yay, technology!)", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const id = await api.getProjectId("gvQqBUqZ");
+
+ expect(id).toBe("gvQqBUqZ");
+ });
+
+ test("returns a project's id by its slug", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const id = await api.getProjectId("lithium");
+
+ expect(id).toBe("gvQqBUqZ");
+ });
+
+ test("returns undefined if a project with the given id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const id = await api.getProjectId("QQQQQQQQ");
+
+ expect(id).toBeUndefined();
+ });
+
+ test("returns undefined if a project with the given slug doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const id = await api.getProject("not-a-real-slug");
+
+ expect(id).toBeUndefined();
+ });
+ });
+
+ describe("getProjects", () => {
+ test("returns projects by their ids", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const projects = await api.getProjects(["P7dR8mSH", "AANobbMI", "gvQqBUqZ"]);
+
+ expect(projects).toBeDefined();
+ expect(projects.map(x => x.slug)).toEqual(["fabric-api", "sodium", "lithium"]);
+ });
+
+ test("returns projects by their slugs", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const projects = await api.getProjects(["fabric-api", "sodium", "lithium"]);
+
+ expect(projects).toBeDefined();
+ expect(projects.map(x => x.id)).toEqual(["P7dR8mSH", "AANobbMI", "gvQqBUqZ"]);
+ });
+
+ test("returns projects by their ids and/or slugs", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const projects = await api.getProjects(["fabric-api", "AANobbMI", "lithium"]);
+
+ expect(projects).toBeDefined();
+ expect(projects.map(x => x.id)).toEqual(["P7dR8mSH", "AANobbMI", "gvQqBUqZ"]);
+ expect(projects.map(x => x.slug)).toEqual(["fabric-api", "sodium", "lithium"]);
+ });
+
+ test("returns an empty array if no ids and/or slugs were provided", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const projects = await api.getProjects([]);
+
+ expect(projects).toEqual([]);
+ });
+
+ test("returns an empty array if projects with the given ids don't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const projects = await api.getProjects(["AAAAAAAA", "BBBBBBBB", "QQQQQQQQ"]);
+
+ expect(projects).toEqual([]);
+ });
+
+ test("returns an empty array if projects with the given slugs don't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const projects = await api.getProjects(["not-a-real-slug", "not-a-real-slug-2", "not-a-real-slug-3"]);
+
+ expect(projects).toEqual([]);
+ });
+ });
+
+ describe("updateProject", () => {
+ test("returns true if the project with the specified id has been successfully updated", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+ const project = DB.projects.find(x => x.id === "gvQqBUqZ");
+ const patch = {
+ ...project,
+ id: project.id,
+ license_id: project.license.id,
+ license_url: project.license.url,
+ } as ModrinthProjectPatch;
+
+ const success = await api.updateProject(patch);
+
+ expect(success).toBe(true);
+ });
+
+ test("returns true if the project with the specified slug has been successfully updated", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+ const project = DB.projects.find(x => x.id === "gvQqBUqZ");
+ const patch = {
+ ...project,
+ id: project.slug,
+ license_id: project.license.id,
+ license_url: project.license.url,
+ } as ModrinthProjectPatch;
+
+ const success = await api.updateProject(patch);
+
+ expect(success).toBe(true);
+ });
+
+ test("returns false if the project with the specified id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.updateProject({ id: "QQQQQQQQ" });
+
+ expect(success).toBe(false);
+ });
+
+ test("returns false if the project with the specified slug doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.updateProject({ id: "not-a-real-slug" });
+
+ expect(success).toBe(false);
+ });
+ });
+
+ describe("deleteProject", () => {
+ test("returns true if the project with the specified id has been deleted", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.deleteProject("gvQqBUqZ");
+
+ expect(success).toBe(true);
+ });
+
+ test("returns true if the project with the specified slug has been deleted", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.deleteProject("lithium");
+
+ expect(success).toBe(true);
+ });
+
+ test("returns false if the project with the specified id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.deleteProject("QQQQQQQQ");
+
+ expect(success).toBe(false);
+ });
+
+ test("returns false if the project with the specified slug doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.deleteProject("not-a-real-slug");
+
+ expect(success).toBe(false);
+ });
+ });
+
+ describe("getVersion", () => {
+ test("returns a version by its id", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const version = await api.getVersion("nMhjKWVE");
+
+ expect(version).toBeDefined();
+ expect(version.id).toBe("nMhjKWVE");
+ });
+
+ test("returns undefined if a version with the given id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const version = await api.getVersion("QQQQQQQQ");
+
+ expect(version).toBeUndefined();
+ });
+ });
+
+ describe("getVersions", () => {
+ test("returns versions by their ids", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getVersions(["nMhjKWVE", "WzQmxYRa", "qdzL5Hkg"]);
+
+ expect(versions).toBeDefined();
+ expect(versions.map(x => x.id)).toEqual(["nMhjKWVE", "WzQmxYRa", "qdzL5Hkg"]);
+ });
+
+ test("returns an empty array if no ids were provided", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getVersions([]);
+
+ expect(versions).toEqual([]);
+ });
+
+ test("returns an empty array if versions with the given ids don't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getVersions(["AAAAAAAA", "BBBBBBBB", "QQQQQQQQ"]);
+
+ expect(versions).toEqual([]);
+ });
+ });
+
+ describe("createVersion", () => {
+ test("creates a new version", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+ const version = DB.versions.find(x => x.id === "nMhjKWVE");
+ const init = {
+ name: version.name,
+ version_number: version.version_number,
+ project_id: version.project_id,
+ changelog: version.changelog,
+ dependencies: version.dependencies,
+ game_versions: version.game_versions,
+ version_type: version.version_type,
+ loaders: version.loaders,
+ featured: version.featured,
+ status: version.status,
+ requested_status: version.requested_status,
+ files: version.files.map(x => x.filename),
+ } as ModrinthVersionInit;
+
+ const createdVersion = await api.createVersion(init);
+
+ expect(createdVersion).toEqual(version);
+ });
+
+ test("returns undefined if a project with the specified id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const version = await api.createVersion({
+ project_id: "QQQQQQQQ",
+ name: "v1.0.0",
+ version_number: "1.0.0",
+ });
+
+ expect(version).toBeUndefined();
+ });
+ });
+
+ describe("updateVersion", () => {
+ test("returns true if the version with the specified id has been successfully updated", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+ const version = DB.versions.find(x => x.id === "nMhjKWVE");
+ const patch = {
+ ...version,
+ id: version.id,
+ primary_file: version.files.filter(x => x.primary).map(x => ["sha1", x.hashes.sha1] as ["sha1", string])[0],
+ } as ModrinthVersionPatch;
+
+ const success = await api.updateVersion(patch);
+
+ expect(success).toBe(true);
+ });
+
+ test("returns false if a version with the specified id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.updateVersion({ id: "QQQQQQQQ" });
+
+ expect(success).toBe(false);
+ });
+ });
+
+ describe("deleteVersion", () => {
+ test("returns true if the version with the specified id has been deleted", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.deleteVersion("nMhjKWVE");
+
+ expect(success).toBe(true);
+ });
+
+ test("returns false if the version with the specified id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const success = await api.deleteVersion("QQQQQQQQ");
+
+ expect(success).toBe(false);
+ });
+ });
+
+ describe("getProjectVersions", () => {
+ test("returns versions by their project's id", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getProjectVersions("gvQqBUqZ");
+
+ expect(versions).toBeDefined();
+ expect(versions.map(x => x.id)).toContain("nMhjKWVE");
+ });
+
+ test("returns versions by their project's slug", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getProjectVersions("lithium");
+
+ expect(versions).toBeDefined();
+ expect(versions.map(x => x.id)).toContain("nMhjKWVE");
+ });
+
+ test("returns an empty array if a project with the specified id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getProjectVersions("QQQQQQQQ");
+
+ expect(versions).toEqual([]);
+ });
+
+ test("returns an empty array if a project with the specified slug doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getProjectVersions("not-a-real-slug");
+
+ expect(versions).toEqual([]);
+ });
+
+ test("returns versions filtered by specified parameters", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getProjectVersions("lithium", {
+ loaders: ["quilt"],
+ game_versions: ["1.20.4"],
+ featured: true,
+ });
+
+ expect(versions).toBeDefined();
+ expect(versions.every(x => x.loaders.includes("quilt"))).toBe(true);
+ expect(versions.every(x => x.game_versions.includes("1.20.4"))).toBe(true);
+ });
+
+ test("returns an empty array if no version matches the specified parameters", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const versions = await api.getProjectVersions("lithium", {
+ loaders: ["forge"],
+ game_versions: ["2.0"],
+ });
+
+ expect(versions).toEqual([]);
+ });
+ });
+
+ describe("unfeaturePreviousProjectVersions", () => {
+ test("unfeatures versions by their project's id", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const map = await api.unfeaturePreviousProjectVersions({ project_id: "gvQqBUqZ" }, ModrinthUnfeatureMode.ANY);
+ const versions = Object.entries(map).filter(([unfeatured]) => unfeatured).map(([_, version]) => version);
+
+ expect(versions).toHaveLength(10);
+ });
+
+ test("unfeatures versions by their project's slug", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const map = await api.unfeaturePreviousProjectVersions({ project_id: "lithium" }, ModrinthUnfeatureMode.ANY);
+ const versions = Object.entries(map).filter(([unfeatured]) => unfeatured).map(([_, version]) => version);
+
+ expect(versions).toHaveLength(10);
+ });
+
+ test("returns an empty record if a project with the specified id doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const map = await api.unfeaturePreviousProjectVersions({ project_id: "QQQQQQQQ" }, ModrinthUnfeatureMode.ANY);
+
+ expect(map).toEqual({});
+ });
+
+ test("returns an empty record if a project with the specified slug doesn't exist", async () => {
+ const api = new ModrinthApiClient({ fetch: MODRINTH_FETCH, token: "token" });
+
+ const map = await api.unfeaturePreviousProjectVersions({ project_id: "not-a-real-slug" }, ModrinthUnfeatureMode.ANY);
+
+ expect(map).toEqual({});
+ });
+ });
+});