lita-slack 1.7.2 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b66cc314ceaee4c634dd501c8a7913548f8c437b
-  data.tar.gz: 25e02797ea080058b6b149a6000f1aaa5366c840
+  metadata.gz: ca96105086115398590afb975e36f44633faf31d
+  data.tar.gz: 21f62a27417aa3fa13fbfc4f4c4091319ee84265
 SHA512:
-  metadata.gz: 96be42cc5971af17763d58f6a9ed7d48b47a7fcd5b766a5f0801c35445de9d4e00f988d5b7adb244745728541456f31ad1e4936c8a9c8a63e2484adb644e70d3
-  data.tar.gz: 3962f0e8955b7eb199e7c6017c560baaabcb87119262b95f79f1efc70d79c8bdde4eb9b25d2ea3e906e356359a7a427456a0efb3e474e6070c7294085835439b
+  metadata.gz: c93fb3be8f2403c50766c7d6cb0127e528efd05e3da10f21aeda34364bef857f0b01ff7b7dcee1b9666f8bc2cd44306a87bd9540a613c241aea8691c1e793aab
+  data.tar.gz: 5dd83d261ce894a9992ac06a1d7af3830cb98cebf8e70bb045f0ae67151628bb81a84b4baca1248d9e37c0454f4f84857d2a83aecb61f0223b73b750a143a7f8

data/.travis.yml

@@ -1,7 +1,8 @@
 language: ruby
 sudo: false
+cache: bundler
 rvm:
-  - 2.0.0
+  - "2.0"
 script: bundle exec rake
 before_install:
   - gem update --system

data/README.md

