slack-ruby-client 1.0.0 → 2.1.0

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Bookmarks do
+  let(:client) { Slack::Web::Client.new }
+  context 'bookmarks_add' do
+    it 'requires channel_id' do
+      expect { client.bookmarks_add(title: %q[], type: %q[]) }.to raise_error ArgumentError, /Required arguments :channel_id missing/
+    end
+    it 'requires title' do
+      expect { client.bookmarks_add(channel_id: %q[], type: %q[]) }.to raise_error ArgumentError, /Required arguments :title missing/
+    end
+    it 'requires type' do
+      expect { client.bookmarks_add(channel_id: %q[], title: %q[]) }.to raise_error ArgumentError, /Required arguments :type missing/
+    end
+  end
+  context 'bookmarks_edit' do
+    it 'requires bookmark_id' do
+      expect { client.bookmarks_edit(channel_id: %q[]) }.to raise_error ArgumentError, /Required arguments :bookmark_id missing/
+    end
+    it 'requires channel_id' do
+      expect { client.bookmarks_edit(bookmark_id: %q[]) }.to raise_error ArgumentError, /Required arguments :channel_id missing/
+    end
+  end
+  context 'bookmarks_list' do
+    it 'requires channel_id' do
+      expect { client.bookmarks_list }.to raise_error ArgumentError, /Required arguments :channel_id missing/
+    end
+  end
+  context 'bookmarks_remove' do
+    it 'requires bookmark_id' do
+      expect { client.bookmarks_remove(channel_id: %q[]) }.to raise_error ArgumentError, /Required arguments :bookmark_id missing/
+    end
+    it 'requires channel_id' do
+      expect { client.bookmarks_remove(bookmark_id: %q[]) }.to raise_error ArgumentError, /Required arguments :channel_id missing/
+    end
+  end
+end

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

@@ -14,11 +14,13 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
     it 'automatically converts attachments and blocks into JSON' do
       expect(client).to receive(:post).with(
         'chat.postEphemeral',
-        channel: 'channel',
-        text: 'text',
-        user: '123',
-        attachments: '[]',
-        blocks: '[]'
+        {
+          channel: 'channel',
+          text: 'text',
+          user: '123',
+          attachments: '[]',
+          blocks: '[]'
+        }
       )
       client.chat_postEphemeral(
         channel: 'channel',
@@ -28,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'))
@@ -58,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: '[]'))
@@ -75,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
@@ -88,31 +95,38 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
     it 'automatically converts attachments and blocks into JSON' do
       expect(client).to receive(:post).with(
         'chat.postMessage',
-        channel: 'channel',
-        text: 'text',
-        attachments: '[]',
-        blocks: '[]'
+        {
+          channel: 'channel',
+          text: 'text',
+          attachments: '[]',
+          blocks: '[]'
+        }
       )
       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)
@@ -131,46 +145,60 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
     it 'automatically converts attachments and blocks into JSON' do
       expect(client).to receive(:post).with(
         'chat.update',
-        channel: 'channel',
-        text: 'text',
-        ts: ts,
-        attachments: '[]',
-        blocks: '[]'
+        {
+          channel: 'channel',
+          text: 'text',
+          ts: ts,
+          attachments: '[]',
+          blocks: '[]'
+        }
       )
       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
 
     context 'text, attachment and blocks arguments' do
