lita-slack 0.1.2 → 1.0.0

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

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe Lita::Adapters::Slack::API do
+  subject { described_class.new(token, stubs) }
+
+  let(:http_status) { 200 }
+  let(:token) { 'abcd-1234567890-hWYd21AmMH2UHAkx29vb5c1Y' }
+
+  describe "#im_open" do
+    let(:channel_id) { 'D024BFF1M' }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('https://slack.com/api/im.open', token: token, user: user_id) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+    let(:user_id) { 'U023BECGF' }
+
+    describe "with a successful response" do
+      let(:http_response) do
+        MultiJson.dump({
+            ok: true,
+            channel: {
+                id: 'D024BFF1M'
+            }
+        })
+      end
+
+      it "returns a response with the IM's ID" do
+        response = subject.im_open(user_id)
+
+        expect(response.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_open(user_id) }.to raise_error(
+          "Slack API call to im.open 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_open(user_id) }.to raise_error(
+          "Slack API call to im.open failed with status code 422."
+        )
+      end
+    end
+  end
+
+  describe "#rtm_start" do
+    let(:http_status) { 200 }
+    let(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('https://slack.com/api/rtm.start', token: token) do
+          [http_status, {}, http_response]
+        end
+      end
+    end
+
+    describe "with a successful response" do
+      let(:http_response) do
+        MultiJson.dump({
+          ok: true,
+          url: 'wss://example.com/',
+          users: [{ id: 'U023BECGF' }],
+          ims: [{ id: 'D024BFF1M' }],
+          self: { id: 'U12345678' }
+        })
+      end
+
+      it "has data on the bot user" do
+        response = subject.rtm_start
+
+        expect(response.self.id).to eq('U12345678')
+      end
+
+      it "has an array of IMs" do
+        response = subject.rtm_start
+
+        expect(response.ims[0].id).to eq('D024BFF1M')
+      end
+
+      it "has an array of users" do
+        response = subject.rtm_start
+
+        expect(response.users[0].id).to eq('U023BECGF')
+      end
+
+      it "has a WebSocket URL" do
+        response = subject.rtm_start
+
+        expect(response.websocket_url).to eq('wss://example.com/')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Lita::Adapters::Slack::IMMapping do
+  subject { described_class.new(api, ims) }
+
+  let(:api) { instance_double('Lita::Adapters::Slack::API') }
+  let(:im) { Lita::Adapters::Slack::SlackIM.new('D1234567890', 'U023BECGF') }
+
+  describe "#im_for" do
+    context "when a mapping is already stored" do
+      let(:ims) { [im] }
+
+      it "returns the IM ID for the given user ID" do
+        expect(subject.im_for('U023BECGF')).to eq('D1234567890')
+      end
+    end
+
+    context "when a mapping is not yet stored" do
+      before do
+        allow(api).to receive(:im_open).with('U023BECGF').and_return(im).once
+      end
+
+      let(:ims) { [] }
+
+      it "fetches the IM ID from the API and returns it" do
+        expect(subject.im_for('U023BECGF')).to eq('D1234567890')
+      end
+
+      it "doesn't hit the API on subsequent look ups of the same user ID" do
+        expect(subject.im_for('U023BECGF')).to eq(subject.im_for('U023BECGF'))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+require "spec_helper"
+
+describe Lita::Adapters::Slack::MessageHandler, lita: true do
+  subject { described_class.new(robot, robot_id, data) }
+
+  let(:robot) { instance_double('Lita::Robot', name: 'Lita', mention_name: 'lita') }
+  let(:robot_id) { 'U12345678' }
+
+  describe "#handle" do
+    context "with a hello message" do
+      let(:data) { { "type" => "hello" } }
+
+      it "triggers a connected event" do
+        expect(robot).to receive(:trigger).with(:connected)
+
+        subject.handle
+      end
+    end
+
+    context "with a normal message" do
+      let(:data) do
+        {
+          "type" => "message",
+          "channel" => "C2147483705",
+          "user" => "U023BECGF",
+          "text" => "Hello"
+        }
+      end
+      let(:message) { instance_double('Lita::Message') }
+      let(:source) { instance_double('Lita::Source') }
+      let(:user) { instance_double('Lita::User', id: 'U023BECGF') }
+
+      before do
+        allow(Lita::User).to receive(:find_by_id).and_return(user)
+        allow(Lita::Source).to receive(:new).with(
+          user: user,
+          room: "C2147483705"
+        ).and_return(source)
+        allow(Lita::Message).to receive(:new).with(robot, "Hello", source).and_return(message)
+        allow(robot).to receive(:receive).with(message)
+      end
+
+      it "dispatches the message to Lita" do
+        expect(robot).to receive(:receive).with(message)
+
+        subject.handle
+      end
+
+      context "when the message starts with a Slack-style @-mention" do
+        let(:data) do
+          {
+            "type" => "message",
+            "channel" => "C2147483705",
+            "user" => "U023BECGF",
+            "text" => "<@#{robot_id}>: Hello"
+          }
+        end
+
+        it "converts it to a Lita-style @-mention" do
+          expect(Lita::Message).to receive(:new).with(
+            robot,
+            "@lita: Hello",
+            source
+          ).and_return(message)
+
+          subject.handle
+        end
+      end
+    end
+
+    context "with a message with an unsupported subtype" do
+      let(:data) do
+        {
+          "type" => "message",
+          "subtype" => "???"
+        }
+      end
+
+      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",
+          "subtype" => "bot_message"
+        }
+      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)
+      end
+
+      it "does not dispatch the message to Lita" do
+        expect(robot).not_to receive(:receive)
+
+        subject.handle
+      end
+    end
+
+    context "with a team join message" do
+      let(:data) do
+        {
+          "type" => "team_join",
+          "user" => "some user data"
+        }
+      end
+
+      it "creates the new user" do
+        expect(
+          Lita::Adapters::Slack::UserCreator
+        ).to receive(:create_user) do |user_data, robot, robot_id|
+          expect(user_data).to eq("some user data")
+        end
+
+        subject.handle
+      end
+    end
+
+    context "with a bot added message" do
+      let(:data) do
+        {
+          "type" => "bot_added",
+          "bot" => "some user data"
+        }
+      end
+
+      it "creates a new user for the bot" do
+        expect(
+          Lita::Adapters::Slack::UserCreator
+        ).to receive(:create_user) do |user_data, robot, robot_id|
+          expect(user_data).to eq("some user data")
+        end
+
+        subject.handle
+      end
+    end
+
+    context "with an error message" do
+      let(:data) do
+        {
+          "type" => "error",
+          "error" => {
+            "code" => 2,
+            "msg" => "message text is missing"
+          }
+        }
+      end
+
+      it "logs the error" do
+        expect(Lita.logger).to receive(:error).with(
+          "Error with code 2 received from Slack: message text is missing"
+        )
+
+        subject.handle
+      end
+    end
+
+    context "with an unknown message" do
+      let(:data) { { "type" => "???" } }
+
+      it "logs the type" do
+        expect(Lita.logger).to receive(:debug).with(
+          "??? event received from Slack and will be ignored."
+        )
+
+        subject.handle
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Lita::Adapters::Slack::RTMConnection, lita: true do
+  def with_websocket(subject, queue)
+    thread = Thread.new { subject.run(queue) }
+    thread.abort_on_exception = true
+    yield queue.pop
+    subject.shut_down
+    thread.join
+  end
+
+  subject { described_class.new(robot, token, rtm_start_response) }
+
+  let(:api) { instance_double("Lita::Adapters::Slack::API") }
+  let(:registry) { Lita::Registry.new }
+  let(:robot) { Lita::Robot.new(registry) }
+  let(:rtm_start_response) do
+    Lita::Adapters::Slack::TeamData.new(
+      [],
+      Lita::Adapters::Slack::SlackUser.new('U12345678', 'carl', nil),
+      [Lita::Adapters::Slack::SlackUser.new('U12345678', 'carl', '')],
+      "wss://example.com/"
+    )
+  end
+  let(:token) { 'abcd-1234567890-hWYd21AmMH2UHAkx29vb5c1Y' }
+  let(:queue) { Queue.new }
+
+  describe ".build" do
+    before do
+      allow(Lita::Adapters::Slack::API).to receive(:new).with(token).and_return(api)
+      allow(api).to receive(:rtm_start).and_return(rtm_start_response)
+    end
+
+    it "constructs a new RTMConnection with the results of rtm.start data" do
+      expect(described_class.build(robot, token)).to be_an_instance_of(described_class)
+    end
+
+    it "creates users with the results of rtm.start data" do
+      expect(Lita::Adapters::Slack::UserCreator).to receive(:create_users)
+
+      described_class.build(robot, token)
+    end
+  end
+
+  describe "#im_for" do
+    before do
+      allow(Lita::Adapters::Slack::IMMapping).to receive(:new).and_return(im_mapping)
+      allow(im_mapping).to receive(:im_for).with('U12345678').and_return('D024BFF1M')
+    end
+
+    let(:im_mapping) { instance_double('Lita::Adapters::Slack::IMMapping') }
+
+    it "delegates to the IMMapping" do
+      with_websocket(subject, queue) do |websocket|
+        expect(subject.im_for('U12345678')).to eq('D024BFF1M')
+      end
+    end
+  end
+
+  describe "#run" do
+    it "starts the reactor" do
+      with_websocket(subject, queue) do |websocket|
+        expect(EM.reactor_running?).to be_truthy
+      end
+    end
+
+    it "creates the WebSocket" do
+      with_websocket(subject, queue) do |websocket|
+        expect(websocket).to be_an_instance_of(Faye::WebSocket::Client)
+      end
+    end
+  end
+
+  describe "#send_messages" do
+    let(:message_json) { MultiJson.dump(id: 1, type: 'message', text: 'hi', channel: channel_id) }
+    let(:channel_id) { 'C024BE91L' }
+    let(:websocket) { instance_double("Faye::WebSocket::Client") }
+
+    before do
+      # TODO: Don't stub what you don't own!
+      allow(Faye::WebSocket::Client).to receive(:new).and_return(websocket)
+      allow(websocket).to receive(:on)
+      allow(websocket).to receive(:close)
+    end
+
+    it "writes messages to the WebSocket" do
+      with_websocket(subject, queue) do |websocket|
+        expect(websocket).to receive(:send).with(message_json)
+
+        subject.send_messages(channel_id, ['hi'])
+      end
+    end
+
+    it "raises an ArgumentError if the payload is too large" do
+      with_websocket(subject, queue) do |websocket|
+        expect do
+          subject.send_messages(channel_id, ['x' * 16_001])
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Lita::Adapters::Slack::SlackIM do
+  let(:im_data_1) do
+    {
+      "id" => "D024BFF1M",
+      "is_im" => true,
+      "user" => "U024BE7LH",
+      "created" => 1360782804,
+    }
+  end
+  let(:im_data_2) do
+    {
+      "id" => "D012ABC3E",
+      "is_im" => true,
+      "user" => "U098ZYX7W",
+      "created" => 1360782904,
+    }
+  end
+  let(:ims_data) { [im_data_1, im_data_2] }
+
+  describe ".from_data_array" do
+    subject { described_class.from_data_array(ims_data) }
+
+    it "returns an object for each hash of IM data" do
+      expect(subject.size).to eq(2)
+    end
+
+    it "creates SlackIM objects" do
+      expect(subject[0].id).to eq('D024BFF1M')
+      expect(subject[0].user_id).to eq('U024BE7LH')
+      expect(subject[1].id).to eq('D012ABC3E')
+      expect(subject[1].user_id).to eq('U098ZYX7W')
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Lita::Adapters::Slack::SlackUser do
+  let(:user_data_1) do
+    {
+      "id" => "U023BECGF",
+      "name" => "bobby",
+      "real_name" => "Bobby Tables"
+    }
+  end
+  let(:user_data_2) do
+    {
+      "id" => "U024BE7LH",
+      "name" => "carl",
+    }
+  end
+  let(:users_data) { [user_data_1, user_data_2] }
+
+  describe ".from_data_array" do
+    subject { described_class.from_data_array(users_data) }
+
+    it "returns an object for each hash of user data" do
+      expect(subject.size).to eq(2)
+    end
+
+    it "creates SlackUser objects" do
+      expect(subject[0].id).to eq('U023BECGF')
+      expect(subject[0].name).to eq('bobby')
+      expect(subject[0].real_name).to eq('Bobby Tables')
+      expect(subject[1].id).to eq('U024BE7LH')
+      expect(subject[1].name).to eq('carl')
+      expect(subject[1].real_name).to be_nil
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Lita::Adapters::Slack::UserCreator do
+  before { allow(Lita::User).to receive(:create) }
+
+  let(:robot) { instance_double('Lita::Robot') }
+
+  describe ".create_users" do
+    let(:real_name) { 'Bobby Tables' }
+    let(:bobby) { Lita::Adapters::Slack::SlackUser.new('U023BECGF', 'bobby', real_name) }
+    let(:robot_id) { 'U12345678' }
+
+    it "creates Lita users for each user in the provided data" do
+      expect(Lita::User).to receive(:create).with(
+        'U023BECGF',
+        name: 'Bobby Tables',
+        mention_name: 'bobby'
+      )
+
+      described_class.create_users([bobby], robot, robot_id)
+    end
+
+    context "when the Slack user has no real name set" do
+      let(:real_name) { "" }
+
+      it "uses the mention name if no real name is available" do
+        expect(Lita::User).to receive(:create).with(
+          'U023BECGF',
+          name: 'bobby',
+          mention_name: 'bobby'
+        )
+
+        described_class.create_users([bobby], robot, robot_id)
+      end
+    end
+  end
+
+  describe ".create_user" do
+    let(:robot_id) { 'U12345678' }
+    let(:slack_user) { Lita::Adapters::Slack::SlackUser.new(robot_id, 'litabot', 'Lita Bot') }
+
+    it "updates the robot's name and mention name if it applicable" do
+      expect(robot).to receive(:name=).with('Lita Bot')
+      expect(robot).to receive(:mention_name=).with('litabot')
+
+      described_class.create_user(slack_user, robot, robot_id)
+    end
+  end
+end

