diff --git a/docs/agents/pre-pr-checklist.md b/docs/agents/pre-pr-checklist.md index c62b1f82..3779b452 100644 --- a/docs/agents/pre-pr-checklist.md +++ b/docs/agents/pre-pr-checklist.md @@ -267,3 +267,24 @@ New findings (section 1 candidates / product constraints): - **WebView 不走应用代理,只认系统全局代理**:墙内网络下没有系统代理的盒子连授权页都打不开(ERR_CONNECTION_TIMED_OUT),OAuth 登录页加载完全不受 App 代理配置保护;只有 token 交换(OkHttp)走应用代理。面向墙内用户的登录方案必须把系统代理写进前置条件,或做二维码等不依赖 TV 出站的替代路径 - **bgm 验证码是自动化天敌**:可疑 IP(代理出口)下几乎必弹验证码,自动化连错 4 次后停手(锁号风险);TV 端遥控器输验证码同样痛苦。验证码环节建议只做人走查,不进自动化 - **Composed-path divergence(沿用 v2.16 条目)**:本次同样先 unit-test 后真机,设备行为与单测一致,未复现发散 + +### RSS 扫描卡死修复:离线 archive 按查询全量解析 + URL 噪音系列名(patch) + +Own checks(HK1 真机证据 + 单测): + +- [真机] ANi RSS 全量扫描冻在 55 文件/黑色五葉草约 15 分钟,取消近 10 分钟才生效;线程 CPU 时间静止(IO 阻塞非死循环);结束后 anime/episode/index_entry 全 0 行 +- [真机] 设备 `MiruLog` 埋点钉死:`bangumi.archive.search` 单次耗时 **704993ms**(11.7 分钟),query 仅 6 字符(`A1%80%`);986MB `subject.jsonlines` 存在(当日 13:47 下载),前一日无 archive 时同款扫描 105 秒跑完 +- 根因一定位就改小:自动扫描 enrichment 传 `includeArchive = false`(扫描恒有网,archive 只留给手动搜索);archive 本体改为流式单遍 + 有界 top-k + 每 4096 行 `ensureActive`(取消立刻生效);分类器对 URL 路径只用文件名做 PATH 证据、跳过 host/date/百分号段 +- 单测:`searchAnime skips archive when includeArchive is false`(archive 有完美命中也被跳过,只走在线);`search honours coroutine cancellation`(100 万行文件 200ms 取消必抛);分类器 `remote URL path does not outvote filename title` + `encoded path segment is not treated as show context`;扫描单测断言 enrichment 全传 `false` +- 现有 archive 排序/匹配单测全过(流式 top-k 与全排序语义一致;季节降权只降不升,top-k 内重排等价) + +Cross-checks: + +- 手动搜索(`searchManualAnime`/`searchPreferredWith` 聚合)仍走 archive + 在线双路,行为不变;手动搜索 ViewModel 自带 35s/90s `withTimeout`,现在因 archive 循环可协作取消而真正有效 +- `AniListScraper` 等其他 `MetadataScraper` 实现同步加参(忽略该标志,无行为变化);单测 fake 全量更新 +- WebDAV/SMB 本地语义路径不受分类器改动影响(machinery 过滤只认 scheme/host/日期/百分号段;`Season N`/第 x 季等季节模式原样保留) +- full `./gradlew assembleDebug test lint` green + +New failure class (section 1 candidate): + +- **Offline-index-at-query-time** —— 离线 archive/索引文件在每次查询时全量解析 + 全排序,单测里几行 fixture 毫秒级全过,真机上 1GB 文件把 50MB 堆的 TV 盒子拖进 10 分钟 GC 泥潭。检查:任何“加载本地大文件再查询”的路径,必须验证真实量级文件在目标设备上的单次耗时;查询必须是流式 + 有界内存 + 可取消;耗时型预处理只做一次(构建期/下载期),绝不在查询热路径上 diff --git a/scanner/src/main/kotlin/com/miruplay/tv/scanner/ScanCoordinator.kt b/scanner/src/main/kotlin/com/miruplay/tv/scanner/ScanCoordinator.kt index efb6b95e..71ced98e 100644 --- a/scanner/src/main/kotlin/com/miruplay/tv/scanner/ScanCoordinator.kt +++ b/scanner/src/main/kotlin/com/miruplay/tv/scanner/ScanCoordinator.kt @@ -657,7 +657,11 @@ class ScanCoordinator @Inject constructor( "confidence_threshold" to RECOGNITION_CONFIDENCE_THRESHOLD.toString(), ) ) - var match = bangumi.searchByAlias(animeName, candidates).getOrNull() + // Auto-scan always has network (it just fetched the feed) and must stay + // responsive over dozens of series: the 1GB offline archive costs minutes + // per query on TV hardware (full parse + match + sort, no index yet), + // so scans use online-only search. Manual search keeps the archive path. + var match = bangumi.searchByAlias(animeName, candidates, includeArchive = false).getOrNull() var matchedBy = "alias" if (match != null) { MiruLog.i( @@ -681,7 +685,7 @@ class ScanCoordinator @Inject constructor( if (fallbackAttemptSample.size < MAX_RECOGNITION_ATTEMPT_SAMPLE_IN_LOG) { fallbackAttemptSample += candidate } - match = bangumi.searchAnime(candidate).getOrNull() + match = bangumi.searchAnime(candidate, includeArchive = false).getOrNull() ?.firstOrNull { it.confidence >= RECOGNITION_CONFIDENCE_THRESHOLD } if (match != null) { matchedBy = "fallback_search" diff --git a/scanner/src/main/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifier.kt b/scanner/src/main/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifier.kt index f1ffe353..c8c1c15b 100644 --- a/scanner/src/main/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifier.kt +++ b/scanner/src/main/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifier.kt @@ -294,6 +294,11 @@ class VideoDirectoryClassifier( private fun modelPathText(path: String, fileName: String): String { val normalized = path.replace('\\', '/').trim() if (normalized.isBlank()) return fileName + // Remote URLs carry no title signal in their machinery (scheme/host/date/hash + // segments); parsing the whole URL fabricates %-fragment titles (e.g. "A1%80%") + // that outscore the clean filename evidence. Use the filename only; real folder + // names still vote through FOLDER_BERT / show-context evidence. + if (normalized.contains("://")) return fileName if (normalized.length <= maxParsedTextLength) return normalized val segments = pathSegments(normalized) @@ -458,7 +463,8 @@ class VideoDirectoryClassifier( this?.takeIf { it > 0 } private fun String.shouldParseContextSegment(): Boolean = - usableName() != null || numericContextPatterns.any { it.matches(normalizedContextName()) } + !isUrlMachinerySegment() && + (usableName() != null || numericContextPatterns.any { it.matches(normalizedContextName()) }) private fun findShowContext( segments: List, @@ -471,6 +477,9 @@ class VideoDirectoryClassifier( } for (index in candidateSegments.indices.reversed()) { val rawName = candidateSegments[index] + // Skip URL machinery (host/date/encoded segments): they are not show names + // and otherwise win show-context over the real filename evidence. + if (rawName.isUrlMachinerySegment()) continue val release = ReleaseFilenameParser.parse(rawName) if (release != null) { val seriesName = release.seriesName.usableName() @@ -485,6 +494,19 @@ class VideoDirectoryClassifier( return null } + private fun String.isUrlMachinerySegment(): Boolean { + val raw = trim().trimEnd('/') + if (raw.isEmpty()) return true + if (raw.contains("://")) return true + if (raw.equals("https:", ignoreCase = true) || raw.equals("http:", ignoreCase = true)) return true + // Percent-encoded blob (series/file link segment): title signal lives in the + // decoded filename, not in the raw triplet soup. + if (PERCENT_TRIPLET_REGEX.containsMatchIn(raw)) return true + if (URL_HOST_SEGMENT_REGEX.matches(raw)) return true + if (URL_DATE_SEGMENT_REGEX.matches(raw)) return true + return false + } + private fun String.isGenericContextName(): Boolean { val normalized = normalizedContextName() if (normalized in genericContextNames) return true @@ -581,6 +603,10 @@ class VideoDirectoryClassifier( Regex("""(?i)^(?:season|series|s)\s*\d{1,2}$"""), Regex("""(?i)^(?:ep|episode|part)\s*[\d一二三四五六七八九十]+(?:[a-z])?$""") ) + private val PERCENT_TRIPLET_REGEX = Regex("%[0-9A-Fa-f]{2}") + private val URL_HOST_SEGMENT_REGEX = + Regex("""^[A-Za-z0-9]([A-Za-z0-9.\-]*[A-Za-z0-9])?\.[A-Za-z]{2,}(:\d+)?$""") + private val URL_DATE_SEGMENT_REGEX = Regex("""^\d{4}-\d{1,2}(-\d{1,2})?$""") } } diff --git a/scanner/src/test/kotlin/com/miruplay/tv/scanner/ScanCoordinatorTest.kt b/scanner/src/test/kotlin/com/miruplay/tv/scanner/ScanCoordinatorTest.kt index 3e1f95db..1e257e93 100644 --- a/scanner/src/test/kotlin/com/miruplay/tv/scanner/ScanCoordinatorTest.kt +++ b/scanner/src/test/kotlin/com/miruplay/tv/scanner/ScanCoordinatorTest.kt @@ -177,6 +177,10 @@ class ScanCoordinatorTest { assertEquals(25, indexRepository.entries.single().episodeNumber) assertEquals("Dr STONE 新石紀", scraper.normalizedName) assertTrue(scraper.aliasCandidates.contains("Dr STONE 新石紀 第四季")) + assertTrue( + "Auto-scan must skip the offline archive (full 1GB parse per query hangs TV scans)", + scraper.includeArchiveFlags.isNotEmpty() && scraper.includeArchiveFlags.all { !it }, + ) } @Test @@ -1093,9 +1097,13 @@ class ScanCoordinatorTest { override val sourceName: String = "Bangumi" var normalizedName: String? = null var aliasCandidates: List = emptyList() + val includeArchiveFlags = mutableListOf() - override suspend fun searchAnime(query: String): Result> = - Result.success(emptyList()) + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> = + Result.success>(emptyList()).also { includeArchiveFlags += includeArchive } override suspend fun getAnimeDetails(animeId: String): Result = Result.failure(AppError.ScrapingError.NoMatchFound(animeId)) @@ -1105,10 +1113,12 @@ class ScanCoordinatorTest { override suspend fun searchByAlias( normalizedName: String, - candidates: List + candidates: List, + includeArchive: Boolean, ): Result { this.normalizedName = normalizedName this.aliasCandidates = candidates + includeArchiveFlags += includeArchive return Result.success(null) } } @@ -1118,7 +1128,10 @@ class ScanCoordinatorTest { ) : MetadataScraper { override val sourceName: String = "Bangumi" - override suspend fun searchAnime(query: String): Result> = + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> = Result.success(listOf(match())) override suspend fun getAnimeDetails(animeId: String): Result = @@ -1136,7 +1149,8 @@ class ScanCoordinatorTest { override suspend fun searchByAlias( normalizedName: String, - candidates: List + candidates: List, + includeArchive: Boolean, ): Result = Result.success(match()) private fun match(): ScraperResult = diff --git a/scanner/src/test/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifierTest.kt b/scanner/src/test/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifierTest.kt index 862863ab..3b77fb30 100644 --- a/scanner/src/test/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifierTest.kt +++ b/scanner/src/test/kotlin/com/miruplay/tv/scanner/VideoDirectoryClassifierTest.kt @@ -3,6 +3,7 @@ package com.miruplay.tv.scanner import com.miruplay.tv.model.FilenameMetadataParser import com.miruplay.tv.model.FilenameParseResult import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -358,6 +359,32 @@ class VideoDirectoryClassifierTest { assertTrue(result.titleCandidates.none { it.contains("电视剧/逐玉") }) } + @Test + fun `remote URL path does not outvote filename title`() { + val fileName = "[ANi] BLEACH 死神 千年血戰篇-禍進譚- - 49 [1080P][Baha][WEB-DL][AAC AVC][CHT].mp4" + val result = classifier.classifyVideo( + path = "https://resources.ani.rip/2026-10/%5BANi%5D%20BLEACH%20%E6%AD%BB%E7%A5%9E%20%E5%8D%83%E5%B9%B4%E8%A1%80%E6%88%B0%E7%AF%87-%E7%A6%8D%E9%80%B2%E8%AD%9A-%20-%2049%20%5B1080P%5D%5BBaha%5D%5BWEB-DL%5D%5BAAC%20AVC%5D%5BCHT%5D.mp4?d=mp4", + fileName = fileName, + ) + + // Host/date/percent-triplet URL machinery must never become the show name. + assertFalse(result.animeName.contains("%")) + assertFalse(result.animeName.contains("resources", ignoreCase = true)) + assertFalse(result.animeName.contains("2026")) + assertTrue(result.animeName.contains("BLEACH")) + } + + @Test + fun `encoded path segment is not treated as show context`() { + val result = classifier.classifyVideo( + path = "https://resources.ani.rip/2026-10/%E9%BB%91%20test.mp4", + fileName = "黑 test.mp4", + ) + + assertFalse(result.animeName.contains("%")) + assertFalse(result.animeName.contains("2026")) + } + private class StaticFilenameParser( private val result: FilenameParseResult ) : FilenameMetadataParser { diff --git a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/MetadataScraper.kt b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/MetadataScraper.kt index 33ec06ae..5a37db27 100644 --- a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/MetadataScraper.kt +++ b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/MetadataScraper.kt @@ -17,7 +17,10 @@ interface MetadataScraper { /** * Search for anime by query. */ - suspend fun searchAnime(query: String): Result> + suspend fun searchAnime( + query: String, + includeArchive: Boolean = true, + ): Result> /** * Get full anime details by ID. @@ -35,6 +38,7 @@ interface MetadataScraper { suspend fun searchByAlias( normalizedName: String, candidates: List, + includeArchive: Boolean = true, ): Result } diff --git a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiAliasSearch.kt b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiAliasSearch.kt index 794b9c7e..4f526e5e 100644 --- a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiAliasSearch.kt +++ b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiAliasSearch.kt @@ -11,6 +11,7 @@ suspend fun BangumiApiClient.searchByAlias( normalizedName: String, candidates: List, confidenceThreshold: Float = BANGUMI_ALIAS_CONFIDENCE_THRESHOLD, + includeArchive: Boolean = true, ): Result = PerformanceLog.measureSuspendResult( tag = "BangumiPerformance", operation = "bangumi.alias_search", @@ -34,7 +35,14 @@ suspend fun BangumiApiClient.searchByAlias( val matches = linkedMapOf() for (candidate in uniqueCandidates) { - val result = searchAnime(candidate).getOrNull().orEmpty() + val result = searchAnime( + candidate, + archiveMinimumConfidence = confidenceThreshold, + includeOnlineWhenArchiveMatches = false, + includeDirectIdResult = false, + onlineLimit = 10, + includeArchive = includeArchive, + ).getOrNull().orEmpty() .firstOrNull { it.confidence >= confidenceThreshold } if (result != null) { val existing = matches[result.animeId] diff --git a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiApiClient.kt b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiApiClient.kt index f9c0b0e2..3dc73069 100644 --- a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiApiClient.kt +++ b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiApiClient.kt @@ -57,13 +57,17 @@ class BangumiApiClient( client.configureProxy(proxyConfig) } - suspend fun searchAnime(query: String): Result> = + suspend fun searchAnime( + query: String, + includeArchive: Boolean = true, + ): Result> = searchAnime( query = query, archiveMinimumConfidence = ARCHIVE_AUTO_MINIMUM_CONFIDENCE, includeOnlineWhenArchiveMatches = false, includeDirectIdResult = false, onlineLimit = 10, + includeArchive = includeArchive, ) suspend fun searchAnimeForManualMatch(query: String): Result> = @@ -75,12 +79,13 @@ class BangumiApiClient( onlineLimit = 20, ) - private suspend fun searchAnime( + internal suspend fun searchAnime( query: String, archiveMinimumConfidence: Float, includeOnlineWhenArchiveMatches: Boolean, includeDirectIdResult: Boolean, onlineLimit: Int, + includeArchive: Boolean = true, ): Result> = PerformanceLog.measureSuspendResult( tag = PERFORMANCE_TAG, operation = "bangumi.search", @@ -89,6 +94,7 @@ class BangumiApiClient( "online_limit" to onlineLimit.toString(), "include_direct_id_result" to includeDirectIdResult.toString(), "archive_minimum_confidence" to archiveMinimumConfidence.toString(), + "include_archive" to includeArchive.toString(), ), ) { withContext(Dispatchers.IO) { @@ -98,11 +104,15 @@ class BangumiApiClient( directIdSearchResult(query)?.let { merged.addBest(it) } } - val localResults = archiveSearch?.search( - query = query, - limit = onlineLimit, - minimumConfidence = archiveMinimumConfidence, - ).orEmpty() + val localResults = if (includeArchive) { + archiveSearch?.search( + query = query, + limit = onlineLimit, + minimumConfidence = archiveMinimumConfidence, + ).orEmpty() + } else { + emptyList() + } localResults.forEach { merged.addBest(it) } if (localResults.isNotEmpty() && !includeOnlineWhenArchiveMatches) { return@withContext Result.success(localResults) diff --git a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiArchive.kt b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiArchive.kt index 840ea95e..5b9737bc 100644 --- a/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiArchive.kt +++ b/scraper-core/src/main/kotlin/com/miruplay/tv/scraper/core/BangumiArchive.kt @@ -6,6 +6,8 @@ import com.miruplay.tv.core.common.logging.PerformanceLog import com.miruplay.tv.model.Anime import com.miruplay.tv.model.ScraperResult import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.currentCoroutineContext +import kotlinx.coroutines.ensureActive import kotlinx.coroutines.withContext import kotlinx.serialization.SerialName import kotlinx.serialization.Serializable @@ -423,11 +425,11 @@ class BangumiArchiveSubjectSearch( private val mapper = BangumiArchiveDocumentMapper(normalizeQuery) - fun search( + suspend fun search( query: String, limit: Int = 10, minimumConfidence: Float = this.minimumConfidence, - ): List = PerformanceLog.measure( + ): List = PerformanceLog.measureSuspend( tag = ARCHIVE_PERFORMANCE_TAG, operation = "bangumi.archive.search", attributes = archiveQueryAttributes(query) + mapOf( @@ -436,54 +438,80 @@ class BangumiArchiveSubjectSearch( ), ) { val trimmedQuery = query.trim() - if (trimmedQuery.isBlank()) return@measure emptyList() + if (trimmedQuery.isBlank()) return@measureSuspend emptyList() val subjectId = trimmedQuery.takeIf { it.all(Char::isDigit) }?.toIntOrNull() if (subjectId != null) { - return@measure findById(trimmedQuery)?.let { subject -> + return@measureSuspend findById(trimmedQuery)?.let { subject -> listOf(subject.toArchiveHit(trimmedQuery, confidence = 1.0f).toScraperResult()) }.orEmpty() } val requestedSeason = extractArchiveSeasonNumber(trimmedQuery) ?: extractArchiveSeasonNumber(normalizeArchiveIndexedText(trimmedQuery, normalizeQuery)) - readSubjects() - .asSequence() - .map { subject -> - val match = mapper.matchSubject(subject, trimmedQuery) - ArchiveHit( - subject = subject, - matchedTitle = match.title, - confidence = match.confidence, - ) + val take = limit.coerceAtLeast(1) + // Single streaming pass over the ~1GB subject file: score each line, keep only + // a bounded top-k heap, discard the subject. Never materializes the full list + // (a 400k-subject object graph thrashes a 50MB TV heap for 10+ minutes) and + // never fully sorts. Seasonal demotion applies to the top-k after the pass: + // it only demotes, so nothing outside the raw top-k could displace into it. + val heap = java.util.PriorityQueue(take, ARCHIVE_HIT_ORDER.reversed()) + val subjectFile = subjectFileProvider() + if (subjectFile.isFile) { + var linesSinceYield = 0 + subjectFile.useLines { lines -> + for (line in lines) { + val subject = mapper.parseSubject(line) ?: continue + val match = mapper.matchSubject(subject, trimmedQuery) + if (match.confidence >= minimumConfidence) { + val hit = ArchiveHit( + subject = subject, + matchedTitle = match.title, + confidence = match.confidence, + ) + if (heap.size < take) { + heap.add(hit) + } else if (ARCHIVE_HIT_ORDER.compare(hit, heap.peek()) < 0) { + heap.poll() + heap.add(hit) + } + } + if (++linesSinceYield >= 4096) { + linesSinceYield = 0 + currentCoroutineContext().ensureActive() + } + } } + } + heap.toList() + .asSequence() .adjustSeasonalConfidence(requestedSeason) .filter { it.confidence >= minimumConfidence } - .sortedWith( - compareByDescending { it.confidence } - .thenBy { it.subject.rank ?: Int.MAX_VALUE } - .thenByDescending { it.subject.score ?: 0f } - .thenByDescending { it.subject.date.orEmpty() } - ) - .take(limit.coerceAtLeast(1)) + .sortedWith(ARCHIVE_HIT_ORDER) + .take(take) .map(ArchiveHit::toScraperResult) .toList() } - fun findById(animeId: String): BangumiArchiveSubject? = PerformanceLog.measure( + suspend fun findById(animeId: String): BangumiArchiveSubject? = PerformanceLog.measureSuspend( tag = ARCHIVE_PERFORMANCE_TAG, operation = "bangumi.archive.find_by_id", attributes = mapOf("anime_id" to animeId), ) { - val subjectId = animeId.toIntOrNull() ?: return@measure null - readSubjects().firstOrNull { it.id == subjectId } - } - - private fun readSubjects(): List { + val subjectId = animeId.toIntOrNull() ?: return@measureSuspend null val subjectFile = subjectFileProvider() - if (!subjectFile.isFile) return emptyList() - return subjectFile.useLines { lines -> - lines.mapNotNull(mapper::parseSubject).toList() + if (!subjectFile.isFile) return@measureSuspend null + var linesSinceYield = 0 + subjectFile.useLines { lines -> + for (line in lines) { + val subject = mapper.parseSubject(line) ?: continue + if (subject.id == subjectId) return@measureSuspend subject + if (++linesSinceYield >= 4096) { + linesSinceYield = 0 + currentCoroutineContext().ensureActive() + } + } } + null } private fun BangumiArchiveSubject.toArchiveHit( @@ -497,6 +525,12 @@ class BangumiArchiveSubjectSearch( ) } +private val ARCHIVE_HIT_ORDER: Comparator = + compareByDescending { it.confidence } + .thenBy { it.subject.rank ?: Int.MAX_VALUE } + .thenByDescending { it.subject.score ?: 0f } + .thenByDescending { it.subject.date.orEmpty() } + private data class ArchiveHit( val subject: BangumiArchiveSubject, val matchedTitle: String, diff --git a/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/MetadataScraperSearchTest.kt b/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/MetadataScraperSearchTest.kt index 46d441cf..ccac8ea8 100644 --- a/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/MetadataScraperSearchTest.kt +++ b/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/MetadataScraperSearchTest.kt @@ -65,7 +65,10 @@ class MetadataScraperSearchTest { override val sourceName: String = "Fake" - override suspend fun searchAnime(query: String): Result> { + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> { searchQueries += query return Result.success(searchResults[query].orEmpty()) } @@ -79,6 +82,7 @@ class MetadataScraperSearchTest { override suspend fun searchByAlias( normalizedName: String, candidates: List, + includeArchive: Boolean, ): Result { aliasCandidates += candidates return Result.success(aliasMatch) diff --git a/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiApiClientTest.kt b/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiApiClientTest.kt index fd551249..abd84529 100644 --- a/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiApiClientTest.kt +++ b/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiApiClientTest.kt @@ -147,6 +147,49 @@ class BangumiApiClientTest { } } + @Test + fun `searchAnime skips archive when includeArchive is false`() = runBlocking { + MockWebServer().use { server -> + server.enqueue( + MockResponse().setBody( + """ + { + "data": [ + { + "id": 500000, + "name": "Online Only Special", + "name_cn": "在线特别篇", + "rating": { "score": 8.0 } + } + ] + } + """.trimIndent() + ) + ) + val tempDir = createTempDirectory(prefix = "bangumi-api-noarchive-test-").toFile() + val subjectFile = File(tempDir, BangumiArchiveStore.SUBJECT_FILE_NAME) + subjectFile.writeText( + """{"id":431767,"type":2,"name":"葬送のフリーレン","name_cn":"葬送的芙莉莲","score":8.8}""" + ) + val client = BangumiApiClient( + baseUrl = server.url("/").toString(), + archiveSearch = BangumiArchiveSubjectSearch(subjectFile), + ) + + val result = client.searchAnime("葬送的芙莉莲", includeArchive = false) + + assertTrue(result is Result.Success) + val onlineOnly = (result as Result.Success).data.single() + // Archive holds the perfect local hit (431767); skipping it must surface + // the online hit instead and actually hit the network. + assertEquals("500000", onlineOnly.animeId) + assertFalse(onlineOnly.fromLocalArchive) + assertEquals(1, server.requestCount) + tempDir.deleteRecursively() + Unit + } + } + @Test fun `manual search merges archive and online candidates`() = runBlocking { MockWebServer().use { server -> diff --git a/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiArchiveTest.kt b/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiArchiveTest.kt index d0fd5ae0..1084108f 100644 --- a/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiArchiveTest.kt +++ b/scraper-core/src/test/kotlin/com/miruplay/tv/scraper/core/BangumiArchiveTest.kt @@ -1,6 +1,9 @@ package com.miruplay.tv.scraper.core import com.miruplay.tv.core.common.Result +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.async +import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking import okhttp3.mockwebserver.MockResponse import okhttp3.mockwebserver.MockWebServer @@ -20,6 +23,37 @@ import java.util.zip.ZipOutputStream import kotlin.io.path.createTempDirectory class BangumiArchiveTest { + @Test + fun `search honours coroutine cancellation instead of hanging the caller`() = runBlocking { + val tempDir = createTempDirectory(prefix = "bangumi-archive-cancel-test-").toFile() + val subjectFile = File(tempDir, BangumiArchiveStore.SUBJECT_FILE_NAME) + // Enough lines to outlast the cancel delay: without cooperative cancellation + // the search would run to completion and return normally. + subjectFile.bufferedWriter().use { out -> + repeat(1_000_000) { index -> + out.write("""{"id":${1_000_000 + index},"type":2,"name":"Filler Anime Number $index","score":5.0}""") + out.newLine() + } + } + val search = BangumiArchiveSubjectSearch(subjectFile) + + // Run off the test thread: the search is blocking IO, the cancel signal + // must be delivered from another thread (same as Dispatchers.IO in prod). + val job = async(Dispatchers.Default) { search.search("zzz-no-such-anime-zzz") } + delay(200) + job.cancel() + var cancelled = false + try { + job.await() + } catch (error: kotlinx.coroutines.CancellationException) { + cancelled = true + } + + assertTrue("Archive search must abort promptly when cancelled", cancelled) + assertTrue(job.isCancelled) + tempDir.deleteRecursively() + Unit + } @Test fun `downloadLatest uses configured HTTP proxy for latest and zip requests`() = runBlocking { val archiveZip = zipOf( @@ -314,7 +348,7 @@ class BangumiArchiveTest { val search = BangumiArchiveSubjectSearch(subjectFile) - val result = search.search("Frieren") + val result = runBlocking { search.search("Frieren") } assertEquals("431767", result.single().animeId) assertEquals("Frieren", result.single().matchedTitle) @@ -335,7 +369,7 @@ class BangumiArchiveTest { val search = BangumiArchiveSubjectSearch(subjectFile) - val result = search.search("Sousou no Frieren") + val result = runBlocking { search.search("Sousou no Frieren") } assertEquals("431767", result.single().animeId) assertEquals("Sousou no Frieren", result.single().matchedTitle) @@ -355,7 +389,7 @@ class BangumiArchiveTest { val search = BangumiArchiveSubjectSearch(subjectFile) - val result = search.search("Dr STONE 新石纪 第四季") + val result = runBlocking { search.search("Dr STONE 新石纪 第四季") } assertEquals("471578", result.single().animeId) assertTrue(result.single().confidence >= 0.62f) @@ -376,7 +410,7 @@ class BangumiArchiveTest { normalizeQuery = { value -> if (value == "繁體標題") "简体标题" else value }, ) - val result = search.search("繁體標題") + val result = runBlocking { search.search("繁體標題") } assertEquals("10", result.single().animeId) assertEquals(1.0f, result.single().confidence) @@ -396,7 +430,7 @@ class BangumiArchiveTest { val search = BangumiArchiveSubjectSearch(subjectFile) - val result = search.search("431767") + val result = runBlocking { search.search("431767") } assertEquals(1, result.size) assertEquals("431767", result.single().animeId) @@ -415,7 +449,7 @@ class BangumiArchiveTest { val search = BangumiArchiveSubjectSearch(subjectFile) - val result = search.search("葬送的芙莉莲") + val result = runBlocking { search.search("葬送的芙莉莲") } assertEquals("431767", result.single().animeId) assertFalse("Android-compatible archive search should not create Lucene sidecar files", luceneDirectory.exists()) @@ -434,7 +468,7 @@ class BangumiArchiveTest { val search = BangumiArchiveSubjectSearch(subjectFile) - val result = search.search("葬送的芙莉莲") + val result = runBlocking { search.search("葬送的芙莉莲") } assertEquals("431767", result.single().animeId) assertTrue("Legacy Lucene sidecar file should not be touched by Android-compatible search", luceneDirectory.isFile) @@ -455,9 +489,9 @@ class BangumiArchiveTest { val search = BangumiArchiveSubjectSearch(subjectFile) - assertEquals("1", search.search("Re ZERO").single().animeId) - assertEquals("2", search.search("Fate stay night").single().animeId) - assertEquals("3", search.search("Dr STONE 新石纪 第四季").single().animeId) + assertEquals("1", runBlocking { search.search("Re ZERO") }.single().animeId) + assertEquals("2", runBlocking { search.search("Fate stay night") }.single().animeId) + assertEquals("3", runBlocking { search.search("Dr STONE 新石纪 第四季") }.single().animeId) tempDir.deleteRecursively() } } diff --git a/scraper/src/main/kotlin/com/miruplay/tv/scraper/AniListScraper.kt b/scraper/src/main/kotlin/com/miruplay/tv/scraper/AniListScraper.kt index 33cebe7f..e373cdcb 100644 --- a/scraper/src/main/kotlin/com/miruplay/tv/scraper/AniListScraper.kt +++ b/scraper/src/main/kotlin/com/miruplay/tv/scraper/AniListScraper.kt @@ -75,7 +75,10 @@ class AniListScraper @Inject constructor() : MetadataScraper { }""" } - override suspend fun searchAnime(query: String): Result> = withContext(Dispatchers.IO) { + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> = withContext(Dispatchers.IO) { try { val variables = buildJsonObject { put("search", query) @@ -162,7 +165,7 @@ class AniListScraper @Inject constructor() : MetadataScraper { Result.success(emptyList()) } - override suspend fun searchByAlias(normalizedName: String, candidates: List): Result = withContext(Dispatchers.IO) { + override suspend fun searchByAlias(normalizedName: String, candidates: List, includeArchive: Boolean): Result = withContext(Dispatchers.IO) { try { for (candidate in candidates) { val results = searchAnime(candidate) diff --git a/scraper/src/main/kotlin/com/miruplay/tv/scraper/BangumiScraper.kt b/scraper/src/main/kotlin/com/miruplay/tv/scraper/BangumiScraper.kt index dc20b37a..d2c825ba 100644 --- a/scraper/src/main/kotlin/com/miruplay/tv/scraper/BangumiScraper.kt +++ b/scraper/src/main/kotlin/com/miruplay/tv/scraper/BangumiScraper.kt @@ -48,8 +48,13 @@ class BangumiScraper @Inject constructor( override val hasToken: Boolean get() = api.hasToken - override suspend fun searchAnime(query: String): Result> = - withConfiguredProxy("bangumi.scraper.search", query.performanceQueryAttributes()) { api.searchAnime(query) } + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> = + withConfiguredProxy("bangumi.scraper.search", query.performanceQueryAttributes()) { + api.searchAnime(query, includeArchive = includeArchive) + } override suspend fun searchManualAnime(query: String): Result> = withConfiguredProxy("bangumi.scraper.manual_search", query.performanceQueryAttributes()) { @@ -69,14 +74,18 @@ class BangumiScraper @Inject constructor( api.getEpisodes(animeId).map { episodes -> episodes.map { it.toEpisodeMetadata() } } } - override suspend fun searchByAlias(normalizedName: String, candidates: List): Result = + override suspend fun searchByAlias( + normalizedName: String, + candidates: List, + includeArchive: Boolean, + ): Result = withConfiguredProxy( operation = "bangumi.scraper.alias_search", attributes = mapOf( "normalized_query_length" to normalizedName.length.toString(), "candidate_count" to candidates.size.toString(), ), - ) { api.searchByAlias(normalizedName, candidates) } + ) { api.searchByAlias(normalizedName, candidates, includeArchive = includeArchive) } override suspend fun getEpisodeComments(episodeId: Int): Result> = withConfiguredProxy( diff --git a/scraper/src/test/kotlin/com/miruplay/tv/scraper/MetadataSearchAggregatorsTest.kt b/scraper/src/test/kotlin/com/miruplay/tv/scraper/MetadataSearchAggregatorsTest.kt index 96cf30f5..b572d0df 100644 --- a/scraper/src/test/kotlin/com/miruplay/tv/scraper/MetadataSearchAggregatorsTest.kt +++ b/scraper/src/test/kotlin/com/miruplay/tv/scraper/MetadataSearchAggregatorsTest.kt @@ -42,7 +42,10 @@ private class RecordingManualScraper : MetadataScraper, ManualMetadataSearchScra return Result.success(listOf(result(query))) } - override suspend fun searchAnime(query: String): Result> = + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> = Result.success(listOf(result(query))) override suspend fun getAnimeDetails(animeId: String): Result = @@ -54,6 +57,7 @@ private class RecordingManualScraper : MetadataScraper, ManualMetadataSearchScra override suspend fun searchByAlias( normalizedName: String, candidates: List, + includeArchive: Boolean, ): Result { aliasSearches += candidates return Result.success(null) diff --git a/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiIndexMetadataCoordinatorTest.kt b/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiIndexMetadataCoordinatorTest.kt index 1aa95531..549c3ec0 100644 --- a/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiIndexMetadataCoordinatorTest.kt +++ b/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiIndexMetadataCoordinatorTest.kt @@ -355,7 +355,10 @@ class BangumiIndexMetadataCoordinatorTest { override val sourceName: String = "Bangumi" - override suspend fun searchAnime(query: String): Result> { + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> { searchQueries += query return Result.success(searchResults[query].orEmpty()) } @@ -369,6 +372,7 @@ class BangumiIndexMetadataCoordinatorTest { override suspend fun searchByAlias( normalizedName: String, candidates: List, + includeArchive: Boolean, ): Result { aliasCandidates += candidates return Result.success(null) diff --git a/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiMetadataRefreshCoreTest.kt b/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiMetadataRefreshCoreTest.kt index fed965b7..28de9ec4 100644 --- a/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiMetadataRefreshCoreTest.kt +++ b/sync-engine-shared/src/test/kotlin/com/miruplay/tv/sync/BangumiMetadataRefreshCoreTest.kt @@ -254,7 +254,10 @@ class BangumiMetadataRefreshCoreTest { override val sourceName: String = "Bangumi" - override suspend fun searchAnime(query: String): Result> { + override suspend fun searchAnime( + query: String, + includeArchive: Boolean, + ): Result> { searchQueries += query return Result.success(directResults) } @@ -270,6 +273,7 @@ class BangumiMetadataRefreshCoreTest { override suspend fun searchByAlias( normalizedName: String, candidates: List, + includeArchive: Boolean, ): Result { aliasCandidates += candidates return Result.success(aliasResult) diff --git a/ui-tv/src/test/kotlin/com/miruplay/tv/ui/detail/AnimeDetailViewModelTest.kt b/ui-tv/src/test/kotlin/com/miruplay/tv/ui/detail/AnimeDetailViewModelTest.kt index 15348bd8..16da1aed 100644 --- a/ui-tv/src/test/kotlin/com/miruplay/tv/ui/detail/AnimeDetailViewModelTest.kt +++ b/ui-tv/src/test/kotlin/com/miruplay/tv/ui/detail/AnimeDetailViewModelTest.kt @@ -353,9 +353,9 @@ private class AnimeDetailFakeBangumiCollectionService : BangumiCollectionService private class NoOpBangumiScraper : MetadataScraper { override val sourceName: String = "Bangumi" - override suspend fun searchAnime(query: String) = Result.success(emptyList()) + override suspend fun searchAnime(query: String, includeArchive: Boolean) = Result.success(emptyList()) override suspend fun getAnimeDetails(animeId: String) = Result.success(Anime(id = animeId, title = animeId)) override suspend fun getEpisodes(animeId: String) = Result.success(emptyList()) - override suspend fun searchByAlias(normalizedName: String, candidates: List) = + override suspend fun searchByAlias(normalizedName: String, candidates: List, includeArchive: Boolean) = Result.success(null) }