@@ -1,7 +1,7 @@
 # lita-slack
 
 [![Gem Version](https://badge.fury.io/rb/lita-slack.png)](http://badge.fury.io/rb/lita-slack)
-[![Build Status](https://travis-ci.org/kenjij/lita-slack.png?branch=master)](https://travis-ci.org/kenjij/lita-slack)
+[![Build Status](https://travis-ci.org/litaio/lita-slack.png?branch=master)](https://travis-ci.org/litaio/lita-slack)
 
 **lita-slack** is an adapter for [Lita](https://www.lita.io/) that allows you to use the robot with [Slack](https://slack.com/). The current adapter is not compatible with pre-1.0.0 versions, as it now uses Slack's [Real Time Messaging API](https://api.slack.com/rtm).
 
@@ -21,7 +21,11 @@ gem "lita-slack"
 
 ### Optional attributes
 
+* `link_names` (Boolean) – Set to `true` to turn all Slack usernames in messages sent by Lita into links.
+* `parse` (String) – Specify the parsing mode. See https://api.slack.com/docs/formatting#parsing_modes.
 * `proxy` (String) – Specify a HTTP proxy URL. (e.g. "http://squid.example.com:3128")
+* `unfurl_links` (Boolean) – Set to `true` to automatically add previews for all links in messages sent by Lita.
+* `unfurl_media` (Boolean) – Set to `false` to prevent automatic previews for media files in messages sent by Lita.
 
 **Note**: When using lita-slack, the adapter will overwrite the bot's name and mention name with the values set on the server, so `config.robot.name` and `config.robot.mention_name` will have no effect.
 
@@ -35,7 +39,13 @@ Each Slack user has a unique ID that never changes even if their real name or us
 Lita.configure do |config|
   config.robot.adapter = :slack
   config.robot.admins = ["U012A3BCD"]
+
   config.adapters.slack.token = "abcd-1234567890-hWYd21AmMH2UHAkx29vb5c1Y"
+
+  config.adapters.slack.link_names = true
+  config.adapters.slack.parse = "full"
+  config.adapters.slack.unfurl_links = false
+  config.adapters.slack.unfurl_media = false
 end
 ```
 
@@ -47,12 +57,14 @@ Lita will join your default channel after initial setup. To have it join additio
 
 * `:connected` - When the robot has connected to Slack. No payload.
 * `:disconnected` - When the robot has disconnected from Slack. No payload.
-* `:slack_user_created` - When the robot creates/updates a user's info - name, mention name, etc., as directed by Slack. The payload has a single object, a `Lita::Slack::Adapters::SlackUser` object, under the `:slack_user` key.
 * `:slack_channel_created` - When the robot creates/updates a channel's or group's info, as directed by Slack. The payload has a single object, a `Lita::Slack::Adapters::SlackChannel` object, under the `:slack_channel` key.
+* `:slack_reaction_added` - When a reaction has been added to a previous message. The payload includes `:user` (a `Lita::User` for the sender of the message in question), `:name` (the string name of the reaction added), `:item` (a hash of raw data from Slack about the message), and `:event_ts` (a string timestamp used to identify the message).
+* `:slack_reaction_removed` - When a reaction has been removed from a previous message. The payload is the same as the `:slack_reaction_added` message.
+* `:slack_user_created` - When the robot creates/updates a user's info - name, mention name, etc., as directed by Slack. The payload has a single object, a `Lita::Slack::Adapters::SlackUser` object, under the `:slack_user` key.
 
 ## Chat service API
 
-lita-slack supports Lita 4.6's chat service API for Slack-specific functionality. You can access this API object by calling the `Lita::Robot#chat_service`. See the API docs for `Lita::Slack::Adapters::ChatService` for details about the provided methods.
+lita-slack supports Lita 4.6's chat service API for Slack-specific functionality. You can access this API object by calling the `Lita::Robot#chat_service`. See the API docs for `Lita::Adapters::Slack::ChatService` for details about the provided methods.
 
 ## API documentation
 

data/lib/lita/adapters/slack.rb

@@ -9,12 +9,20 @@ module Lita
       # Required configuration attributes.
       config :token, type: String, required: true
       config :proxy, type: String
+      config :parse, type: [String]
+      config :link_names, type: [true, false]
+      config :unfurl_links, type: [true, false]
+      config :unfurl_media, type: [true, false]
 
       # Provides an object for Slack-specific features.
       def chat_service
         ChatService.new(config)
       end
 
+      def mention_format(name)
+        "@#{name}"
+      end
+
       # Starts the connection.
       def run
         return if rtm_connection
@@ -23,10 +31,16 @@ module Lita
         rtm_connection.run
       end
 
-      def send_messages(target, strings)
-        return unless rtm_connection
+      # Returns UID(s) in an Array or String for:
+      # Channels, MPIMs, IMs
+      def roster(target)
+        api = API.new(config)
+        room_roster target.id, api
+      end
 
-        rtm_connection.send_messages(channel_for(target), strings)
+      def send_messages(target, strings)
+        api = API.new(config)
+        api.send_messages(channel_for(target), strings)
       end
 
       def set_topic(target, topic)
@@ -53,6 +67,45 @@ module Lita
           target.room
         end
       end
+
+      def channel_roster(room_id, api)
+        response = api.channels_info room_id
+        response['channel']['members']
+      end
+
+      # Returns the members of a group, but only can do so if it's a member
+      def group_roster(room_id, api)
+        response = api.groups_list
+        group = response['groups'].select { |hash| hash['id'].eql? room_id }.first
+        group.nil? ? [] : group['members']
+      end
+
+      # Returns the members of a mpim, but only can do so if it's a member
+      def mpim_roster(room_id, api)
+        response = api.mpim_list
+        mpim = response['groups'].select { |hash| hash['id'].eql? room_id }.first
+        mpim.nil? ? [] : mpim['members']
+      end
+
+      # Returns the user of an im
+      def im_roster(room_id, api)
+        response = api.mpim_list
+        im = response['ims'].select { |hash| hash['id'].eql? room_id }.first
+        im.nil? ? '' : im['user']
+      end
+
+      def room_roster(room_id, api)
+        case room_id
+        when /^C/
+          channel_roster room_id, api
+        when /^G/
+          # Groups & MPIMs have the same room ID pattern, check both if needed
+          roster = group_roster room_id, api
+          roster.empty? ? mpim_roster(room_id, api) : roster
+        when /^D/
+          im_roster room_id, api
+        end
+      end
     end
 
     # Register Slack adapter to Lita

data/lib/lita/adapters/slack/api.rb

@@ -13,6 +13,11 @@ module Lita
         def initialize(config, stubs = nil)
           @config = config
           @stubs = stubs
+          @post_message_config = {}
+          @post_message_config[:parse] = config.parse unless config.parse.nil?
+          @post_message_config[:link_names] = config.link_names ? 1 : 0 unless config.link_names.nil?
+          @post_message_config[:unfurl_links] = config.unfurl_links unless config.unfurl_links.nil?
+          @post_message_config[:unfurl_media] = config.unfurl_media unless config.unfurl_media.nil?
         end
 
         def im_open(user_id)
@@ -21,6 +26,26 @@ module Lita
           SlackIM.new(response_data["channel"]["id"], user_id)
         end
 
+        def channels_info(channel_id)
+          call_api("channels.info", channel: channel_id)
+        end
+
+        def channels_list
+          call_api("channels.list")
+        end
+
+        def groups_list
+          call_api("groups.list")
+        end
+
+        def mpim_list
+          call_api("mpim.list")
+        end
+
+        def im_list
+          call_api("im.list")
+        end
+
         def send_attachments(room_or_user, attachments)
           call_api(
             "chat.postMessage",
@@ -30,6 +55,16 @@ module Lita
           )
         end
 
+        def send_messages(channel_id, messages)
+          call_api(
+            "chat.postMessage",
+            **post_message_config,
+            as_user: true,
+            channel: channel_id,
+            text: messages.join("\n"),
+          )
+        end
+
         def set_topic(channel, topic)
           call_api("channels.setTopic", channel: channel, topic: topic)
         end
@@ -51,6 +86,7 @@ module Lita
 
         attr_reader :stubs
         attr_reader :config
+        attr_reader :post_message_config
 
         def call_api(method, post_data = {})
           response = connection.post(
@@ -79,7 +115,7 @@ module Lita
 
         def parse_response(response, method)
           unless response.success?
-            raise "Slack API call to #{method} failed with status code #{response.status}."
+            raise "Slack API call to #{method} failed with status code #{response.status}: '#{response.body}'. Headers: #{response.headers}"
           end
 
           MultiJson.load(response.body)

data/lib/lita/adapters/slack/message_handler.rb

@@ -16,6 +16,8 @@ module Lita
             handle_hello
           when "message"
             handle_message
+          when "reaction_added", "reaction_removed"
+            handle_reaction
           when "user_change", "team_join"
             handle_user_change
           when "bot_added", "bot_changed"
@@ -44,7 +46,7 @@ module Lita
          normalized_message = remove_formatting(normalized_message) unless normalized_message.nil?
 
           attachment_text = Array(data["attachments"]).map do |attachment|
-            attachment["text"]
+            attachment["text"] || attachment["fallback"]
           end
 
           ([normalized_message] + attachment_text).compact.join("\n")
@@ -115,16 +117,13 @@ module Lita
           source.private_message! if channel && channel[0] == "D"
           message = Message.new(robot, body, source)
           message.command! if source.private_message?
+          message.extensions[:slack] = { timestamp: data["ts"] }
           log.debug("Dispatching message to Lita from #{user.id}.")
           robot.receive(message)
         end
 
         def from_self?(user)
-          if data["subtype"] == "bot_message"
-            robot_user = User.find_by_name(robot.name)
-
-            robot_user && robot_user.id == user.id
-          end
+          user.id == robot_id
         end
 
         def handle_bot_change
@@ -151,6 +150,7 @@ module Lita
 
         def handle_message
           return unless supported_subtype?
+          return if data["user"] == 'USLACKBOT'
 
           user = User.find_by_id(data["user"]) || User.create(data["user"])
 
@@ -159,6 +159,22 @@ module Lita
           dispatch_message(user)
         end
 
+        def handle_reaction
+          log.debug "#{type} event received from Slack"
+
+          # find or create user
+          user = User.find_by_id(data["user"]) || User.create(data["user"])
+
+          # avoid processing reactions added/removed by self
+          return if from_self?(user)
+
+          # build a payload following slack convention for reactions
+          payload = { user: user, name: data["reaction"], item: data["item"], event_ts: data["event_ts"] }
+
+          # trigger the appropriate slack reaction event
+          robot.trigger("slack_#{type}".to_sym, payload)
+        end
+
         def handle_unknown
           unless data["reply_to"]
             log.debug("#{type} event received from Slack and will be ignored.")
@@ -176,7 +192,7 @@ module Lita
 
         # Types of messages Lita should dispatch to handlers.
         def supported_message_subtypes
-          %w(bot_message me_message)
+          %w(me_message)
         end
 
         def supported_subtype?

data/lita-slack.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-slack"
-  spec.version       = "1.7.2"
+  spec.version       = "1.8.0"
   spec.authors       = ["Ken J.", "Jimmy Cuadra"]
   spec.email         = ["kenjij@gmail.com", "jimmy@jimmycuadra.com"]
   spec.description   = %q{Lita adapter for Slack.}
@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "eventmachine"
   spec.add_runtime_dependency "faraday"
   spec.add_runtime_dependency "faye-websocket", ">= 0.8.0"
-  spec.add_runtime_dependency "lita", ">= 4.6.0"
+  spec.add_runtime_dependency "lita", ">= 4.7.1"
   spec.add_runtime_dependency "multi_json"
 
   spec.add_development_dependency "bundler", "~> 1.3"
@@ -25,6 +25,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rack-test"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ">= 3.0.0"
-  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov", ">= 0.9.2"
   spec.add_development_dependency "coveralls"
 end

data/spec/lita/adapters/slack/api_spec.rb

@@ -60,7 +60,277 @@ describe Lita::Adapters::Slack::API do
 
       it "raises a RuntimeError" do
         expect { subject.im_open(user_id) }.to raise_error(
-          "Slack API call to im.open failed with status code 422."
+          "Slack API call to im.open failed with status code 422: ''. Headers: {}"
+        )
+      end
+    end
+  end
+
+  describe "#channels_info" do
+    let(:channel_id) { 'C024BE91L' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('https://slack.com/api/channels.info', token: token, channel: channel_id) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+
+    describe "with a successful response" do
+      let(:http_response) do
+        MultiJson.dump({
+            ok: true,
+            channel: {
+                id: 'C024BE91L'
+            }
+        })
+      end
+
+      it "returns a response with the Channel's ID" do
+        response = subject.channels_info(channel_id)
+
+        expect(response['channel']['id']).to eq(channel_id)
+      end
+    end
+
+    describe "with a Slack error" do
+      let(:http_response) do
+        MultiJson.dump({
+          ok: false,
+          error: 'channel_not_found'
+        })
+      end
+
+      it "raises a RuntimeError" do
+        expect { subject.channels_info(channel_id) }.to raise_error(
+          "Slack API call to channels.info returned an error: channel_not_found."
+        )
+      end
+    end
+
+    describe "with an HTTP error" do
+      let(:http_status) { 422 }
+      let(:http_response) { '' }
+
+      it "raises a RuntimeError" do
+        expect { subject.channels_info(channel_id) }.to raise_error(
+          "Slack API call to channels.info failed with status code 422: ''. Headers: {}"
+        )
+      end
+    end
+  end
+
+  describe "#channels_list" do
+    let(:channel_id) { 'C024BE91L' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('https://slack.com/api/channels.list', token: token) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+
+    describe "with a successful response" do
+      let(:http_response) do
+        MultiJson.dump({
+            ok: true,
+            channel: [{
+                id: 'C024BE91L'
+            }]
+        })
+      end
+
+      it "returns a response with the Channel's ID" do
+        response = subject.channels_list
+
+        expect(response['channel'].first['id']).to eq(channel_id)
+      end
+    end
+
+    describe "with a Slack error" do
+      let(:http_response) do
+        MultiJson.dump({
+          ok: false,
+          error: 'invalid_auth'
+        })
+      end
+
+      it "raises a RuntimeError" do
+        expect { subject.channels_list }.to raise_error(
+          "Slack API call to channels.list returned an error: invalid_auth."
+        )
+      end
+    end
+
+    describe "with an HTTP error" do
+      let(:http_status) { 422 }
+      let(:http_response) { '' }
+
+      it "raises a RuntimeError" do
+        expect { subject.channels_list }.to raise_error(
+          "Slack API call to channels.list failed with status code 422: ''. Headers: {}"
+        )
+      end
+    end
+  end
+
+  describe "#groups_list" do
+    let(:channel_id) { 'G024BE91L' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('https://slack.com/api/groups.list', token: token) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+
+    describe "with a successful response" do
+      let(:http_response) do
+        MultiJson.dump({
+            ok: true,
+            groups: [{
+                id: 'G024BE91L'
+            }]
+        })
+      end
+
+      it "returns a response with groupss Channel ID's" do
+        response = subject.groups_list
+
+        expect(response['groups'].first['id']).to eq(channel_id)
+      end
+    end
+
+    describe "with a Slack error" do
+      let(:http_response) do
+        MultiJson.dump({
+          ok: false,
+          error: 'invalid_auth'
+        })
+      end
+
+      it "raises a RuntimeError" do
+        expect { subject.groups_list }.to raise_error(
+          "Slack API call to groups.list returned an error: invalid_auth."
+        )
+      end
+    end
+
+    describe "with an HTTP error" do
+      let(:http_status) { 422 }
+      let(:http_response) { '' }
+
+      it "raises a RuntimeError" do
+        expect { subject.groups_list }.to raise_error(
+          "Slack API call to groups.list failed with status code 422: ''. Headers: {}"
+        )
+      end
+    end
+  end
+
+  describe "#mpim_list" do
+    let(:channel_id) { 'G024BE91L' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('https://slack.com/api/mpim.list', token: token) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+
+    describe "with a successful response" do
+      let(:http_response) do
+        MultiJson.dump({
+            ok: true,
+            groups: [{
+                id: 'G024BE91L'
+            }]
+        })
+      end
+
+      it "returns a response with MPIMs Channel ID's" do
+        response = subject.mpim_list
+
+        expect(response['groups'].first['id']).to eq(channel_id)
+      end
+    end
+
+    describe "with a Slack error" do
+      let(:http_response) do
+        MultiJson.dump({
+          ok: false,
+          error: 'invalid_auth'
+        })
+      end
+
+      it "raises a RuntimeError" do
+        expect { subject.mpim_list }.to raise_error(
+          "Slack API call to mpim.list returned an error: invalid_auth."
+        )
+      end
+    end
+
+    describe "with an HTTP error" do
+      let(:http_status) { 422 }
+      let(:http_response) { '' }
+
+      it "raises a RuntimeError" do
+        expect { subject.mpim_list }.to raise_error(
+          "Slack API call to mpim.list failed with status code 422: ''. Headers: {}"
+        )
+      end
+    end
+  end
+
+   describe "#im_list" do
+    let(:channel_id) { 'D024BFF1M' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('https://slack.com/api/im.list', token: token) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+
+    describe "with a successful response" do
+      let(:http_response) do
+        MultiJson.dump({
+            ok: true,
+            ims: [{
+                id: 'D024BFF1M'
+            }]
+        })
+      end
+
+      it "returns a response with IMs Channel ID's" do
+        response = subject.im_list
+
+        expect(response['ims'].first['id']).to eq(channel_id)
+      end
+    end
+
+    describe "with a Slack error" do
+      let(:http_response) do
+        MultiJson.dump({
+          ok: false,
+          error: 'invalid_auth'
+        })
+      end
+
+      it "raises a RuntimeError" do
+        expect { subject.im_list }.to raise_error(
+          "Slack API call to im.list returned an error: invalid_auth."
+        )
+      end
+    end
+
+    describe "with an HTTP error" do
+      let(:http_status) { 422 }
+      let(:http_response) { '' }
+
+      it "raises a RuntimeError" do
+        expect { subject.im_list }.to raise_error(
+          "Slack API call to im.list failed with status code 422: ''. Headers: {}"
         )
       end
     end
@@ -173,7 +443,137 @@ describe Lita::Adapters::Slack::API do
 
       it "raises a RuntimeError" do
         expect { subject.send_attachments(room, [attachment]) }.to raise_error(
-          "Slack API call to chat.postMessage failed with status code 422."
+          "Slack API call to chat.postMessage failed with status code 422: ''. Headers: {}"
+        )
+      end
+    end
+  end
+
+  describe "#send_messages" do
+    let(:messages) { ["attachment text"] }
+    let(:http_response) { MultiJson.dump({ ok: true }) }
+    let(:room) { "C1234567890" }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post(
+          "https://slack.com/api/chat.postMessage",
+          token: token,
+          as_user: true,
+          channel: room,
+          text: messages.join("\n"),
+        ) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+
+    context "with a simple text attachment" do
+      it "sends the attachment" do
+        response = subject.send_messages(room, messages)
+
+        expect(response['ok']).to be(true)
+      end
+    end
+
+    context "with configuration" do
+      before do
+        allow(config).to receive(:link_names).and_return(true)
+      end
+
+      def stubs(postMessage_options = {})
+        Faraday::Adapter::Test::Stubs.new do |stub|
+          stub.post(
+            "https://slack.com/api/chat.postMessage",
+            token: token,
+            link_names: 1,
+            as_user: true,
+            channel: room,
+            text: messages.join("\n"),
+          ) do
+            [http_status, {}, http_response]
+          end
+        end
+      end
+
+      it "sends the message with configuration" do
+        response = subject.send_messages(room, messages)
+
+        expect(response['ok']).to be(true)
+      end
+    end
+
+    context "with a different fallback message" do
+      let(:attachment) do
+        Lita::Adapters::Slack::Attachment.new(attachment_text, fallback: fallback_text)
+      end
+      let(:fallback_text) { "fallback text" }
+
+      it "sends the attachment" do
+        response = subject.send_messages(room, messages)
+
+        expect(response['ok']).to be(true)
+      end
+    end
+
+    context "with all the valid options" do
+      let(:attachment) do
+        Lita::Adapters::Slack::Attachment.new(attachment_text, common_hash_data)
+      end
+      let(:attachment_hash) do
+        common_hash_data.merge(fallback: attachment_text, text: attachment_text)
+      end
+      let(:common_hash_data) do
+        {
+          author_icon: "http://example.com/author.jpg",
+          author_link: "http://example.com/author",
+          author_name: "author name",
+          color: "#36a64f",
+          fields: [{
+            title: "priority",
+            value: "high",
+            short: true,
+          }, {
+            title: "super long field title",
+            value: "super long field value",
+            short: false,
+          }],
+          image_url: "http://example.com/image.jpg",
+          pretext: "pretext",
+          thumb_url: "http://example.com/thumb.jpg",
+          title: "title",
+          title_link: "http://example.com/title",
+        }
+      end
+
+      it "sends the attachment" do
+        response = subject.send_messages(room, messages)
+
+        expect(response['ok']).to be(true)
+      end
+    end
+
+    context "with a Slack error" do
+      let(:http_response) do
+        MultiJson.dump({
+          ok: false,
+          error: 'invalid_auth'
+        })
+      end
+
+      it "raises a RuntimeError" do
+        expect { subject.send_messages(room, messages) }.to raise_error(
+          "Slack API call to chat.postMessage returned an error: invalid_auth."
+        )
+      end
+    end
+
+    context "with an HTTP error" do
+      let(:http_status) { 422 }
+      let(:http_response) { '' }
+
+      it "raises a RuntimeError" do
+        expect { subject.send_messages(room, messages) }.to raise_error(
+          "Slack API call to chat.postMessage failed with status code 422: ''. Headers: {}"
         )
       end
     end
@@ -231,7 +631,7 @@ describe Lita::Adapters::Slack::API do
 
       it "raises a RuntimeError" do
         expect { subject.set_topic(channel, topic) }.to raise_error(
-          "Slack API call to channels.setTopic failed with status code 422."
+          "Slack API call to channels.setTopic failed with status code 422: ''. Headers: {}"
         )
       end
     end

data/spec/lita/adapters/slack/message_handler_spec.rb

@@ -30,10 +30,11 @@ describe Lita::Adapters::Slack::MessageHandler, lita: true do
           "type" => "message",
           "channel" => "C2147483705",
           "user" => "U023BECGF",
-          "text" => "Hello"
+          "text" => "Hello",
+          "ts" => "1234.5678"
         }
       end
-      let(:message) { instance_double('Lita::Message', command!: false) }
+      let(:message) { instance_double('Lita::Message', command!: false, extensions: {}) }
       let(:source) { instance_double('Lita::Source', private_message?: false) }
       let(:user) { instance_double('Lita::User', id: 'U023BECGF') }
 
@@ -49,8 +50,12 @@ describe Lita::Adapters::Slack::MessageHandler, lita: true do
 
       it "dispatches the message to Lita" do
         expect(robot).to receive(:receive).with(message)
+        subject.handle
+      end
 
+      it "saves the timestamp in extensions" do
         subject.handle
+        expect(message.extensions[:slack][:timestamp]).to eq("1234.5678")
       end
 
       context "when the message is a direct message" do
@@ -468,19 +473,27 @@ describe Lita::Adapters::Slack::MessageHandler, lita: true do
       end
     end
 
-    context "with a message from the robot itself" do
+    context "with a message from slackbot" do
       let(:data) do
         {
           "type" => "message",
-          "subtype" => "bot_message"
+          "user" => "USLACKBOT"
         }
       end
-      let(:user) { instance_double('Lita::User', id: 12345) }
 
-      before do
-        # TODO: This probably shouldn't be tested with stubs.
-        allow(Lita::User).to receive(:find_by_id).and_return(user)
-        allow(Lita::User).to receive(:find_by_name).and_return(user)
+      it "does not dispatch the message to Lita" do
+        expect(robot).not_to receive(:receive)
+
+        subject.handle
+      end
+    end
+
+    context "with a message from the robot itself" do
+      let(:data) do
+        {
+          "type" => "message",
+          "user" => robot_id
+        }
       end
 
       it "does not dispatch the message to Lita" do
@@ -578,6 +591,54 @@ describe Lita::Adapters::Slack::MessageHandler, lita: true do
       end
     end
 
+    context "with a reaction_added message" do
+      let(:data) do
+        {
+          "type" => "reaction_added",
+          "user" => "U023BECGF",
+          "item"=>{"type"=>"message", "channel"=>"C2147483705", "ts"=>"1234567.000008"},
+          "reaction"=>"+1",
+          "event_ts"=>"1234.5678"
+        }
+      end
+      let(:user) { instance_double('Lita::User', id: 'U023BECGF') }
+      let(:payload) { {user: user, name: data["reaction"], item: data["item"], event_ts: data["event_ts"]} }
+
+      before do
+        allow(Lita::User).to receive(:find_by_id).and_return(user)
+        allow(robot).to receive(:trigger).with(:slack_reaction_added, payload)
+      end
+
+      it "triggers the slack_reaction_added event with the correct payload" do
+        expect(robot).to receive(:trigger).with(:slack_reaction_added, payload)
+        subject.handle
+      end
+    end
+
+    context "with a reaction_removed message" do
+      let(:data) do
+        {
+          "type" => "reaction_removed",
+          "user" => "U023BECGF",
+          "item"=>{"type"=>"message", "channel"=>"C2147483705", "ts"=>"1234567.000008"},
+          "reaction"=>"+1",
+          "event_ts"=>"1234.5678"
+        }
+      end
+      let(:user) { instance_double('Lita::User', id: 'U023BECGF') }
+      let(:payload) { {user: user, name: data["reaction"], item: data["item"], event_ts: data["event_ts"]} }
+
+      before do
+        allow(Lita::User).to receive(:find_by_id).and_return(user)
+        allow(robot).to receive(:trigger).with(:slack_reaction_removed, payload)
+      end
+
+      it "triggers the slack_reaction_removed event with the correct payload" do
+        expect(robot).to receive(:trigger).with(:slack_reaction_removed, payload)
+        subject.handle
+      end
+    end
+
     context "with an unknown message" do
       let(:data) { { "type" => "???" } }
 

data/spec/lita/adapters/slack_spec.rb

@@ -27,6 +27,12 @@ describe Lita::Adapters::Slack, lita: true do
     end
   end
 
+  describe "#mention_format" do
+    it "returns the name prefixed with an @" do
+      expect(subject.mention_format("carl")).to eq("@carl")
+    end
+  end
+
   describe "#run" do
     it "starts the RTM connection" do
       expect(rtm_connection).to receive(:run)
@@ -42,6 +48,74 @@ describe Lita::Adapters::Slack, lita: true do
     end
   end
 
+  describe "#roster" do
+    describe "via the Web API, retrieving the roster for a channel" do
+      let(:room_source) { Lita::Source.new(room: 'C024BE91L') }
+      let(:response) do
+        {
+          ok: true,
+          channel: {
+              members: ['C024BE91L']
+          }
+        }
+      end
+      let(:api) { instance_double('Lita::Adapters::Slack::API') }
+
+      before do
+        allow(Lita::Adapters::Slack::API).to receive(:new).with(subject.config).and_return(api)
+      end
+
+      it "returns UID(s)" do
+        expect(subject).to receive(:channel_roster).with(room_source.room_object.id, api)
+
+        subject.roster(room_source.room_object)
+      end
+    end
+
+    describe "via the Web API, retrieving the roster for a group/mpim channel" do
+      let(:room_source) { Lita::Source.new(room: 'G024BE91L') }
+      let(:response) do
+        {
+          ok: true,
+          groups: [{ id: 'G024BE91L' }]
+        }
+      end
+      let(:api) { instance_double('Lita::Adapters::Slack::API') }
+
+      before do
+        allow(Lita::Adapters::Slack::API).to receive(:new).with(subject.config).and_return(api)
+      end
+
+      it "returns UID(s)" do
+        expect(subject).to receive(:group_roster).with(room_source.room_object.id, api).and_return(%q{})
+        expect(subject).to receive(:mpim_roster).with(room_source.room_object.id, api).and_return(%q{G024BE91L})
+
+        subject.roster(room_source.room_object)
+      end
+    end
+
+    describe "via the Web API, retrieving the roster for an im channel" do
+      let(:room_source) { Lita::Source.new(room: 'D024BFF1M') }
+      let(:response) do
+        {
+          ok: true,
+          ims: [{ id: 'D024BFF1M' }]
+        }
+      end
+      let(:api) { instance_double('Lita::Adapters::Slack::API') }
+
+      before do
+        allow(Lita::Adapters::Slack::API).to receive(:new).with(subject.config).and_return(api)
+      end
+
+      it "returns UID" do
+        expect(subject).to receive(:im_roster).with(room_source.room_object.id, api)
+
+        subject.roster(room_source.room_object)
+      end
+    end
+  end
+
   describe "#send_messages" do
     let(:room_source) { Lita::Source.new(room: 'C024BE91L') }
     let(:user) { Lita::User.new('U023BECGF') }
@@ -50,32 +124,19 @@ describe Lita::Adapters::Slack, lita: true do
       Lita::Source.new(room: 'C024BE91L', user: user, private_message: true)
     end
 
-    it "sends messages to rooms" do
-      expect(rtm_connection).to receive(:send_messages).with(room_source.room, ['foo'])
-
-      subject.run
-
-      subject.send_messages(room_source, ['foo'])
-    end
-
-    it "sends messages to users" do
-      allow(rtm_connection).to receive(:im_for).with(user.id).and_return('D024BFF1M')
-
-      expect(rtm_connection).to receive(:send_messages).with('D024BFF1M', ['foo'])
+    describe "via the Web API" do
+      let(:api) { instance_double('Lita::Adapters::Slack::API') }
 
-      subject.run
+      before do
+        allow(Lita::Adapters::Slack::API).to receive(:new).with(subject.config).and_return(api)
+      end
 
-      subject.send_messages(user_source, ['foo'])
-    end
-
-    it "sends messages to users when the source is marked as a private message" do
-      allow(rtm_connection).to receive(:im_for).with(user.id).and_return('D024BFF1M')
-
-      expect(rtm_connection).to receive(:send_messages).with('D024BFF1M', ['foo'])
-
-      subject.run
+      it "does not send via the RTM api" do
+        expect(rtm_connection).to_not receive(:send_messages)
+        expect(api).to receive(:send_messages).with(room_source.room, ['foo'])
 
-      subject.send_messages(private_message_source, ['foo'])
+        subject.send_messages(room_source, ['foo'])
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require "simplecov"
 require "coveralls"
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+SimpleCov.formatters = [
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
 ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lita-slack
 version: !ruby/object:Gem::Version
-  version: 1.7.2
+  version: 1.8.0
 platform: ruby
 authors:
 - Ken J.
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-17 00:00:00.000000000 Z
+date: 2016-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -59,14 +59,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.6.0
+        version: 4.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.6.0
+        version: 4.7.1
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -157,14 +157,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -244,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Lita adapter for Slack.
@@ -262,4 +262,3 @@ test_files:
 - spec/lita/adapters/slack/user_creator_spec.rb
 - spec/lita/adapters/slack_spec.rb
 - spec/spec_helper.rb
-has_rdoc: