Files
AudioManager/src/test/kotlin/win/taptap/musicmanager/api/ApiRoutesTest.kt
T
TapTap 0caeecb325
CI / chart (push) Successful in 4s
CI / test (push) Successful in 2m19s
CI / chart-push (push) Successful in 5s
CI / image (push) Failing after 6m4s
feat: mark search results that are already in the target mood
2026-11-15 21:46:57 +00:00

652 lines
27 KiB
Kotlin

package win.taptap.musicmanager.api
import io.ktor.client.HttpClient
import io.ktor.client.request.delete
import io.ktor.client.request.get
import io.ktor.client.request.header
import io.ktor.client.request.patch
import io.ktor.client.request.post
import io.ktor.client.request.setBody
import io.ktor.client.statement.bodyAsBytes
import io.ktor.client.statement.bodyAsText
import io.ktor.http.ContentType
import io.ktor.http.HttpHeaders
import io.ktor.http.HttpStatusCode
import io.ktor.http.contentType
import io.ktor.serialization.kotlinx.json.json
import io.ktor.server.application.install
import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
import io.ktor.server.plugins.partialcontent.PartialContent
import io.ktor.server.plugins.statuspages.StatusPages
import io.ktor.server.response.respond
import io.ktor.server.routing.routing
import io.ktor.server.testing.ApplicationTestBuilder
import io.ktor.server.testing.testApplication
import java.nio.file.Files
import java.nio.file.Path
import java.time.Instant
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.int
import kotlinx.serialization.json.jsonArray
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertNotNull
import kotlin.test.assertTrue
import org.junit.jupiter.api.io.TempDir
import win.taptap.musicmanager.TestAudio
import win.taptap.musicmanager.config.AppConfig
import win.taptap.musicmanager.config.UserAccount
import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.db.ConfigRepository
import win.taptap.musicmanager.db.DatabaseFactory
import win.taptap.musicmanager.db.DatabaseHandle
import win.taptap.musicmanager.db.DownloadRepository
import win.taptap.musicmanager.db.MoodRepository
import win.taptap.musicmanager.db.RecommendationUpsert
import win.taptap.musicmanager.db.SongRecord
import win.taptap.musicmanager.db.SongRepository
import win.taptap.musicmanager.db.SongUpsert
import win.taptap.musicmanager.discovery.DiscoveryService
import win.taptap.musicmanager.discovery.TopUpService
import win.taptap.musicmanager.discovery.YtCandidate
import win.taptap.musicmanager.discovery.YtResolver
import win.taptap.musicmanager.discovery.YtSearch
import win.taptap.musicmanager.media.MediaGcService
import win.taptap.musicmanager.media.MediaStore
import win.taptap.musicmanager.radio.RadioService
import win.taptap.musicmanager.scanner.CoverArtService
import win.taptap.musicmanager.scanner.ScanStatus
import win.taptap.musicmanager.transcoding.FfmpegTranscoder
import win.taptap.musicmanager.util.IdGenerator
class ApiRoutesTest {
@TempDir
lateinit var tempDir: Path
@Test
fun `login issues a bearer token and rejects bad credentials`() {
seededContext().use { seed ->
testApplication {
setupApp(seed)
val ok = parse(client.login("alice", "alice-pw").bodyAsText())
assertTrue(ok.string("token").isNotBlank())
assertEquals("alice", ok["user"]!!.jsonObject.string("name"))
assertTrue(ok["user"]!!.jsonObject["admin"]!!.jsonPrimitive.content.toBoolean())
val bad = client.login("alice", "wrong")
assertEquals(HttpStatusCode.Unauthorized, bad.status)
assertEquals(
"invalid_credentials",
parse(bad.bodyAsText())["error"]!!.jsonObject.string("code"),
)
assertEquals(HttpStatusCode.Unauthorized, client.get("/api/v1/moods").status)
val token = client.token("alice", "alice-pw")
val me = parse(client.get("/api/v1/me") { bearer(token) }.bodyAsText())
assertEquals("alice", me.string("name"))
val malformed = client.post("/api/v1/moods") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("not-json")
}
assertEquals(HttpStatusCode.BadRequest, malformed.status)
}
}
}
@Test
fun `moods own their songs and are private`() {
seededContext().use { seed ->
testApplication {
setupApp(seed)
val token = client.token("alice", "alice-pw")
val created = client.post("/api/v1/moods") {
bearer(token)
contentType(ContentType.Application.Json)
setBody(
"""{"name":"Focus","genres":["Ambient"],"collectionPercent":70,"recommendationCount":0}""",
)
}
assertEquals(HttpStatusCode.Created, created.status)
val body = parse(created.bodyAsText())
val moodId = body["mood"]!!.jsonObject.string("id")
assertEquals(0, body["mood"]!!.jsonObject.int("songCount"))
assertEquals(70, body["mood"]!!.jsonObject.int("collectionPercent"))
assertEquals(30, body["mood"]!!.jsonObject.int("recommendationPercent"))
val added = client.post("/api/v1/moods/$moodId/songs") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"songId":"${seed.ambient1}"}""")
}
assertEquals(HttpStatusCode.OK, added.status)
val addedBody = parse(added.bodyAsText())
assertTrue(addedBody["added"]!!.jsonPrimitive.content.toBoolean())
assertEquals(1, addedBody["detail"]!!.jsonObject["mood"]!!.jsonObject.int("songCount"))
assertEquals(
seed.ambient1,
addedBody["detail"]!!.jsonObject["songs"]!!.jsonArray.single()
.jsonObject["song"]!!.jsonObject.string("id"),
)
val again = client.post("/api/v1/moods/$moodId/songs") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"songId":"${seed.ambient1}"}""")
}
assertFalse(
parse(again.bodyAsText())["added"]!!.jsonPrimitive.content.toBoolean(),
)
val patched = client.patch("/api/v1/moods/$moodId") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"name":"Deep Focus","collectionPercent":40}""")
}
val patchedMood = parse(patched.bodyAsText())["mood"]!!.jsonObject
assertEquals("Deep Focus", patchedMood.string("name"))
assertEquals(40, patchedMood.int("collectionPercent"))
val list = parse(client.get("/api/v1/moods") { bearer(token) }.bodyAsText())
assertEquals(1, list["moods"]!!.jsonArray.size)
val bob = client.token("bob", "bob-pw")
assertEquals(
HttpStatusCode.NotFound,
client.get("/api/v1/moods/$moodId") { bearer(bob) }.status,
)
val removed = client.delete("/api/v1/moods/$moodId/songs/${seed.ambient1}") {
bearer(token)
}
assertEquals(HttpStatusCode.NoContent, removed.status)
val detail = parse(client.get("/api/v1/moods/$moodId") { bearer(token) }.bodyAsText())
assertTrue(detail["songs"]!!.jsonArray.isEmpty())
assertEquals(
HttpStatusCode.NoContent,
client.delete("/api/v1/moods/$moodId") { bearer(token) }.status,
)
}
}
}
@Test
fun `a mood needs a song before a session can start`() {
seededContext().use { seed ->
testApplication {
setupApp(seed)
val token = client.token("alice", "alice-pw")
val moodId = client.createMood(token, """{"name":"Empty","recommendationCount":0}""")
val rejected = client.post("/api/v1/moods/$moodId/sessions") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"limit":5}""")
}
assertEquals(HttpStatusCode.BadRequest, rejected.status)
assertEquals(
"empty_mood",
parse(rejected.bodyAsText())["error"]!!.jsonObject.string("code"),
)
client.addSong(token, moodId, seed.ambient1)
val started = client.post("/api/v1/moods/$moodId/sessions") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"limit":8}""")
}
assertEquals(HttpStatusCode.Created, started.status)
val session = parse(started.bodyAsText())
val sessionId = session.string("id")
assertEquals(moodId, session.string("moodId"))
assertTrue(
session["queue"]!!.jsonArray.map { it.jsonObject.string("id") }
.contains(seed.ambient1),
)
val next = client.post("/api/v1/sessions/$sessionId/next") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"limit":5}""")
}
assertEquals(HttpStatusCode.OK, next.status)
val nextIds = parse(next.bodyAsText())["songs"]!!.jsonArray
.map { it.jsonObject.string("id") }
assertEquals(nextIds.size, nextIds.distinct().size)
val event = client.post("/api/v1/sessions/$sessionId/events") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"events":[{"songId":"${seed.ambient1}","type":"completed"}]}""")
}
assertEquals(1, parse(event.bodyAsText()).int("accepted"))
val unknown = client.post("/api/v1/sessions/$sessionId/events") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"events":[{"songId":"sg-missing","type":"completed"}]}""")
}
assertEquals(0, parse(unknown.bodyAsText()).int("accepted"))
val added = client.post("/api/v1/sessions/$sessionId/add-to-mood") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"songId":"${seed.ambient2}"}""")
}
assertEquals(
2,
parse(added.bodyAsText())["mood"]!!.jsonObject.int("songCount"),
)
assertEquals(
HttpStatusCode.NoContent,
client.delete("/api/v1/sessions/$sessionId") { bearer(token) }.status,
)
}
}
}
@Test
fun `a session is scoped to its owner`() {
seededContext().use { seed ->
testApplication {
setupApp(seed)
val alice = client.token("alice", "alice-pw")
val bob = client.token("bob", "bob-pw")
val moodId = client.createMood(alice, """{"name":"Private","recommendationCount":0}""")
client.addSong(alice, moodId, seed.ambient1)
val started = client.post("/api/v1/moods/$moodId/sessions") {
bearer(alice)
contentType(ContentType.Application.Json)
setBody("""{"limit":5}""")
}
val sessionId = parse(started.bodyAsText()).string("id")
assertEquals(
HttpStatusCode.NotFound,
client.get("/api/v1/sessions/$sessionId") { bearer(bob) }.status,
)
}
}
}
@Test
fun `search hides long tracks and marks downloaded songs`() {
seededContext().use { seed ->
val results = listOf(
YtCandidate("vid-ambient-1", "Already Here", "Artist", duration = 180),
YtCandidate("vid-new", "Fresh Track", "New Artist", duration = 200),
YtCandidate("vid-long", "Late Night Set", "Some DJ", duration = 3_600),
YtCandidate("vid-short", "Interlude", "Some DJ", duration = 20),
)
testApplication {
setupApp(seed, search = FakeYt(results))
val token = client.token("alice", "alice-pw")
val moodId = client.createMood(token, """{"name":"Search Mood","recommendationCount":0}""")
client.addSong(token, moodId, seed.ambient1)
val body = parse(
client.get("/api/v1/search?q=ambient&moodId=$moodId") { bearer(token) }.bodyAsText(),
)
val found = body["results"]!!.jsonArray.map { it.jsonObject }
assertEquals(2, found.size)
assertFalse(found.any { it.string("videoId") == "vid-long" })
assertFalse(found.any { it.string("videoId") == "vid-short" })
val downloaded = found.first { it.string("videoId") == "vid-ambient-1" }
assertTrue(downloaded["downloaded"]!!.jsonPrimitive.content.toBoolean())
assertTrue(downloaded["inMood"]!!.jsonPrimitive.content.toBoolean())
assertEquals(seed.ambient1, downloaded.string("songId"))
assertFalse(
found.first { it.string("videoId") == "vid-new" }["downloaded"]!!
.jsonPrimitive.content.toBoolean(),
)
}
}
}
@Test
fun `adding a search result downloads it and a URL is resolved`() {
seededContext().use { seed ->
val resolved = YtCandidate("vid-url", "From URL", "Artist", duration = 180)
val search = FakeYt(
results = emptyList(),
resolved = mapOf(
"https://youtu.be/vid-url" to resolved,
"https://youtu.be/vid-long" to
YtCandidate("vid-long", "Long", "Artist", duration = 3_600),
),
)
testApplication {
setupApp(seed, search = search)
val token = client.token("alice", "alice-pw")
val moodId = client.createMood(token, """{"name":"Adds","recommendationCount":0}""")
val queued = client.post("/api/v1/moods/$moodId/songs") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"videoId":"vid-new"}""")
}
assertEquals(HttpStatusCode.Accepted, queued.status)
assertTrue(
parse(queued.bodyAsText())["downloading"]!!.jsonPrimitive.content.toBoolean(),
)
assertEquals(
"queued",
DownloadRepository.find(moodId, "vid-new", DownloadRepository.KIND_SONG)?.state,
)
val byUrl = client.post("/api/v1/moods/$moodId/songs") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"url":"https://youtu.be/vid-url"}""")
}
assertEquals(HttpStatusCode.Accepted, byUrl.status)
assertEquals(
"queued",
DownloadRepository.find(moodId, "vid-url", DownloadRepository.KIND_SONG)?.state,
)
val long = client.post("/api/v1/moods/$moodId/songs") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"url":"https://youtu.be/vid-long"}""")
}
assertEquals(HttpStatusCode.BadRequest, long.status)
}
}
}
@Test
fun `recommendations can be added rejected and retried`() {
seededContext().use { seed ->
val results = listOf(
YtCandidate("vid-ready", "Ready Track", "Artist", duration = 180),
YtCandidate("vid-reject", "Rejected Track", "Artist", duration = 180),
YtCandidate("vid-failed", "Failed Track", "Artist", duration = 180),
)
testApplication {
setupApp(seed, search = FakeYt(results))
val token = client.token("alice", "alice-pw")
val moodId = client.createMood(token, """{"name":"Radio","recommendationCount":3}""")
client.addSong(token, moodId, seed.ambient1)
val refreshed = client.post("/api/v1/moods/$moodId/recommendations/refresh") {
bearer(token)
}
assertEquals(HttpStatusCode.OK, refreshed.status)
val recommendations = parse(refreshed.bodyAsText())["recommendations"]!!.jsonArray
.map { it.jsonObject }
assertEquals(3, recommendations.size)
assertTrue(recommendations.all { it.string("state") == "downloading" })
// Simulate a finished download for the first slot.
val readySong = insertSong(seed, "vid-ready", "Ready Track")
MoodRepository.completeDownload(moodId, "vid-ready", readySong)
val detail = parse(client.get("/api/v1/moods/$moodId") { bearer(token) }.bodyAsText())
val ready = detail["recommendations"]!!.jsonArray.map { it.jsonObject }
.first { it.string("videoId") == "vid-ready" }
assertEquals("ready", ready.string("state"))
assertEquals(readySong, ready["song"]!!.jsonObject.string("id"))
val added = client.post("/api/v1/moods/$moodId/recommendations/vid-ready/add") {
bearer(token)
}
assertEquals(HttpStatusCode.OK, added.status)
val addedBody = parse(added.bodyAsText())
assertEquals(
"added",
addedBody["recommendation"]!!.jsonObject.string("state"),
)
assertEquals(
2,
addedBody["detail"]!!.jsonObject["mood"]!!.jsonObject.int("songCount"),
)
assertFalse(
addedBody["detail"]!!.jsonObject["recommendations"]!!.jsonArray
.map { it.jsonObject.string("videoId") }
.contains("vid-ready"),
)
val rejected = client.post("/api/v1/moods/$moodId/recommendations/vid-reject/reject") {
bearer(token)
}
assertEquals(
"rejected",
parse(rejected.bodyAsText())["recommendation"]!!.jsonObject.string("state"),
)
// The third slot is visible but failed; it must be retried first.
val remaining = MoodRepository.recommendations(moodId)
assertEquals(1, remaining.size)
assertEquals("vid-failed", remaining.single().videoId)
MoodRepository.failRecommendation(moodId, "vid-failed", "boom", 3)
val cannotAdd = client.post("/api/v1/moods/$moodId/recommendations/vid-failed/add") {
bearer(token)
}
assertEquals(HttpStatusCode.Conflict, cannotAdd.status)
val retried = client.post("/api/v1/moods/$moodId/recommendations/vid-failed/retry") {
bearer(token)
}
assertEquals(HttpStatusCode.OK, retried.status)
val retryBody = parse(retried.bodyAsText())
assertEquals(
"downloading",
retryBody["recommendations"]!!.jsonArray.map { it.jsonObject }
.first { it.string("videoId") == "vid-failed" }
.string("state"),
)
assertEquals(
"queued",
DownloadRepository.find(
moodId,
"vid-failed",
DownloadRepository.KIND_RECOMMENDATION,
)?.state,
)
}
}
}
@Test
fun `streaming and covers work with a query token`() {
seededContext().use { seed ->
testApplication {
setupApp(seed)
val token = client.token("alice", "alice-pw")
val stream = client.get("/api/v1/songs/${seed.ambient1}/stream?token=$token")
assertEquals(HttpStatusCode.OK, stream.status)
assertTrue(stream.bodyAsBytes().isNotEmpty())
val ranged = client.get("/api/v1/songs/${seed.ambient1}/stream?token=$token") {
header(HttpHeaders.Range, "bytes=0-3")
}
assertEquals(HttpStatusCode.PartialContent, ranged.status)
assertEquals(4, ranged.bodyAsBytes().size)
assertEquals(
HttpStatusCode.NotFound,
client.get("/api/v1/songs/sg-missing/stream?token=$token").status,
)
val cover = client.get("/api/v1/songs/${seed.ambient1}/cover?size=16&token=$token")
assertEquals(HttpStatusCode.OK, cover.status)
assertTrue(cover.bodyAsBytes().isNotEmpty())
}
}
}
private fun ApplicationTestBuilder.setupApp(
seed: Seed,
search: FakeYt = FakeYt(emptyList()),
) {
val discovery = DiscoveryService(search)
application {
install(ContentNegotiation) {
json(Json { ignoreUnknownKeys = true; encodeDefaults = true })
}
install(PartialContent)
install(StatusPages) {
exception<ApiException> { call, cause ->
call.respond(
cause.status,
apiErrorBody(cause.code, cause.message),
)
}
}
routing {
apiRoutes(
users = seed.users,
coverArtService = seed.coverArt,
transcoder = FfmpegTranscoder("ffmpeg"),
radioService = RadioService(),
discoveryService = discovery,
topUpService = TopUpService(discovery),
ytSearch = search,
ytResolver = search,
mediaStore = seed.media,
gc = seed.gc,
startScan = { false },
scanStatus = { ScanStatus(false, 0) },
)
}
}
}
private suspend fun HttpClient.token(user: String, password: String): String =
parse(login(user, password).bodyAsText()).string("token")
private suspend fun HttpClient.login(user: String, password: String) =
post("/api/v1/auth/login") {
contentType(ContentType.Application.Json)
setBody("""{"username":"$user","password":"$password","deviceName":"test","platform":"test"}""")
}
private fun io.ktor.client.request.HttpRequestBuilder.bearer(token: String) {
header(HttpHeaders.Authorization, "Bearer $token")
}
private suspend fun HttpClient.createMood(token: String, body: String): String {
val created = post("/api/v1/moods") {
bearer(token)
contentType(ContentType.Application.Json)
setBody(body)
}
assertEquals(HttpStatusCode.Created, created.status)
return parse(created.bodyAsText())["mood"]!!.jsonObject.string("id")
}
private suspend fun HttpClient.addSong(token: String, moodId: String, songId: String) {
val response = post("/api/v1/moods/$moodId/songs") {
bearer(token)
contentType(ContentType.Application.Json)
setBody("""{"songId":"$songId"}""")
}
assertEquals(HttpStatusCode.OK, response.status)
}
private fun seededContext(): Seed {
val users = UsersConfig(
listOf(
UserAccount("alice", "alice-pw", admin = true),
UserAccount("bob", "bob-pw", admin = false),
),
)
val db = DatabaseFactory.connect(
AppConfig(
port = 8080,
dataDir = tempDir.resolve("data"),
usersFile = tempDir.resolve("users.yaml"),
ffmpegPath = "ffmpeg",
),
)
ConfigRepository.sync(users)
val media = MediaStore(Files.createDirectories(tempDir.resolve("media")))
val coverArt = CoverArtService(tempDir.resolve("data"))
val seed = Seed(
db = db,
users = users,
media = media,
coverArt = coverArt,
gc = MediaGcService(media, coverArt),
)
seed.ambient1 = insertSong(seed, "vid-ambient-1", "Focus One", artist = "Alpha")
seed.ambient2 = insertSong(seed, "vid-ambient-2", "Focus Two", artist = "Beta")
seed.rock = insertSong(seed, "vid-rock", "Loud", artist = "Gamma")
seed.bobSong = insertSong(seed, "vid-bob", "Bob Song", artist = "Bob")
seed.coverArt.saveCover(seed.ambient1, pngBytes())
return seed
}
/** Seeds a shared song directly (normally the downloader does this). */
private fun insertSong(seed: Seed, videoId: String, title: String, artist: String = "Artist"): String {
val file = seed.media.target(videoId, title)
Files.createDirectories(file.parent)
Files.write(file, "ID3-fake-audio".toByteArray())
return SongRepository.upsert(
SongUpsert(
videoId = videoId,
title = title,
artist = artist,
album = "Album",
duration = 180,
bitRate = 128,
size = Files.size(file),
relativePath = seed.media.root.relativize(file).joinToString("/") { it.toString() },
fileMtime = Files.getLastModifiedTime(file).toMillis(),
thumbnail = null,
),
).id
}
private fun pngBytes(): ByteArray {
val cover = tempDir.resolve("cover.png")
TestAudio.writePng(cover, 32, 32)
return Files.readAllBytes(cover)
}
private fun parse(body: String): JsonObject = Json.parseToJsonElement(body).jsonObject
private fun JsonObject.string(name: String): String = this[name]!!.jsonPrimitive.content
private fun JsonObject.int(name: String): Int = this[name]!!.jsonPrimitive.int
private class FakeYt(
private val results: List<YtCandidate>,
private val resolved: Map<String, YtCandidate> = emptyMap(),
) : YtSearch, YtResolver {
override fun search(query: String, limit: Int): List<YtCandidate> = results
override fun resolve(url: String): YtCandidate? = resolved[url]
}
private data class Seed(
val db: DatabaseHandle,
val users: UsersConfig,
val media: MediaStore,
val coverArt: CoverArtService,
val gc: MediaGcService,
) : AutoCloseable {
lateinit var ambient1: String
lateinit var ambient2: String
lateinit var rock: String
lateinit var bobSong: String
override fun close() = db.close()
}
}