-      it 'requires text, attachments or blocks' do
+      it 'requires text, attachments, blocks or reply_broadcast' do
         expect { client.chat_update(channel: 'channel', ts: ts) }.to(
-          raise_error(ArgumentError, /Required arguments :text, :attachments or :blocks missing/)
+          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

@@ -8,8 +8,10 @@ RSpec.describe Slack::Web::Api::Endpoints::Dialog do
     it 'automatically converts dialog into JSON' do
       expect(client).to receive(:post).with(
         'dialog.open',
-        trigger_id: '12345.98765.abcd2358fdea',
-        dialog: '[]'
+        {
+          trigger_id: '12345.98765.abcd2358fdea',
+          dialog: '[]'
+        }
       )
       client.dialog_open(trigger_id: '12345.98765.abcd2358fdea', dialog: [])
     end
@@ -20,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,13 +4,14 @@ 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
       let(:view_str) { '{"celery":"man"}' }
 
       it 'automatically converts view into JSON' do
-        expect(client).to receive(:post).with('views.open', trigger_id: trigger_id, view: view_str)
+        expect(client).to receive(:post).with('views.open', { trigger_id: trigger_id, view: view_str })
         client.views_open(trigger_id: trigger_id, view: { celery: 'man' })
       end
     end
@@ -19,7 +20,7 @@ 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.open', trigger_id: trigger_id, view: view_str)
+        expect(client).to receive(:post).with('views.open', { trigger_id: trigger_id, view: view_str })
         client.views_open(trigger_id: trigger_id, view: 'celery man')
       end
     end
@@ -32,10 +33,14 @@ 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.publish',
-                                              user_id: user_id,
-                                              trigger_id: trigger_id,
-                                              view: view_str)
+        expect(client).to receive(:post).with(
+          'views.publish',
+          {
+            trigger_id: trigger_id,
+            user_id: user_id,
+            view: view_str
+          }
+        )
         client.views_publish(user_id: user_id, trigger_id: trigger_id, view: { celery: 'man' })
       end
     end
@@ -44,10 +49,14 @@ 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.publish',
-                                              user_id: user_id,
-                                              trigger_id: trigger_id,
-                                              view: view_str)
+        expect(client).to receive(:post).with(
+          'views.publish',
+          {
+            user_id: user_id,
+            trigger_id: trigger_id,
+            view: view_str
+          }
+        )
         client.views_publish(user_id: user_id, trigger_id: trigger_id, view: 'celery man')
       end
     end
@@ -58,7 +67,7 @@ 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.push', trigger_id: trigger_id, view: view_str)
+        expect(client).to receive(:post).with('views.push', { trigger_id: trigger_id, view: view_str })
         client.views_push(trigger_id: trigger_id, view: { celery: 'man' })
       end
     end
@@ -67,7 +76,7 @@ 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.push', trigger_id: trigger_id, view: view_str)
+        expect(client).to receive(:post).with('views.push', { trigger_id: trigger_id, view: view_str })
         client.views_push(trigger_id: trigger_id, view: 'celery man')
       end
     end
@@ -78,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
 
@@ -87,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/endpoints/functions_workflows_steps_responses_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::FunctionsWorkflowsStepsResponses do
+  let(:client) { Slack::Web::Client.new }
+  context 'functions.workflows.steps.responses_export' do
+    it 'requires step_id' do
+      expect { client.functions_workflows_steps_responses_export }.to raise_error ArgumentError, /Required arguments :step_id missing/
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::FunctionsWorkflowsSteps do
+  let(:client) { Slack::Web::Client.new }
+  context 'functions.workflows.steps_list' do
+    it 'requires function_id' do
+      expect { client.functions_workflows_steps_list }.to raise_error ArgumentError, /Required arguments :function_id missing/
+    end
+  end
+end

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

@@ -8,19 +8,22 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
     let(:cursor) { described_class.new(client, 'users_list', {}) }
 
     it 'provides a default limit' do
-      expect(client).to receive(:users_list).with(limit: 100, cursor: nil)
+      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 })) }
 
@@ -36,17 +40,17 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
         it 'sleeps after a TooManyRequestsError' do
           expect(client).to(
             receive(:users_list)
-              .with(limit: 100, cursor: nil)
+              .with({ limit: 100, cursor: nil })
               .ordered
               .and_return(Slack::Messages::Message.new(response_metadata: { next_cursor: 'next' }))
           )
           expect(client).to(
-            receive(:users_list).with(limit: 100, cursor: 'next').ordered.and_raise(error)
+            receive(:users_list).with({ limit: 100, cursor: 'next' }).ordered.and_raise(error)
           )
           expect(cursor).to receive(:sleep).once.ordered.with(9)
           expect(client).to(
             receive(:users_list)
-              .with(limit: 100, cursor: 'next')
+              .with({ limit: 100, cursor: 'next' })
               .ordered
               .and_return(Slack::Messages::Message.new)
           )
