slack-ruby-client 1.1.0 → 2.0.0

data/spec/slack/real_time/event_handlers/{channel_spec.rb → public_channel_spec.rb}

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' } do
+RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_connect' } do
   include_context 'connected client'
+  include_context 'loaded client'
 
-  context 'channel' do
-    it 'sets channel data' do
-      expect(client.channels.count).to eq 156
-    end
+  context 'public channel' do
     it 'channel_archive' do
-      channel = client.channels['C0HNTD0CW']
+      channel = client.public_channels['C0HNTD0CW']
       expect(channel.is_archived).to be false
       event = Slack::RealTime::Event.new(
         'type' => 'channel_archive',
@@ -19,36 +17,39 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       client.send(:dispatch, event)
       expect(channel.is_archived).to be true
     end
+
     it 'channel_created' do
-      expect(client.channels['C024BE91L']).to be_nil
+      expect(client.public_channels['C024BE91L']).to be_nil
       event = Slack::RealTime::Event.new(
         'type' => 'channel_created',
         'channel' => {
           'id' => 'C024BE91L',
           'name' => 'fun',
-          'created' => 1_360_782_804,
+          'created' => 1360782804,
           'creator' => 'U04KB5WQR'
         }
       )
       client.send(:dispatch, event)
-      channel = client.channels['C024BE91L']
+      channel = client.public_channels['C024BE91L']
       expect(channel).not_to be_nil
       expect(channel.name).to eq 'fun'
       expect(channel.creator).to eq 'U04KB5WQR'
-      expect(channel.created).to eq 1_360_782_804
+      expect(channel.created).to eq 1360782804
     end
+
     it 'channel_deleted' do
-      expect(client.channels['C0HLE0BBL']).not_to be_nil
+      expect(client.public_channels['C0HLE0BBL']).not_to be_nil
       event = Slack::RealTime::Event.new(
         'type' => 'channel_deleted',
         'channel' => 'C0HLE0BBL'
       )
       client.send(:dispatch, event)
-      expect(client.channels['C0HLE0BBL']).to be_nil
+      expect(client.public_channels['C0HLE0BBL']).to be_nil
     end
+
     context 'channel_joined' do
       it 'creates channel' do
-        expect(client.channels['CDEADBEEF']).to be_nil
+        expect(client.public_channels['CDEADBEEF']).to be_nil
         event = Slack::RealTime::Event.new(
           'type' => 'channel_joined',
           'channel' => {
@@ -57,13 +58,14 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
           }
         )
         client.send(:dispatch, event)
-        channel = client.channels['CDEADBEEF']
+        channel = client.public_channels['CDEADBEEF']
         expect(channel).not_to be_nil
         expect(channel.name).to eq 'beef'
       end
+
       it 'updates channel' do
-        expect(client.channels['CDEADBEEF']).to be_nil
-        client.channels['CDEADBEEF'] =
+        expect(client.public_channels['CDEADBEEF']).to be_nil
+        client.public_channels['CDEADBEEF'] =
           Slack::RealTime::Models::Channel.new('id' => 'CDEADBEEF', name: 'beef')
         event = Slack::RealTime::Event.new(
           'type' => 'channel_joined',
@@ -74,14 +76,14 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
           }
         )
         client.send(:dispatch, event)
-        channel = client.channels['CDEADBEEF']
+        channel = client.public_channels['CDEADBEEF']
         expect(channel).not_to be_nil
         expect(channel.updated).to be true
       end
     end
 
     it 'channel_left' do
