diff --git a/stream-video-android-core/api/stream-video-android-core.api b/stream-video-android-core/api/stream-video-android-core.api index 5475daa3d01..d9306593e25 100644 --- a/stream-video-android-core/api/stream-video-android-core.api +++ b/stream-video-android-core/api/stream-video-android-core.api @@ -8886,7 +8886,6 @@ public final class io/getstream/video/android/core/ClientState { public final fun getRingingCall ()Lkotlinx/coroutines/flow/StateFlow; public final fun getTelecomIntegrationType ()Lio/getstream/video/android/core/notifications/internal/telecom/TelecomIntegrationType; public final fun getUser ()Lkotlinx/coroutines/flow/StateFlow; - public final fun handleError (Lio/getstream/result/Error;)V public final fun handleEvent (Lio/getstream/android/video/generated/models/VideoEvent;)V public final fun hasActiveOrRingingCall ()Z public final fun removeActiveCall ()V @@ -8899,40 +8898,58 @@ public abstract interface class io/getstream/video/android/core/ConnectionState } public final class io/getstream/video/android/core/ConnectionState$Connected : io/getstream/video/android/core/ConnectionState { - public static final field INSTANCE Lio/getstream/video/android/core/ConnectionState$Connected; + public fun (Lio/getstream/android/core/api/model/connection/StreamConnectedUser;Ljava/lang/String;)V + public final fun component1 ()Lio/getstream/android/core/api/model/connection/StreamConnectedUser; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Lio/getstream/android/core/api/model/connection/StreamConnectedUser;Ljava/lang/String;)Lio/getstream/video/android/core/ConnectionState$Connected; + public static synthetic fun copy$default (Lio/getstream/video/android/core/ConnectionState$Connected;Lio/getstream/android/core/api/model/connection/StreamConnectedUser;Ljava/lang/String;ILjava/lang/Object;)Lio/getstream/video/android/core/ConnectionState$Connected; public fun equals (Ljava/lang/Object;)Z + public final fun getConnectedUser ()Lio/getstream/android/core/api/model/connection/StreamConnectedUser; + public final fun getConnectionId ()Ljava/lang/String; public fun hashCode ()I public fun toString ()Ljava/lang/String; } -public final class io/getstream/video/android/core/ConnectionState$Disconnected : io/getstream/video/android/core/ConnectionState { - public static final field INSTANCE Lio/getstream/video/android/core/ConnectionState$Disconnected; +public abstract interface class io/getstream/video/android/core/ConnectionState$Connecting : io/getstream/video/android/core/ConnectionState { +} + +public final class io/getstream/video/android/core/ConnectionState$Connecting$Authenticating : io/getstream/video/android/core/ConnectionState$Connecting { + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/getstream/video/android/core/ConnectionState$Connecting$Authenticating; + public static synthetic fun copy$default (Lio/getstream/video/android/core/ConnectionState$Connecting$Authenticating;Ljava/lang/String;ILjava/lang/Object;)Lio/getstream/video/android/core/ConnectionState$Connecting$Authenticating; public fun equals (Ljava/lang/Object;)Z + public final fun getUserId ()Ljava/lang/String; public fun hashCode ()I public fun toString ()Ljava/lang/String; } -public final class io/getstream/video/android/core/ConnectionState$Failed : io/getstream/video/android/core/ConnectionState { - public fun (Lio/getstream/result/Error;)V - public final fun getError ()Lio/getstream/result/Error; -} - -public final class io/getstream/video/android/core/ConnectionState$Loading : io/getstream/video/android/core/ConnectionState { - public static final field INSTANCE Lio/getstream/video/android/core/ConnectionState$Loading; +public final class io/getstream/video/android/core/ConnectionState$Connecting$Opening : io/getstream/video/android/core/ConnectionState$Connecting { + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/getstream/video/android/core/ConnectionState$Connecting$Opening; + public static synthetic fun copy$default (Lio/getstream/video/android/core/ConnectionState$Connecting$Opening;Ljava/lang/String;ILjava/lang/Object;)Lio/getstream/video/android/core/ConnectionState$Connecting$Opening; public fun equals (Ljava/lang/Object;)Z + public final fun getUserId ()Ljava/lang/String; public fun hashCode ()I public fun toString ()Ljava/lang/String; } -public final class io/getstream/video/android/core/ConnectionState$PreConnect : io/getstream/video/android/core/ConnectionState { - public static final field INSTANCE Lio/getstream/video/android/core/ConnectionState$PreConnect; +public final class io/getstream/video/android/core/ConnectionState$Disconnected : io/getstream/video/android/core/ConnectionState { + public fun ()V + public fun (Ljava/lang/Throwable;)V + public synthetic fun (Ljava/lang/Throwable;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/Throwable; + public final fun copy (Ljava/lang/Throwable;)Lio/getstream/video/android/core/ConnectionState$Disconnected; + public static synthetic fun copy$default (Lio/getstream/video/android/core/ConnectionState$Disconnected;Ljava/lang/Throwable;ILjava/lang/Object;)Lio/getstream/video/android/core/ConnectionState$Disconnected; public fun equals (Ljava/lang/Object;)Z + public final fun getCause ()Ljava/lang/Throwable; public fun hashCode ()I public fun toString ()Ljava/lang/String; } -public final class io/getstream/video/android/core/ConnectionState$Reconnecting : io/getstream/video/android/core/ConnectionState { - public static final field INSTANCE Lio/getstream/video/android/core/ConnectionState$Reconnecting; +public final class io/getstream/video/android/core/ConnectionState$Idle : io/getstream/video/android/core/ConnectionState { + public static final field INSTANCE Lio/getstream/video/android/core/ConnectionState$Idle; public fun equals (Ljava/lang/Object;)Z public fun hashCode ()I public fun toString ()Ljava/lang/String; diff --git a/stream-video-android-core/src/androidTest/kotlin/io/getstream/video/android/core/AndroidDeviceTest.kt b/stream-video-android-core/src/androidTest/kotlin/io/getstream/video/android/core/AndroidDeviceTest.kt index 653418ea80c..a446d98fd50 100644 --- a/stream-video-android-core/src/androidTest/kotlin/io/getstream/video/android/core/AndroidDeviceTest.kt +++ b/stream-video-android-core/src/androidTest/kotlin/io/getstream/video/android/core/AndroidDeviceTest.kt @@ -260,7 +260,9 @@ class AndroidDeviceTest : IntegrationTestBase(connectCoordinatorWS = false) { @Test fun coordinatorWSConnection() = runTest { - assertThat(client.state.connection.value).isEqualTo(ConnectionState.Connected) + assertThat( + client.state.connection.value, + ).isInstanceOf(ConnectionState.Connected::class.java) } @Test diff --git a/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/ClientState.kt b/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/ClientState.kt index 3c499c4003d..0702b054439 100644 --- a/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/ClientState.kt +++ b/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/ClientState.kt @@ -17,18 +17,18 @@ package io.getstream.video.android.core import androidx.compose.runtime.Stable +import io.getstream.android.core.api.model.connection.StreamConnectedUser +import io.getstream.android.core.api.model.connection.StreamConnectionState import io.getstream.android.video.generated.models.CallCreatedEvent import io.getstream.android.video.generated.models.CallRingEvent -import io.getstream.android.video.generated.models.ConnectedEvent import io.getstream.android.video.generated.models.VideoEvent import io.getstream.log.taggedLogger -import io.getstream.result.Error import io.getstream.video.android.core.internal.InternalStreamVideoApi import io.getstream.video.android.core.notifications.internal.service.CallService import io.getstream.video.android.core.notifications.internal.service.ServiceIntentBuilder import io.getstream.video.android.core.notifications.internal.service.ServiceLauncher import io.getstream.video.android.core.notifications.internal.telecom.TelecomIntegrationType -import io.getstream.video.android.core.socket.coordinator.state.VideoSocketState +import io.getstream.video.android.core.socket.coordinator.v2.toVideoConnectionState import io.getstream.video.android.core.utils.safeCallWithDefault import io.getstream.video.android.model.User import kotlinx.coroutines.delay @@ -36,15 +36,19 @@ import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.launch -// These are UI states, need to move out. +// Public coordinator connection state — mirrors core's StreamConnectionState 1:1. @Stable public sealed interface ConnectionState { - public data object PreConnect : ConnectionState - public data object Loading : ConnectionState - public data object Connected : ConnectionState - public data object Reconnecting : ConnectionState - public data object Disconnected : ConnectionState - public class Failed(val error: Error) : ConnectionState + public data object Idle : ConnectionState + public data class Disconnected(val cause: Throwable? = null) : ConnectionState + public data class Connected( + val connectedUser: StreamConnectedUser, + val connectionId: String, + ) : ConnectionState + public sealed interface Connecting : ConnectionState { + public data class Opening(val userId: String) : Connecting + public data class Authenticating(val userId: String) : Connecting + } } // These are UI states, need to move out. @@ -65,7 +69,7 @@ class ClientState(private val client: StreamVideo) { // Internal data private val _user: MutableStateFlow = MutableStateFlow(client.user) private val _connection: MutableStateFlow = - MutableStateFlow(ConnectionState.PreConnect) + MutableStateFlow(ConnectionState.Idle) internal val _ringingCall: MutableStateFlow = MutableStateFlow(null) private val _activeCall: MutableStateFlow = MutableStateFlow(null) @@ -127,12 +131,7 @@ class ClientState(private val client: StreamVideo) { * Most event logic happens in the Call instead of the client */ fun handleEvent(event: VideoEvent) { - // mark connected when (event) { - is ConnectedEvent -> { - _connection.value = ConnectionState.Connected - } - is CallCreatedEvent -> { // what's the right thing to do here? // if it's ringing we add it @@ -150,28 +149,8 @@ class ClientState(private val client: StreamVideo) { } } - internal fun handleState(socketState: VideoSocketState) { - val state = when (socketState) { - // Before connection is established - is VideoSocketState.Disconnected.Stopped -> ConnectionState.PreConnect - // Loading - is VideoSocketState.Connecting -> ConnectionState.Loading - // Connected - is VideoSocketState.Connected -> ConnectionState.Connected - // Reconnecting - is VideoSocketState.Disconnected.DisconnectedTemporarily -> ConnectionState.Reconnecting - is VideoSocketState.RestartConnection -> ConnectionState.Reconnecting - // Disconnected - is VideoSocketState.Disconnected.WebSocketEventLost -> ConnectionState.Disconnected - is VideoSocketState.Disconnected.NetworkDisconnected -> ConnectionState.Disconnected - is VideoSocketState.Disconnected.DisconnectedByRequest -> ConnectionState.Disconnected - is VideoSocketState.Disconnected.DisconnectedPermanently -> ConnectionState.Disconnected - } - _connection.value = state - } - - fun handleError(error: Error) { - _connection.value = ConnectionState.Failed(error) + internal fun handleStreamState(streamState: StreamConnectionState) { + _connection.value = streamState.toVideoConnectionState() } /** diff --git a/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/StreamVideoClient.kt b/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/StreamVideoClient.kt index 92f733a0663..fd937f476f6 100644 --- a/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/StreamVideoClient.kt +++ b/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/StreamVideoClient.kt @@ -230,9 +230,7 @@ internal class StreamVideoClient internal constructor( } override fun onState(state: StreamConnectionState) { - // TODO(02-03): replace with this@StreamVideoClient.state.handleStreamState(state) - // once ClientState.handleStreamState lands in Plan 02-03. Held to validate the - // listener wiring at SDK init; connection-state routing is deferred to the next plan. + this@StreamVideoClient.state.handleStreamState(state) } override fun onError(err: Throwable) { diff --git a/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/socket/coordinator/v2/ConnectionStateMapper.kt b/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/socket/coordinator/v2/ConnectionStateMapper.kt index 57307bd07bf..1b48da8991c 100644 --- a/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/socket/coordinator/v2/ConnectionStateMapper.kt +++ b/stream-video-android-core/src/main/kotlin/io/getstream/video/android/core/socket/coordinator/v2/ConnectionStateMapper.kt @@ -17,37 +17,24 @@ package io.getstream.video.android.core.socket.coordinator.v2 import io.getstream.android.core.api.model.connection.StreamConnectionState -import io.getstream.result.Error import io.getstream.video.android.core.ConnectionState /** - * Maps a core [StreamConnectionState] onto the SDK's existing [ConnectionState] shape. + * Maps a core [StreamConnectionState] onto the SDK's [ConnectionState] shape 1:1. * - * The mapping produced here is a placeholder that preserves compilation until a later plan - * reshapes the video [ConnectionState] sealed interface to mirror the richer core states 1:1 - * (D-04, D-09). Once that reshape lands, both this function body and the collaborating tests - * flip together in a single commit. + * Both hierarchies expose the same five variants (Idle, Connecting.Opening, + * Connecting.Authenticating, Connected, Disconnected); this extension carries the payloads + * across the boundary so integrators observe a video-owned type while the underlying transitions + * are driven by the core client. */ -internal fun StreamConnectionState.toVideoConnectionState(): ConnectionState { - // TODO(02-03): replace placeholder mapping when ConnectionState sealed interface is - // rewritten per D-04/D-09. - return when (this) { - is StreamConnectionState.Idle -> ConnectionState.PreConnect - is StreamConnectionState.Connecting.Opening -> ConnectionState.Loading - is StreamConnectionState.Connecting.Authenticating -> ConnectionState.Loading - is StreamConnectionState.Connected -> ConnectionState.Connected - is StreamConnectionState.Disconnected -> { - val throwable = cause - if (throwable == null) { - ConnectionState.Disconnected - } else { - ConnectionState.Failed( - Error.ThrowableError( - message = throwable.message ?: "", - cause = throwable, - ), - ) - } - } +internal fun StreamConnectionState.toVideoConnectionState(): ConnectionState = + when (this) { + is StreamConnectionState.Idle -> ConnectionState.Idle + is StreamConnectionState.Connecting.Opening -> + ConnectionState.Connecting.Opening(userId) + is StreamConnectionState.Connecting.Authenticating -> + ConnectionState.Connecting.Authenticating(userId) + is StreamConnectionState.Connected -> + ConnectionState.Connected(connectedUser, connectionId) + is StreamConnectionState.Disconnected -> ConnectionState.Disconnected(cause) } -} diff --git a/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientAndAuthTest.kt b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientAndAuthTest.kt index cfc17805610..f03c91abe7f 100644 --- a/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientAndAuthTest.kt +++ b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientAndAuthTest.kt @@ -235,14 +235,16 @@ class ClientAndAuthTest : TestBase() { user = testData.users["thierry"]!!, token = authData!!.token, ).build() - assertThat(client.state.connection.value).isEqualTo(ConnectionState.PreConnect) + assertThat(client.state.connection.value).isEqualTo(ConnectionState.Idle) val clientImpl = client as StreamVideoClient val connectResultDeferred = clientImpl.connectAsync() val connectResult = connectResultDeferred.await() delay(100L) - assertThat(client.state.connection.value).isEqualTo(ConnectionState.Connected) + assertThat( + client.state.connection.value, + ).isInstanceOf(ConnectionState.Connected::class.java) } @Test diff --git a/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientStateConnectionMappingTest.kt b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientStateConnectionMappingTest.kt index 0b63fbe69dc..8ad33856fb6 100644 --- a/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientStateConnectionMappingTest.kt +++ b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientStateConnectionMappingTest.kt @@ -22,66 +22,66 @@ import io.getstream.video.android.core.socket.coordinator.v2.toVideoConnectionSt import org.junit.Test import java.util.Date import kotlin.test.assertEquals +import kotlin.test.assertNull +import kotlin.test.assertSame import kotlin.test.assertTrue /** * Table-driven mapping test for [StreamConnectionState] -> [ConnectionState] extension. * - * Asserts the temporary placeholder mapping shipped by Plan 02-01. A subsequent plan reshapes - * the video [ConnectionState] sealed interface to mirror core 1:1; both this test and the - * mapper body flip together in that plan. + * Asserts the final 1:1 mapping: each core variant produces the video-owned counterpart with + * payload fields carried through verbatim (userId, connectedUser + connectionId, cause). */ internal class ClientStateConnectionMappingTest { @Test - fun `Idle maps to PreConnect`() { + fun `Idle maps to Idle`() { val result = (StreamConnectionState.Idle as StreamConnectionState).toVideoConnectionState() - assertEquals(ConnectionState.PreConnect, result) - // TODO(02-03): update expected value when ConnectionState sealed interface is rewritten + assertEquals(ConnectionState.Idle, result) } @Test - fun `Connecting Opening maps to Loading`() { + fun `Connecting Opening maps to Connecting Opening with userId`() { val result: ConnectionState = StreamConnectionState.Connecting.Opening("user-1").toVideoConnectionState() - assertEquals(ConnectionState.Loading, result) - // TODO(02-03): update expected value when ConnectionState sealed interface is rewritten + assertTrue(result is ConnectionState.Connecting.Opening) + assertEquals("user-1", result.userId) } @Test - fun `Connecting Authenticating maps to Loading`() { + fun `Connecting Authenticating maps to Connecting Authenticating with userId`() { val result: ConnectionState = StreamConnectionState.Connecting.Authenticating("user-1").toVideoConnectionState() - assertEquals(ConnectionState.Loading, result) - // TODO(02-03): update expected value when ConnectionState sealed interface is rewritten + assertTrue(result is ConnectionState.Connecting.Authenticating) + assertEquals("user-1", result.userId) } @Test - fun `Connected maps to Connected`() { + fun `Connected maps to Connected with connectedUser and connectionId`() { + val fixture = connectedUserFixture() val result: ConnectionState = StreamConnectionState - .Connected(connectedUserFixture(), "connection-id") + .Connected(fixture, "connection-id") .toVideoConnectionState() - assertEquals(ConnectionState.Connected, result) - // TODO(02-03): update expected value when ConnectionState sealed interface is rewritten + assertTrue(result is ConnectionState.Connected) + assertSame(fixture, result.connectedUser) + assertEquals("connection-id", result.connectionId) } @Test - fun `Disconnected with null cause maps to Disconnected`() { + fun `Disconnected with null cause maps to Disconnected with null cause`() { val result: ConnectionState = StreamConnectionState.Disconnected(cause = null).toVideoConnectionState() - assertEquals(ConnectionState.Disconnected, result) - // TODO(02-03): update expected value when ConnectionState sealed interface is rewritten + assertTrue(result is ConnectionState.Disconnected) + assertNull(result.cause) } @Test - fun `Disconnected with cause maps to Failed`() { + fun `Disconnected with cause maps to Disconnected with same cause`() { val boom = IllegalStateException("boom") val result: ConnectionState = StreamConnectionState.Disconnected(cause = boom).toVideoConnectionState() - - assertTrue(result is ConnectionState.Failed) - assertEquals("boom", result.error.message) - // TODO(02-03): update expected value when ConnectionState sealed interface is rewritten + assertTrue(result is ConnectionState.Disconnected) + assertSame(boom, result.cause) } private fun connectedUserFixture(): StreamConnectedUser = StreamConnectedUser( diff --git a/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientStateTest.kt b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientStateTest.kt new file mode 100644 index 00000000000..1ad38f4601f --- /dev/null +++ b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/ClientStateTest.kt @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2014-2026 Stream.io Inc. All rights reserved. + * + * Licensed under the Stream License; + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://github.com/GetStream/stream-video-android/blob/main/LICENSE + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.getstream.video.android.core + +import io.getstream.android.core.api.model.connection.StreamConnectedUser +import io.getstream.android.core.api.model.connection.StreamConnectionState +import io.getstream.video.android.model.User +import io.mockk.every +import io.mockk.mockk +import org.junit.Test +import java.util.Date +import kotlin.test.assertEquals +import kotlin.test.assertNull +import kotlin.test.assertSame +import kotlin.test.assertTrue + +/** + * Direct unit test for [ClientState.handleStreamState] — asserts that every + * [StreamConnectionState] variant is projected onto the corresponding video-owned + * [ConnectionState] payload and pushed on the [ClientState.connection] StateFlow. + * + * The test constructs a bare [ClientState] against a mocked [StreamVideo] to avoid pulling in + * the full [StreamVideoClient] dependency graph. + */ +internal class ClientStateTest { + + @Test + fun `initial connection state is Idle`() { + val state = clientState() + + assertEquals(ConnectionState.Idle, state.connection.value) + } + + @Test + fun `handleStreamState Idle publishes Idle`() { + val state = clientState() + + state.handleStreamState(StreamConnectionState.Idle) + + assertEquals(ConnectionState.Idle, state.connection.value) + } + + @Test + fun `handleStreamState Connecting Opening publishes Connecting Opening with userId`() { + val state = clientState() + + state.handleStreamState(StreamConnectionState.Connecting.Opening("user-1")) + + val current = state.connection.value + assertTrue(current is ConnectionState.Connecting.Opening) + assertEquals("user-1", current.userId) + } + + @Test + fun `handleStreamState Connecting Authenticating publishes Connecting Authenticating with userId`() { + val state = clientState() + + state.handleStreamState(StreamConnectionState.Connecting.Authenticating("user-1")) + + val current = state.connection.value + assertTrue(current is ConnectionState.Connecting.Authenticating) + assertEquals("user-1", current.userId) + } + + @Test + fun `handleStreamState Connected publishes Connected with connectedUser and connectionId`() { + val state = clientState() + val fixture = connectedUserFixture() + + state.handleStreamState(StreamConnectionState.Connected(fixture, "connection-id")) + + val current = state.connection.value + assertTrue(current is ConnectionState.Connected) + assertSame(fixture, current.connectedUser) + assertEquals("connection-id", current.connectionId) + } + + @Test + fun `handleStreamState Disconnected with null cause publishes Disconnected with null cause`() { + val state = clientState() + + state.handleStreamState(StreamConnectionState.Disconnected(cause = null)) + + val current = state.connection.value + assertTrue(current is ConnectionState.Disconnected) + assertNull(current.cause) + } + + @Test + fun `handleStreamState Disconnected with cause publishes Disconnected with same cause`() { + val state = clientState() + val boom = RuntimeException("boom") + + state.handleStreamState(StreamConnectionState.Disconnected(cause = boom)) + + val current = state.connection.value + assertTrue(current is ConnectionState.Disconnected) + assertSame(boom, current.cause) + } + + private fun clientState(): ClientState { + val streamVideo = mockk(relaxed = true) + every { streamVideo.user } returns User(id = "user-1") + return ClientState(streamVideo) + } + + private fun connectedUserFixture(): StreamConnectedUser = StreamConnectedUser( + createdAt = Date(0), + id = "user-1", + language = "en", + role = "user", + updatedAt = Date(0), + blockedUserIds = emptyList(), + teams = emptyList(), + ) +} diff --git a/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/rtc/RtcSessionTest.kt b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/rtc/RtcSessionTest.kt index e4f43803c80..5871849d86f 100644 --- a/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/rtc/RtcSessionTest.kt +++ b/stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/rtc/RtcSessionTest.kt @@ -97,7 +97,9 @@ class RtcSessionTest : IntegrationTestBase() { val joinResult = call.join() assertSuccess(joinResult) waitForNextEvent() - Truth.assertThat(call.state.connection.value).isEqualTo(ConnectionState.Connected) + Truth.assertThat( + call.state.connection.value, + ).isInstanceOf(ConnectionState.Connected::class.java) // call.session?.publishVideo() }