Skip to content

Native Android client for Spotify, built with Jetpack Compose

6.9 KB
Raw Blame
package com.music.spotui.cli

import app.myspoti.extensions.Hook
import app.myspoti.extensions.Setting
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test

class CliTest {
    private fun fails(cmd: String, vararg args: String): String =
        runCatching { CliParser.parse(cmd, args.toList()) }.exceptionOrNull().let { (it as? CliError)?.message ?: error("$cmd did not fail: $it") }

    @Test fun argsComeAsJsonOrBase64() {
        assertEquals(listOf("a", "b c"), CliParser.args("""["a","b c"]""", null))
        val b64 = java.util.Base64.getEncoder().encodeToString("""["x","{\"q\":1}"]""".toByteArray())
        assertEquals(listOf("x", """{"q":1}"""), CliParser.args("ignored", b64))
        assertEquals(emptyList<String>(), CliParser.args(null, null))
        assertTrue(runCatching { CliParser.args("""[1]""", null) }.exceptionOrNull() is CliError)
        assertTrue(runCatching { CliParser.args(null, "%%%") }.exceptionOrNull() is CliError)
    }

    @Test fun parsesEachCommand() {
        assertEquals(CliCommand.Status, CliParser.parse("status", emptyList()))
        assertEquals(CliCommand.ExtInstall("/sdcard/Android/data/app.myspoti.dev/files/cli/in/x.zip"),
            CliParser.parse("ext.install", listOf("/sdcard/Android/data/app.myspoti.dev/files/cli/in/x.zip")))
        assertEquals(CliCommand.ExtEnable("my.ext", false), CliParser.parse("ext.disable", listOf("my.ext")))
        assertEquals(CliCommand.ExtSetting("my.ext", "quality", "\"high\""), CliParser.parse("ext.setting", listOf("my.ext", "quality", "high")))
        assertEquals(CliCommand.ExtSetting("my.ext", "on", "true"), CliParser.parse("ext.setting", listOf("my.ext", "on", "true")))
        assertEquals(CliCommand.ExtSetting("my.ext", "on", null), CliParser.parse("ext.setting", listOf("my.ext", "on", "null")))
        assertEquals(CliCommand.ExtPress("my.ext", "pair"), CliParser.parse("ext.press", listOf("my.ext", "pair")))
        assertEquals(CliCommand.ExtCall("my.ext", Hook.AUDIO_SOURCE, """{"id":"1"}"""), CliParser.parse("ext.call", listOf("my.ext", "audio-source", """{"id":"1"}""")))
        assertEquals(CliCommand.ExtCall("my.ext", Hook.LYRICS, "{}"), CliParser.parse("ext.call", listOf("my.ext", "lyrics")))
        assertEquals(CliCommand.ExtLog("my.ext", 50), CliParser.parse("ext.log", listOf("my.ext")))
        assertEquals(CliCommand.ExtLog("my.ext", 1000), CliParser.parse("ext.log", listOf("my.ext", "99999")))
        assertEquals(CliCommand.Play("spotify:track:4uLU6hMCjMI75M1A2tKUQC", null), CliParser.parse("play", listOf("spotify:track:4uLU6hMCjMI75M1A2tKUQC")))
        assertEquals(CliCommand.Nav("extension/my.ext"), CliParser.parse("nav", listOf("extension/my.ext")))
    }

    @Test fun refusesBadInput() {
        assertTrue(fails("nope").startsWith("unknown command"))
        assertTrue(fails("ext.enable").contains("missing <id>"))
        assertTrue(fails("ext.enable", "../x").contains("bad extension id"))
        assertTrue(fails("ext.install", "relative.zip").contains("absolute"))
        assertTrue(fails("ext.install", "/sdcard/../data/x.zip").contains("absolute"))
        assertTrue(fails("ext.call", "my.ext", "nohook").contains("unknown hook"))
        assertTrue(fails("ext.call", "my.ext", "lyrics", "{oops").contains("not JSON"))
        assertTrue(fails("ext.setting", "my.ext", "k").contains("missing <value>"))
        assertTrue(fails("play", "https://example.com/x").contains("spotify:"))
        assertTrue(fails("nav", "https://example.com").contains("route"))
        assertTrue(fails("pause", "extra").contains("too many"))
    }