-      channel = client.channels['C0JHNAB5H']
+      channel = client.public_channels['C0JHNAB5H']
       expect(channel.members).to include client.self.id
       event = Slack::RealTime::Event.new(
         'type' => 'channel_left',
@@ -90,8 +92,9 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       client.send(:dispatch, event)
       expect(channel.members).not_to include client.self.id
     end
+
     it 'channel_rename' do
-      channel = client.channels['C0HLE0BBL']
+      channel = client.public_channels['C0HLE0BBL']
       expect(channel.name).to eq 'gifs'
       event = Slack::RealTime::Event.new(
         'type' => 'channel_rename',
@@ -104,8 +107,9 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       client.send(:dispatch, event)
       expect(channel.name).to eq 'updated'
     end
+
     it 'channel_unarchive' do
-      channel = client.channels['C0HLE0BBL']
+      channel = client.public_channels['C0HLE0BBL']
       expect(channel.is_archived).to be true
       event = Slack::RealTime::Event.new(
         'type' => 'channel_unarchive',

data/spec/slack/real_time/event_handlers/team_spec.rb

@@ -2,20 +2,15 @@
 require 'spec_helper'
 
 [Slack::RealTime::Stores::Store, Slack::RealTime::Stores::Starter].each do |store_class|
-  cassette = store_class == Slack::RealTime::Stores::Store ? 'web/rtm_start' : 'web/rtm_connect'
-  RSpec.describe store_class, vcr: { cassette_name: cassette } do
+  RSpec.describe store_class, vcr: { cassette_name: 'web/rtm_connect' } do
     include_context 'connected client', store_class: store_class
 
     context 'team' do
-      it 'sets team data on rtm.start' do
+      it 'sets team data on rtm.connect' do
         expect(client.team.name).to eq 'dblock'
         expect(client.team.domain).to eq 'dblockdotorg'
-        if store_class == Slack::RealTime::Stores::Store
-          expect(client.team.email_domain).to eq 'dblock.org'
-          expect(client.team.prefs.invites_only_admins).to be true
-          expect(client.team.plan).to eq ''
-        end
       end
+
       it 'team_domain_change' do
         event = Slack::RealTime::Event.new(
           'type' => 'team_domain_change',
@@ -26,6 +21,7 @@ require 'spec_helper'
         expect(client.team.domain).to eq 'my'
         expect(client.team['url']).to eq 'https://my.slack.com'
       end
+
       it 'email_domain_changed' do
         event = Slack::RealTime::Event.new(
           'type' => 'email_domain_changed',
@@ -34,6 +30,7 @@ require 'spec_helper'
         client.send(:dispatch, event)
         expect(client.team.email_domain).to eq 'example.com'
       end
+
       it 'team_pref_change' do
         event = Slack::RealTime::Event.new(
           'type' => 'team_pref_change',
@@ -43,6 +40,7 @@ require 'spec_helper'
         client.send(:dispatch, event)
         expect(client.team.prefs.invites_only_admins).to be false
       end
+
       it 'team_rename' do
         event = Slack::RealTime::Event.new(
           'type' => 'team_rename',
@@ -51,6 +49,7 @@ require 'spec_helper'
         client.send(:dispatch, event)
         expect(client.team.name).to eq 'New Team Name Inc.'
       end
+
       it 'team_plan_change' do
         event = Slack::RealTime::Event.new(
           'type' => 'team_plan_change',

data/spec/slack/real_time/event_handlers/user_spec.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' } do
+RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_connect' } do
   include_context 'connected client'
+  include_context 'loaded client'
 
   context 'user' do
-    it 'combines user and self data on rtm.start' do
-      expect(client.users['U0J1GAHN1'].name).to eq 'travis-ci'
-      expect(client.users['U0J1GAHN1']['prefs']['push_sound']).to eq 'b2.mp3'
-    end
     it 'user_change' do
       expect(client.users['U07KECJ77'].name).to eq 'aws'
       event = Slack::RealTime::Event.new(
@@ -20,6 +17,7 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       client.send(:dispatch, event)
       expect(client.users['U07KECJ77'].name).to eq 'renamed'
     end
+
     it 'team_join' do
       expect do
         event = Slack::RealTime::Event.new(
@@ -32,6 +30,7 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       end.to change(client.users, :count).by(1)
       expect(client.users['DEADBEEF'].name).to eq 'added'
     end
+
     it 'pref_change' do
       event = Slack::RealTime::Event.new(
         'type' => 'pref_change',
@@ -41,6 +40,7 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       client.send(:dispatch, event)
       expect(client.self.prefs['push_sound']).to eq 'updated.mp3'
     end
+
     it 'presence_change' do
       expect(client.users['U07KECJ77'].presence).to eq 'away'
       event = Slack::RealTime::Event.new(
@@ -51,6 +51,7 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       client.send(:dispatch, event)
       expect(client.users['U07KECJ77'].presence).to eq 'updated'
     end
+
     it 'manual_presence_change' do
       expect(client.self['presence']).to eq 'away'
       event = Slack::RealTime::Event.new(

data/spec/slack/real_time/stores/store_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Slack::RealTime::Stores::Store do
+  it 'can be initialized with an empty hash' do
+    store = described_class.new(Hashie::Mash.new)
+    expect(store.team).to be_nil
+    expect(store.teams.count).to eq 0
+    expect(store.self).to be_nil
+    expect(store.public_channels.count).to eq 0
+    expect(store.private_channels.count).to eq 0
+  end
+
+  it 'includes event handlers in subclasses' do
+    subclass = Class.new(described_class)
+    expect(subclass.events.key?('channel_created')).to be true
+  end
+
+  context 'with client started' do
+    let(:client) { Slack::RealTime::Client.new(store_class: described_class, concurrency: Slack::RealTime::Concurrency::Mock) }
+
+    before do
+      client.store = described_class.new(Hashie::Mash.new, { caches: :all })
+    end
+
+    it 'initializes itself with data' do
+      team_info = Hashie::Mash.new(team: {})
+      allow(client.web_client).to receive(:team_info).and_return(team_info)
+      expect(client.web_client).to receive(:team_info)
+      expect(client.web_client).to receive(:users_list)
+      expect(client.web_client).to receive(:conversations_list).with(types: 'public_channel,private_channel,im,mpim')
+      event = Slack::RealTime::Event.new('type' => 'hello', 'start' => true)
+      client.send(:dispatch, event)
+    end
+
+    context 'when configured to only cache some types' do
+      before do
+        client.store = described_class.new(Hashie::Mash.new, { caches: %i[users public_channels] })
+      end
+
+      it 'initializes specified caches with data' do
+        expect(client.web_client).to receive(:users_list)
+        expect(client.web_client).to receive(:conversations_list).with(types: 'public_channel')
+        event = Slack::RealTime::Event.new('type' => 'hello', 'start' => true)
+        client.send(:dispatch, event)
+      end
+    end
+  end
+end

data/spec/slack/slack_spec.rb

@@ -30,6 +30,7 @@ describe Slack do
       expect(output).to include 'POST https://slack.com/api/auth.test'
       expect(output).to include 'Status 200'
     end
+
     it 'requires --slack-api-token' do
       err = `"#{slack}" auth test 2>&1`
       expect(err).to(

data/spec/slack/web/api/endpoints/admin_audit_anomaly_allow_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::AdminAuditAnomalyAllow do
+  let(:client) { Slack::Web::Client.new }
+end

data/spec/slack/web/api/endpoints/custom_specs/chat_spec.rb

@@ -30,17 +30,20 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
         blocks: []
       )
     end
+
     context 'text and user arguments' do
       it 'requires text or attachments' do
         expect { client.chat_postEphemeral(channel: 'channel') }.to(
           raise_error(ArgumentError, /Required arguments :text, :attachments or :blocks missing/)
         )
       end
+
       it 'requires user' do
         expect { client.chat_postEphemeral(channel: 'channel', text: 'text') }.to(
           raise_error(ArgumentError, /Required arguments :user missing/)
         )
       end
+
       it 'both text and user' do
         expect(client).to(
           receive(:post).with('chat.postEphemeral', hash_including(text: 'text', user: '123'))
@@ -60,6 +63,7 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
           client.chat_postEphemeral(channel: 'channel', text: 'text', user: '123', attachments: [])
         end.not_to raise_error
       end
+
       it 'attachments without text' do
         expect(client).to(
           receive(:post).with('chat.postEphemeral', hash_including(attachments: '[]'))
@@ -77,6 +81,7 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
           client.chat_postEphemeral(channel: 'channel', text: 'text', user: '123', blocks: [])
         end.not_to raise_error
       end
+
       it 'blocks without text' do
         expect(client).to receive(:post).with('chat.postEphemeral', hash_including(blocks: '[]'))
         expect do
@@ -99,24 +104,29 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
       )
       client.chat_postMessage(channel: 'channel', text: 'text', attachments: [], blocks: [])
     end
+
     context 'text, attachment and blocks arguments' do
       it 'requires text, attachments or blocks' do
         expect { client.chat_postMessage(channel: 'channel') }.to(
           raise_error(ArgumentError, /Required arguments :text, :attachments or :blocks missing/)
         )
       end
+
       it 'only text' do
         expect(client).to receive(:post).with('chat.postMessage', hash_including(text: 'text'))
         expect { client.chat_postMessage(channel: 'channel', text: 'text') }.not_to raise_error
       end
+
       it 'only attachments' do
         expect(client).to receive(:post).with('chat.postMessage', hash_including(attachments: '[]'))
         expect { client.chat_postMessage(channel: 'channel', attachments: []) }.not_to raise_error
       end
+
       it 'only blocks' do
         expect(client).to receive(:post).with('chat.postMessage', hash_including(blocks: '[]'))
         expect { client.chat_postMessage(channel: 'channel', blocks: []) }.not_to raise_error
       end
+
       it 'all text, attachments and blocks' do
         expect(client).to(
           receive(:post)
@@ -145,11 +155,12 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
       )
       client.chat_update(channel: 'channel', text: 'text', ts: ts, attachments: [], blocks: [])
     end
+
     context 'ts arguments' do
       it 'requires ts' do
         expect do
           client.chat_update(channel: 'channel', text: 'text')
-        end.to raise_error(ArgumentError, /Required arguments :ts missing>/)
+        end.to raise_error(ArgumentError, /Required arguments :ts missing/)
       end
     end
 
@@ -159,30 +170,35 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
           raise_error(ArgumentError, /Required arguments :text, :attachments, :blocks or :reply_broadcast missing/)
         )
       end
+
       it 'only text' do
         expect(client).to receive(:post).with('chat.update', hash_including(text: 'text'))
         expect do
           client.chat_update(channel: 'channel', text: 'text', ts: ts)
         end.not_to raise_error
       end
+
       it 'only attachments' do
         expect(client).to receive(:post).with('chat.update', hash_including(attachments: '[]'))
         expect do
           client.chat_update(channel: 'channel', ts: ts, attachments: [])
         end.not_to raise_error
       end
+
       it 'only blocks' do
         expect(client).to receive(:post).with('chat.update', hash_including(blocks: '[]'))
         expect do
           client.chat_update(channel: 'channel', ts: ts, blocks: [])
         end.not_to raise_error
       end
+
       it 'only reply_broadcast' do
         expect(client).to receive(:post).with('chat.update', hash_including(reply_broadcast: true))
         expect do
           client.chat_update(channel: 'channel', ts: ts, reply_broadcast: true)
         end.not_to raise_error
       end
+
       it 'all text, attachments and blocks' do
         expect(client).to(
           receive(:post)

data/spec/slack/web/api/endpoints/custom_specs/dialog_spec.rb

@@ -22,11 +22,13 @@ RSpec.describe Slack::Web::Api::Endpoints::Dialog do
           raise_error(ArgumentError, /Required arguments :dialog missing/)
         )
       end
+
       it 'requires trigger_id' do
         expect { client.dialog_open(dialog: []) }.to(
           raise_error(ArgumentError, /Required arguments :trigger_id missing/)
         )
       end
+
       it 'likes both dialog and trigger_id' do
         expect(client).to(
           receive(:post).with('dialog.open', hash_including(trigger_id: '123', dialog: '[]'))

data/spec/slack/web/api/endpoints/custom_specs/views_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 RSpec.describe Slack::Web::Api::Endpoints::Views do
   let(:client) { Slack::Web::Client.new }
   let(:trigger_id) { '12345.98765.abcd2358fdea' }
+  let(:view_id) { 'abc123567' }
 
   describe 'views_open' do
     context 'with a hash for view' do
@@ -86,8 +87,8 @@ RSpec.describe Slack::Web::Api::Endpoints::Views do
       let(:view_str) { '{"celery":"man"}' }
 
       it 'automatically converts view into JSON' do
-        expect(client).to receive(:post).with('views.update', { view: view_str })
-        client.views_update(view: { celery: 'man' })
+        expect(client).to receive(:post).with('views.update', { view_id: view_id, view: view_str })
+        client.views_update(view_id: view_id, view: { celery: 'man' })
       end
     end
 
@@ -95,8 +96,16 @@ RSpec.describe Slack::Web::Api::Endpoints::Views do
       let(:view_str) { 'celery man' }
 
       it 'leaves view as is' do
-        expect(client).to receive(:post).with('views.update', { view: view_str })
-        client.views_update(view: 'celery man')
+        expect(client).to receive(:post).with('views.update', { view_id: view_id, view: view_str })
+        client.views_update(view_id: view_id, view: 'celery man')
+      end
+
+      context 'with both an external_id and view_id' do
+        it 'raises error' do
+          expect do
+            client.views_update(external_id: trigger_id, view_id: view_id, view: 'celery man')
+          end.to raise_error ArgumentError, 'One of :external_id, :view_id is required'
+        end
       end
     end
   end

data/spec/slack/web/api/endpoints/files_spec.rb

@@ -5,6 +5,11 @@ require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Endpoints::Files do
   let(:client) { Slack::Web::Client.new }
+  context 'files_completeUploadExternal' do
+    it 'requires files' do
+      expect { client.files_completeUploadExternal }.to raise_error ArgumentError, /Required arguments :files missing/
+    end
+  end
   context 'files_delete' do
     it 'requires file' do
       expect { client.files_delete }.to raise_error ArgumentError, /Required arguments :file missing/
@@ -18,6 +23,14 @@ RSpec.describe Slack::Web::Api::Endpoints::Files do
       expect { client.files_edit(file: %q[F2147483862]) }.to raise_error ArgumentError, /Required arguments :title missing/
     end
   end
+  context 'files_getUploadURLExternal' do
+    it 'requires filename' do
+      expect { client.files_getUploadURLExternal(length: %q[]) }.to raise_error ArgumentError, /Required arguments :filename missing/
+    end
+    it 'requires length' do
+      expect { client.files_getUploadURLExternal(filename: %q[]) }.to raise_error ArgumentError, /Required arguments :length missing/
+    end
+  end
   context 'files_info' do
     it 'requires file' do
       expect { client.files_info }.to raise_error ArgumentError, /Required arguments :file missing/

data/spec/slack/web/api/mixins/conversations_spec.rb

@@ -29,11 +29,13 @@ RSpec.describe Slack::Web::Api::Mixins::Conversations do
         eq('ok' => true, 'channel' => { 'id' => 'C123456' })
       )
     end
+
     it 'translates a channel that starts with a #' do
       expect(conversations.conversations_id(channel: '#general')).to(
         eq('ok' => true, 'channel' => { 'id' => 'CDEADBEEF' })
       )
     end
+
     it 'fails with an exception' do
       expect { conversations.conversations_id(channel: '#invalid') }.to(
         raise_error(Slack::Web::Api::Errors::SlackError, 'channel_not_found')

data/spec/slack/web/api/mixins/users_spec.rb

@@ -28,9 +28,11 @@ RSpec.describe Slack::Web::Api::Mixins::Users do
     it 'leaves users specified by ID alone' do
       expect(users.users_id(user: 'U123456')).to eq('ok' => true, 'user' => { 'id' => 'U123456' })
     end
+
     it 'translates a user that starts with a #' do
       expect(users.users_id(user: '@aws')).to eq('ok' => true, 'user' => { 'id' => 'UDEADBEEF' })
     end
+
     it 'fails with an exception' do
       expect { users.users_id(user: '@foo') }.to(
         raise_error(Slack::Web::Api::Errors::SlackError, 'user_not_found')

data/spec/slack/web/api/pagination/cursor_spec.rb

@@ -11,16 +11,19 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
       expect(client).to receive(:users_list).with({ limit: 100, cursor: nil })
       cursor.first
     end
+
     it 'handles blank response metadata' do
       expect(client).to receive(:users_list).once.and_return(Slack::Messages::Message.new)
       cursor.to_a
     end
+
     it 'handles nil response metadata' do
       expect(client).to(
         receive(:users_list).once.and_return(Slack::Messages::Message.new(response_metadata: nil))
       )
       cursor.to_a
     end
+
     it 'paginates with a cursor inside response metadata' do
       expect(client).to receive(:users_list).twice.and_return(
         Slack::Messages::Message.new(response_metadata: { next_cursor: 'next' }),
@@ -29,6 +32,7 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
       expect(cursor).not_to receive(:sleep)
       cursor.to_a
     end
+
     context 'with rate limiting' do
       let(:error) { Slack::Web::Api::Errors::TooManyRequestsError.new(OpenStruct.new(headers: { 'retry-after' => 9 })) }
 

data/spec/slack/web/client_spec.rb

@@ -15,6 +15,7 @@ RSpec.describe Slack::Web::Client do
         expect(client.user_agent).to eq Slack::Web::Config.user_agent
         expect(client.user_agent).to include Slack::VERSION
       end
+
       (Slack::Web::Config::ATTRIBUTES - [:logger]).each do |key|
         it "sets #{key}" do
           expect(client.send(key)).to eq Slack::Web::Config.send(key)
@@ -56,6 +57,7 @@ RSpec.describe Slack::Web::Client do
         it 'sets user-agent' do
           expect(client.user_agent).to eq 'custom/user-agent'
         end
+
         it 'creates a connection with the custom user-agent' do
           expect(client.send(:connection).headers).to eq(
             'Accept' => 'application/json; charset=utf-8',
@@ -76,6 +78,7 @@ RSpec.describe Slack::Web::Client do
         client = described_class.new
         expect(client.token).to eq 'global default'
       end
+
       context 'with web config' do
         before do
           described_class.configure do |config|
@@ -87,6 +90,7 @@ RSpec.describe Slack::Web::Client do
           client = described_class.new
           expect(client.token).to eq 'custom web token'
         end
+
         it 'overrides token to specific token' do
           client = described_class.new(token: 'local token')
           expect(client.token).to eq 'local token'
@@ -105,6 +109,7 @@ RSpec.describe Slack::Web::Client do
         it 'sets proxy' do
           expect(client.proxy).to eq 'http://localhost:8080'
         end
+
         it 'creates a connection with the proxy' do
           expect(client.send(:connection).proxy.uri.to_s).to eq 'http://localhost:8080'
         end
@@ -124,6 +129,7 @@ RSpec.describe Slack::Web::Client do
           expect(client.ca_path).to eq '/ca_path'
           expect(client.ca_file).to eq '/ca_file'
         end
+
         it 'creates a connection with ssl options' do
           ssl = client.send(:connection).ssl
           expect(ssl.ca_path).to eq '/ca_path'
@@ -145,6 +151,7 @@ RSpec.describe Slack::Web::Client do
         it 'sets logger' do
           expect(client.logger).to eq logger
         end
+
         it 'creates a connection with a logger' do
           expect(client.send(:connection).builder.handlers).to include ::Faraday::Response::Logger
         end
@@ -168,6 +175,7 @@ RSpec.describe Slack::Web::Client do
           it 'sets adapter' do
             expect(client.adapter).to eq adapter
           end
+
           it 'creates a connection with an adapter' do
             expect(client.send(:connection).adapter).to eq adapter_class
           end
@@ -188,6 +196,7 @@ RSpec.describe Slack::Web::Client do
           it 'sets adapter' do
             expect(client.adapter).to eq adapter
           end
+
           it 'creates a connection with an adapter' do
             expect(client.send(:connection).adapter).to eq adapter_class
           end
@@ -208,6 +217,7 @@ RSpec.describe Slack::Web::Client do
           expect(client.timeout).to eq 10
           expect(client.open_timeout).to eq 15
         end
+
         it 'creates a connection with timeout options' do
           conn = client.send(:connection)
           expect(conn.options.timeout).to eq 10
@@ -217,16 +227,16 @@ RSpec.describe Slack::Web::Client do
     end
 
     context 'per-request options' do
-      it 'applies timeout', vcr: { cassette_name: 'web/rtm_start', allow_playback_repeats: true } do
+      it 'applies timeout', vcr: { cassette_name: 'web/rtm_connect', allow_playback_repeats: true } do
         # reuse the same connection for the test, otherwise it creates a new one every time
         conn = client.send(:connection)
         expect(client).to receive(:connection).and_return(conn)
 
         # get the yielded request to reuse in the next call to
-        # rtm_start so that we can examine request.options later
+        # rtm.connect so that we can examine request.options later
         request = nil
         response = conn.post do |r|
-          r.path = 'rtm.start'
+          r.path = 'rtm.connect'
           r.headers = {
             'Accept' => ['application/json; charset=utf-8'],
             'Authorization' => ['Bearer <SLACK_API_TOKEN>']
@@ -236,7 +246,7 @@ RSpec.describe Slack::Web::Client do
 
         expect(conn).to receive(:post).and_yield(request).and_return(response)
 
-        client.rtm_start(request: { timeout: 3 })
+        client.rtm_connect(request: { timeout: 3 })
 
         expect(request.options.timeout).to eq 3
       end