Merge pull request #36 from noobot/dm-channel-missing-issue-34

Dm channel missing issue 34

src/SlackConnector.Tests.Integration/SlackConnectorTests.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using SlackConnector.Models;
 using SlackConnector.Tests.Integration.Configuration;
@@ -8,6 +10,8 @@ namespace SlackConnector.Tests.Integration
     [TestFixture]
     public class SlackConnectorTests
     {
+        private ISlackConnection _slackConnection; 
+
         [Test]
         public void should_connect_and_stuff()
         {
@@ -17,20 +21,20 @@ public void should_connect_and_stuff()
             var slackConnector = new SlackConnector();
 
             // when
-            var connection = slackConnector.Connect(config.Slack.ApiToken).Result;
-            connection.OnDisconnect += SlackConnector_OnDisconnect;
-            connection.OnMessageReceived += SlackConnectorOnOnMessageReceived;
+            _slackConnection = slackConnector.Connect(config.Slack.ApiToken).Result;
+            _slackConnection.OnDisconnect += SlackConnector_OnDisconnect;
+            _slackConnection.OnMessageReceived += SlackConnectorOnMessageReceived;
 
             // then
-            Assert.That(connection.IsConnected, Is.True);
+            Assert.That(_slackConnection.IsConnected, Is.True);
         }
 
         private void SlackConnector_OnDisconnect()
         {
 
         }
 
-        private Task SlackConnectorOnOnMessageReceived(SlackMessage message)
+        private Task SlackConnectorOnMessageReceived(SlackMessage message)
         {
             return new Task(() => { });
         }

src/SlackConnector.Tests.Integration/TypingIndicatorTests.cs

@@ -17,6 +17,7 @@ public void should_send_typing_indicator()
 
             var slackConnector = new SlackConnector();
             var connection = slackConnector.Connect(config.Slack.ApiToken).Result;
+
             SlackChatHub channel = connection.ConnectedChannels().First(x => x.Name.Equals("#general", StringComparison.InvariantCultureIgnoreCase));
 
             // when

src/SlackConnector.Tests.Unit/Connections/Sockets/Messages/MessageInterpreterTests.cs

@@ -1,5 +1,4 @@
-using System;
-using Moq;
+using Moq;
 using NUnit.Framework;
 using Should;
 using SlackConnector.Connections.Models;
@@ -134,6 +133,103 @@ public void then_should_look_like_expected()
         }
     }
 
+    internal class given_dm_channel_joined_message_when_processing_message : SpecsFor<MessageInterpreter>
+    {
+        private string Json { get; set; }
+        private InboundMessage Result { get; set; }
+
+        protected override void Given()
+        {
+            Json = @"
+                {
+                   'type':'im_created',
+                   'channel':{
+                      'id':'D99999',
+                      'user':'U99999',
+                      'is_im':true,
+                      'is_open':true
+                   }
+                }
+            ";
+        }
+
+        protected override void When()
+        {
+            Result = SUT.InterpretMessage(Json);
+        }
+
+        [Test]
+        public void then_should_look_like_expected()
+        {
+            var expected = new DmChannelJoinedMessage
+            {
+                MessageType = MessageType.Im_Created,
+                Channel = new Im
+                {
+                    Id = "D99999",
+                    User = "U99999",
+                    IsIm = true,
+                    IsOpen = true
+                },
+                RawData = Json,
+            };
+
+            Result.ShouldLookLike(expected);
+        }
+    }
+
+    internal class given_user_joined_message_when_processing_message : SpecsFor<MessageInterpreter>
+    {
+        private string Json { get; set; }
+        private InboundMessage Result { get; set; }
+
+        protected override void Given()
+        {
+            Json = @"
+                {  
+                   'type':'team_join',
+                   'user':{  
+                      'id':'U3339999',
+                      'name':'tmp',
+                      'profile':{  
+                         'real_name':'temp-name'
+                      },
+                      'is_admin':false,
+                      'is_bot':true
+                   }
+                }
+            ";
+        }
+
+        protected override void When()
+        {
+            Result = SUT.InterpretMessage(Json);
+        }
+
+        [Test]
+        public void then_should_look_like_expected()
+        {
+            var expected = new UserJoinedMessage
+            {
+                MessageType = MessageType.Team_Join,
+                User = new User
+                {
+                    Id = "U3339999",
+                    Name = "tmp",
+                    IsAdmin = false,
+                    IsBot = true,
+                    Profile = new Profile
+                    {
+                        RealName = "temp-name"
+                    }
+                },
+                RawData = Json,
+            };
+
+            Result.ShouldLookLike(expected);
+        }
+    }
+
     internal class given_non_message_type_message_when_processing_message : SpecsFor<MessageInterpreter>
     {
         private string Json { get; set; }

src/SlackConnector.Tests.Unit/SlackConnectionTests/InboundMessageTests/ChatMessageTests.cs

@@ -70,6 +70,47 @@ public void then_should_pass_through_expected_message()
         }
     }
 
