feat: add store maintenance

This commit is contained in:
Kurt Himebauch committed 2026-10-28 17:30:58 -04:00
1 parent aef1f85aa9
commit cd09deddba
46 files changed
+3830 -251

No files matched your search

@@ -3,11 +3,15 @@ package com.droiddeck.launcher.stores.itch
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Assert.assertThrows
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.rules.TemporaryFolder
import org.robolectric.RobolectricTestRunner
import java.io.File
@RunWith(RobolectricTestRunner::class)
class ItchStagingTest {
@get:Rule val tmp = TemporaryFolder()
@@ -34,18 +38,16 @@ class ItchStagingTest {
assertTrue(staged.listFiles().orEmpty().all { it.isDirectory && it.listFiles().orEmpty().isEmpty() })
}
@Test fun aFileReplacingADirectoryAndTheOtherWayRound() {
@Test fun aFileDirectoryCollisionFailsWithoutDeletingExistingData() {
val game = tmp.newFolder("game")
val staged = tmp.newFolder("staged")
file(game, "a/inner.txt", "old")
file(game, "b", "old")
file(staged, "a", "new")
file(staged, "b/inner.txt", "new")
ItchStaging.merge(staged, game)
assertTrue(File(game, "a").isFile)
assertEquals("new", File(game, "a").readText())
assertEquals("new", File(game, "b/inner.txt").readText())
assertFalse(File(game, "a/inner.txt").exists())
assertThrows(IllegalArgumentException::class.java) { ItchStaging.merge(staged, game) }
assertEquals("old", File(game, "a/inner.txt").readText())
assertEquals("old", File(game, "b").readText())
}
@Test fun deletingFollowsNoLinkOutOfTheTree() {
@@ -82,4 +84,148 @@ class ItchStagingTest {
assertEquals("record", File(game, ".droiddeck-store.json").readText())
assertEquals("nested", File(game, "sub/.droiddeck-store.json").readText())
}
@Test fun managedCommitRepairsCorruptionRemovesOnlyUntouchedObsoleteFilesAndKeepsSaves() {
val game = tmp.newFolder("managed-game")
val staged = tmp.newFolder("managed-stage")
file(game, "bin/game.exe", "corrupted")
file(game, "data/removed.dat", "publisher-old")
file(game, "saves/slot1.sav", "my-save")
file(game, "data/user.ini", "my-config")
file(staged, "bin/game.exe", "publisher-new")
file(staged, "data/new.dat", "new")
val previous = ItchStaging.inventory(tmp.newFolder("old-inventory")).toMutableMap()
val oldFiles = tmp.newFolder("old-publisher")
file(oldFiles, "bin/game.exe", "publisher-prior")
file(oldFiles, "data/removed.dat", "publisher-old")
previous.putAll(ItchStaging.inventory(oldFiles))
val next = ItchStaging.commit(staged, game, previous)
assertEquals("publisher-new", File(game, "bin/game.exe").readText())
assertFalse(File(game, "data/removed.dat").exists())
assertEquals("my-save", File(game, "saves/slot1.sav").readText())
assertEquals("my-config", File(game, "data/user.ini").readText())
assertEquals("new", File(game, "data/new.dat").readText())
ItchStaging.writeInventory(game, next)
assertEquals(next, ItchStaging.readInventory(game))
}
@Test fun interruptedCommitResumesFromPinnedInventoryAndCompletesObsoleteCleanup() {
val game = tmp.newFolder("resume-game")
val staged = tmp.newFolder("resume-stage")
file(game, "old.txt", "old")
file(staged, "a.txt", "new-a")
file(staged, "b.txt", "new-b")
val previous = ItchStaging.inventory(game)
assertThrows(IllegalStateException::class.java) {
ItchStaging.commit(staged, game, previous) { if (it == 1) error("simulated interruption") }
}
assertTrue(ItchStaging.recover(game))
val next = ItchStaging.commit(staged, game, previous)
assertEquals("new-a", File(game, "a.txt").readText())
assertEquals("new-b", File(game, "b.txt").readText())
assertFalse(File(game, "old.txt").exists())
assertEquals(setOf("a.txt", "b.txt"), next.keys)
assertFalse(ItchStaging.recover(game))
}
@Test fun unmanagedCollisionPreservesUserFile() {
val game = tmp.newFolder("collision-game")
val staged = tmp.newFolder("collision-stage")
file(game, "saves/slot1.sav", "my-save")
file(staged, "saves/slot1.sav", "archive-file")
assertThrows(IllegalArgumentException::class.java) { ItchStaging.commit(staged, game, emptyMap()) }
assertEquals("my-save", File(game, "saves/slot1.sav").readText())
}
@Test fun publisherUserDataPlaceholdersAndEmptyDirectoriesAreInstalledAndManaged() {
val game = tmp.newFolder("publisher-user-data-game")
val staged = tmp.newFolder("publisher-user-data-stage")
file(staged, "profiles/default/config.ini", "publisher defaults")
file(staged, "saves/default.sav", "")
File(staged, "data/required-empty").mkdirs()
assertThrows(IllegalStateException::class.java) {
ItchStaging.commit(staged, game, emptyMap()) { if (it == 2) error("simulated interruption") }
}
assertTrue(ItchStaging.recover(game))
val next = ItchStaging.commit(staged, game, emptyMap())
assertEquals("publisher defaults", File(game, "profiles/default/config.ini").readText())
assertTrue(File(game, "saves/default.sav").isFile)
assertEquals(0L, File(game, "saves/default.sav").length())
assertTrue(File(game, "data/required-empty").isDirectory)
assertTrue("profiles/default/config.ini" in next)
assertTrue("saves/default.sav" in next)
assertEquals("<directory>", next["data/required-empty/"])
ItchStaging.writeInventory(game, next)
assertEquals(next, ItchStaging.readInventory(game))
assertFalse(ItchStaging.recover(game))
}
@Test fun locallyModifiedManagedProfileIsPreservedByRefusingReplacement() {
val game = tmp.newFolder("modified-save-game")
val oldPublisher = tmp.newFolder("modified-save-old")
val staged = tmp.newFolder("modified-save-stage")
file(oldPublisher, "profiles/settings.ini", "publisher defaults")
file(game, "profiles/settings.ini", "user settings")
file(staged, "profiles/settings.ini", "new publisher defaults")
val previous = ItchStaging.inventory(oldPublisher)
assertThrows(IllegalArgumentException::class.java) { ItchStaging.commit(staged, game, previous) }
assertEquals("user settings", File(game, "profiles/settings.ini").readText())
}
@Test fun aDoneJournalEntryIsRehashedBeforeResumeSkipsIt() {
val game = tmp.newFolder("corrupt-resume-game")
val staged = tmp.newFolder("corrupt-resume-stage")
file(game, "old.txt", "old")
file(staged, "a.txt", "new-a")
file(staged, "b.txt", "new-b")
val previous = ItchStaging.inventory(game)
assertThrows(IllegalStateException::class.java) {
ItchStaging.commit(staged, game, previous) { if (it == 2) error("simulated interruption") }
}
file(game, "a.txt", "tampered")
file(staged, "a.txt", "new-a")
ItchStaging.commit(staged, game, previous)
assertEquals("new-a", File(game, "a.txt").readText())
assertEquals("new-b", File(game, "b.txt").readText())
}
@Test fun corruptOrSymlinkedCommitJournalsFailClosed() {
val game = tmp.newFolder("journal-game")
val staged = tmp.newFolder("journal-stage")
val metadata = File(game, ".droiddeck-maintenance").also { it.mkdirs() }
file(game, "user.txt", "keep")
file(staged, "user.txt", "publisher")
val journal = File(metadata, "itch-commit.json")
journal.writeText("{")
assertThrows(IllegalStateException::class.java) { ItchStaging.commit(staged, game, emptyMap()) }
assertThrows(IllegalStateException::class.java) { ItchStaging.recover(game) }
assertEquals("keep", File(game, "user.txt").readText())
journal.delete()
val outside = file(tmp.newFolder("journal-outside"), "outside.json", "{}")
java.nio.file.Files.createSymbolicLink(journal.toPath(), outside.toPath())
assertThrows(IllegalStateException::class.java) { ItchStaging.commit(staged, game, emptyMap()) }
assertThrows(IllegalStateException::class.java) { ItchStaging.recover(game) }
assertEquals("{}", outside.readText())
assertEquals("keep", File(game, "user.txt").readText())
journal.delete()
metadata.delete()
val outsideMetadata = tmp.newFolder("outside-metadata")
file(outsideMetadata, "itch-commit.json", "{}")
java.nio.file.Files.createSymbolicLink(metadata.toPath(), outsideMetadata.toPath())
assertThrows(IllegalArgumentException::class.java) { ItchStaging.recover(game) }
assertEquals("{}", File(outsideMetadata, "itch-commit.json").readText())
}
@Test fun corruptManagedInventoryFailsClosed() {
val game = tmp.newFolder("inventory-game")
val metadata = File(game, ".droiddeck-maintenance").also { it.mkdirs() }
file(game, "publisher.txt", "keep")
File(metadata, "itch-inventory.json").writeText("{\"../outside.txt\":\"bad\"}")
assertThrows(IllegalArgumentException::class.java) { ItchStaging.readInventory(game) }
assertEquals("keep", File(game, "publisher.txt").readText())
}
}
@@ -0,0 +1,122 @@
package com.droiddeck.launcher.stores.maintenance
import android.content.Context
import com.droiddeck.launcher.stores.InstalledStoreGame
import com.droiddeck.launcher.stores.Store
import com.droiddeck.launcher.stores.StoreGameSidecar
import org.json.JSONObject
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Rule
import org.junit.Test
import org.junit.rules.TemporaryFolder
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import org.robolectric.annotation.Config
import java.io.File
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [33])
class StoreMaintenanceTest {
@get:Rule val temporary = TemporaryFolder()
private val adapter = object : StoreMaintenanceAdapter {
override val store = Store.EPIC
override fun capabilities(game: InstalledStoreGame) = setOf(MaintenanceAction.UPDATE)
override fun check(context: Context, game: InstalledStoreGame) = MaintenanceCheck(MaintenanceCheckState.CURRENT)
override fun prepare(context: Context, game: InstalledStoreGame, action: MaintenanceAction) = error("unused")
override fun enqueue(context: Context, game: InstalledStoreGame, proposal: MaintenanceProposal) = Unit
override fun resume(context: Context, game: InstalledStoreGame, operation: JSONObject) = Unit
}
@Test fun operationPinsFolderTargetAndFullSidecarBeforeApply() {
val app = RuntimeEnvironment.getApplication()
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "app", "Example", "bin/game.exe", args = listOf("--user-value"),
env = mapOf("CUSTOM_SETTING" to "kept"), installedAt = 1234L, extra = mapOf("channel" to "test"))
sidecar.write(folder)
val game = InstalledStoreGame(sidecar, folder)
StoreMaintenance.register(adapter)
StoreMaintenance.enqueue(app, game, MaintenanceProposal(folder, sidecar, "version 2", MaintenanceAction.UPDATE,
downloadBytes = 42, diskBytes = 84, target = JSONObject().put("schema", 1).put("build", "2")))
val journal = StoreMaintenance.readOperation(folder)!!
assertEquals(folder.path, journal.getString("folder"))
assertEquals("app", journal.getString("id"))
assertEquals("queued", journal.getString("phase"))
assertEquals("2", journal.getJSONObject("target").getString("build"))
val before = StoreGameSidecar.parse(journal.getJSONObject("before").toString())!!
assertEquals(sidecar.args, before.args)
assertEquals(sidecar.env, before.env)
assertEquals(sidecar.installedAt, before.installedAt)
assertEquals(sidecar.extra, before.extra)
}
@Test fun failedApplyLeavesLaunchExcludedRecoveryStateAndJournal() {
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "app", "Example", "bin/game.exe")
sidecar.write(folder)
val game = InstalledStoreGame(sidecar, folder)
StoreMaintenance.register(adapter)
StoreMaintenance.enqueue(RuntimeEnvironment.getApplication(), game,
MaintenanceProposal(folder, sidecar, "version 2", MaintenanceAction.UPDATE, target = JSONObject().put("schema", 1)))
runCatching {
StoreMaintenance.withApplyLease(game) {
error("simulated interrupted apply")
}
}
assertEquals(StoreGameSidecar.STATE_UPDATING, StoreGameSidecar.read(folder)!!.state)
assertEquals("applying", StoreMaintenance.readOperation(folder)!!.getString("phase"))
assertEquals(RecoveryState.NEEDS_ATTENTION, StoreMaintenance.recovery(RuntimeEnvironment.getApplication(), game).state)
assertTrue(StoreMaintenance.launchExcluded(game))
assertTrue(StoreMaintenance.operationFile(folder).isFile)
}
@Test fun queuedOperationDoesNotMarkTheInstallAsApplying() {
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "app", "Example", "bin/game.exe")
sidecar.write(folder)
val game = InstalledStoreGame(sidecar, folder)
StoreMaintenance.register(adapter)
StoreMaintenance.enqueue(RuntimeEnvironment.getApplication(), game,
MaintenanceProposal(folder, sidecar, "version 2", MaintenanceAction.UPDATE, target = JSONObject().put("schema", 1)))
assertFalse(StoreMaintenance.launchExcluded(game))
assertEquals(RecoveryState.RESUMABLE, StoreMaintenance.recovery(RuntimeEnvironment.getApplication(), game).state)
}
@Test fun applyLeaseIsExclusiveAndMarksTheJournalBeforeMutation() {
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "app", "Example", "bin/game.exe")
sidecar.write(folder)
val game = InstalledStoreGame(sidecar, folder)
StoreMaintenance.register(adapter)
StoreMaintenance.enqueue(RuntimeEnvironment.getApplication(), game,
MaintenanceProposal(folder, sidecar, "version 2", MaintenanceAction.UPDATE, target = JSONObject().put("schema", 1)))
val lease = StoreMaintenance.beginApplyLease(game)
try {
assertEquals("applying", StoreMaintenance.readOperation(folder)!!.getString("phase"))
assertEquals(StoreGameSidecar.STATE_UPDATING, StoreGameSidecar.read(folder)!!.state)
assertTrue(runCatching { StoreMaintenance.beginApplyLease(game) }.isFailure)
} finally {
lease.close()
}
}
@Test fun unsupportedOrMismatchedJournalBlocksLaunch() {
val folder = temporary.newFolder().canonicalFile
val game = InstalledStoreGame(StoreGameSidecar(Store.EPIC, "app", "Example", "bin/game.exe"), folder)
File(folder, ".droiddeck-maintenance").mkdirs()
StoreMaintenance.operationFile(folder).writeText(JSONObject().put("schema", 9).put("folder", folder.path).put("phase", "download").toString())
assertTrue(StoreMaintenance.launchExcluded(game))
assertTrue(runCatching { StoreMaintenance.readOperation(folder) }.isFailure)
assertEquals(RecoveryState.NEEDS_ATTENTION, StoreMaintenance.recovery(RuntimeEnvironment.getApplication(), game).state)
}
}
@@ -0,0 +1,28 @@
package com.droiddeck.launcher.stores.xbox
import com.droiddeck.launcher.stores.maintenance.StoreMaintenance
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Test
class XboxMaintenancePersistenceTest {
@Test fun completedMaintenanceDoesNotPersistQueueMarkers() {
val persisted = XboxInstaller.maintenanceSidecarExtra(
mapOf(
"contentId" to "old-content",
"market" to "US",
"preferredLanguage" to "fr-FR",
StoreMaintenance.OPERATION_KEY to "UPDATE",
StoreMaintenance.FOLDER_KEY to "/games/example",
),
"new-content",
"GB",
)
assertEquals("new-content", persisted["contentId"])
assertEquals("GB", persisted["market"])
assertEquals("fr-FR", persisted["preferredLanguage"])
assertFalse(persisted.containsKey(StoreMaintenance.OPERATION_KEY))
assertFalse(persisted.containsKey(StoreMaintenance.FOLDER_KEY))
}
}