test(catchup): require Guide to Player semantic intent wiring

app/tv/src/test/kotlin/app/muxtv/navigation/PlayerCatchupDestinationTest.kt

@@ -0,0 +1,77 @@
+package app.muxtv.navigation
+
+import app.muxtv.feature.guide.GuidePlaybackSelection
+import app.muxtv.player.PlaybackIntent
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class PlayerCatchupDestinationTest {
+    @Test
+    fun `legacy player destination remains live`() {
+        val destination = AppDestination.Player(CHANNEL_ID)
+
+        assertThat(destination.toPlaybackIntent())
+            .isEqualTo(PlaybackIntent.Live(CHANNEL_ID))
+    }
+
+    @Test
+    fun `catchup destination reconstructs provider neutral programme intent`() {
+        val destination = AppDestination.Player(
+            channelId = CHANNEL_ID,
+            programmeId = PROGRAMME_ID,
+            programmeStartEpochMillis = PROGRAMME_START,
+            programmeEndEpochMillis = PROGRAMME_END,
+        )
+
+        assertThat(destination.toPlaybackIntent()).isEqualTo(
+            PlaybackIntent.CatchupProgram(
+                channelId = CHANNEL_ID,
+                programmeId = PROGRAMME_ID,
+                startEpochMillis = PROGRAMME_START,
+                endEpochMillis = PROGRAMME_END,
+            ),
+        )
+    }
+
+    @Test
+    fun `guide catchup selection maps to bounded player destination`() {
+        val destination = GuidePlaybackSelection.CatchupProgram(
+            channelId = CHANNEL_ID,
+            programmeId = PROGRAMME_ID,
+            startEpochMillis = PROGRAMME_START,
+            endEpochMillis = PROGRAMME_END,
+        ).toPlayerDestination()
+
+        assertThat(destination).isEqualTo(
+            AppDestination.Player(
+                channelId = CHANNEL_ID,
+                programmeId = PROGRAMME_ID,
+                programmeStartEpochMillis = PROGRAMME_START,
+                programmeEndEpochMillis = PROGRAMME_END,
+            ),
+        )
+    }
+
+    @Test
+    fun `guide live selection maps to legacy player destination`() {
+        assertThat(GuidePlaybackSelection.Live(CHANNEL_ID).toPlayerDestination())
+            .isEqualTo(AppDestination.Player(CHANNEL_ID))
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `partial catchup tuple is rejected`() {
+        AppDestination.Player(
+            channelId = CHANNEL_ID,
+            programmeId = PROGRAMME_ID,
+            programmeStartEpochMillis = PROGRAMME_START,
+            programmeEndEpochMillis = null,
+        )
+    }
+
+    private companion object {
+        const val CHANNEL_ID = "channel-news"
+        const val PROGRAMME_ID = "gp1_00112233445566778899aabbccddeeff"
+        const val PROGRAMME_START = 1_800_000_000_000L
+        const val PROGRAMME_END = PROGRAMME_START + 3_600_000L
+    }
+}

catalog/api/src/main/kotlin/app/muxtv/catalog/PlaybackCatalog.kt

@@ -165,6 +165,23 @@ interface PlaybackCandidateResolver {
         profileId: String,
         candidate: PlaybackCandidateIdentity,
     ): PlaybackVariantResolution?
+
+    suspend fun resolveIntentCandidate(
+        profileId: String,
+        intent: PlaybackIntent,
+        candidate: PlaybackCandidateIdentity,
+    ): PlaybackVariantResolution? = when (intent) {
+        is PlaybackIntent.Live -> resolveCandidate(
+            profileId = profileId,
+            candidate = candidate,
+        )
+
+        is PlaybackIntent.CatchupProgram,
+        is PlaybackIntent.CatchupPosition,
+        -> PlaybackVariantResolution.AccessUnavailable(
+            PlaybackAccessUnavailableReason.ArchiveUnsupported,
+        )
+    }
 }
 
 interface PlaybackCatalog {

catalog/api/src/test/kotlin/app/muxtv/catalog/PlaybackCandidateResolverIntentTest.kt

@@ -0,0 +1,91 @@
+package app.muxtv.catalog
+
+import app.muxtv.player.PlaybackIntent
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+
+class PlaybackCandidateResolverIntentTest {
+    @Test
+    fun liveIntentDefaultsToExistingExactCandidateResolution() {
+        runBlocking {
+            val candidate = PlaybackCandidateIdentity(
+                channelId = CHANNEL_ID,
+                variantId = VARIANT_ID,
+            )
+            val expected = PlaybackVariantResolution.AccessUnavailable(
+                PlaybackAccessUnavailableReason.CredentialUnavailable,
+            )
+            val resolvedCandidates = mutableListOf<PlaybackCandidateIdentity>()
+            val resolver = recordingResolver(resolvedCandidates, expected)
+
+            val result = resolver.resolveIntentCandidate(
+                profileId = PROFILE_ID,
+                intent = PlaybackIntent.Live(CHANNEL_ID),
+                candidate = candidate,
+            )
+
+            assertThat(result).isEqualTo(expected)
+            assertThat(resolvedCandidates).containsExactly(candidate)
+        }
+    }
+
+    @Test
+    fun archiveIntentDefaultsToUnsupportedWithoutFallingBackToLiveCandidateResolution() {
+        runBlocking {
+            val candidate = PlaybackCandidateIdentity(
+                channelId = CHANNEL_ID,
+                variantId = VARIANT_ID,
+            )
+            val resolvedCandidates = mutableListOf<PlaybackCandidateIdentity>()
+            val resolver = recordingResolver(
+                resolvedCandidates = resolvedCandidates,
+                resolution = PlaybackVariantResolution.AccessUnavailable(
+                    PlaybackAccessUnavailableReason.CredentialUnavailable,
+                ),
+            )
+
+            val result = resolver.resolveIntentCandidate(
+                profileId = PROFILE_ID,
+                intent = PlaybackIntent.CatchupPosition(
+                    channelId = CHANNEL_ID,
+                    positionEpochMillis = 1_800_000_000_000L,
+                ),
+                candidate = candidate,
+            )
+
+            assertThat(result).isEqualTo(
+                PlaybackVariantResolution.AccessUnavailable(
+                    PlaybackAccessUnavailableReason.ArchiveUnsupported,
+                ),
+            )
+            assertThat(resolvedCandidates).isEmpty()
+        }
+    }
+
+    private fun recordingResolver(
+        resolvedCandidates: MutableList<PlaybackCandidateIdentity>,
+        resolution: PlaybackVariantResolution,
+    ): PlaybackCandidateResolver = object : PlaybackCandidateResolver {
+        override suspend fun getCandidates(
+            profileId: String,
+            channelId: String,
+            preferredVariantId: String?,
+            limit: Int,
+        ): List<PlaybackCandidateIdentity> = emptyList()
+
+        override suspend fun resolveCandidate(
+            profileId: String,
+            candidate: PlaybackCandidateIdentity,
+        ): PlaybackVariantResolution {
+            resolvedCandidates += candidate
+            return resolution
+        }
+    }
+
+    private companion object {
+        const val PROFILE_ID = "profile-main"
+        const val CHANNEL_ID = "channel-news"
+        const val VARIANT_ID = "variant-primary"
+    }
+}