@@ -60,11 +64,11 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
         it 'raises the error after hitting the max retries' do
           expect(client).to(
             receive(:users_list)
-              .with(limit: 100, cursor: nil)
+              .with({ limit: 100, cursor: nil })
               .and_return(Slack::Messages::Message.new(response_metadata: { next_cursor: 'next' }))
           )
           expect(client).to(
-            receive(:users_list).with(limit: 100, cursor: 'next').exactly(5).times.and_raise(error)
+            receive(:users_list).with({ limit: 100, cursor: 'next' }).exactly(5).times.and_raise(error)
           )
           expect(cursor).to receive(:sleep).exactly(4).times.with(9)
           expect { cursor.to_a }.to raise_error(error)
@@ -77,7 +81,7 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
     let(:cursor) { described_class.new(client, 'users_list', limit: 42) }
 
     it 'overrides default limit' do
-      expect(client).to receive(:users_list).with(limit: 42, cursor: nil)
+      expect(client).to receive(:users_list).with({ limit: 42, cursor: nil })
       cursor.first
     end
   end

data/spec/slack/web/client_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'spec_helper'
+require 'faraday/typhoeus'
 
 RSpec.describe Slack::Web::Client do
   before do
@@ -14,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)
@@ -55,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',
@@ -75,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|
@@ -86,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'
@@ -104,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
@@ -123,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'
@@ -144,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
@@ -167,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
@@ -187,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
@@ -207,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
@@ -216,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>']
@@ -235,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
@@ -275,13 +286,28 @@ RSpec.describe Slack::Web::Client do
       end
 
       context 'parsing error' do
-        before {  stub_slack_request.to_return(body: '<html></html>') }
+        context 'when the response is not JSON' do
+          before do
+            stub_slack_request.to_return(body: '<html></html>', headers: { 'Content-Type' => 'text/html' })
+          end
+
+          it 'raises ParsingError' do
+            expect { request }.to raise_error(Slack::Web::Api::Errors::ParsingError).with_message('parsing_error')
+            expect(exception.response.body).to eq('<html></html>')
+            expect(exception.cause).to be_a(Faraday::ParsingError)
+            expect(exception.cause.cause).to be_a(JSON::ParserError)
+          end
+        end
+
+        context 'when the response is malformed JSON' do
+          before { stub_slack_request.to_return(body: '{') }
 
-        it 'raises ParsingError' do
-          expect { request }.to raise_error(Slack::Web::Api::Errors::ParsingError).with_message('parsing_error')
-          expect(exception.response.body).to eq('<html></html>')
-          expect(exception.cause).to be_a(Faraday::ParsingError)
-          expect(exception.cause.cause.cause).to be_a(JSON::ParserError)
+          it 'raises ParsingError' do
+            expect { request }.to raise_error(Slack::Web::Api::Errors::ParsingError).with_message('parsing_error')
+            expect(exception.response.body).to eq('{')
+            expect(exception.cause).to be_a(Faraday::ParsingError)
+            expect(exception.cause.cause).to be_a(JSON::ParserError)
+          end
         end
       end
 
@@ -318,7 +344,9 @@ RSpec.describe Slack::Web::Client do
         end
 
         context 'with a HTML response' do
-          before { stub_slack_request.to_return(status: 500, body: '<html></html>') }
+          before do
+            stub_slack_request.to_return(status: 500, body: '<html></html>', headers: { 'Content-Type' => 'text/html' })
+          end
 
           it 'raises UnavailableError' do
             expect { request }.to raise_error(Slack::Web::Api::Errors::UnavailableError).with_message('unavailable_error')