Merge pull request #51 from GetStream/feature/refactor-stream-video-c…

…lient-to-allow-mocking

Refactor the client to enable mocking in tests

Packages/StreamVideo/Runtime/Core/IInternalStreamVideoClient.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using StreamVideo.Core.LowLevelClient;
+using StreamVideo.Core.StatefulModels;
+
+namespace StreamVideo.Core
+{
+    internal interface IInternalStreamVideoClient
+    {
+        StreamVideoLowLevelClient InternalLowLevelClient { get; }
+
+        Task LeaveCallAsync(IStreamCall call);
+
+        Task EndCallAsync(IStreamCall call);
+
+        Task StartHLSAsync(IStreamCall call);
+
+        Task StopHLSAsync(IStreamCall call);
+
+        Task GoLiveAsync(IStreamCall call);
+
+        Task StopLiveAsync(IStreamCall call);
+
+        Task StartRecordingAsync(IStreamCall call);
+
+        Task StopRecordingAsync(IStreamCall call);
+
+        Task MuteAllUsersAsync(IStreamCall call, bool audio, bool video, bool screenShare);
+
+        Task BlockUserAsync(IStreamCall call, string userId);
+
+        Task UnblockUserAsync(IStreamCall call, string userId);
+
+        Task RequestPermissionAsync(IStreamCall call, List<string> capabilities);
+
+        Task UpdateUserPermissions(IStreamCall call, string userId, List<string> grantPermissions,
+            List<string> revokePermissions);
+
+        Task RemoveMembersAsync(IStreamCall call, List<string> removeUsers);
+    }
+}

Packages/StreamVideo/Runtime/Core/State/IStatefulModelContext.cs

@@ -7,7 +7,7 @@ namespace StreamVideo.Core.State
     internal interface IStatefulModelContext
     {
         ICache Cache { get; }
-        StreamVideoClient Client { get; }
+        IInternalStreamVideoClient Client { get; }
         ILogs Logs { get; }
         ISerializer Serializer { get; }
     }

Packages/StreamVideo/Runtime/Core/State/StatefulModelContext.cs