data/spec/lita/adapters/slack_spec.rb

@@ -1,53 +1,86 @@
 require "spec_helper"
 
 describe Lita::Adapters::Slack, lita: true do
-	before do
-		Lita.configure do |config|
-			config.adapter.incoming_token = 'aN1NvAlIdDuMmYt0k3n'
-			config.adapter.team_domain = 'example'
-			config.adapter.username = 'lita'
-			config.adapter.add_mention = true
-		end
-	end
-
-	subject { described_class.new(robot) }
-	let(:robot) { double("Lita::Robot") }
-
-	it "registers with Lita" do
-		expect(Lita.adapters[:slack]).to eql(described_class)
-	end
-
-	it "fails without valid config: incoming_token and team_domain" do
-		Lita.clear_config
-		expect(Lita.logger).to receive(:fatal).with(/incoming_token, team_domain/)
-		expect { subject }.to raise_error(SystemExit)
-	end
-
-	describe "#send_messages" do
-		it "sends JSON payload via HTTP POST to Slack channel" do
-			target = double("Lita::Source", room: "CR00M1D")
-			payload = {'channel' => target.room, 'username' => Lita.config.adapter.username, 'text' => 'Hello!'}
-			expect(subject).to receive(:http_post).with(payload)
-			subject.send_messages(target, ["Hello!"])
-		end
-
-		it "sends message with mention if user info is provided" do
-			user = double("Lita::User", id: "UM3NT10N")
-			target = double("Lita::Source", room: "CR00M1D", user: user)
-			text = "<@#{user.id}> Hello!"
-			payload = {'channel' => target.room, 'username' => Lita.config.adapter.username, 'text' => text}
-			expect(subject).to receive(:http_post).with(payload)
-			subject.send_messages(target, ["Hello!"])
-		end
-
-		it "proceeds but logs WARN when directed to an user without channel(room) info" do
-			user = double("Lita::User", id: "UM3NT10N")
-			target = double("Lita::Source", user: user)
-			text = "<@#{user.id}> Hello!"
-			payload = {'channel' => nil, 'username' => Lita.config.adapter.username, 'text' => text}
-			expect(subject).to receive(:http_post).with(payload)
-			expect(Lita.logger).to receive(:warn).with(/without channel/)
-			subject.send_messages(target, ["Hello!"])
-		end
-	end
+  subject { described_class.new(robot) }
+
+  let(:robot) { Lita::Robot.new(registry) }
+  let(:rtm_connection) { instance_double('Lita::Adapters::Slack::RTMConnection') }
+  let(:token) { 'abcd-1234567890-hWYd21AmMH2UHAkx29vb5c1Y' }
+
+  before do
+    registry.register_adapter(:slack, described_class)
+    registry.config.adapters.slack.token = token
+
+    allow(
+      described_class::RTMConnection
+    ).to receive(:build).with(robot, token).and_return(rtm_connection)
+    allow(rtm_connection).to receive(:run)
+  end
+
+  it "registers with Lita" do
+    expect(Lita.adapters[:slack]).to eql(described_class)
+  end
+
+  describe "#run" do
+    it "starts the RTM connection" do
+      expect(rtm_connection).to receive(:run)
+
+      subject.run
+    end
+
+    it "does nothing if the RTM connection is already created" do
+      expect(rtm_connection).to receive(:run).once
+
+      subject.run
+      subject.run
+    end
+  end
+
+  describe "#send_messages" do
+    let(:room_source) { Lita::Source.new(room: 'C024BE91L') }
+    let(:user) { Lita::User.new('U023BECGF') }
+    let(:user_source) { Lita::Source.new(user: user) }
+
+    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'])
+
+      subject.run
+
+      subject.send_messages(Lita::Source.new(user: user), ['foo'])
+    end
+  end
+
+  describe "#shut_down" do
+    before { allow(rtm_connection).to receive(:shut_down) }
+
+    it "shuts down the RTM connection" do
+      expect(rtm_connection).to receive(:shut_down)
+
+      subject.run
+      subject.shut_down
+    end
+
+    it "triggers a :disconnected event" do
+      expect(robot).to receive(:trigger).with(:disconnected)
+
+      subject.run
+      subject.shut_down
+    end
+
+    it "does nothing if the RTM connection hasn't been created yet" do
+      expect(rtm_connection).not_to receive(:shut_down)
+
+      subject.shut_down
+    end
+  end
 end