Updated connect procedure

lib/lita-slack.rb

@@ -4,4 +4,4 @@
   File.join("..", "..", "locales", "*.yml"), __FILE__
 )]
 
-require "lita/adapters/slack"
+require_relative "lita/adapters/slack"

lib/lita/adapters/slack.rb

@@ -1,5 +1,5 @@
-require 'lita/adapters/slack/chat_service'
-require 'lita/adapters/slack/rtm_connection'
+require_relative 'slack/chat_service'
+require_relative 'slack/rtm_connection'
 
 module Lita
   module Adapters
@@ -40,7 +40,7 @@ def roster(target)
 
       def send_messages(target, strings)
         api = API.new(config)
-        api.send_messages(channel_for(target), strings)
+        api.send_messages(target.room, strings)
       end
 
       def set_topic(target, topic)
@@ -60,14 +60,6 @@ def shut_down
 
       attr_reader :rtm_connection
 
-      def channel_for(target)
-        if target.private_message?
-          rtm_connection.im_for(target.user.id)
-        else
-          target.room
-        end
-      end
-
       def channel_roster(room_id, api)
         response = api.channels_info room_id
         response['channel']['members']

lib/lita/adapters/slack/api.rb

@@ -1,9 +1,9 @@
 require 'faraday'
 
-require 'lita/adapters/slack/team_data'
-require 'lita/adapters/slack/slack_im'
-require 'lita/adapters/slack/slack_user'
-require 'lita/adapters/slack/slack_channel'
+require_relative 'team_data'
+require_relative 'slack_im'
+require_relative 'slack_user'
+require_relative 'slack_channel'
 
 module Lita
   module Adapters
@@ -69,15 +69,16 @@ def set_topic(channel, topic)
           call_api("channels.setTopic", channel: channel, topic: topic)
         end
 
-        def rtm_start
-          response_data = call_api("rtm.start")
+        def rtm_connect
+          response_data = call_api("rtm.connect")
+
+          raise RuntimeError, response_data["error"] if response_data["ok"] != true
 
           TeamData.new(
-            SlackIM.from_data_array(response_data["ims"]),
+            response_data["team"]["id"],
+            response_data["team"]["name"],
+            response_data["team"]["domain"],
             SlackUser.from_data(response_data["self"]),
-            SlackUser.from_data_array(response_data["users"]),
-            SlackChannel.from_data_array(response_data["channels"]) +
-              SlackChannel.from_data_array(response_data["groups"]),
             response_data["url"],
           )
         end

lib/lita/adapters/slack/chat_service.rb

@@ -1,4 +1,4 @@
-require "lita/adapters/slack/attachment"
+require_relative "attachment"
 
 module Lita
   module Adapters

lib/lita/adapters/slack/rtm_connection.rb

@@ -1,12 +1,12 @@
 require 'faye/websocket'
 require 'multi_json'
 
-require 'lita/adapters/slack/api'
-require 'lita/adapters/slack/event_loop'
-require 'lita/adapters/slack/im_mapping'
-require 'lita/adapters/slack/message_handler'
-require 'lita/adapters/slack/room_creator'
-require 'lita/adapters/slack/user_creator'
+require_relative 'api'
+require_relative 'event_loop'
+require_relative 'im_mapping'
+require_relative 'message_handler'
+require_relative 'room_creator'
+require_relative 'user_creator'
 
 module Lita
   module Adapters
@@ -17,23 +17,15 @@ class RTMConnection
 
         class << self
           def build(robot, config)
-            new(robot, config, API.new(config).rtm_start)
+            new(robot, config, API.new(config).rtm_connect)
           end
         end
 
         def initialize(robot, config, team_data)
           @robot = robot
           @config = config
-          @im_mapping = IMMapping.new(API.new(config), team_data.ims)
           @websocket_url = team_data.websocket_url
           @robot_id = team_data.self.id
-
-          UserCreator.create_users(team_data.users, robot, robot_id)
-          RoomCreator.create_rooms(team_data.channels, robot)
-        end
-
-        def im_for(user_id)
-          im_mapping.im_for(user_id)
         end
 
         def run(queue = nil, options = {})

