mock e2e tests (#19)

* mock e2e tests

* fix peer connection mock initialization

@@ -43,7 +43,7 @@ android {
         targetCompatibility java_version
         targetCompatibility java_version
     }
     }
     kotlinOptions {
     kotlinOptions {
-        freeCompilerArgs = ["-Xinline-classes"]
+        freeCompilerArgs = ["-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn"]
         jvmTarget = java_version
         jvmTarget = java_version
     }
     }
 }
 }
@@ -117,6 +117,7 @@ dependencies {
     testImplementation "org.mockito.kotlin:mockito-kotlin:3.1.0"
     testImplementation "org.mockito.kotlin:mockito-kotlin:3.1.0"
     testImplementation 'androidx.test:core:1.4.0'
     testImplementation 'androidx.test:core:1.4.0'
     testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.4.3"
     testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.4.3"
+    kaptTest 'com.google.dagger:dagger-compiler:2.38'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
 }
 }

@@ -8,8 +8,7 @@ import kotlinx.serialization.json.Json
 import javax.inject.Named
 import javax.inject.Named
 
 
 @Module
 @Module
-class JsonFormatModule {
-    companion object {
+object JsonFormatModule {
     @Provides
     @Provides
     fun protobufJsonFormatParser(): JsonFormat.Parser {
     fun protobufJsonFormatParser(): JsonFormat.Parser {
         return JsonFormat.parser()
         return JsonFormat.parser()
@@ -30,5 +29,4 @@ class JsonFormatModule {
     @Provides
     @Provides
     @Named(InjectionNames.SIGNAL_JSON_ENABLED)
     @Named(InjectionNames.SIGNAL_JSON_ENABLED)
     fun signalJsonEnabled(): Boolean = false
     fun signalJsonEnabled(): Boolean = false
-    }
 }
 }

@@ -13,8 +13,7 @@ import javax.inject.Singleton
 
 
 
 
 @Module
 @Module
-class RTCModule {
-    companion object {
+object RTCModule {
     @Provides
     @Provides
     @Singleton
     @Singleton
     fun audioModule(appContext: Context): AudioDeviceModule {
     fun audioModule(appContext: Context): AudioDeviceModule {
@@ -151,5 +150,4 @@ class RTCModule {
     @Provides
     @Provides
     @Named(InjectionNames.OPTIONS_VIDEO_HW_ACCEL)
     @Named(InjectionNames.OPTIONS_VIDEO_HW_ACCEL)
     fun videoHwAccel() = true
     fun videoHwAccel() = true
-    }
 }
 }

@@ -7,8 +7,7 @@ import okhttp3.WebSocket
 import javax.inject.Singleton
 import javax.inject.Singleton
 
 
 @Module
 @Module
-class WebModule {
-    companion object {
+object WebModule {
     @Provides
     @Provides
     @Singleton
     @Singleton
     fun okHttpClient(): OkHttpClient {
     fun okHttpClient(): OkHttpClient {
@@ -19,5 +18,4 @@ class WebModule {
     fun websocketFactory(okHttpClient: OkHttpClient): WebSocket.Factory {
     fun websocketFactory(okHttpClient: OkHttpClient): WebSocket.Factory {
         return okHttpClient
         return okHttpClient
     }
     }
-    }
 }
 }

+package io.livekit.android.mock
+
+import org.webrtc.DataChannel
+
+class MockDataChannel(private val label: String?) : DataChannel(1L) {
+
+    var observer: DataChannel.Observer? = null
+    override fun registerObserver(observer: Observer?) {
+        this.observer = observer
+    }
+
+    override fun unregisterObserver() {
+        observer = null
+    }
+
+    override fun label(): String? {
+        return label
+    }
+
+    override fun id(): Int {
+        return 0
+    }
+
+    override fun state(): State {
+        return State.OPEN
+    }
+
+    override fun bufferedAmount(): Long {
+        return 0
+    }
+
+    override fun send(buffer: Buffer?): Boolean {
+        return true
+    }
+}

-package io.livekit.android.room.mock
+package io.livekit.android.mock
 
 
 import android.graphics.SurfaceTexture
 import android.graphics.SurfaceTexture
 import android.view.Surface
 import android.view.Surface

+package io.livekit.android.mock
+
+import org.webrtc.*
+
+private class MockNativePeerConnectionFactory : NativePeerConnectionFactory {
+    override fun createNativePeerConnection(): Long = 0L
+}
+
+class MockPeerConnection(
+    private val observer: PeerConnection.Observer?
+) : PeerConnection(MockNativePeerConnectionFactory()) {
+
+    var localDesc: SessionDescription? = null
+    var remoteDesc: SessionDescription? = null
+    override fun getLocalDescription(): SessionDescription? = localDesc
+    override fun setLocalDescription(observer: SdpObserver?, sdp: SessionDescription?) {
+        localDesc = sdp
+        observer?.onSetSuccess()
+    }
+
+    override fun getRemoteDescription(): SessionDescription? = remoteDesc
+    override fun setRemoteDescription(observer: SdpObserver?, sdp: SessionDescription?) {
+        remoteDesc = sdp
+        observer?.onSetSuccess()
+    }
+
+    override fun getCertificate(): RtcCertificatePem? {
+        return null
+    }
+
+    override fun createDataChannel(label: String?, init: DataChannel.Init?): DataChannel {
+        return MockDataChannel(label)
+    }
+
+    override fun createOffer(observer: SdpObserver?, constraints: MediaConstraints?) {
+        val sdp = SessionDescription(SessionDescription.Type.OFFER, "")
+        observer?.onCreateSuccess(sdp)
+    }
+
+    override fun createAnswer(observer: SdpObserver?, constraints: MediaConstraints?) {
+        val sdp = SessionDescription(SessionDescription.Type.ANSWER, "")
+        observer?.onCreateSuccess(sdp)
+    }
+
+
+    override fun setAudioPlayout(playout: Boolean) {
+    }
+
+    override fun setAudioRecording(recording: Boolean) {
+    }
+
+    override fun setConfiguration(config: RTCConfiguration?): Boolean {
+        return true
+    }
+
+    override fun addIceCandidate(candidate: IceCandidate?): Boolean {
+        return true
+    }
+
+    override fun removeIceCandidates(candidates: Array<out IceCandidate>?): Boolean {
+        return true
+    }
+
+    override fun addStream(stream: MediaStream?): Boolean {
+        return super.addStream(stream)
+    }
+
+    override fun removeStream(stream: MediaStream?) {
+        super.removeStream(stream)
+    }
+
+    override fun createSender(kind: String?, stream_id: String?): RtpSender {
+        return super.createSender(kind, stream_id)
+    }
+
+    override fun getSenders(): MutableList<RtpSender> {
+        return super.getSenders()
+    }
+
+    override fun getReceivers(): MutableList<RtpReceiver> {
+        return super.getReceivers()
+    }
+
+    override fun getTransceivers(): MutableList<RtpTransceiver> {
+        return super.getTransceivers()
+    }
+
+    override fun addTrack(track: MediaStreamTrack?): RtpSender {
+        return super.addTrack(track)
+    }
+
+    override fun addTrack(track: MediaStreamTrack?, streamIds: MutableList<String>?): RtpSender {
+        return super.addTrack(track, streamIds)
+    }
+
+    override fun removeTrack(sender: RtpSender?): Boolean {
+        return super.removeTrack(sender)
+    }
+
+    override fun addTransceiver(track: MediaStreamTrack?): RtpTransceiver {
+        return super.addTransceiver(track)
+    }
+
+    override fun addTransceiver(
+        track: MediaStreamTrack?,
+        init: RtpTransceiver.RtpTransceiverInit?
+    ): RtpTransceiver {
+        return super.addTransceiver(track, init)
+    }
+
+    override fun addTransceiver(mediaType: MediaStreamTrack.MediaType?): RtpTransceiver {
+        return super.addTransceiver(mediaType)
+    }
+
+    override fun addTransceiver(
+        mediaType: MediaStreamTrack.MediaType?,
+        init: RtpTransceiver.RtpTransceiverInit?
+    ): RtpTransceiver {
+        return super.addTransceiver(mediaType, init)
+    }
+
+    override fun getStats(observer: StatsObserver?, track: MediaStreamTrack?): Boolean {
+        observer?.onComplete(emptyArray())
+        return true
+    }
+
+    override fun getStats(callback: RTCStatsCollectorCallback?) {
+        callback?.onStatsDelivered(RTCStatsReport(0, emptyMap()))
+    }
+
+    override fun setBitrate(min: Int?, current: Int?, max: Int?): Boolean {
+        return true
+    }
+
+    override fun startRtcEventLog(file_descriptor: Int, max_size_bytes: Int): Boolean {
+        return true
+    }
+
+    override fun stopRtcEventLog() {
+    }
+
+    override fun signalingState(): SignalingState {
+        return super.signalingState()
+    }
+
+    override fun iceConnectionState(): IceConnectionState {
+        return super.iceConnectionState()
+    }
+
+    override fun connectionState(): PeerConnectionState {
+        return super.connectionState()
+    }
+
+    override fun iceGatheringState(): IceGatheringState {
+        return super.iceGatheringState()
+    }
+
+    override fun close() {
+    }
+
+    override fun dispose() {
+    }
+
+    override fun getNativePeerConnection(): Long = 0L
+}

+package io.livekit.android.mock
+
+import io.livekit.android.room.PeerConnectionTransport
+import kotlinx.coroutines.CoroutineDispatcher
+import org.webrtc.PeerConnection
+import org.webrtc.PeerConnectionFactory
+
+internal class MockPeerConnectionTransportFactory(
+    private val dispatcher: CoroutineDispatcher,
+) : PeerConnectionTransport.Factory {
+    override fun create(
+        config: PeerConnection.RTCConfiguration,
+        pcObserver: PeerConnection.Observer,
+        listener: PeerConnectionTransport.Listener?
+    ): PeerConnectionTransport {
+        return PeerConnectionTransport(
+            config,
+            pcObserver,
+            listener,
+            dispatcher,
+            PeerConnectionFactory.builder()
+                .createPeerConnectionFactory()
+        )
+    }
+}

+package io.livekit.android.mock
+
+import okhttp3.Request
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import org.mockito.Mockito
+
+class MockWebsocketFactory : WebSocket.Factory {
+    lateinit var ws: WebSocket
+    lateinit var request: Request
+    lateinit var listener: WebSocketListener
+    override fun newWebSocket(request: Request, listener: WebSocketListener): WebSocket {
+        this.ws = Mockito.mock(WebSocket::class.java)
+        this.listener = listener
+        this.request = request
+        return ws
+    }
+}

+package io.livekit.android.mock.dagger
+
+import dagger.Module
+import dagger.Provides
+import io.livekit.android.dagger.InjectionNames
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestCoroutineDispatcher
+import javax.inject.Named
+
+@Module
+object TestCoroutinesModule {
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val coroutineDispatcher: CoroutineDispatcher = TestCoroutineDispatcher()
+
+    @Provides
+    @Named(InjectionNames.DISPATCHER_DEFAULT)
+    fun defaultDispatcher() = coroutineDispatcher
+
+    @Provides
+    @Named(InjectionNames.DISPATCHER_IO)
+    fun ioDispatcher() = coroutineDispatcher
+
+    @Provides
+    @Named(InjectionNames.DISPATCHER_MAIN)
+    fun mainDispatcher() = coroutineDispatcher
+
+    @Provides
+    @Named(InjectionNames.DISPATCHER_UNCONFINED)
+    fun unconfinedDispatcher() = coroutineDispatcher
+}

+package io.livekit.android.mock.dagger
+
+import android.content.Context
+import dagger.BindsInstance
+import dagger.Component
+import io.livekit.android.dagger.JsonFormatModule
+import io.livekit.android.dagger.LiveKitComponent
+import io.livekit.android.mock.MockWebsocketFactory
+import javax.inject.Singleton
+
+@Singleton
+@Component(
+    modules = [
+        TestCoroutinesModule::class,
+        TestRTCModule::class,
+        TestWebModule::class,
+        JsonFormatModule::class,
+    ]
+)
+interface TestLiveKitComponent : LiveKitComponent {
+
+    fun websocketFactory(): MockWebsocketFactory
+
+    @Component.Factory
+    interface Factory {
+        fun create(@BindsInstance appContext: Context): TestLiveKitComponent
+    }
+}

+package io.livekit.android.mock.dagger
+
+import android.content.Context
+import dagger.Module
+import dagger.Provides
+import io.livekit.android.dagger.InjectionNames
+import io.livekit.android.mock.MockEglBase
+import org.webrtc.*
+import javax.inject.Named
+import javax.inject.Singleton
+
+
+@Module
+object TestRTCModule {
+
+    @Provides
+    @Singleton
+    fun eglBase(): EglBase {
+        return MockEglBase()
+    }
+
+    @Provides
+    fun eglContext(eglBase: EglBase): EglBase.Context = eglBase.eglBaseContext
+
+
+    @Provides
+    @Singleton
+    fun peerConnectionFactory(
+        appContext: Context
+    ): PeerConnectionFactory {
+        try {
+            ContextUtils.initialize(appContext)
+            NativeLibraryLoaderTestHelper.initialize()
+        } catch (e: Throwable) {
+            // do nothing. this is expected.
+        }
+
+        return MockPeerConnectionFactory()
+    }
+
+    @Provides
+    @Named(InjectionNames.OPTIONS_VIDEO_HW_ACCEL)
+    fun videoHwAccel() = true
+}

+package io.livekit.android.mock.dagger
+
+import dagger.Module
+import dagger.Provides
+import io.livekit.android.mock.MockWebsocketFactory
+import okhttp3.OkHttpClient
+import okhttp3.Response
+import okhttp3.WebSocket
+import javax.inject.Singleton
+
+@Module
+object TestWebModule {
+
+    @Provides
+    @Singleton
+    fun okHttpClient(): OkHttpClient {
+        return OkHttpClient.Builder()
+            .addInterceptor {
+                // Don't make actual network calls
+                Response.Builder()
+                    .code(200)
+                    .build()
+            }
+            .build()
+    }
+
+    @Provides
+    @Singleton
+    fun websocketFactory(websocketFactory: MockWebsocketFactory): WebSocket.Factory {
+        return websocketFactory
+    }
+
+    @Provides
+    @Singleton
+    fun mockWebsocketFactory(): MockWebsocketFactory {
+        return MockWebsocketFactory()
+    }
+}

+package io.livekit.android.room
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import io.livekit.android.mock.MockWebsocketFactory
+import io.livekit.android.mock.dagger.DaggerTestLiveKitComponent
+import io.livekit.android.util.toOkioByteString
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestCoroutineScope
+import kotlinx.coroutines.test.runBlockingTest
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.junit.MockitoJUnit
+import org.robolectric.RobolectricTestRunner
+
+@ExperimentalCoroutinesApi
+@RunWith(RobolectricTestRunner::class)
+class RoomMockE2ETest {
+
+    @get:Rule
+    var mockitoRule = MockitoJUnit.rule()
+
+    lateinit var context: Context
+    lateinit var room: Room
+    lateinit var wsFactory: MockWebsocketFactory
+
+    @Before
+    fun setup() {
+        context = ApplicationProvider.getApplicationContext()
+        val component = DaggerTestLiveKitComponent
+            .factory()
+            .create(context)
+
+        room = component.roomFactory()
+            .create(context)
+        wsFactory = component.websocketFactory()
+    }
+
+    @Test
+    fun connectTest() {
+        val job = TestCoroutineScope().launch {
+            room.connect(
+                url = "http://www.example.com",
+                token = "",
+                options = null
+            )
+        }
+
+        wsFactory.listener.onMessage(wsFactory.ws, SignalClientTest.JOIN.toOkioByteString())
+
+        runBlockingTest {
+            job.join()
+        }
+    }
+
+    @Test
+    fun roomUpdateTest() {
+        val handler = CoroutineExceptionHandler { _, exception ->
+            println("CoroutineExceptionHandler got $exception")
+            exception.printStackTrace()
+        }
+        val job = TestCoroutineScope().launch(handler) {
+            room.connect(
+                url = "http://www.example.com",
+                token = "",
+                options = null
+            )
+        }
+
+        wsFactory.listener.onMessage(wsFactory.ws, SignalClientTest.JOIN.toOkioByteString())
+
+        runBlockingTest {
+            job.join()
+        }
+        wsFactory.listener.onMessage(wsFactory.ws, SignalClientTest.ROOM_UPDATE.toOkioByteString())
+
+        Assert.assertEquals(
+            SignalClientTest.ROOM_UPDATE.roomUpdate.room.metadata,
+            room.metadata
+        )
+    }
+}

@@ -2,7 +2,7 @@ package io.livekit.android.room
 
 
 import android.content.Context
 import android.content.Context
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.core.app.ApplicationProvider
-import io.livekit.android.room.mock.MockEglBase
+import io.livekit.android.mock.MockEglBase
 import io.livekit.android.room.participant.LocalParticipant
 import io.livekit.android.room.participant.LocalParticipant
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.launch
@@ -18,7 +18,6 @@ import org.mockito.Mockito
 import org.mockito.junit.MockitoJUnit
 import org.mockito.junit.MockitoJUnit
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.RobolectricTestRunner
 import org.webrtc.EglBase
 import org.webrtc.EglBase
-import org.webrtc.PeerConnectionFactory
 
 
 @ExperimentalCoroutinesApi
 @ExperimentalCoroutinesApi
 @RunWith(RobolectricTestRunner::class)
 @RunWith(RobolectricTestRunner::class)

 package io.livekit.android.room
 package io.livekit.android.room
 
 
 import com.google.protobuf.util.JsonFormat
 import com.google.protobuf.util.JsonFormat
+import io.livekit.android.mock.MockWebsocketFactory
 import io.livekit.android.util.toOkioByteString
 import io.livekit.android.util.toOkioByteString
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.async
 import kotlinx.coroutines.async
@@ -29,16 +30,6 @@ class SignalClientTest {
     lateinit var coroutineDispatcher: TestCoroutineDispatcher
     lateinit var coroutineDispatcher: TestCoroutineDispatcher
     lateinit var coroutineScope: TestCoroutineScope
     lateinit var coroutineScope: TestCoroutineScope
 
 
-    class MockWebsocketFactory : WebSocket.Factory {
-        lateinit var ws: WebSocket
-        lateinit var request: Request
-        override fun newWebSocket(request: Request, listener: WebSocketListener): WebSocket {
-            ws = Mockito.mock(WebSocket::class.java)
-            this.request = request
-            return ws
-        }
-    }
-
     @Before
     @Before
     fun setup() {
     fun setup() {
         coroutineDispatcher = TestCoroutineDispatcher()
         coroutineDispatcher = TestCoroutineDispatcher()
@@ -139,7 +130,7 @@ class SignalClientTest {
     companion object {
     companion object {
         private const val EXAMPLE_URL = "http://www.example.com"
         private const val EXAMPLE_URL = "http://www.example.com"
 
 
-        private val JOIN = with(LivekitRtc.SignalResponse.newBuilder()) {
+        val JOIN = with(LivekitRtc.SignalResponse.newBuilder()) {
             join = with(joinBuilder) {
             join = with(joinBuilder) {
                 room = with(roomBuilder) {
                 room = with(roomBuilder) {
                     name = "roomname"
                     name = "roomname"
@@ -150,7 +141,8 @@ class SignalClientTest {
             }
             }
             build()
             build()
         }
         }
-        private val OFFER = with(LivekitRtc.SignalResponse.newBuilder()) {
+
+        val OFFER = with(LivekitRtc.SignalResponse.newBuilder()) {
             offer = with(offerBuilder) {
             offer = with(offerBuilder) {
                 sdp = ""
                 sdp = ""
                 type = "offer"
                 type = "offer"
@@ -158,5 +150,16 @@ class SignalClientTest {
             }
             }
             build()
             build()
         }
         }
+
+        val ROOM_UPDATE = with(LivekitRtc.SignalResponse.newBuilder()) {
+            roomUpdate = with(roomUpdateBuilder) {
+                room = with(roomBuilder) {
+                    metadata = "metadata"
+                    build()
+                }
+                build()
+            }
+            build()
+        }
     }
     }
 }
 }

+package org.webrtc
+
+import io.livekit.android.mock.MockPeerConnection
+
+class MockPeerConnectionFactory : PeerConnectionFactory(1L) {
+    override fun createPeerConnectionInternal(
+        rtcConfig: PeerConnection.RTCConfiguration?,
+        constraints: MediaConstraints?,
+        observer: PeerConnection.Observer?,
+        sslCertificateVerifier: SSLCertificateVerifier?
+    ): PeerConnection {
+        return MockPeerConnection(observer)
+    }
+}

+package org.webrtc
+
+object NativeLibraryLoaderTestHelper {
+    fun initialize() {
+        NativeLibrary.initialize({ true }, "")
+    }
+}