pakstr 0.19.3 → 0.21.0

package/android-template/app/src/test/java/com/pakstr/app/signer/bunker/Nip46RelayTransportTest.kt

@@ -0,0 +1,508 @@
+package com.pakstr.app.signer.bunker
+
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+
+class Nip46RelayTransportTest {
+    private val factories = mutableListOf<FakeConnectionFactory>()
+    private val transports = mutableListOf<Nip46RelayTransport>()
+
+    @After
+    fun teardown() {
+        transports.forEach(Nip46RelayTransport::close)
+    }
+
+    @Test
+    fun connects_subscribes_and_publishes_to_every_available_relay() {
+        val factory = factory()
+        val transport = transport(factory, RELAY_ONE, RELAY_TWO)
+        val event = eventJson(EVENT_ID)
+
+        transport.start { }
+        factory.connection(RELAY_ONE).open()
+        factory.connection(RELAY_TWO).open()
+        transport.publish(REQUEST_ID, event)
+
+        listOf(RELAY_ONE, RELAY_TWO).forEach { relayUrl ->
+            val messages = factory.connection(relayUrl).messages
+            val subscription = JSONArray(messages[0])
+            assertEquals("REQ", subscription.getString(0))
+            assertEquals(
+                24133,
+                subscription.getJSONObject(2)
+                    .getJSONArray("kinds")
+                    .getInt(0)
+            )
+            assertEquals(
+                REMOTE_PUBKEY,
+                subscription.getJSONObject(2)
+                    .getJSONArray("authors")
+                    .getString(0)
+            )
+            val publication = JSONArray(messages[1])
+            assertEquals("EVENT", publication.getString(0))
+            assertEquals(EVENT_ID, publication.getJSONObject(1).getString("id"))
+        }
+    }
+
+    @Test
+    fun readiness_waits_until_pairing_subscription_is_sent() = runBlocking {
+        val factory = factory()
+        val transport = transport(factory, RELAY_ONE)
+        transport.start { }
+        val readiness = async(start = CoroutineStart.UNDISPATCHED) {
+            transport.awaitReady(1_000)
+        }
+
+        assertFalse(readiness.isCompleted)
+        val connection = factory.connection(RELAY_ONE)
+        assertTrue(connection.messages.isEmpty())
+
+        connection.open()
+
+        assertTrue(readiness.await())
+        assertEquals("REQ", JSONArray(connection.messages.single()).getString(0))
+    }
+
+    @Test
+    fun failed_subscription_send_reconnects_without_reporting_readiness() = runBlocking {
+        val factory = factory()
+        val scheduler = Executors.newSingleThreadScheduledExecutor()
+        val transport = Nip46RelayTransport(
+            relayUrls = listOf(RELAY_ONE),
+            remoteSignerPubkey = REMOTE_PUBKEY,
+            clientPubkey = CLIENT_PUBKEY,
+            connectionFactory = factory,
+            scheduler = scheduler,
+            reconnectBaseDelayMillis = 1,
+            reconnectMaximumDelayMillis = 1
+        ).also(transports::add)
+        transport.start { }
+        val first = factory.connection(RELAY_ONE)
+        first.sendResult = false
+
+        first.open()
+
+        assertFalse(transport.awaitReady(25))
+        assertTrue(first.closed)
+        assertEquals("REQ", JSONArray(first.messages.single()).getString(0))
+        assertTrue(factory.awaitConnectionCount(RELAY_ONE, 2))
+        val second = factory.connection(RELAY_ONE, 1)
+        second.open()
+        assertTrue(transport.awaitReady(100))
+    }
+
+    @Test
+    fun any_successful_pairing_subscription_reports_readiness() = runBlocking {
+        val factory = factory()
+        val transport = transport(factory, RELAY_ONE, RELAY_TWO)
+        transport.start { }
+        val first = factory.connection(RELAY_ONE)
+        val second = factory.connection(RELAY_TWO)
+        first.sendResult = false
+
+        first.open()
+        assertFalse(transport.awaitReady(25))
+
+        second.open()
+
+        assertTrue(transport.awaitReady(100))
+    }
+
+    @Test
+    fun close_before_subscription_unblocks_readiness_waiter() = runBlocking {
+        val factory = factory()
+        val transport = transport(factory, RELAY_ONE)
+        transport.start { }
+        val readiness = async(start = CoroutineStart.UNDISPATCHED) {
+            transport.awaitReady(1_000)
+        }
+
+        transport.close()
+
+        assertFalse(readiness.await())
+    }
+
+    @Test
+    fun pairing_subscription_filters_recipient_without_known_author() {
+        val factory = factory()
+        val transport =
+            Nip46RelayTransport(
+                relayUrls = listOf(RELAY_ONE),
+                remoteSignerPubkey = null,
+                clientPubkey = CLIENT_PUBKEY,
+                connectionFactory = factory
+            ).also(transports::add)
+
+        transport.start { }
+        val connection = factory.connection(RELAY_ONE)
+        connection.open()
+        val filter = JSONArray(connection.messages.single()).getJSONObject(2)
+
+        assertEquals(24133, filter.getJSONArray("kinds").getInt(0))
+        assertEquals(CLIENT_PUBKEY, filter.getJSONArray("#p").getString(0))
+        assertFalse(filter.has("authors"))
+    }
+
+    @Test
+    fun early_open_callback_still_subscribes_and_flushes_requests() {
+        val factory = EarlyOpenConnectionFactory()
+        val transport =
+            Nip46RelayTransport(
+                relayUrls = listOf(RELAY_ONE),
+                remoteSignerPubkey = REMOTE_PUBKEY,
+                clientPubkey = CLIENT_PUBKEY,
+                connectionFactory = factory
+            ).also(transports::add)
+        val event = eventJson(EVENT_ID)
+
+        transport.start { }
+        transport.publish(REQUEST_ID, event)
+
+        assertEquals(2, factory.connection.messages.size)
+        assertEquals(
+            "REQ",
+            JSONArray(factory.connection.messages[0]).getString(0)
+        )
+        assertEquals(
+            "EVENT",
+            JSONArray(factory.connection.messages[1]).getString(0)
+        )
+    }
+
+    @Test
+    fun relay_acknowledgements_and_malformed_frames_are_not_delivered() {
+        val factory = factory()
+        val transport = transport(factory, RELAY_ONE)
+        val received = mutableListOf<String>()
+        transport.start(received::add)
+        val connection = factory.connection(RELAY_ONE)
+        connection.open()
+
+        connection.receive("not-json")
+        connection.receive(JSONArray().put("OK").put(EVENT_ID).put(true).toString())
+        connection.receive(
+            JSONArray()
+                .put("EVENT")
+                .put(connection.subscriptionId())
+                .put(JSONObject(eventJson("invalid")))
+                .toString()
+        )
+
+        assertTrue(received.isEmpty())
+    }
+
+    @Test
+    fun duplicate_event_ids_are_delivered_once_across_relays() {
+        val factory = factory()
+        val transport = transport(factory, RELAY_ONE, RELAY_TWO)
+        val received = mutableListOf<String>()
+        transport.start(received::add)
+        val first = factory.connection(RELAY_ONE)
+        val second = factory.connection(RELAY_TWO)
+        first.open()
+        second.open()
+        val event = eventJson(EVENT_ID)
+
+        first.receiveEvent(event)
+        second.receiveEvent(event)
+
+        assertEquals(1, received.size)
+    }
+
+    @Test
+    fun reconnect_recreates_subscription_and_republishes_pending_events() {
+        val factory = factory()
+        val scheduler = Executors.newSingleThreadScheduledExecutor()
+        val transport = Nip46RelayTransport(
+            relayUrls = listOf(RELAY_ONE),
+            remoteSignerPubkey = REMOTE_PUBKEY,
+            clientPubkey = CLIENT_PUBKEY,
+            connectionFactory = factory,
+            scheduler = scheduler,
+            reconnectBaseDelayMillis = 1,
+            reconnectMaximumDelayMillis = 1
+        )
+        transports += transport
+        transport.start { }
+        val first = factory.connection(RELAY_ONE)
+        first.open()
+        transport.publish(REQUEST_ID, eventJson(EVENT_ID))
+        first.fail()
+
+        assertTrue(factory.awaitConnectionCount(RELAY_ONE, 2))
+        val second = factory.connection(RELAY_ONE, 1)
+        second.open()
+
+        assertEquals("REQ", JSONArray(second.messages[0]).getString(0))
+        assertEquals("EVENT", JSONArray(second.messages[1]).getString(0))
+    }
+
+    @Test
+    fun clean_relay_close_reconnects_and_republishes_pending_events() {
+        val factory = factory()
+        val scheduler = Executors.newSingleThreadScheduledExecutor()
+        val transport = Nip46RelayTransport(
+            relayUrls = listOf(RELAY_ONE),
+            remoteSignerPubkey = REMOTE_PUBKEY,
+            clientPubkey = CLIENT_PUBKEY,
+            connectionFactory = factory,
+            scheduler = scheduler,
+            reconnectBaseDelayMillis = 1,
+            reconnectMaximumDelayMillis = 1
+        )
+        transports += transport
+        transport.start { }
+        val first = factory.connection(RELAY_ONE)
+        first.open()
+        transport.publish(REQUEST_ID, eventJson(EVENT_ID))
+        first.disconnect()
+
+        assertTrue(factory.awaitConnectionCount(RELAY_ONE, 2))
+        val second = factory.connection(RELAY_ONE, 1)
+        second.open()
+
+        assertEquals("REQ", JSONArray(second.messages[0]).getString(0))
+        assertEquals("EVENT", JSONArray(second.messages[1]).getString(0))
+    }
+
+    @Test
+    fun connection_factory_failure_is_retried() {
+        val factory = FailingOnceConnectionFactory()
+        val scheduler = Executors.newSingleThreadScheduledExecutor()
+        val transport = Nip46RelayTransport(
+            relayUrls = listOf(RELAY_ONE),
+            remoteSignerPubkey = REMOTE_PUBKEY,
+            clientPubkey = CLIENT_PUBKEY,
+            connectionFactory = factory,
+            scheduler = scheduler,
+            reconnectBaseDelayMillis = 1,
+            reconnectMaximumDelayMillis = 1
+        )
+        transports += transport
+
+        transport.start { }
+
+        assertTrue(factory.awaitSuccessfulConnection())
+        factory.connection.open()
+        assertEquals(
+            "REQ",
+            JSONArray(factory.connection.messages.single()).getString(0)
+        )
+    }
+
+    @Test
+    fun close_is_idempotent_and_closes_every_connection() {
+        val factory = factory()
+        val transport = transport(factory, RELAY_ONE, RELAY_TWO)
+        transport.start { }
+        val first = factory.connection(RELAY_ONE)
+        val second = factory.connection(RELAY_TWO)
+        first.open()
+        second.open()
+
+        transport.close()
+        transport.close()
+
+        assertTrue(first.closed)
+        assertTrue(second.closed)
+        assertTrue(factory.closed)
+        assertFalse(first.messages.isEmpty())
+        assertEquals(
+            "CLOSE",
+            JSONArray(first.messages.last()).getString(0)
+        )
+    }
+
+    private fun transport(
+        factory: FakeConnectionFactory,
+        vararg relayUrls: String
+    ): Nip46RelayTransport {
+        return Nip46RelayTransport(
+            relayUrls = relayUrls.toList(),
+            remoteSignerPubkey = REMOTE_PUBKEY,
+            clientPubkey = CLIENT_PUBKEY,
+            connectionFactory = factory
+        ).also(transports::add)
+    }
+
+    private fun factory(): FakeConnectionFactory {
+        return FakeConnectionFactory().also(factories::add)
+    }
+
+    private fun eventJson(id: String): String {
+        return JSONObject()
+            .put("id", id)
+            .put("pubkey", REMOTE_PUBKEY)
+            .put("created_at", 1_700_000_000L)
+            .put("kind", 24133)
+            .put("tags", JSONArray())
+            .put("content", "redacted")
+            .put("sig", "0".repeat(128))
+            .toString()
+    }
+
+    private class EarlyOpenConnectionFactory : Nip46RelayConnectionFactory {
+        lateinit var connection: FakeConnection
+            private set
+
+        override fun connect(
+            relayUrl: String,
+            listener: Nip46RelayConnectionListener
+        ): Nip46RelayConnection {
+            connection = FakeConnection(listener)
+            connection.open()
+            return connection
+        }
+    }
+
+    private class FailingOnceConnectionFactory : Nip46RelayConnectionFactory {
+        private var attempts = 0
+        private val monitor = java.lang.Object()
+        lateinit var connection: FakeConnection
+            private set
+
+        override fun connect(
+            relayUrl: String,
+            listener: Nip46RelayConnectionListener
+        ): Nip46RelayConnection {
+            synchronized(monitor) {
+                attempts++
+                if (attempts == 1) {
+                    throw IllegalStateException("connection failed")
+                }
+                connection = FakeConnection(listener)
+                monitor.notifyAll()
+                return connection
+            }
+        }
+
+        fun awaitSuccessfulConnection(): Boolean {
+            synchronized(monitor) {
+                val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(2)
+                while (!::connection.isInitialized) {
+                    val remaining = deadline - System.nanoTime()
+                    if (remaining <= 0) {
+                        return false
+                    }
+                    monitor.wait(
+                        TimeUnit.NANOSECONDS.toMillis(remaining).coerceAtLeast(1)
+                    )
+                }
+                return true
+            }
+        }
+    }
+
+    private class FakeConnectionFactory : Nip46RelayConnectionFactory {
+        private val connections = mutableMapOf<String, MutableList<FakeConnection>>()
+        var closed = false
+
+        @Synchronized
+        override fun connect(
+            relayUrl: String,
+            listener: Nip46RelayConnectionListener
+        ): Nip46RelayConnection {
+            return FakeConnection(listener).also { connection ->
+                connections.getOrPut(relayUrl, ::mutableListOf).add(connection)
+                (this as java.lang.Object).notifyAll()
+            }
+        }
+
+        @Synchronized
+        fun connection(
+            relayUrl: String,
+            index: Int = 0
+        ): FakeConnection {
+            return connections.getValue(relayUrl)[index]
+        }
+
+        @Synchronized
+        fun awaitConnectionCount(
+            relayUrl: String,
+            count: Int
+        ): Boolean {
+            val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(2)
+            while ((connections[relayUrl]?.size ?: 0) < count) {
+                val remaining = deadline - System.nanoTime()
+                if (remaining <= 0) {
+                    return false
+                }
+                (this as java.lang.Object).wait(
+                    TimeUnit.NANOSECONDS.toMillis(remaining).coerceAtLeast(1)
+                )
+            }
+            return true
+        }
+
+        override fun close() {
+            closed = true
+        }
+    }
+
+    private class FakeConnection(
+        private val listener: Nip46RelayConnectionListener
+    ) : Nip46RelayConnection {
+        val messages = mutableListOf<String>()
+        var closed = false
+        var sendResult = true
+
+        override fun send(message: String): Boolean {
+            messages += message
+            return !closed && sendResult
+        }
+
+        override fun close() {
+            closed = true
+        }
+
+        fun open() {
+            listener.onOpen()
+        }
+
+        fun fail() {
+            listener.onFailure()
+        }
+
+        fun disconnect() {
+            listener.onClosed()
+        }
+
+        fun receive(message: String) {
+            listener.onMessage(message)
+        }
+
+        fun receiveEvent(eventJson: String) {
+            receive(
+                JSONArray()
+                    .put("EVENT")
+                    .put(subscriptionId())
+                    .put(JSONObject(eventJson))
+                    .toString()
+            )
+        }
+
+        fun subscriptionId(): String {
+            return JSONArray(messages.first()).getString(1)
+        }
+    }
+
+    private companion object {
+        const val RELAY_ONE = "wss://relay.one"
+        const val RELAY_TWO = "wss://relay.two"
+        val REQUEST_ID = "a".repeat(64)
+        val EVENT_ID = "b".repeat(64)
+        val REMOTE_PUBKEY = "c".repeat(64)
+        val CLIENT_PUBKEY = "d".repeat(64)
+    }
+}