lib/lita/adapters/slack/team_data.rb

@@ -2,7 +2,7 @@ module Lita
   module Adapters
     # @api private
     class Slack < Adapter
-      TeamData = Struct.new(:ims, :self, :users, :channels, :websocket_url)
+      TeamData = Struct.new(:id, :name, :domain, :self, :websocket_url)
     end
   end
 end

spec/lita/adapters/slack/api_spec.rb

@@ -637,11 +637,11 @@ def stubs(postMessage_options = {})
     end
   end
 
-  describe "#rtm_start" do
+  describe "#rtm_connect" 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
+        stub.post('https://slack.com/api/rtm.connect', token: token) do
           [http_status, {}, http_response]
         end
       end
@@ -652,34 +652,19 @@ def stubs(postMessage_options = {})
         MultiJson.dump({
           ok: true,
           url: 'wss://example.com/',
-          users: [{ id: 'U023BECGF' }],
-          ims: [{ id: 'D024BFF1M' }],
           self: { id: 'U12345678' },
-          channels: [{ id: 'C1234567890' }],
-          groups: [{ id: 'G0987654321' }],
+          team: { id: 'T0987654321' },
         })
       end
 
       it "has data on the bot user" do
-        response = subject.rtm_start
+        response = subject.rtm_connect
 
         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
+        response = subject.rtm_connect
 
         expect(response.websocket_url).to eq('wss://example.com/')
       end

spec/lita/adapters/slack/rtm_connection_spec.rb

@@ -9,21 +9,18 @@ def with_websocket(subject, queue)
     thread.join
   end
 
-  subject { described_class.new(robot, config, rtm_start_response) }
+  subject { described_class.new(robot, config, rtm_connect_response) }
 
   let(:api) { instance_double("Lita::Adapters::Slack::API") }
   let(:registry) { Lita::Registry.new }
   let(:robot) { Lita::Robot.new(registry) }
-  let(:raw_user_data) { Hash.new }
-  let(:channel) { Lita::Adapters::Slack::SlackChannel.new('C2147483705', 'general', 1360782804, 'U023BECGF', metadata) }
-  let(:metadata) { Hash.new }
 
-  let(:rtm_start_response) do
+  let(:rtm_connect_response) do
     Lita::Adapters::Slack::TeamData.new(
-      [],
-      Lita::Adapters::Slack::SlackUser.new('U12345678', 'carl', nil, raw_user_data),
-      [Lita::Adapters::Slack::SlackUser.new('U12345678', 'carl', '', raw_user_data)],
-      [channel],
+      'T2U81E2FP',
+      'SlackDemo',
+      'slackdemo',
+      Lita::Adapters::Slack::SlackUser.new('U12345678', 'carl', nil, {}),
       "wss://example.com/"
     )
   end
@@ -39,42 +36,12 @@ def with_websocket(subject, queue)
   describe ".build" do
     before do
       allow(Lita::Adapters::Slack::API).to receive(:new).with(config).and_return(api)
-      allow(api).to receive(:rtm_start).and_return(rtm_start_response)
+      allow(api).to receive(:rtm_connect).and_return(rtm_connect_response)
     end
 
-    it "constructs a new RTMConnection with the results of rtm.start data" do
+    it "constructs a new RTMConnection with the results of rtm.connect data" do
       expect(described_class.build(robot, config)).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, config)
-    end
-
-    it "creates rooms with the results of rtm.start data" do
-      expect(Lita::Adapters::Slack::RoomCreator).to receive(:create_rooms)
-
-      described_class.build(robot, config)
-    end
-  end
-
-  describe "#im_for" do
-    before do
-      allow(Lita::Adapters::Slack::API).to receive(:new).with(config).and_return(api)
-      allow(
-        Lita::Adapters::Slack::IMMapping
-      ).to receive(:new).with(api, []).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
@@ -118,6 +85,7 @@ def with_websocket(subject, queue)
     context "when the WebSocket is closed from outside" do
       it "shuts down the reactor" do
         with_websocket(subject, queue) do |websocket|
+            sleep 0.1 # Since this code is run in a thread, we need to wait for it to finish
             websocket.close
             expect(EM.stopping?).to be_truthy
           end