Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

Fix series detail favorites and season loading

David Nashashacbba82c91c7
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt
index 595d1a2f..c55f7a17 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailScreen.kt
@@ -19,6 +19,9 @@ import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Favorite
+import androidx.compose.material.icons.outlined.FavoriteBorder
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
@@ -40,6 +43,7 @@ import androidx.tv.material3.Border
import androidx.tv.material3.Button
import androidx.tv.material3.ButtonDefaults
import androidx.tv.material3.ClickableSurfaceDefaults
+import androidx.tv.material3.Icon
import androidx.tv.material3.MaterialTheme
import androidx.tv.material3.Surface
import androidx.tv.material3.SurfaceDefaults
@@ -109,6 +113,7 @@ fun SeriesDetailScreen(
unwatchedEpisodeCount = uiState.unwatchedEpisodeCount,
externalRatings = uiState.externalRatings,
isLoadingExternalRatings = uiState.isLoadingExternalRatings,
+ onToggleFavorite = viewModel::toggleFavorite,
onSeasonSelected = viewModel::selectSeason,
onEpisodeClick = onEpisodeClick,
onResumeClick = onResumeClick ?: onEpisodeClick,
@@ -124,6 +129,7 @@ private fun SeriesDetailContent(
unwatchedEpisodeCount: Int,
externalRatings: ExternalRatings,
isLoadingExternalRatings: Boolean,
+ onToggleFavorite: () -> Unit,
onSeasonSelected: (Season) -> Unit,
onEpisodeClick: (Episode) -> Unit,
onResumeClick: (Episode) -> Unit,
@@ -262,30 +268,16 @@ private fun SeriesDetailContent(
)
resumeEpisode?.let { ep ->
val hasProgress = ep.watchProgress > 5000L
- TvButton(
- onClick = { onResumeClick(ep) },
- colors = ButtonDefaults.colors(
- containerColor = AppColors.Brand,
- contentColor = Color.White
- )
- ) {
- Text(
- text = if (hasProgress) {
- stringResource(
- R.string.series_detail_resume,
- ep.seasonNumber,
- ep.episodeNumber,
- formatPositionMs(ep.watchProgress)
- )
- } else {
- stringResource(
- R.string.series_detail_play_episode,
- ep.seasonNumber,
- ep.episodeNumber
- )
- }
- )
- }
+ SeriesDetailActions(
+ series = series,
+ resumeEpisode = ep,
+ hasProgress = hasProgress,
+ onResumeClick = onResumeClick,
+ onToggleFavorite = onToggleFavorite
+ )
+ }
+ if (resumeEpisode == null) {
+ SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)
}
}
}
@@ -356,30 +348,16 @@ private fun SeriesDetailContent(
)
resumeEpisode?.let { ep ->
val hasProgress = ep.watchProgress > 5000L
- TvButton(
- onClick = { onResumeClick(ep) },
- colors = ButtonDefaults.colors(
- containerColor = AppColors.Brand,
- contentColor = Color.White
- )
- ) {
- Text(
- text = if (hasProgress) {
- stringResource(
- R.string.series_detail_resume,
- ep.seasonNumber,
- ep.episodeNumber,
- formatPositionMs(ep.watchProgress)
- )
- } else {
- stringResource(
- R.string.series_detail_play_episode,
- ep.seasonNumber,
- ep.episodeNumber
- )
- }
- )
- }
+ SeriesDetailActions(
+ series = series,
+ resumeEpisode = ep,
+ hasProgress = hasProgress,
+ onResumeClick = onResumeClick,
+ onToggleFavorite = onToggleFavorite
+ )
+ }
+ if (resumeEpisode == null) {
+ SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)
}
}
}
@@ -451,6 +429,64 @@ private fun SeriesDetailContent(
}
}
+@Composable
+private fun SeriesDetailActions(
+ series: Series,
+ resumeEpisode: Episode,
+ hasProgress: Boolean,
+ onResumeClick: (Episode) -> Unit,
+ onToggleFavorite: () -> Unit
+) {
+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {
+ TvButton(
+ onClick = { onResumeClick(resumeEpisode) },
+ colors = ButtonDefaults.colors(
+ containerColor = AppColors.Brand,
+ contentColor = Color.White
+ )
+ ) {
+ Text(
+ text = if (hasProgress) {
+ stringResource(
+ R.string.series_detail_resume,
+ resumeEpisode.seasonNumber,
+ resumeEpisode.episodeNumber,
+ formatPositionMs(resumeEpisode.watchProgress)
+ )
+ } else {
+ stringResource(
+ R.string.series_detail_play_episode,
+ resumeEpisode.seasonNumber,
+ resumeEpisode.episodeNumber
+ )
+ }
+ )
+ }
+ SeriesDetailFavoriteAction(series = series, onToggleFavorite = onToggleFavorite)
+ }
+}
+
+@Composable
+private fun SeriesDetailFavoriteAction(
+ series: Series,
+ onToggleFavorite: () -> Unit
+) {
+ TvIconButton(
+ onClick = onToggleFavorite,
+ colors = ButtonDefaults.colors(
+ containerColor = if (series.isFavorite) AppColors.Brand else AppColors.SurfaceEmphasis,
+ contentColor = if (series.isFavorite) Color.White else AppColors.TextSecondary
+ )
+ ) {
+ Icon(
+ imageVector = if (series.isFavorite) Icons.Filled.Favorite else Icons.Outlined.FavoriteBorder,
+ contentDescription = stringResource(
+ if (series.isFavorite) R.string.favorites_remove else R.string.favorites_add
+ )
+ )
+ }
+}
+
@Composable
fun SeasonChip(
season: Season,
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailViewModel.kt
index 1083730c..c06d665d 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesDetailViewModel.kt
@@ -11,17 +11,19 @@ import com.streamvault.domain.model.Result
import com.streamvault.domain.model.Season
import com.streamvault.domain.model.Series
import com.streamvault.domain.repository.ExternalRatingsRepository
+import com.streamvault.domain.repository.FavoriteRepository
import com.streamvault.domain.repository.PlaybackHistoryRepository
-import com.streamvault.domain.repository.SeriesRepository
import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.domain.repository.SeriesRepository
import com.streamvault.domain.util.isPlaybackComplete
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import javax.inject.Inject
@@ -31,7 +33,8 @@ class SeriesDetailViewModel @Inject constructor(
private val seriesRepository: SeriesRepository,
private val providerRepository: ProviderRepository,
private val playbackHistoryRepository: PlaybackHistoryRepository,
- private val externalRatingsRepository: ExternalRatingsRepository
+ private val externalRatingsRepository: ExternalRatingsRepository,
+ private val favoriteRepository: FavoriteRepository
) : ViewModel() {
private val seriesId: Long = checkNotNull(
@@ -54,31 +57,40 @@ class SeriesDetailViewModel @Inject constructor(
return@collect
}
providerDetailJob = launch {
+ val effectiveProviderId = resolveEffectiveProviderId(provider.id)
launch {
playbackHistoryRepository.getUnwatchedCount(
- providerId = provider.id,
+ providerId = effectiveProviderId,
seriesId = seriesId
).collect { count ->
_uiState.update { it.copy(unwatchedEpisodeCount = count) }
}
}
- loadSeriesDetailsForProvider(provider.id)
+ loadSeriesDetailsForProvider(effectiveProviderId)
}
}
}
}
+ private suspend fun resolveEffectiveProviderId(fallbackProviderId: Long): Long {
+ return seriesRepository.getSeriesById(seriesId)?.providerId?.takeIf { it > 0L }
+ ?: fallbackProviderId
+ }
+
private suspend fun loadSeriesDetailsForProvider(providerId: Long) {
try {
_uiState.update { it.copy(isLoading = true, error = null) }
when (val result = seriesRepository.getSeriesDetails(providerId, seriesId)) {
is Result.Success -> {
+ val isFavoriteDeferred = viewModelScope.async {
+ favoriteRepository.isFavorite(providerId, seriesId, ContentType.SERIES)
+ }
loadExternalRatings(result.data)
_uiState.update {
it.copy(
isLoading = false,
- series = result.data,
+ series = result.data.copy(isFavorite = isFavoriteDeferred.await()),
selectedSeason = result.data.seasons.firstOrNull(),
resumeEpisode = findResumeEpisode(result.data),
error = null
@@ -104,6 +116,19 @@ class SeriesDetailViewModel @Inject constructor(
}
}
+ fun toggleFavorite() {
+ val series = _uiState.value.series ?: return
+ viewModelScope.launch {
+ val newState = !series.isFavorite
+ if (newState) {
+ favoriteRepository.addFavorite(series.providerId, series.id, ContentType.SERIES)
+ } else {
+ favoriteRepository.removeFavorite(series.providerId, series.id, ContentType.SERIES)
+ }
+ _uiState.update { it.copy(series = series.copy(isFavorite = newState)) }
+ }
+ }
+
private fun loadExternalRatings(series: Series) {
viewModelScope.launch {
_uiState.update { it.copy(isLoadingExternalRatings = true) }
diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt
index 0e14fe7e..052057db 100644
--- a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt
@@ -409,58 +409,73 @@ class XtreamProvider(
categoryName = info?.categoryName,
adultCategoryIds = adultCategoryIds
)
- val seasons = response.episodes.map { (seasonNum, episodes) ->
- val resolvedSeasonNumber = seasonNum.toIntOrNull() ?: episodes.firstNotNullOfOrNull { episode ->
- episode.season.takeIf { it > 0 }
- } ?: 0
- val mappedEpisodes = episodes.mapIndexedNotNull { index, ep ->
- val episodeId = ep.id.toLongOrNull()?.takeIf { it > 0 }
- ?: ep.episodeNum.takeIf { it > 0 }?.let { resolvedSeasonNumber * 10000L + it }
- ?: ((index + 1).let { resolvedSeasonNumber * 10000L + it })
- val normalizedEpisodeNum = if (ep.episodeNum > 0) ep.episodeNum else index + 1
- val normalizedExtension = normalizeContainerExtension(ep.containerExtension)
- Episode(
- id = episodeId,
- title = decodeXtreamText(
- ep.title.ifBlank { decodeXtreamNullableText(ep.info?.name, XtreamTextDecodeMode.RAW) ?: "Episode $normalizedEpisodeNum" },
- XtreamTextDecodeMode.RAW
- ),
- episodeNumber = normalizedEpisodeNum,
- seasonNumber = ep.season.takeIf { it > 0 } ?: resolvedSeasonNumber,
- containerExtension = normalizedExtension,
- coverUrl = sanitizeAssetValue(ep.info?.movieImage),
- plot = decodeXtreamNullableText(ep.info?.plot, XtreamTextDecodeMode.METADATA),
- duration = ep.info?.duration,
- durationSeconds = ep.info?.durationSecs ?: 0,
- rating = ep.info?.rating?.toFloatOrNull() ?: 0f,
- releaseDate = ep.info?.releaseDate,
- seriesId = seriesId,
- providerId = providerId,
- streamUrl = XtreamUrlFactory.buildInternalStreamUrl(
- providerId = providerId,
- kind = XtreamStreamKind.SERIES,
- streamId = episodeId,
+ val seasonMetadataByNumber = response.seasons.associateBy { it.seasonNumber }
+ val seasons = when {
+ response.episodes.isNotEmpty() -> response.episodes.map { (seasonNum, episodes) ->
+ val resolvedSeasonNumber = seasonNum.toIntOrNull() ?: episodes.firstNotNullOfOrNull { episode ->
+ episode.season.takeIf { it > 0 }
+ } ?: 0
+ val mappedEpisodes = episodes.mapIndexedNotNull { index, ep ->
+ val episodeId = ep.id.toLongOrNull()?.takeIf { it > 0 }
+ ?: ep.episodeNum.takeIf { it > 0 }?.let { resolvedSeasonNumber * 10000L + it }
+ ?: ((index + 1).let { resolvedSeasonNumber * 10000L + it })
+ val normalizedEpisodeNum = if (ep.episodeNum > 0) ep.episodeNum else index + 1
+ val normalizedExtension = normalizeContainerExtension(ep.containerExtension)
+ Episode(
+ id = episodeId,
+ title = decodeXtreamText(
+ ep.title.ifBlank { decodeXtreamNullableText(ep.info?.name, XtreamTextDecodeMode.RAW) ?: "Episode $normalizedEpisodeNum" },
+ XtreamTextDecodeMode.RAW
+ ),
+ episodeNumber = normalizedEpisodeNum,
+ seasonNumber = ep.season.takeIf { it > 0 } ?: resolvedSeasonNumber,
containerExtension = normalizedExtension,
- directSource = sanitizeAssetValue(ep.directSource)
- ),
- isAdult = isAdult,
- isUserProtected = false,
- episodeId = episodeId
+ coverUrl = sanitizeAssetValue(ep.info?.movieImage),
+ plot = decodeXtreamNullableText(ep.info?.plot, XtreamTextDecodeMode.METADATA),
+ duration = ep.info?.duration,
+ durationSeconds = ep.info?.durationSecs ?: 0,
+ rating = ep.info?.rating?.toFloatOrNull() ?: 0f,
+ releaseDate = ep.info?.releaseDate,
+ seriesId = seriesId,
+ providerId = providerId,
+ streamUrl = XtreamUrlFactory.buildInternalStreamUrl(
+ providerId = providerId,
+ kind = XtreamStreamKind.SERIES,
+ streamId = episodeId,
+ containerExtension = normalizedExtension,
+ directSource = sanitizeAssetValue(ep.directSource)
+ ),
+ isAdult = isAdult,
+ isUserProtected = false,
+ episodeId = episodeId
+ )
+ }
+ val seasonMetadata = seasonMetadataByNumber[resolvedSeasonNumber]
+ Season(
+ seasonNumber = resolvedSeasonNumber,
+ name = seasonMetadata?.name?.takeIf { it.isNotBlank() } ?: "Season $resolvedSeasonNumber",
+ coverUrl = seasonMetadata?.cover,
+ airDate = seasonMetadata?.airDate,
+ episodes = mappedEpisodes,
+ episodeCount = seasonMetadata?.episodeCount?.takeIf { it > 0 } ?: mappedEpisodes.size
)
- }
- Season(
- seasonNumber = resolvedSeasonNumber,
- name = response.seasons.find { it.seasonNumber == resolvedSeasonNumber }?.name
- ?.takeIf { it.isNotBlank() }
- ?: "Season $resolvedSeasonNumber",
- coverUrl = response.seasons.find { it.seasonNumber == resolvedSeasonNumber }?.cover,
- airDate = response.seasons.find { it.seasonNumber == resolvedSeasonNumber }?.airDate,
- episodes = mappedEpisodes,
- episodeCount = response.seasons.find { it.seasonNumber == resolvedSeasonNumber }?.episodeCount
- ?.takeIf { it > 0 }
- ?: mappedEpisodes.size
- )
- }.sortedBy { it.seasonNumber }
+ }.sortedBy { it.seasonNumber }
+
+ response.seasons.isNotEmpty() -> response.seasons
+ .sortedBy { it.seasonNumber }
+ .map { season ->
+ Season(
+ seasonNumber = season.seasonNumber,
+ name = season.name.takeIf { it.isNotBlank() } ?: "Season ${season.seasonNumber}",
+ coverUrl = season.cover,
+ airDate = season.airDate,
+ episodes = emptyList(),
+ episodeCount = season.episodeCount
+ )
+ }
+
+ else -> emptyList()
+ }
Result.success(
baseSeries.copy(
diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
index 44ad3e0d..d27dabf6 100644
--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
@@ -424,7 +424,8 @@ class SeriesRepositoryImpl @Inject constructor(
it.episodeId.takeIf { remoteId -> remoteId > 0 } ?: it.id
}
- val mergedSeasons = if (remoteSeries.seasons.isNotEmpty()) {
+ val remoteSeasonMetadataByNumber = remoteSeries.seasons.associateBy { it.seasonNumber }
+ val mergedSeasons = if (remoteSeries.seasons.any { it.episodes.isNotEmpty() }) {
remoteSeries.seasons
.sortedBy { it.seasonNumber }
.map { remoteSeason ->
@@ -450,6 +451,23 @@ class SeriesRepositoryImpl @Inject constructor(
episodeCount = mergedEpisodes.size
)
}
+ } else if (persistedEpisodes.isNotEmpty()) {
+ persistedEpisodes.groupBy { it.seasonNumber }
+ .entries
+ .sortedBy { it.key }
+ .map { (seasonNumber, episodes) ->
+ val seasonMetadata = remoteSeasonMetadataByNumber[seasonNumber]
+ Season(
+ seasonNumber = seasonNumber,
+ name = seasonMetadata?.name?.takeIf { it.isNotBlank() } ?: "Season $seasonNumber",
+ coverUrl = seasonMetadata?.coverUrl,
+ airDate = seasonMetadata?.airDate,
+ episodes = episodes,
+ episodeCount = seasonMetadata?.episodeCount?.takeIf { it > 0 } ?: episodes.size
+ )
+ }
+ } else if (remoteSeries.seasons.isNotEmpty()) {
+ remoteSeries.seasons.sortedBy { it.seasonNumber }
} else {
persistedEpisodes.groupBy { it.seasonNumber }
.entries
diff --git a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt
index ced78efb..97a66291 100644
--- a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt
@@ -9,6 +9,7 @@ import com.streamvault.data.remote.dto.XtreamEpgResponse
import com.streamvault.data.remote.dto.XtreamEpisode
import com.streamvault.data.remote.dto.XtreamEpisodeInfo
import com.streamvault.data.remote.dto.XtreamLiveStreamRow
+import com.streamvault.data.remote.dto.XtreamSeason
import com.streamvault.data.remote.dto.XtreamSeriesInfoResponse
import com.streamvault.data.remote.dto.XtreamSeriesItem
import com.streamvault.data.remote.dto.XtreamServerInfo
@@ -683,6 +684,36 @@ class XtreamProviderTest {
assertThat(series?.seasons?.first()?.episodes).hasSize(1)
}
+ @Test
+ fun `getSeriesInfo preserves season metadata when provider omits episode rows`() = runBlocking {
+ val provider = XtreamProvider(
+ providerId = 42,
+ api = FakeXtreamApiService(
+ seriesInfo = XtreamSeriesInfoResponse(
+ info = XtreamSeriesItem(name = "Season Only Series"),
+ seasons = listOf(
+ XtreamSeason(
+ seasonNumber = 1,
+ name = "Season 1",
+ episodeCount = 10
+ )
+ )
+ )
+ ),
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass"
+ )
+
+ val series = provider.getSeriesInfo(91).getOrNull()
+
+ assertThat(series).isNotNull()
+ assertThat(series?.seasons).hasSize(1)
+ assertThat(series?.seasons?.first()?.name).isEqualTo("Season 1")
+ assertThat(series?.seasons?.first()?.episodeCount).isEqualTo(10)
+ assertThat(series?.seasons?.first()?.episodes).isEmpty()
+ }
+
private class FakeXtreamApiService(
private val authResponse: XtreamAuthResponse = XtreamAuthResponse(XtreamUserInfo(auth = 1), XtreamServerInfo()),
private val liveCategories: List<XtreamCategory> = emptyList(),
diff --git a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
index ae24f721..fbd5ca24 100644
--- a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
@@ -10,11 +10,14 @@ import com.streamvault.data.local.dao.ProviderDao
import com.streamvault.data.local.dao.SeriesDao
import com.streamvault.data.local.dao.SeriesCategoryHydrationDao
import com.streamvault.data.local.dao.XtreamContentIndexDao
+import com.streamvault.data.local.entity.EpisodeBrowseEntity
import com.streamvault.data.local.entity.EpisodeEntity
import com.streamvault.data.local.entity.SeriesEntity
import com.streamvault.data.local.entity.SeriesBrowseEntity
import com.streamvault.data.local.entity.ProviderEntity
import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.remote.dto.XtreamSeason
+import com.streamvault.data.remote.dto.XtreamSeriesInfoResponse
import com.streamvault.data.remote.stalker.StalkerCategoryRecord
import com.streamvault.data.remote.stalker.StalkerEpisodeRecord
import com.streamvault.data.remote.stalker.StalkerItemRecord
@@ -381,6 +384,64 @@ class SeriesRepositoryImplTest {
assertThat(series.posterUrl).isEqualTo("https://img.example.test/poster.jpg")
}
+ @Test
+ fun `getSeriesDetails keeps persisted episodes when remote payload only has season metadata`() = runTest {
+ whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
+ val seriesEntity = SeriesEntity(
+ id = 15L,
+ seriesId = 301L,
+ name = "Stored Series",
+ providerId = 7L
+ )
+ whenever(seriesDao.getById(15L)).thenReturn(seriesEntity)
+ whenever(seriesDao.getById(15L)).thenReturn(seriesEntity)
+ whenever(providerDao.getById(7L)).thenReturn(
+ ProviderEntity(
+ id = 7L,
+ name = "Xtream",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://example.com",
+ username = "user",
+ password = "pass",
+ status = ProviderStatus.ACTIVE
+ )
+ )
+ whenever(xtreamApiService.getSeriesInfo(any(), any())).thenReturn(
+ XtreamSeriesInfoResponse(
+ info = XtreamSeriesItem(name = "Stored Series"),
+ seasons = listOf(
+ XtreamSeason(
+ seasonNumber = 1,
+ name = "Season 1",
+ episodeCount = 12
+ )
+ )
+ )
+ )
+ whenever(episodeDao.getBySeriesSync(15L)).thenReturn(
+ listOf(
+ EpisodeBrowseEntity(
+ id = 1L,
+ episodeId = 7001L,
+ title = "Pilot",
+ episodeNumber = 1,
+ seasonNumber = 1,
+ streamUrl = "internal://episode/7001",
+ seriesId = 15L,
+ providerId = 7L
+ )
+ )
+ )
+
+ val result = createRepository().getSeriesDetails(7L, 15L)
+
+ assertThat(result).isInstanceOf(com.streamvault.domain.model.Result.Success::class.java)
+ val series = (result as com.streamvault.domain.model.Result.Success).data
+ assertThat(series.seasons).hasSize(1)
+ assertThat(series.seasons.first().name).isEqualTo("Season 1")
+ assertThat(series.seasons.first().episodes.map { it.title }).containsExactly("Pilot")
+ }
+
@Test
fun `getSeriesDetails uses provider series id for stalker details`() = runTest {
val seriesEntity = SeriesEntity(