    @Test fun masksTokensInText() {
        val t = CliMask.text("GET https://cdn.example/a.flac?token=abcdef123&id=7 Authorization: Bearer abcdefghijk cookie=sess=1; x")
        assertFalse(t, t.contains("abcdef123"))
        assertFalse(t, t.contains("abcdefghijk"))
        assertFalse(t, t.contains("sess=1"))
        assertTrue(t, t.contains("id=7"))
        assertEquals("seen *** here", CliMask.text("seen supersecretvalue here", listOf("supersecretvalue", "abc")))
        assertEquals("short abc", CliMask.text("short abc", listOf("abc")))
        assertFalse(CliMask.text("jwt eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig").contains("eyJ"))
    }

    @Test fun masksSensitiveJsonFields() {
        val e = CliMask.json(Json.parseToJsonElement("""{"url":"https://x/y?sig=zzzzzz","accessToken":"t0k3n","author":"Someone","nested":{"cookie":"c"},"n":3}"""))
        val o = e.jsonObject
        assertEquals(CliMask.MASK, o["accessToken"]!!.jsonPrimitive.content)
        assertEquals(CliMask.MASK, o["nested"]!!.jsonObject["cookie"]!!.jsonPrimitive.content)
        assertEquals("Someone", o["author"]!!.jsonPrimitive.content)
        assertEquals("https://x/y?sig=${CliMask.MASK}", o["url"]!!.jsonPrimitive.content)
        assertEquals(JsonPrimitive(3), o["n"])
    }

    @Test fun settingsHideSecretsAndButtons() {
        val declared = listOf(
            Setting("quality", "choice", "Quality", default = JsonPrimitive("high"), options = listOf("high", "low")),
            Setting("password", "secret", "Password"),
            Setting("pair", "button", "Pair again"),
            Setting("server", "text", "Server"),
        )
        val shown = CliMask.settings(declared, mapOf("password" to "\"hunter22\"", "server" to "\"https://s\"", "leftover" to "\"x\""))
        assertEquals(JsonPrimitive("high"), shown["quality"])
        assertEquals(JsonPrimitive(CliMask.MASK), shown["password"])
        assertEquals(JsonPrimitive("https://s"), shown["server"])
        assertEquals(JsonPrimitive(CliMask.MASK), shown["leftover"])
        assertFalse(shown.containsKey("pair"))
        assertEquals(JsonNull, CliMask.settings(listOf(Setting("p", "secret", "P")), emptyMap())["p"])
    }

    @Test fun knownSecretsTakeStoredStrings() {
        val known = CliMask.knownSecrets(listOf(Setting("password", "secret", "P"), Setting("server", "text", "S")),
            mapOf("password" to "\"hunter22\"", "server" to "\"https://s\""), mapOf("auth" to """{"refresh":"r3fr3sh-value"}"""))
        assertTrue("hunter22" in known)
        assertTrue("r3fr3sh-value" in known)
        assertFalse("https://s" in known)
        assertEquals("log *** ok", CliMask.text("log r3fr3sh-value ok", known))
    }

    @Test fun replies() {
        val ok = Json.parseToJsonElement(CliReply.ok("status", JsonPrimitive(1))).jsonObject
        assertEquals(JsonPrimitive(true), ok["ok"])
        val err = Json.parseToJsonElement(CliReply.error("x", "no")).jsonObject
        assertEquals(JsonPrimitive("no"), err["error"])
        assertEquals("a-1_B", CliReply.safeRequestId("a-1_B"))
        assertEquals(null, CliReply.safeRequestId("../x"))
    }
}