+    internal class given_connector_is_setup_when_inbound_direct_message_arrives_from_a_user_for_the_first_time : ChatMessageTest
+    {
+        protected override void Given()
+        {
+            base.Given();
+
+            ConnectionInfo.Users.Add("userABC", new SlackUser() { Id = "userABC", Name = "i-have-a-name" });
+
+            InboundMessage = new ChatMessage
+            {
+                User = "userABC",
+                MessageType = MessageType.Message,
+                Text = "amazing-text",
+                RawData = "I am raw data yo"
+            };
+        }
+
+        [Test]
+        public void then_should_raise_event()
+        {
+            MessageRaised.ShouldBeTrue();
+        }
+
+        [Test]
+        public void then_should_pass_through_expected_message()
+        {
+            var expected = new SlackMessage
+            {
+                Text = "amazing-text",
+                User = new SlackUser
+                {
+                    Id = "userABC",
+                    Name = "i-have-a-name"
+                },
+                RawData = InboundMessage.RawData
+            };
+
+            Result.ShouldLookLike(expected);
+        }
+    }
+
     internal class given_connector_is_missing_use_when_inbound_message_arrives : ChatMessageTest
     {
         protected override void Given()

src/SlackConnector.Tests.Unit/SlackConnectionTests/InboundMessageTests/DmJoinedTests.cs

@@ -0,0 +1,56 @@
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Should;
+using SlackConnector.Connections.Models;
+using SlackConnector.Connections.Sockets.Messages.Inbound;
+using SlackConnector.Models;
+using SpecsFor.ShouldExtensions;
+
+namespace SlackConnector.Tests.Unit.SlackConnectionTests.InboundMessageTests
+{
+    internal class given_new_dm_channel : BaseTest<DmChannelJoinedMessage>
+    {
+        private SlackChatHub _lastHub;
+
+        protected override void Given()
+        {
+            base.Given();
+
+            SUT.OnChatHubJoined += hub =>
+            {
+                _lastHub = hub;
+                return Task.FromResult(false);
+            };
+
+            InboundMessage = new DmChannelJoinedMessage
+            {
+                Channel = new Im
+                {
+                    User = "test-user",
+                    Id = "channel-id",
+                    IsIm = true,
+                    IsOpen = true
+                }
+            };
+        }
+
+        [Test]
+        public void then_should_raised_event_with_expected_channel_information()
+        {
+            var expectedChatHub = new SlackChatHub
+            {
+                Id = "channel-id",
+                Name = "@test-user",
+                Type = SlackChatHubType.DM
+            };
+            _lastHub.ShouldLookLike(expectedChatHub);
+        }
+
+        [Test]
+        public void then_should_add_channel_to_connected_hubs()
+        {
+            SUT.ConnectedHubs.ContainsKey("channel-id").ShouldBeTrue();
+            SUT.ConnectedHubs["channel-id"].ShouldEqual(_lastHub);
+        }
+    }
+}