HerozDotExe/node-launcher-kit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: fix tests to supports 26.1+

Browse source
This commit is contained in:
HerozDotExe 2026-05-23 11:21:55 +02:00
parent 34fb68079d
commit 221182a06f
2 changed files with 306 additions and 138 deletions
Download patch file Download diff file Expand all files Collapse all files

2
shell.nix
View file

@ -7,6 +7,7 @@ pkgs.mkShell {
# Java # Java
packages = with pkgs; [ packages = with pkgs; [
jdk21 jdk21
jdk25
jre8 jre8
xrandr xrandr
]; ];
@ -49,4 +50,5 @@ pkgs.mkShell {
j8 = pkgs.jre8 + "/bin/java"; j8 = pkgs.jre8 + "/bin/java";
j21 = pkgs.jdk21 + "/bin/java"; j21 = pkgs.jdk21 + "/bin/java";
j25 = pkgs.jdk25 + "/bin/java";
} }

440
tests/generator.js
View file

@ -1,183 +1,349 @@
import fs from "fs/promises" import fs from "fs/promises";
import path from "path" import path from "path";
import { Browser, BrowserWindow } from 'happy-dom'; import { Browser, BrowserWindow } from "happy-dom";
import PQueue from 'p-queue'; import PQueue from "p-queue";
// Use "java" tests if you don't want tests to download java by themselves, you will need to provide binaries path : // Use "java" tests if you don't want tests to download java by themselves, you will need to provide binaries path :
// pnpm run test /path/to/java8/bin/java /path/to/java21/bin/java // pnpm run test /path/to/java8/bin/java /path/to/java21/bin/java /path/to/java25/bin/java
const importantVersions = ["1.7.10", "1.12.2", "1.16.5", "1.18.2", "1.20.1", "1.21.1", "1.21.11"] const importantVersions = [
const modpacksUrls = ["https://cdn.modrinth.com/data/1KVo5zza/versions/FbnAVst2/Fabulously.Optimized-v12.0.7.mrpack", "https://cdn.modrinth.com/data/4BV47HRn/versions/krFPoaLH/Better%20MC%20%5BFORGE%5D%20BMC4%20v43.mrpack"] "1.7.10",
"1.12.2",
"1.16.5",
"1.18.2",
"1.20.1",
"1.21.1",
"1.21.11",
"26.1.2",
];
const modpacksUrls = [
"https://cdn.modrinth.com/data/1KVo5zza/versions/FbnAVst2/Fabulously.Optimized-v12.0.7.mrpack",
"https://cdn.modrinth.com/data/4BV47HRn/versions/krFPoaLH/Better%20MC%20%5BFORGE%5D%20BMC4%20v43.mrpack",
];
const java8 = process.argv[2] const java8 = process.argv[2];
const java21 = process.argv[3] const java21 = process.argv[3];
const java = java8 && java21 const java25 = process.argv[4];
const java = java8 && java21 && java25;
const vanillaVersions = ( const vanillaVersions = (
await (await fetch( await (
"https://piston-meta.mojang.com/mc/game/version_manifest_v2.json", await fetch(
)).json()).versions.filter(v => v.type === "release") "https://piston-meta.mojang.com/mc/game/version_manifest_v2.json",
)
).json()
).versions.filter((v) => v.type === "release");
async function getJava(mcVersion) { async function getJava(mcVersion) {
const versionManifestUrl = vanillaVersions.find(v => { const versionManifestUrl = vanillaVersions.find((v) => {
const parsedVersion = mcVersion.split(".") const parsedVersion = mcVersion.split(".");
if (parsedVersion[2] === "0") { if (parsedVersion[2] === "0") {
mcVersion = `${parsedVersion[0]}.${parsedVersion[1]}` mcVersion = `${parsedVersion[0]}.${parsedVersion[1]}`;
} }
return v.id === mcVersion return v.id === mcVersion;
}).url }).url;
const versionManifest = await ( const versionManifest = await await (await fetch(versionManifestUrl)).json();
await (await fetch(
versionManifestUrl,
)).json()
)
return versionManifest.javaVersion ? (versionManifest.javaVersion.component === "jre-legacy" ? java8 : java21) : java8 switch (versionManifest.javaVersion.component) {
case "jre-legacy":
return java8;
case "java-runtime-epsilon":
return java25;
default:
return java21;
}
} }
async function fExists(path) { async function fExists(path) {
try { try {
await fs.stat(path) await fs.stat(path);
return true return true;
} catch (error) { } catch (error) {
return false return false;
} }
} }
const tempFolder = import.meta.dirname const tempFolder = import.meta.dirname;
if (await fExists(path.join(tempFolder, "vanilla"))) { await fs.rm(path.join(tempFolder, "vanilla"), { recursive: true }) } if (await fExists(path.join(tempFolder, "vanilla"))) {
if (await fExists(path.join(tempFolder, "modrinth"))) { await fs.rm(path.join(tempFolder, "modrinth"), { recursive: true }) } await fs.rm(path.join(tempFolder, "vanilla"), { recursive: true });
if (await fExists(path.join(tempFolder, "modloaders/forge"))) { await fs.rm(path.join(tempFolder, "modloaders/forge"), { recursive: true }) } }
if (await fExists(path.join(tempFolder, "modloaders/neoforge"))) { await fs.rm(path.join(tempFolder, "modloaders/neoforge"), { recursive: true }) } if (await fExists(path.join(tempFolder, "modrinth"))) {
if (await fExists(path.join(tempFolder, "modloaders/fabric"))) { await fs.rm(path.join(tempFolder, "modloaders/fabric"), { recursive: true }) } await fs.rm(path.join(tempFolder, "modrinth"), { recursive: true });
}
if (await fExists(path.join(tempFolder, "modloaders/forge"))) {
await fs.rm(path.join(tempFolder, "modloaders/forge"), { recursive: true });
}
if (await fExists(path.join(tempFolder, "modloaders/neoforge"))) {
await fs.rm(path.join(tempFolder, "modloaders/neoforge"), {
recursive: true,
});
}
if (await fExists(path.join(tempFolder, "modloaders/fabric"))) {
await fs.rm(path.join(tempFolder, "modloaders/fabric"), { recursive: true });
}
await fs.mkdir(path.join(tempFolder, "vanilla"), { recursive: true }) await fs.mkdir(path.join(tempFolder, "vanilla"), { recursive: true });
await fs.mkdir(path.join(tempFolder, "modrinth"), { recursive: true }) await fs.mkdir(path.join(tempFolder, "modrinth"), { recursive: true });
await fs.mkdir(path.join(tempFolder, "modloaders/forge"), { recursive: true }) await fs.mkdir(path.join(tempFolder, "modloaders/forge"), { recursive: true });
await fs.mkdir(path.join(tempFolder, "modloaders/neoforge"), { recursive: true }) await fs.mkdir(path.join(tempFolder, "modloaders/neoforge"), {
await fs.mkdir(path.join(tempFolder, "modloaders/fabric"), { recursive: true }) recursive: true,
});
await fs.mkdir(path.join(tempFolder, "modloaders/fabric"), { recursive: true });
// Forge // Forge
{ {
const queue = new PQueue({ concurrency: 10 }) const queue = new PQueue({ concurrency: 10 });
const browser = new Browser() const browser = new Browser();
for (const version of importantVersions) { for (const version of importantVersions) {
queue.add(async () => { queue.add(async () => {
const page = browser.newPage() const page = browser.newPage();
await page.goto(`https://files.minecraftforge.net/net/minecraftforge/forge/index_${version}.html`) await page.goto(
const document = page.mainFrame.document; `https://files.minecraftforge.net/net/minecraftforge/forge/index_${version}.html`,
const forgeVersion = document.querySelector("body > main > div.sidebar-sticky-wrapper-content > div.promos-wrapper > div.promos-content > div > div:nth-child(1) > div.title > small").innerText.split("- ")[1] );
const document = page.mainFrame.document;
const forgeVersion = document
.querySelector(
"body > main > div.sidebar-sticky-wrapper-content > div.promos-wrapper > div.promos-content > div > div:nth-child(1) > div.title > small",
)
.innerText.split("- ")[1];
if (!await fExists(path.join(tempFolder, `modloaders/forge/forge-${version}-${forgeVersion}.test.ts`))) { if (
let result = "" !(await fExists(
if (java) { path.join(
const template = await fs.readFile(path.join(tempFolder, "modloader-java.test.ts.template"), { encoding: "utf-8" }) tempFolder,
result = template.replaceAll("${version}", version).replaceAll("${modloader}", "forge").replaceAll("${modloader_version}", forgeVersion).replaceAll("${java}", await getJava(version)) `modloaders/forge/forge-${version}-${forgeVersion}.test.ts`,
} else { ),
const template = await fs.readFile(path.join(tempFolder, "modloader.test.ts.template"), { encoding: "utf-8" }) ))
result = template.replaceAll("${version}", version).replaceAll("${modloader}", "forge").replaceAll("${modloader_version}", forgeVersion) ) {
} let result = "";
await fs.writeFile(path.join(tempFolder, `modloaders/forge/forge-${version}-${forgeVersion}.test.ts`), result) if (java) {
console.log(`Done forge ${forgeVersion}`) const template = await fs.readFile(
} path.join(tempFolder, "modloader-java.test.ts.template"),
}) { encoding: "utf-8" },
} );
result = template
.replaceAll("${version}", version)
.replaceAll("${modloader}", "forge")
.replaceAll("${modloader_version}", forgeVersion)
.replaceAll("${java}", await getJava(version));
} else {
const template = await fs.readFile(
path.join(tempFolder, "modloader.test.ts.template"),
{ encoding: "utf-8" },
);
result = template
.replaceAll("${version}", version)
.replaceAll("${modloader}", "forge")
.replaceAll("${modloader_version}", forgeVersion);
}
await fs.writeFile(
path.join(
tempFolder,
`modloaders/forge/forge-${version}-${forgeVersion}.test.ts`,
),
result,
);
console.log(`Done forge ${forgeVersion}`);
}
});
}
} }
// Neoforge // Neoforge
{ {
let versions = (await (await fetch("https://maven.neoforged.net/api/maven/versions/releases/net%2Fneoforged%2Fneoforge")).json()).versions.filter(v => !v.includes("beta") && !v.includes("craftmine") && importantVersions.includes(`1.${v.split(".")[0]}.${v.split(".")[1]}`)) let versions = (
versions = Object.values(Object.groupBy(versions, (v) => { await (
const parsedVersion = v.split(".") await fetch(
const start = `1.${parsedVersion[0]}.${parsedVersion[1]}` "https://maven.neoforged.net/api/maven/versions/releases/net%2Fneoforged%2Fneoforge",
return start )
})).map(arr => arr[arr.length - 1]) ).json()
).versions.filter(
(v) =>
!v.includes("beta") &&
!v.includes("craftmine") &&
importantVersions.includes(`1.${v.split(".")[0]}.${v.split(".")[1]}`),
);
versions = Object.values(
Object.groupBy(versions, (v) => {
const parsedVersion = v.split(".");
const start = `1.${parsedVersion[0]}.${parsedVersion[1]}`;
return start;
}),
).map((arr) => arr[arr.length - 1]);
for (const neoForgeVersion of versions) { for (const neoForgeVersion of versions) {
const parsedVersion = neoForgeVersion.split(".") const parsedVersion = neoForgeVersion.split(".");
let mcVersion = `${parsedVersion[0]}.${parsedVersion[1]}` let mcVersion = `${parsedVersion[0]}.${parsedVersion[1]}`;
if (parseInt(parsedVersion[0]) < 26) { if (parseInt(parsedVersion[0]) < 26) {
mcVersion = "1." + mcVersion mcVersion = "1." + mcVersion;
}
if (!await fExists(path.join(tempFolder, `modloaders/neoforge/neoforge-${mcVersion}-${neoForgeVersion}.test.ts`))) {
let result = ""
if (java) {
const template = await fs.readFile(path.join(tempFolder, "modloader-java.test.ts.template"), { encoding: "utf-8" })
result = template.replaceAll("${version}", mcVersion).replaceAll("${modloader}", "neoforge").replaceAll("${modloader_version}", neoForgeVersion).replaceAll("${java}", await getJava(mcVersion))
} else {
const template = await fs.readFile(path.join(tempFolder, "modloader.test.ts.template"), { encoding: "utf-8" })
result = template.replaceAll("${version}", mcVersion).replaceAll("${modloader}", "neoforge").replaceAll("${modloader_version}", neoForgeVersion)
}
await fs.writeFile(path.join(tempFolder, `modloaders/neoforge/neoforge-${mcVersion}-${neoForgeVersion}.test.ts`), result)
console.log(`Done neoforge ${neoForgeVersion}`)
}
} }
if (
!(await fExists(
path.join(
tempFolder,
`modloaders/neoforge/neoforge-${mcVersion}-${neoForgeVersion}.test.ts`,
),
))
) {
let result = "";
if (java) {
const template = await fs.readFile(
path.join(tempFolder, "modloader-java.test.ts.template"),
{ encoding: "utf-8" },
);
result = template
.replaceAll("${version}", mcVersion)
.replaceAll("${modloader}", "neoforge")
.replaceAll("${modloader_version}", neoForgeVersion)
.replaceAll("${java}", await getJava(mcVersion));
} else {
const template = await fs.readFile(
path.join(tempFolder, "modloader.test.ts.template"),
{ encoding: "utf-8" },
);
result = template
.replaceAll("${version}", mcVersion)
.replaceAll("${modloader}", "neoforge")
.replaceAll("${modloader_version}", neoForgeVersion);
}
await fs.writeFile(
path.join(
tempFolder,
`modloaders/neoforge/neoforge-${mcVersion}-${neoForgeVersion}.test.ts`,
),
result,
);
console.log(`Done neoforge ${neoForgeVersion}`);
}
}
} }
// Fabric // Fabric
{ {
let mcVersions = (await (await fetch("https://meta.fabricmc.net/v2/versions/game")).json()).filter(v => { let mcVersions = (
return importantVersions.includes(v.version) await (await fetch("https://meta.fabricmc.net/v2/versions/game")).json()
}).map(v => v.version) )
.filter((v) => {
return importantVersions.includes(v.version);
})
.map((v) => v.version);
for (const mcVersion of mcVersions) { for (const mcVersion of mcVersions) {
const loaderVersions = (await (await fetch(`https://meta.fabricmc.net/v2/versions/loader/${mcVersion}`)).json()) const loaderVersions = await (
const fabricVersion = loaderVersions.find(v => v.loader.stable) await fetch(`https://meta.fabricmc.net/v2/versions/loader/${mcVersion}`)
if (fabricVersion) { ).json();
if (!await fExists(path.join(tempFolder, `modloaders/fabric/fabric-${mcVersion}-${fabricVersion.loader.version}.test.ts`))) { const fabricVersion = loaderVersions.find((v) => v.loader.stable);
let result = "" if (fabricVersion) {
if (java) { if (
const template = await fs.readFile(path.join(tempFolder, "modloader-java.test.ts.template"), { encoding: "utf-8" }) !(await fExists(
result = template.replaceAll("${version}", mcVersion).replaceAll("${modloader}", "fabric").replaceAll("${modloader_version}", fabricVersion.loader.version).replaceAll("${java}", await getJava(mcVersion)) path.join(
} else { tempFolder,
const template = await fs.readFile(path.join(tempFolder, "modloader.test.ts.template"), { encoding: "utf-8" }) `modloaders/fabric/fabric-${mcVersion}-${fabricVersion.loader.version}.test.ts`,
result = template.replaceAll("${version}", mcVersion).replaceAll("${modloader}", "fabric").replaceAll("${modloader_version}", fabricVersion.loader.version) ),
} ))
await fs.writeFile(path.join(tempFolder, `modloaders/fabric/fabric-${mcVersion}-${fabricVersion.loader.version}.test.ts`), result) ) {
console.log(`Done fabric ${mcVersion}`) let result = "";
} if (java) {
const template = await fs.readFile(
path.join(tempFolder, "modloader-java.test.ts.template"),
{ encoding: "utf-8" },
);
result = template
.replaceAll("${version}", mcVersion)
.replaceAll("${modloader}", "fabric")
.replaceAll("${modloader_version}", fabricVersion.loader.version)
.replaceAll("${java}", await getJava(mcVersion));
} else {
const template = await fs.readFile(
path.join(tempFolder, "modloader.test.ts.template"),
{ encoding: "utf-8" },
);
result = template
.replaceAll("${version}", mcVersion)
.replaceAll("${modloader}", "fabric")
.replaceAll("${modloader_version}", fabricVersion.loader.version);
} }
await fs.writeFile(
path.join(
tempFolder,
`modloaders/fabric/fabric-${mcVersion}-${fabricVersion.loader.version}.test.ts`,
),
result,
);
console.log(`Done fabric ${mcVersion}`);
}
} }
}
} }
// Vanilla // Vanilla
{ {
vanillaVersions.filter(v => importantVersions.includes(v.id)).forEach(async v => { vanillaVersions
if (!await fExists(path.join(tempFolder, `vanilla/vanilla-${v.id}.test.ts`))) { .filter((v) => importantVersions.includes(v.id))
let result = "" .forEach(async (v) => {
if (java) { if (
const template = await fs.readFile(path.join(tempFolder, "vanilla-java.test.ts.template"), { encoding: "utf-8" }) !(await fExists(
result = template.replaceAll("${version}", v.id).replaceAll("${java}", await getJava(v.id)) path.join(tempFolder, `vanilla/vanilla-${v.id}.test.ts`),
} else { ))
const template = await fs.readFile(path.join(tempFolder, "vanilla.test.ts.template"), { encoding: "utf-8" }) ) {
result = template.replaceAll("${version}", v.id) let result = "";
} if (java) {
await fs.writeFile(path.join(tempFolder, `vanilla/vanilla-${v.id}.test.ts`), result) const template = await fs.readFile(
console.log(`Done vanilla ${v.id}`) path.join(tempFolder, "vanilla-java.test.ts.template"),
{ encoding: "utf-8" },
);
result = template
.replaceAll("${version}", v.id)
.replaceAll("${java}", await getJava(v.id));
} else {
const template = await fs.readFile(
path.join(tempFolder, "vanilla.test.ts.template"),
{ encoding: "utf-8" },
);
result = template.replaceAll("${version}", v.id);
} }
await fs.writeFile(
path.join(tempFolder, `vanilla/vanilla-${v.id}.test.ts`),
result,
);
console.log(`Done vanilla ${v.id}`);
}
}); });
} }
// Modrinth modpacks // Modrinth modpacks
{ {
modpacksUrls.forEach(async (url) => { modpacksUrls.forEach(async (url) => {
const modpackId = url.split("/").pop().replace(".mrpack", "") const modpackId = url.split("/").pop().replace(".mrpack", "");
let result = "" let result = "";
if (java) { if (java) {
const template = await fs.readFile(path.join(tempFolder, "modrinth-java.test.ts.template"), { encoding: "utf-8" }) const template = await fs.readFile(
// TODO: use java version based on modpack's minecraft version path.join(tempFolder, "modrinth-java.test.ts.template"),
result = template.replaceAll("${modpack_url}", url).replaceAll("${modpack_id}", modpackId).replaceAll("${java}", java21) { encoding: "utf-8" },
} else { );
const template = await fs.readFile(path.join(tempFolder, "modrinth.test.ts.template"), { encoding: "utf-8" }) // TODO: use java version based on modpack's minecraft version
// Same but inside tests result = template
result = template.replaceAll("${modpack_url}", url).replaceAll("${modpack_id}", modpackId) .replaceAll("${modpack_url}", url)
} .replaceAll("${modpack_id}", modpackId)
await fs.writeFile(path.join(tempFolder, `modrinth/modrinth-${modpackId}.test.ts`), result) .replaceAll("${java}", java21);
console.log(`Done modrinth ${modpackId}`) } else {
}) const template = await fs.readFile(
path.join(tempFolder, "modrinth.test.ts.template"),
{ encoding: "utf-8" },
);
// Same but inside tests
result = template
.replaceAll("${modpack_url}", url)
.replaceAll("${modpack_id}", modpackId);
}
await fs.writeFile(
path.join(tempFolder, `modrinth/modrinth-${modpackId}.test.ts`),
result,
);
console.log(`Done modrinth ${modpackId}`);
});
} }