Merge pull request #77 from cdauphinee/no-dynamic-2

Adding alternative methods to avoid dynamic usage

Author: damdo

PusherClient.Tests.Utilities/FakeAuthoriser.cs

@@ -21,7 +21,7 @@ public string Authorize(string channelName, string socketId)
             {
                 var channelData = new PresenceChannelData();
                 channelData.user_id = socketId;
-                channelData.user_info = new { name = _userName };
+                channelData.user_info = new FakeUserInfo { name = _userName };
 
                 authData = provider.Authenticate(channelName, socketId, channelData).ToJson();
             }

PusherClient.Tests.Utilities/FakeUserInfo.cs

@@ -0,0 +1,9 @@
+using PusherServer;
+
+namespace PusherClient.Tests.Utilities
+{
+    public class FakeUserInfo
+    {
+        public string name { get; set; }
+    }
+}

PusherClient.Tests.Utilities/PusherClient.Tests.Utilities.csproj

@@ -69,6 +69,7 @@
   <ItemGroup>
     <Compile Include="ChannelNameFactory.cs" />
     <Compile Include="Config.cs" />
+    <Compile Include="FakeUserInfo.cs" />
     <Compile Include="FakeAuthoriser.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="PusherFactory.cs" />

PusherClient.Tests/AcceptanceTests/PresenceChannel.cs

@@ -92,5 +92,49 @@ public void PresenceChannelShouldAddAMemberWhenGivenAMemberAsync()
             Assert.IsTrue(channel.IsSubscribed);
             Assert.IsTrue(channelSubscribed);
         }
+
+        [Test]
+        public void PresenceChannelShouldAddATypedMemberWhenGivenAMemberAsync()
+        {
+            // Arrange
+            var stubOptions = new PusherOptions
+            {
+                Authorizer = new FakeAuthoriser(UserNameFactory.CreateUniqueUserName())
+            };
+
+            var pusher = PusherFactory.GetPusher(stubOptions);
+            AutoResetEvent reset = new AutoResetEvent(false);
+
+            pusher.Connected += sender =>
+            {
+                reset.Set();
+            };
+
+            AsyncContext.Run(() => pusher.ConnectAsync());
+            reset.WaitOne(TimeSpan.FromSeconds(5));
+            reset.Reset();
+
+            var mockChannelName = ChannelNameFactory.CreateUniqueChannelName(presenceChannel: true);
+
+            var channelSubscribed = false;
+
+            // Act
+            var channel = AsyncContext.Run(() => pusher.SubscribePresenceAsync<FakeUserInfo>(mockChannelName));
+            channel.Subscribed += sender =>
+            {
+                channelSubscribed = true;
+                reset.Set();
+            };
+
+            reset.WaitOne(TimeSpan.FromSeconds(10));
+
+            // Assert
+            Assert.IsNotNull(channel);
+            StringAssert.Contains(mockChannelName, channel.Name);
+            Assert.IsTrue(channel.IsSubscribed);
+            Assert.IsTrue(channelSubscribed);
+
+            CollectionAssert.IsNotEmpty(channel.Members);
+        }
     }
 }

PusherClient.Tests/UnitTests/PusherTests.cs

@@ -1,6 +1,7 @@
 using System;
 using Nito.AsyncEx;
 using NUnit.Framework;
+using PusherClient.Tests.Utilities;
 
 namespace PusherClient.Tests.UnitTests
 {
@@ -147,5 +148,75 @@ public void PusherShouldThrowAnExceptionWhenSubscribeIsCalledWithANullStringForA
             Assert.IsNotNull(caughtException);
             StringAssert.Contains("The channel name cannot be null or whitespace", caughtException.Message);
         }
+
+        [Test]
+        public void PusherShouldThrowAnExceptionWhenSubscribePresenceIsCalledWithANonPresenceChannelAsync()
+        {
+            // Arrange
+            ArgumentException caughtException = null;
+
+            // Act
+            try
+            {
+                var pusher = new Pusher("FakeAppKey");
+                var channel = AsyncContext.Run(() => pusher.SubscribePresenceAsync<string>("private-123"));
+            }
+            catch (ArgumentException ex)
+            {
+                caughtException = ex;
+            }
+
+            // Assert
+            Assert.IsNotNull(caughtException);
+            StringAssert.Contains("The channel name must be refer to a presence channel", caughtException.Message);
+        }
+
+        [Test]
+        public void PusherShouldThrowAnExceptionWhenSubscribePresenceIsCalledWithADifferentTypeAsync()
+        {
+            // Arrange
+            InvalidOperationException caughtException = null;
+
+            // Act
+            var pusher = new Pusher("FakeAppKey", new PusherOptions { Authorizer = new FakeAuthoriser("test") });
+            AsyncContext.Run(() => pusher.SubscribePresenceAsync<string>("presence-123"));
+
+            try
+            {
+                AsyncContext.Run(() => pusher.SubscribePresenceAsync<int>("presence-123"));
+            }
+            catch (InvalidOperationException ex)
+            {
+                caughtException = ex;
+            }
+
+            // Assert
+            Assert.IsNotNull(caughtException);
+            StringAssert.Contains("Cannot change channel member type; was previously defined as", caughtException.Message);
+        }
+
+        [Test]
+        public void PusherShouldThrowAnExceptionWhenSubscribePresenceIsCalledAfterSubscribe()
+        {
+            // Arrange
+            InvalidOperationException caughtException = null;
+
+            // Act
+            var pusher = new Pusher("FakeAppKey", new PusherOptions { Authorizer = new FakeAuthoriser("test") });
+            AsyncContext.Run(() => pusher.SubscribeAsync("presence-123"));
+
+            try
+            {
+                AsyncContext.Run(() => pusher.SubscribePresenceAsync<int>("presence-123"));
+            }
+            catch (InvalidOperationException ex)
+            {
+                caughtException = ex;
+            }
+
+            // Assert
+            Assert.IsNotNull(caughtException);
+            StringAssert.Contains("This presence channel has already been created without specifying the member info type", caughtException.Message);
+        }
     }
 }

