239 lines
8.4 KiB
TypeScript
239 lines
8.4 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
|
|
import {
|
|
createLatestRequestGuard,
|
|
gameVersionSelectorText,
|
|
isLoaderSupportStateDisabled,
|
|
loaderMetadataCacheKey,
|
|
loaderMetadataQueryKey,
|
|
loaderSupportState,
|
|
loaderVersionSelectorText,
|
|
loaderVersionsForGameVersion,
|
|
loaderVersionSummaryState,
|
|
preserveOrSelectGameVersion,
|
|
scopedLoaderMetadataQueryKey,
|
|
} from '../../../../packages/ui/src/components/flows/creation-flow-modal/loader-metadata.ts'
|
|
import {
|
|
clientInstallableLoaders,
|
|
instanceInstallablePlatforms,
|
|
} from '../../../../packages/ui/src/utils/loaders.ts'
|
|
|
|
const manifest = (gameVersion: string, versions: string[]) => ({
|
|
gameVersions: [
|
|
{
|
|
id: gameVersion,
|
|
loaders: versions.map((id) => ({ id, stable: true })),
|
|
},
|
|
],
|
|
})
|
|
|
|
test('shares the complete client loader list with instance installation settings', () => {
|
|
assert.deepEqual(
|
|
[...clientInstallableLoaders],
|
|
[
|
|
'fabric',
|
|
'neoforge',
|
|
'forge',
|
|
'quilt',
|
|
'optifine',
|
|
'cleanroom',
|
|
'lite_loader',
|
|
'legacy_fabric',
|
|
'babric',
|
|
],
|
|
)
|
|
assert.deepEqual([...instanceInstallablePlatforms], ['vanilla', ...clientInstallableLoaders])
|
|
})
|
|
|
|
test('instance settings scopes Forge and Fabric queries by Minecraft version', () => {
|
|
const forgeA = scopedLoaderMetadataQueryKey('instance-settings', 'forge', '1.20.1')
|
|
const forgeB = scopedLoaderMetadataQueryKey('instance-settings', 'forge', '26.2')
|
|
const forgeAReturn = scopedLoaderMetadataQueryKey('instance-settings', 'forge', '1.20.1')
|
|
const fabricA = scopedLoaderMetadataQueryKey('instance-settings', 'fabric', '1.20.1')
|
|
const fabricB = scopedLoaderMetadataQueryKey('instance-settings', 'fabric', '1.21.1')
|
|
|
|
assert.deepEqual(forgeA, ['instance-settings', 'loader-versions', 'forge', '1.20.1'])
|
|
assert.deepEqual(forgeB, ['instance-settings', 'loader-versions', 'forge', '26.2'])
|
|
assert.deepEqual(forgeAReturn, forgeA)
|
|
assert.notDeepEqual(forgeA, forgeB)
|
|
assert.notDeepEqual(fabricA, fabricB)
|
|
|
|
const cache = new Map([
|
|
[JSON.stringify(forgeA), manifest('1.20.1', ['47.4.22'])],
|
|
[JSON.stringify(forgeB), manifest('26.2', ['65.1.1', '65.1.0'])],
|
|
[JSON.stringify(fabricA), manifest('1.20.1', ['0.18.4'])],
|
|
[JSON.stringify(fabricB), manifest('1.21.1', ['0.18.4', '0.17.3'])],
|
|
])
|
|
const ids = (key: readonly string[], gameVersion: string) =>
|
|
loaderVersionsForGameVersion(cache.get(JSON.stringify(key)), gameVersion).map(
|
|
(version) => version.id,
|
|
)
|
|
|
|
assert.deepEqual(ids(forgeA, '1.20.1'), ['47.4.22'])
|
|
assert.deepEqual(ids(forgeB, '26.2'), ['65.1.1', '65.1.0'])
|
|
assert.deepEqual(ids(forgeAReturn, '1.20.1'), ['47.4.22'])
|
|
assert.deepEqual(ids(fabricA, '1.20.1'), ['0.18.4'])
|
|
assert.deepEqual(ids(fabricB, '1.21.1'), ['0.18.4', '0.17.3'])
|
|
})
|
|
|
|
test('isolates loader metadata by loader and Minecraft version', () => {
|
|
const forge262Key = loaderMetadataCacheKey('forge', '26.2')
|
|
const forge1201Key = loaderMetadataCacheKey('forge', '1.20.1')
|
|
const cache = {
|
|
[forge262Key]: manifest('26.2', ['65.1.1', '65.1.0']),
|
|
[forge1201Key]: manifest('1.20.1', ['47.4.22', '47.4.21']),
|
|
}
|
|
|
|
assert.notEqual(forge262Key, forge1201Key)
|
|
assert.deepEqual(loaderMetadataQueryKey('forge', '26.2'), [
|
|
'creation-flow',
|
|
'loader-versions',
|
|
'forge',
|
|
'26.2',
|
|
])
|
|
assert.deepEqual(loaderMetadataQueryKey('forge', '1.20.1'), [
|
|
'creation-flow',
|
|
'loader-versions',
|
|
'forge',
|
|
'1.20.1',
|
|
])
|
|
|
|
assert.deepEqual(
|
|
loaderVersionsForGameVersion(cache[forge262Key], '26.2').map((version) => version.id),
|
|
['65.1.1', '65.1.0'],
|
|
)
|
|
assert.deepEqual(
|
|
loaderVersionsForGameVersion(cache[forge1201Key], '1.20.1').map((version) => version.id),
|
|
['47.4.22', '47.4.21'],
|
|
)
|
|
assert.deepEqual(
|
|
loaderVersionsForGameVersion(cache[forge262Key], '26.2').map((version) => version.id),
|
|
['65.1.1', '65.1.0'],
|
|
)
|
|
})
|
|
|
|
test('rejects stale loader metadata requests after rapid selection changes', () => {
|
|
const guard = createLatestRequestGuard()
|
|
const minecraftARequest = guard.begin()
|
|
const minecraftBRequest = guard.begin()
|
|
const minecraftAReturnRequest = guard.begin()
|
|
|
|
assert.equal(guard.isCurrent(minecraftARequest), false)
|
|
assert.equal(guard.isCurrent(minecraftBRequest), false)
|
|
assert.equal(guard.isCurrent(minecraftAReturnRequest), true)
|
|
|
|
const fabricRequest = guard.begin()
|
|
const forgeRequest = guard.begin()
|
|
const neoForgeRequest = guard.begin()
|
|
assert.equal(guard.isCurrent(fabricRequest), false)
|
|
assert.equal(guard.isCurrent(forgeRequest), false)
|
|
assert.equal(guard.isCurrent(neoForgeRequest), true)
|
|
})
|
|
|
|
test('does not treat missing, loading, or errored metadata as unsupported', () => {
|
|
assert.equal(loaderSupportState('unknown', undefined, '1.20.1'), 'unknown')
|
|
assert.equal(loaderSupportState('loading', undefined, '1.20.1'), 'loading')
|
|
assert.equal(loaderSupportState('error', undefined, '1.20.1'), 'error')
|
|
})
|
|
|
|
test('marks only a successfully resolved empty loader set as unsupported', () => {
|
|
assert.equal(
|
|
loaderSupportState('success', manifest('1.20.1', ['47.4.22']), '1.20.1'),
|
|
'supported',
|
|
)
|
|
assert.equal(
|
|
loaderSupportState('success', manifest('unsupported', []), 'unsupported'),
|
|
'unsupported',
|
|
)
|
|
})
|
|
|
|
test('restores loader support state across Minecraft version changes', () => {
|
|
const cache = {
|
|
[loaderMetadataCacheKey('forge', '1.20.1')]: manifest('1.20.1', ['47.4.22']),
|
|
[loaderMetadataCacheKey('forge', 'unsupported')]: manifest('unsupported', []),
|
|
}
|
|
|
|
const support = (gameVersion: string) =>
|
|
loaderSupportState(
|
|
'success',
|
|
cache[loaderMetadataCacheKey('forge', gameVersion) as keyof typeof cache],
|
|
gameVersion,
|
|
)
|
|
|
|
assert.equal(support('1.20.1'), 'supported')
|
|
assert.equal(support('unsupported'), 'unsupported')
|
|
assert.equal(support('1.20.1'), 'supported')
|
|
})
|
|
|
|
test('disables loader chips until compatibility is positively confirmed', () => {
|
|
assert.equal(isLoaderSupportStateDisabled('unknown'), true)
|
|
assert.equal(isLoaderSupportStateDisabled('loading'), true)
|
|
assert.equal(isLoaderSupportStateDisabled('unsupported'), true)
|
|
assert.equal(isLoaderSupportStateDisabled('supported'), false)
|
|
assert.equal(isLoaderSupportStateDisabled('error'), true)
|
|
})
|
|
|
|
test('does not replace an explicit Minecraft version when loader options change', () => {
|
|
assert.equal(preserveOrSelectGameVersion('26.2', ['26.1.2', '1.21.11']), '26.2')
|
|
assert.equal(preserveOrSelectGameVersion(null, ['26.1.2', '1.21.11']), '26.1.2')
|
|
assert.equal(preserveOrSelectGameVersion(null, []), null)
|
|
})
|
|
|
|
test('tracks loader chips through pending, supported, and unsupported responses', () => {
|
|
const pendingB = loaderSupportState('loading', undefined, '26.2')
|
|
assert.equal(isLoaderSupportStateDisabled(pendingB), true)
|
|
|
|
const unsupportedB = loaderSupportState('success', manifest('unsupported', []), 'unsupported')
|
|
assert.equal(unsupportedB, 'unsupported')
|
|
assert.equal(isLoaderSupportStateDisabled(unsupportedB), true)
|
|
|
|
const pendingC = loaderSupportState('loading', undefined, '1.20.1')
|
|
assert.equal(isLoaderSupportStateDisabled(pendingC), true)
|
|
|
|
const supportedC = loaderSupportState('success', manifest('1.20.1', ['47.4.22']), '1.20.1')
|
|
assert.equal(supportedC, 'supported')
|
|
assert.equal(isLoaderSupportStateDisabled(supportedC), false)
|
|
})
|
|
|
|
test('uses the loading label for both loader version selector placeholders while pending', () => {
|
|
assert.deepEqual(
|
|
loaderVersionSelectorText(true, false, {
|
|
loading: 'Loading',
|
|
empty: 'No versions available',
|
|
placeholder: 'Select loader version',
|
|
searchPlaceholder: 'Search loader version...',
|
|
}),
|
|
{ placeholder: 'Loading', searchPlaceholder: 'Loading' },
|
|
)
|
|
})
|
|
|
|
test('hides an old loader version behind the loading summary until the new version resolves', () => {
|
|
assert.equal(loaderVersionSummaryState(true, '47.4.22'), 'loading')
|
|
assert.equal(loaderVersionSummaryState(false, '65.1.0'), 'selected')
|
|
assert.equal(loaderVersionSummaryState(false, null), 'empty')
|
|
})
|
|
|
|
test('shows a loader-specific message after game version metadata resolves empty', () => {
|
|
const labels = {
|
|
loading: 'Loading',
|
|
empty: 'No game versions support this loader',
|
|
error: 'Failed to load game versions',
|
|
placeholder: 'Select game version',
|
|
searchPlaceholder: 'Search game version...',
|
|
}
|
|
|
|
assert.deepEqual(gameVersionSelectorText('loading', labels), {
|
|
placeholder: 'Loading',
|
|
searchPlaceholder: 'Loading',
|
|
})
|
|
assert.deepEqual(gameVersionSelectorText('empty', labels), {
|
|
placeholder: 'No game versions support this loader',
|
|
searchPlaceholder: 'No game versions support this loader',
|
|
})
|
|
assert.deepEqual(gameVersionSelectorText('error', labels), {
|
|
placeholder: 'Failed to load game versions',
|
|
searchPlaceholder: 'Failed to load game versions',
|
|
})
|
|
})
|