fix: guard maintenance queue admission

This commit is contained in:
Kurt Himebauch committed 2026-10-28 18:12:58 -04:00
1 parent be51429fa4
commit 3ccf8ca01a
16 files changed
+362 -141

No files matched your search

@@ -1,6 +1,7 @@
package com.droiddeck.launcher.stores
import android.app.Application
import android.os.Looper
import com.droiddeck.launcher.frontend.AddedGames
import com.droiddeck.launcher.session.SessionPrefs
import org.junit.Assert.*
@@ -10,6 +11,9 @@ import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import org.robolectric.annotation.Config
import java.io.File
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicBoolean
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [33], application = Application::class)
@@ -18,9 +22,12 @@ class StoreLaunchTest {
private fun install(state: String = StoreGameSidecar.STATE_INSTALLED): File {
SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
val folder = File(StoreInstallRoot.storeDir(StoreInstallRoot.installRoot(app), Store.XBOX), "Deep Rock Galactic")
val storeDir = StoreInstallRoot.storeDir(StoreInstallRoot.installRoot(app), Store.XBOX)
storeDir.listFiles()?.filter { StoreGameSidecar.read(it)?.id == "9NHFVWX1V7QJ" }?.forEach { it.deleteRecursively() }
val folder = File(storeDir, "Deep Rock Galactic")
File(folder, "FSD/Binaries/WinGDK/FSD.exe").apply { parentFile!!.mkdirs(); writeText("licensed image") }
StoreGameSidecar(Store.XBOX, "9NHFVWX1V7QJ", "Deep Rock Galactic", "FSD/Binaries/WinGDK/FSD.exe", state = state).write(folder)
SessionPrefs.setAddedGameRemoved(app, folder.path, false)
return folder
}
@@ -53,4 +60,46 @@ class StoreLaunchTest {
File(folder, "FSD/Binaries/WinGDK/FSD.exe").delete()
assertNull(StoreLaunch.installedGame(app, Store.XBOX, "9NHFVWX1V7QJ"))
}
@Test fun installedTargetWinsOverAnEarlierUpdatingDuplicate() {
val updating = install(StoreGameSidecar.STATE_UPDATING)
val installed = File(updating.parentFile, "ZZZ installed copy")
File(installed, "FSD/Binaries/WinGDK/FSD.exe").apply { parentFile!!.mkdirs(); writeText("installed image") }
StoreGameSidecar(Store.XBOX, "9NHFVWX1V7QJ", "Deep Rock Galactic", "FSD/Binaries/WinGDK/FSD.exe").write(installed)
try {
assertEquals(installed, StoreLaunch.findInstalled(app, Store.XBOX, "9NHFVWX1V7QJ")!!.first)
} finally {
installed.deleteRecursively()
}
}
@Test fun prepareScansOffTheCallerAndPostsReadyBackToMainLooper() {
val updating = install(StoreGameSidecar.STATE_UPDATING)
val installed = File(updating.parentFile, "ZZZ installed copy")
File(installed, "FSD/Binaries/WinGDK/FSD.exe").apply { parentFile!!.mkdirs(); writeText("installed image") }
StoreGameSidecar(Store.XBOX, "9NHFVWX1V7QJ", "Deep Rock Galactic", "FSD/Binaries/WinGDK/FSD.exe").write(installed)
val callbackRan = AtomicBoolean(false)
val callbackOnMain = AtomicBoolean(false)
val callback = CountDownLatch(1)
try {
StoreLaunch.prepare(app, Store.XBOX, "9NHFVWX1V7QJ") {
callbackOnMain.set(Looper.myLooper() == Looper.getMainLooper())
callbackRan.set(true)
callback.countDown()
}
assertFalse("ready callback must not run inline on the caller", callbackRan.get())
val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
while (callback.count > 0 && System.nanoTime() < deadline) {
org.robolectric.shadows.ShadowLooper.idleMainLooper()
Thread.sleep(10)
}
assertTrue("ready callback was not posted", callback.await(1, TimeUnit.SECONDS))
assertTrue("ready callback must run on the main looper", callbackOnMain.get())
} finally {
installed.deleteRecursively()
}
}
}
@@ -0,0 +1,18 @@
package com.droiddeck.launcher.stores.battlenet
import com.droiddeck.launcher.stores.InstalledStoreGame
import com.droiddeck.launcher.stores.Store
import com.droiddeck.launcher.stores.StoreGameSidecar
import com.droiddeck.launcher.stores.maintenance.MaintenanceAction
import org.junit.Assert.assertEquals
import org.junit.Test
import java.io.File
class BattleNetMaintenanceTest {
@Test fun agentManagedGamesOfferOnlyClientHandoffThroughSharedMaintenance() {
val folder = File("/tmp/battlenet-agent-game")
val game = InstalledStoreGame(StoreGameSidecar(Store.BATTLENET, "wow", "World of Warcraft", ""), folder)
assertEquals(setOf(MaintenanceAction.OPEN_CLIENT), BattleNetMaintenanceAdapter.capabilities(game))
}
}
@@ -7,6 +7,7 @@ import java.io.File
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicBoolean
import org.junit.After
import org.junit.Assert.*
import org.junit.Test
@@ -137,4 +138,40 @@ class DownloadQueueRetryTest {
assertTrue(ran.await(5, TimeUnit.SECONDS))
awaitFailure(entry.key, "restored")
}
@Test fun maintenanceAdmissionRejectsDuplicateWithoutReplacingSavedQueueItem() {
val id = "maintenance-admission-${java.util.UUID.randomUUID()}"
val first = CatalogItem(Store.EPIC, id, "First update", imageUrl = null, owned = true)
val second = CatalogItem(Store.EPIC, id, "Other operation", imageUrl = null, owned = true)
val entry = DownloadEntry(Store.EPIC, id, first.title)
val firstFactory = { object : DownloadQueue.DownloadJob {
override fun run(handle: DownloadQueue.JobHandle): String? = null
override fun cancel(deleteFiles: Boolean) = Unit
} }
DownloadQueue.holdPaused(entry.key)
val firstAccepted = DownloadQueue.enqueueIfIdle(app, entry,
onAccepted = { SavedQueue.remember(app, first, null) }, factory = firstFactory)
val duplicateRemembered = AtomicBoolean(false)
val secondAccepted = DownloadQueue.enqueueIfIdle(app, entry.copy(name = second.title),
onAccepted = { duplicateRemembered.set(true); SavedQueue.remember(app, second, null) }, factory = firstFactory)
assertTrue(firstAccepted)
assertFalse(secondAccepted)
assertFalse(duplicateRemembered.get())
assertEquals(DownloadState.PAUSED, DownloadQueue.entry(entry.key)?.state)
val saved = File(app.filesDir, "store-queue.json")
val until = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
var savedFirst = false
while (!savedFirst && System.nanoTime() < until) {
savedFirst = runCatching {
val rows = JSONArray(saved.readText())
(0 until rows.length()).any { i -> rows.getJSONObject(i).getJSONObject("item").getString("title") == first.title }
}.getOrDefault(false)
if (!savedFirst) Thread.sleep(10)
}
assertTrue("only the accepted operation's saved item should persist", savedFirst)
DownloadQueue.clear(app, entry.key)
}
}
@@ -4,9 +4,17 @@ import android.content.Context
import com.droiddeck.launcher.stores.InstalledStoreGame
import com.droiddeck.launcher.stores.Store
import com.droiddeck.launcher.stores.StoreGameSidecar
import com.droiddeck.launcher.stores.CatalogItem
import com.droiddeck.launcher.stores.download.DownloadEntry
import com.droiddeck.launcher.stores.download.DownloadQueue
import com.droiddeck.launcher.stores.download.DownloadState
import com.droiddeck.launcher.stores.download.SavedQueue
import org.json.JSONObject
import org.json.JSONArray
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertSame
import org.junit.Assert.assertTrue
import org.junit.Rule
import org.junit.Test
@@ -16,6 +24,7 @@ import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import org.robolectric.annotation.Config
import java.io.File
import java.util.concurrent.TimeUnit
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [33])
@@ -27,7 +36,7 @@ class StoreMaintenanceTest {
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 enqueue(context: Context, game: InstalledStoreGame, proposal: MaintenanceProposal) = true
override fun resume(context: Context, game: InstalledStoreGame, operation: JSONObject) = Unit
}
@@ -90,6 +99,105 @@ class StoreMaintenanceTest {
assertEquals(RecoveryState.RESUMABLE, StoreMaintenance.recovery(RuntimeEnvironment.getApplication(), game).state)
}
@Test fun failedQueueSubmissionClearsOnlyItsNewQueuedJournalAndRethrowsOriginalError() {
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "enqueue-failure", "Example", "bin/game.exe")
sidecar.write(folder)
val game = InstalledStoreGame(sidecar, folder)
val failure = IllegalStateException("queue rejected")
StoreMaintenance.register(object : StoreMaintenanceAdapter {
override val store = Store.EPIC
override fun capabilities(game: InstalledStoreGame) = setOf(MaintenanceAction.UPDATE)
override fun check(context: Context, game: InstalledStoreGame) = MaintenanceCheck()
override fun prepare(context: Context, game: InstalledStoreGame, action: MaintenanceAction) = error("unused")
override fun enqueue(context: Context, game: InstalledStoreGame, proposal: MaintenanceProposal): Boolean { throw failure }
override fun resume(context: Context, game: InstalledStoreGame, operation: JSONObject) = Unit
})
val proposal = MaintenanceProposal(folder, sidecar, "target", MaintenanceAction.UPDATE,
target = JSONObject().put("schema", 1).put("build", "target"))
val thrown = runCatching { StoreMaintenance.enqueue(RuntimeEnvironment.getApplication(), game, proposal) }.exceptionOrNull()
assertSame(failure, thrown)
assertNull(StoreMaintenance.readOperation(folder))
}
@Test fun failedQueueSubmissionPreservesJournalThatHasAdvancedFromQueued() {
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "enqueue-advanced", "Example", "bin/game.exe")
sidecar.write(folder)
val game = InstalledStoreGame(sidecar, folder)
val failure = IllegalStateException("queue response lost")
StoreMaintenance.register(object : StoreMaintenanceAdapter {
override val store = Store.EPIC
override fun capabilities(game: InstalledStoreGame) = setOf(MaintenanceAction.UPDATE)
override fun check(context: Context, game: InstalledStoreGame) = MaintenanceCheck()
override fun prepare(context: Context, game: InstalledStoreGame, action: MaintenanceAction) = error("unused")
override fun enqueue(context: Context, game: InstalledStoreGame, proposal: MaintenanceProposal): Boolean {
val file = StoreMaintenance.operationFile(game.folder)
file.writeText(JSONObject(file.readText()).put("phase", "download").toString())
throw failure
}
override fun resume(context: Context, game: InstalledStoreGame, operation: JSONObject) = Unit
})
val proposal = MaintenanceProposal(folder, sidecar, "target", MaintenanceAction.UPDATE,
target = JSONObject().put("schema", 1).put("build", "target"))
val thrown = runCatching { StoreMaintenance.enqueue(RuntimeEnvironment.getApplication(), game, proposal) }.exceptionOrNull()
assertSame(failure, thrown)
assertEquals("download", StoreMaintenance.readOperation(folder)!!.getString("phase"))
}
@Test fun queueRaceRejectionClearsOnlyMaintenanceJournalAndKeepsExistingSavedJob() {
val app = RuntimeEnvironment.getApplication()
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "queue-race", "Example", "bin/game.exe")
sidecar.write(folder)
val game = InstalledStoreGame(sidecar, folder)
val existing = CatalogItem(Store.EPIC, sidecar.id, "Existing job", imageUrl = null, owned = true)
val maintenance = CatalogItem(Store.EPIC, sidecar.id, "Maintenance job", imageUrl = null, owned = true)
val key = DownloadEntry(Store.EPIC, sidecar.id, existing.title).key
fun job() = object : DownloadQueue.DownloadJob {
override fun run(handle: DownloadQueue.JobHandle): String? = null
override fun cancel(deleteFiles: Boolean) = Unit
}
DownloadQueue.holdPaused(key)
StoreMaintenance.register(object : StoreMaintenanceAdapter {
override val store = Store.EPIC
override fun capabilities(game: InstalledStoreGame) = setOf(MaintenanceAction.UPDATE)
override fun check(context: Context, game: InstalledStoreGame) = MaintenanceCheck()
override fun prepare(context: Context, game: InstalledStoreGame, action: MaintenanceAction) = error("unused")
override fun enqueue(context: Context, game: InstalledStoreGame, proposal: MaintenanceProposal): Boolean {
SavedQueue.remember(context, existing, null)
DownloadQueue.enqueue(context, DownloadEntry(Store.EPIC, sidecar.id, existing.title), ::job)
return DownloadQueue.enqueueIfIdle(context, DownloadEntry(Store.EPIC, sidecar.id, maintenance.title), onAccepted = {
SavedQueue.remember(context, maintenance, null)
}, factory = ::job)
}
override fun resume(context: Context, game: InstalledStoreGame, operation: JSONObject) = Unit
})
val proposal = MaintenanceProposal(folder, sidecar, "target", MaintenanceAction.UPDATE,
target = JSONObject().put("schema", 1).put("build", "target"))
assertTrue(runCatching { StoreMaintenance.enqueue(app, game, proposal) }.isFailure)
assertNull(StoreMaintenance.readOperation(folder))
assertEquals(DownloadState.PAUSED, DownloadQueue.entry(key)?.state)
val saved = File(app.filesDir, "store-queue.json")
val until = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
var existingSaved = false
while (!existingSaved && System.nanoTime() < until) {
existingSaved = runCatching {
val rows = JSONArray(saved.readText())
(0 until rows.length()).any { i -> rows.getJSONObject(i).getJSONObject("item").getString("title") == existing.title }
}.getOrDefault(false)
if (!existingSaved) Thread.sleep(10)
}
assertTrue("rejected maintenance must not replace the active queue's saved item", existingSaved)
DownloadQueue.clear(app, key)
}
@Test fun applyLeaseIsExclusiveAndMarksTheJournalBeforeMutation() {
val folder = temporary.newFolder().canonicalFile
val sidecar = StoreGameSidecar(Store.EPIC, "app", "Example", "bin/game.exe")