Merge pull request #63 from noobot/return-message-sub-type

Return message sub type

src/SlackConnector/Extensions/MessageSubTypeExtensions.cs

@@ -0,0 +1,13 @@
+using SlackConnector.Connections.Sockets.Messages.Inbound;
+using SlackConnector.Models;
+
+namespace SlackConnector.Extensions
+{
+    internal static class MessageSubTypeExtensions
+    {
+        public static SlackMessageSubType ToSlackMessageSubType(this MessageSubType subType)
+        {
+            return (SlackMessageSubType)subType;
+        }
+    }
+}

src/SlackConnector/Models/SlackMessage.cs

@@ -8,5 +8,6 @@ public class SlackMessage
         public string Text { get; set; }
         public SlackUser User { get; set; }
         public double Timestamp { get; set; }
+        public SlackMessageSubType MessageSubType { get; set; }
     }
 }

src/SlackConnector/Models/SlackMessageSubType.cs

@@ -0,0 +1,30 @@
+namespace SlackConnector.Models
+{
+    public enum SlackMessageSubType
+    {
+        Unknown = 0,
+        BotMessage,
+        MeMessage,
+        MessageChanged,
+        MessageDeleted,
+        ChannelJoin,
+        ChannelLeave,
+        ChannelTopic,
+        ChannelPurpose,
+        ChannelName,
+        ChannelArchive,
+        ChannelUnarchive,
+        GroupJoin,
+        GroupLeave,
+        GroupTopic,
+        GroupPurpose,
+        GroupName,
+        GroupArchive,
+        GroupUnarchive,
+        FileShare,
+        FileComment,
+        FileMention,
+        PinnedItem,
+        UnpinnedItem
+    }
+}

src/SlackConnector/SlackConnection.cs

@@ -117,7 +117,8 @@ private Task HandleMessage(ChatMessage inboundMessage)
                 Text = inboundMessage.Text,
                 ChatHub = inboundMessage.Channel == null ? null : _connectedHubs[inboundMessage.Channel],
                 RawData = inboundMessage.RawData,
-                MentionsBot = _mentionDetector.WasBotMentioned(Self.Name, Self.Id, inboundMessage.Text)
+                MentionsBot = _mentionDetector.WasBotMentioned(Self.Name, Self.Id, inboundMessage.Text),
+                MessageSubType = inboundMessage.MessageSubType.ToSlackMessageSubType()
             };
 
             return RaiseMessageReceived(message);

tests/SlackConnector.Tests.Unit/Connections/Monitoring/TimerTests.cs

@@ -38,6 +38,7 @@ public void should_run_task_at_least_5_times()
             eventTriggered.WaitOne(TimeSpan.FromSeconds(1));
             eventTriggered.WaitOne(TimeSpan.FromSeconds(1));
             eventTriggered.WaitOne(TimeSpan.FromSeconds(1));
+            eventTriggered.WaitOne(TimeSpan.FromSeconds(1));
             count.ShouldBeGreaterThanOrEqualTo(5);
         }
 

tests/SlackConnector.Tests.Unit/Extensions/MessageSubTypeExtensionsTests.cs

@@ -0,0 +1,23 @@
+using Shouldly;
+using SlackConnector.Connections.Sockets.Messages.Inbound;
+using SlackConnector.Extensions;
+using SlackConnector.Models;
+using Xunit;
+
+namespace SlackConnector.Tests.Unit.Extensions
+{
+    public class MessageSubTypeExtensionsTests
+    {
+        [Theory]
+        [InlineData(MessageSubType.bot_message, SlackMessageSubType.BotMessage)]
+        [InlineData(MessageSubType.channel_name, SlackMessageSubType.ChannelName)]
+        [InlineData(MessageSubType.channel_topic, SlackMessageSubType.ChannelTopic)]
+        [InlineData(MessageSubType.group_join, SlackMessageSubType.GroupJoin)]
+        private void should_convert_to_expected_enum(MessageSubType inbound, SlackMessageSubType expected)
+        {
+            inbound
+                .ToSlackMessageSubType()
+                .ShouldBe(expected);
+        }
+    }
+}

tests/SlackConnector.Tests.Unit/Models/MessageSubTypeEnumTests.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Shouldly;
+using SlackConnector.Connections.Sockets.Messages.Inbound;
+using SlackConnector.Models;
+using Xunit;
+
+namespace SlackConnector.Tests.Unit.Models
+{
+    public class MessageSubTypeEnumTests
+    {
+        [Fact]
+        public void should_have_same_number_of_enum_values_as_internal_enum_type()
+        {
+            // given 
+            int numberOfInternalEnumNames = Enum.GetNames(typeof(MessageSubType)).Length;
+            int numberOfPublicEnumNames = Enum.GetNames(typeof(SlackMessageSubType)).Length;
+
+            // then
+            numberOfPublicEnumNames.ShouldBe(numberOfInternalEnumNames);
+        }
+
+        [Fact]
+        public void should_have_same_message_types_as_internal_models()
+        {
+            // given 
+            var internalEnumNames = Enum.GetNames(typeof(MessageSubType))
+                .Select(x => x.Replace("_", string.Empty))
+                .Select(x => x.ToLower());
+            var publicEnumNames = Enum.GetNames(typeof(SlackMessageSubType))
+                .Select(x => x.ToLower());
+
+            // then
+            publicEnumNames.All(x => internalEnumNames.Contains(x)).ShouldBeTrue();
+        }
+
+        [Fact]
+        public void should_have_same_message_type_values_as_internal_models()
+        {
+            // given 
+            var internalEnumValues = GetEnumValues<MessageSubType>();
+            var publicEnumValues = GetEnumValues<SlackMessageSubType>();
+
+            // then
+            foreach (var publicEnumName in publicEnumValues.Keys)
+            {
+                publicEnumValues[publicEnumName].ShouldBe(internalEnumValues[publicEnumName]);
+            }
+        }
+
+        private static Dictionary<string, int> GetEnumValues<T>() where T : struct, IConvertible
+        {
+            var internalEnumNames = Enum.GetNames(typeof(T));
+
+            var vals = new Dictionary<string, int>();
+            foreach (var enumName in internalEnumNames)
+            {
+                T thingy;
+                Enum.TryParse(enumName, out thingy);
+
+                var name = enumName
+                    .Replace("_", string.Empty)
+                    .ToLower();
+
+                vals.Add(name, thingy.ToInt32(new NumberFormatInfo()));
+            }
+            return vals;
+        }
+    }
+}

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

@@ -33,7 +33,8 @@ private async Task should_raise_event(
                 User = "userABC",
                 MessageType = MessageType.Message,
                 Text = "amazing-text",
-                RawData = "I am raw data yo"
+                RawData = "I am raw data yo",
+                MessageSubType = MessageSubType.channel_leave
             };
 
             SlackMessage receivedMessage = null;
@@ -51,7 +52,8 @@ private async Task should_raise_event(
             {
                 Text = "amazing-text",
                 User = new SlackUser { Id = "userABC", Name = "i-have-a-name" },
-                RawData = inboundMessage.RawData
+                RawData = inboundMessage.RawData,
+                MessageSubType = SlackMessageSubType.ChannelLeave
             });
         }