@@ -7,11 +7,11 @@ namespace StreamVideo.Core.State
     internal sealed class StatefulModelContext : IStatefulModelContext
     {
         public ICache Cache { get; }
-        public StreamVideoClient Client { get; }
+        public IInternalStreamVideoClient Client { get; }
         public ILogs Logs { get; }
         public ISerializer Serializer { get; }
 
-        public StatefulModelContext(ICache cache, StreamVideoClient client, ISerializer serializer, ILogs logs)
+        public StatefulModelContext(ICache cache, IInternalStreamVideoClient client, ISerializer serializer, ILogs logs)
         {
             Cache = cache;
             Client = client;

Packages/StreamVideo/Runtime/Core/StatefulModels/StreamStatefulModelBase.cs

@@ -43,7 +43,7 @@ internal StreamStatefulModelBase(string uniqueId, ICacheRepository<TStatefulMode
         protected abstract string InternalUniqueId { get; set; }
 
         protected abstract TStatefulModel Self { get; }
-        protected StreamVideoClient Client { get; }
+        protected IInternalStreamVideoClient Client { get; }
         protected StreamVideoLowLevelClient LowLevelClient => Client.InternalLowLevelClient;
         protected ILogs Logs { get; }
         protected ICache Cache { get; }

Packages/StreamVideo/Runtime/Core/StreamVideoClient.cs

@@ -32,7 +32,7 @@ namespace StreamVideo.Core
 
     public delegate void ConnectHandler(IStreamVideoUser localUser);
 
-    public class StreamVideoClient : IStreamVideoClient
+    public class StreamVideoClient : IStreamVideoClient, IInternalStreamVideoClient
     {
         public event ConnectHandler Connected;
 
@@ -244,41 +244,38 @@ void IStreamVideoClientEventsListener.Destroy()
 
         #endregion
 
-        internal StreamVideoLowLevelClient InternalLowLevelClient { get; private set; }
 
-        internal async Task LeaveCallAsync(IStreamCall call)
-        {
-            //StreamTodo: check if call is active
-            await InternalLowLevelClient.RtcSession.StopAsync();
-            CallEnded?.Invoke(call);
-        }
 
-        internal async Task EndCallAsync(IStreamCall call)
+        StreamVideoLowLevelClient IInternalStreamVideoClient.InternalLowLevelClient => InternalLowLevelClient;
+
+        Task IInternalStreamVideoClient.LeaveCallAsync(IStreamCall call) => LeaveCallAsync(call);
+
+        async Task IInternalStreamVideoClient.EndCallAsync(IStreamCall call)
         {
             //StreamTodo: check if call is active
             await InternalLowLevelClient.InternalVideoClientApi.EndCallAsync(call.Type, call.Id);
             await LeaveCallAsync(call);
         }
 
-        internal Task StartHLSAsync(IStreamCall call)
+        Task IInternalStreamVideoClient.StartHLSAsync(IStreamCall call)
             => InternalLowLevelClient.InternalVideoClientApi.StartBroadcastingAsync(call.Type, call.Id);
 
-        internal Task StopHLSAsync(IStreamCall call)
+        Task IInternalStreamVideoClient.StopHLSAsync(IStreamCall call)
             => InternalLowLevelClient.InternalVideoClientApi.StopBroadcastingAsync(call.Type, call.Id);
 
-        internal Task GoLiveAsync(IStreamCall call)
+        Task IInternalStreamVideoClient.GoLiveAsync(IStreamCall call)
             => InternalLowLevelClient.InternalVideoClientApi.GoLiveAsync(call.Type, call.Id);
 
-        internal Task StopLiveAsync(IStreamCall call)
+        Task IInternalStreamVideoClient.StopLiveAsync(IStreamCall call)
             => InternalLowLevelClient.InternalVideoClientApi.StopLiveAsync(call.Type, call.Id);
 
-        internal Task StartRecordingAsync(IStreamCall call)
+        Task IInternalStreamVideoClient.StartRecordingAsync(IStreamCall call)
             => InternalLowLevelClient.InternalVideoClientApi.StartRecordingAsync(call.Type, call.Id);
 
-        internal Task StopRecordingAsync(IStreamCall call)
+        Task IInternalStreamVideoClient.StopRecordingAsync(IStreamCall call)
             => InternalLowLevelClient.InternalVideoClientApi.StopRecordingAsync(call.Type, call.Id);
 
-        internal Task MuteAllUsersAsync(IStreamCall call, bool audio, bool video, bool screenShare)
+        Task IInternalStreamVideoClient.MuteAllUsersAsync(IStreamCall call, bool audio, bool video, bool screenShare)
         {
             var body = new MuteUsersRequestInternalDTO
             {
@@ -291,28 +288,28 @@ internal Task MuteAllUsersAsync(IStreamCall call, bool audio, bool video, bool s
             return InternalLowLevelClient.InternalVideoClientApi.MuteUsersAsync(call.Type, call.Id, body);
         }
 
-        internal Task BlockUserAsync(IStreamCall call, string userId)
+        Task IInternalStreamVideoClient.BlockUserAsync(IStreamCall call, string userId)
             => InternalLowLevelClient.InternalVideoClientApi.BlockUserAsync(call.Type, call.Id,
                 new BlockUserRequestInternalDTO
                 {
                     UserId = userId
                 });
 
-        internal Task UnblockUserAsync(IStreamCall call, string userId)
+        Task IInternalStreamVideoClient.UnblockUserAsync(IStreamCall call, string userId)
             => InternalLowLevelClient.InternalVideoClientApi.UnblockUserAsync(call.Type, call.Id,
                 new UnblockUserRequestInternalDTO
                 {
                     UserId = userId
                 });
 
-        internal Task RequestPermissionAsync(IStreamCall call, List<string> capabilities)
+        Task IInternalStreamVideoClient.RequestPermissionAsync(IStreamCall call, List<string> capabilities)
             => InternalLowLevelClient.InternalVideoClientApi.RequestPermissionAsync(call.Type, call.Id,
                 new RequestPermissionRequestInternalDTO
                 {
                     Permissions = capabilities
                 });
 
-        internal Task UpdateUserPermissions(IStreamCall call, string userId, List<string> grantPermissions,
+        Task IInternalStreamVideoClient.UpdateUserPermissions(IStreamCall call, string userId, List<string> grantPermissions,
             List<string> revokePermissions)
             => InternalLowLevelClient.InternalVideoClientApi.UpdateUserPermissionsAsync(call.Type, call.Id,
                 new UpdateUserPermissionsRequestInternalDTO
@@ -322,17 +319,26 @@ internal Task UpdateUserPermissions(IStreamCall call, string userId, List<string
                     UserId = userId
                 });
 
-        internal Task RemoveMembersAsync(IStreamCall call, List<string> removeUsers)
+        Task IInternalStreamVideoClient.RemoveMembersAsync(IStreamCall call, List<string> removeUsers)
             => InternalLowLevelClient.InternalVideoClientApi.UpdateCallMembersAsync(call.Type, call.Id,
                 new UpdateCallMembersRequestInternalDTO
                 {
                     RemoveMembers = removeUsers,
                 });
 
+        private StreamVideoLowLevelClient InternalLowLevelClient { get; }
+
         private event Action Destroyed;
 
         private readonly ILogs _logs;
         private readonly ICache _cache;
+
+        private async Task LeaveCallAsync(IStreamCall call)
+        {
+            //StreamTodo: check if call is active
+            await InternalLowLevelClient.RtcSession.StopAsync();
+            CallEnded?.Invoke(call);
+        }
 
         private StreamVideoClient(IWebsocketClient coordinatorWebSocket, IWebsocketClient sfuWebSocket,
             IHttpClient httpClient, ISerializer serializer, ITimeService timeService, INetworkMonitor networkMonitor,