StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktindex 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.LazyColumnimport androidx.compose.foundation.lazy.LazyRowimport androidx.compose.foundation.lazy.itemsimport androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.material.icons.Icons+import androidx.compose.material.icons.filled.Favorite+import androidx.compose.material.icons.outlined.FavoriteBorderimport androidx.lifecycle.compose.collectAsStateWithLifecycleimport androidx.compose.runtime.Composableimport androidx.compose.runtime.getValue@@ -40,6 +43,7 @@ import androidx.tv.material3.Borderimport androidx.tv.material3.Buttonimport androidx.tv.material3.ButtonDefaultsimport androidx.tv.material3.ClickableSurfaceDefaults+import androidx.tv.material3.Iconimport androidx.tv.material3.MaterialThemeimport androidx.tv.material3.Surfaceimport 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+ )+ )+ }+}+@Composablefun 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.ktindex 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.Resultimport com.streamvault.domain.model.Seasonimport com.streamvault.domain.model.Seriesimport com.streamvault.domain.repository.ExternalRatingsRepository+import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepository-import com.streamvault.domain.repository.SeriesRepositoryimport com.streamvault.domain.repository.ProviderRepository+import com.streamvault.domain.repository.SeriesRepositoryimport com.streamvault.domain.util.isPlaybackCompleteimport dagger.hilt.android.lifecycle.HiltViewModelimport kotlinx.coroutines.Job+import kotlinx.coroutines.asyncimport kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.flow.StateFlowimport kotlinx.coroutines.flow.asStateFlow-import kotlinx.coroutines.flow.updateimport kotlinx.coroutines.flow.first+import kotlinx.coroutines.flow.updateimport kotlinx.coroutines.launchimport 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.ktindex 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.ktindex 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 }.entriesdiff --git a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.ktindex 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.XtreamEpgResponseimport com.streamvault.data.remote.dto.XtreamEpisodeimport com.streamvault.data.remote.dto.XtreamEpisodeInfoimport com.streamvault.data.remote.dto.XtreamLiveStreamRow+import com.streamvault.data.remote.dto.XtreamSeasonimport com.streamvault.data.remote.dto.XtreamSeriesInfoResponseimport com.streamvault.data.remote.dto.XtreamSeriesItemimport 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.ktindex 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.ProviderDaoimport com.streamvault.data.local.dao.SeriesDaoimport com.streamvault.data.local.dao.SeriesCategoryHydrationDaoimport com.streamvault.data.local.dao.XtreamContentIndexDao+import com.streamvault.data.local.entity.EpisodeBrowseEntityimport com.streamvault.data.local.entity.EpisodeEntityimport com.streamvault.data.local.entity.SeriesEntityimport com.streamvault.data.local.entity.SeriesBrowseEntityimport com.streamvault.data.local.entity.ProviderEntityimport com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.remote.dto.XtreamSeason+import com.streamvault.data.remote.dto.XtreamSeriesInfoResponseimport com.streamvault.data.remote.stalker.StalkerCategoryRecordimport com.streamvault.data.remote.stalker.StalkerEpisodeRecordimport 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")+ }+@Testfun `getSeriesDetails uses provider series id for stalker details`() = runTest {val seriesEntity = SeriesEntity(