PusherClient/EventEmitter.cs

@@ -12,6 +12,9 @@ public class EventEmitter
         private readonly Dictionary<string, List<Action<dynamic>>> _eventListeners = new Dictionary<string, List<Action<dynamic>>>();
         private readonly List<Action<string, dynamic>> _generalListeners = new List<Action<string, dynamic>>();
 
+        private readonly Dictionary<string, List<Action<string>>> _rawEventListeners = new Dictionary<string, List<Action<string>>>();
+        private readonly List<Action<string, string>> _rawGeneralListeners = new List<Action<string, string>>();
+
         /// <summary>
         /// Binds to a given event name
         /// </summary>
@@ -30,6 +33,24 @@ public void Bind(string eventName, Action<dynamic> listener)
             }
         }
 
+        /// <summary>
+        /// Binds to a given event name. The listener will receive the raw JSON message.
+        /// </summary>
+        /// <param name="eventName">The Event Name to listen for</param>
+        /// <param name="listener">The action to perform when the event occurs</param>
+        public void Bind(string eventName, Action<string> listener)
+        {
+            if (_rawEventListeners.ContainsKey(eventName))
+            {
+                _rawEventListeners[eventName].Add(listener);
+            }
+            else
+            {
+                var listeners = new List<Action<string>> { listener };
+                _rawEventListeners.Add(eventName, listeners);
+            }
+        }
+
         /// <summary>
         /// Binds to ALL event
         /// </summary>
@@ -39,13 +60,23 @@ public void BindAll(Action<string, dynamic> listener)
             _generalListeners.Add(listener);
         }
 
+        /// <summary>
+        /// Binds to ALL event. The listener will receive the raw JSON message.
+        /// </summary>
+        /// <param name="listener">The action to perform when the any event occurs</param>
+        public void BindAll(Action<string, string> listener)
+        {
+            _rawGeneralListeners.Add(listener);
+        }
+
         /// <summary>
         /// Removes the binding for the given event name
         /// </summary>
         /// <param name="eventName">The name of the event to unbind</param>
         public void Unbind(string eventName)
         {
             _eventListeners.Remove(eventName);
+            _rawEventListeners.Remove(eventName);
         }
 
         /// <summary>
@@ -55,36 +86,68 @@ public void Unbind(string eventName)
         /// <param name="listener">The action to remove</param>
         public void Unbind(string eventName, Action<dynamic> listener)
         {
-            if(_eventListeners.ContainsKey(eventName))
+            if (_eventListeners.ContainsKey(eventName))
             {
                 _eventListeners[eventName].Remove(listener);
             }
         }
 
+        /// <summary>
+        /// Remove the action for the event name
+        /// </summary>
+        /// <param name="eventName">The name of the event to unbind</param>
+        /// <param name="listener">The action to remove</param>
+        public void Unbind(string eventName, Action<string> listener)
+        {
+            if (_rawEventListeners.ContainsKey(eventName))
+            {
+                _rawEventListeners[eventName].Remove(listener);
+            }
+        }
+
         /// <summary>
         /// Remove All bindings
         /// </summary>
         public void UnbindAll()
         {
             _eventListeners.Clear();
             _generalListeners.Clear();
+
+            _rawEventListeners.Clear();
+            _rawGeneralListeners.Clear();
         }
 
         internal void EmitEvent(string eventName, string data)
         {
-            var obj = JsonConvert.DeserializeObject<dynamic>(data);
+            foreach (var action in _rawGeneralListeners)
+            {
+                action(eventName, data);
+            }
 
-            // Emit to general listeners regardless of event type
-            foreach (var action in _generalListeners)
+            if (_rawEventListeners.ContainsKey(eventName))
             {
-                action(eventName, obj);
+                foreach (var action in _rawEventListeners[eventName])
+                {
+                    action(data);
+                }
             }
 
-            if (_eventListeners.ContainsKey(eventName))
+            // Don't bother with deserialization if there are no dynamic listeners
+            if (_generalListeners.Count > 0 || _eventListeners.Count > 0)
             {
-                foreach (var action in _eventListeners[eventName])
+                var obj = JsonConvert.DeserializeObject<dynamic>(data);
+
+                foreach (var action in _generalListeners)
+                {
+                    action(eventName, obj);
+                }
+
+                if (_eventListeners.ContainsKey(eventName))
                 {
-                    action(obj);
+                    foreach (var action in _eventListeners[eventName])
+                    {
+                        action(obj);
+                    }
                 }
             }
         }