slack-ruby-client 0.9.0 → 0.11.0

data/spec/slack/real_time/concurrency/celluloid_spec.rb

@@ -7,45 +7,55 @@ begin
     context 'with url' do
       let(:url) { 'wss://echo.websocket.org/websocket/xyz' }
       let(:logger) { ::Logger.new(STDOUT) }
-      let(:test_socket) do
-        Class.new(described_class) do
-          def read
-            fail EOFError
+
+      [EOFError, Errno::EPIPE].each do |err|
+        context "finishing run_loop with #{err}" do
+          let(:test_socket) do
+            Class.new(described_class) do
+              def read
+                raise options[:err]
+              end
+            end
           end
-        end
-      end
-      let(:socket) { test_socket.new(url, ping: 42, logger: logger) }
-      let(:driver) { WebSocket::Driver::Client }
-      let(:ws) { double(driver) }
-      subject { socket }
-
-      describe '#connect!' do
-        pending 'connects'
-        pending 'pings every 30s'
-      end
 
-      context 'with a driver' do
-        before do
-          socket.instance_variable_set('@driver', ws)
-        end
+          let(:socket) do
+            test_socket.new(url, ping: 42, logger: logger, err: err)
+          end
 
-        describe '#disconnect!' do
-          it 'closes and nils the websocket' do
-            expect(ws).to receive(:close)
-            socket.disconnect!
+          let(:driver) { WebSocket::Driver::Client }
+          let(:ws) { double(driver) }
+          subject { socket }
+
+          describe '#connect!' do
+            pending 'connects'
+            pending 'pings every 30s'
           end
-        end
 
-        describe '#run_loop' do
-          it 'runs' do
-            expect(ws).to receive(:emit)
-            expect(ws).to receive(:start)
-            socket.run_loop
+          context 'with a driver' do
+            before do
+              socket.instance_variable_set('@driver', ws)
+            end
+
+            describe '#disconnect!' do
+              it 'closes and nils the websocket' do
+                expect(ws).to receive(:close)
+                socket.disconnect!
+              end
+            end
+
+            context 'consumes data' do
+              it 'runs' do
+                expect(ws).to receive(:emit)
+                expect(ws).to receive(:start)
+                expect(logger).to receive(:debug).with("#{test_socket}#run_loop")
+                socket.run_loop
+              end
+            end
           end
+
+          pending 'send_data'
         end
       end
-
-      pending 'send_data'
     end
   end
 rescue LoadError

data/spec/slack/real_time/concurrency/it_behaves_like_a_realtime_socket.rb

@@ -10,7 +10,7 @@ RSpec.shared_examples_for 'a realtime socket' do
     end
   end
   describe 'api' do
-    [:start_sync, :start_sync, :disconnect!, :connect!, :connected?, :send_data, :close].each do |m|
+    %i[start_sync start_sync disconnect! connect! connected? send_data close].each do |m|
       it m do
         expect(socket).to respond_to(m)
       end

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

@@ -17,7 +17,8 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
             'icons' => {
               'image_48' => 'https:\/\/slack.com\/path\/to\/hugbot_48.png'
             }
-          })
+          }
+        )
         client.send(:dispatch, event)
       end.to change(client.bots, :count).by(1)
       bot = client.bots['B024BE7LH']
@@ -32,7 +33,8 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
           'bot' => {
             'id' => 'B0751JU2H',
             'name' => 'hugbot'
-          })
+          }
+        )
         client.send(:dispatch, event)
       end.to_not change(client.bots, :count)
       bot = client.bots['B0751JU2H']

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

@@ -9,7 +9,7 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
       'name' => 'push_sound',
       'value' => 'updated.mp3'
     )
-    expect(client.self).to receive(:prefs) { fail ArgumentError }
+    expect(client.self).to receive(:prefs) { raise ArgumentError }
     expect { client.send(:dispatch, event) }.to_not raise_error
   end
 end

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

@@ -14,7 +14,8 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
         'type' => 'user_change',
         'user' => {
           'id' => 'U07KECJ77', 'name' => 'renamed'
-        })
+        }
+      )
       client.send(:dispatch, event)
       expect(client.users['U07KECJ77'].name).to eq 'renamed'
     end
@@ -24,7 +25,8 @@ RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' }
           'type' => 'team_join',
           'user' => {
             'id' => 'DEADBEEF', 'name' => 'added'
-          })
+          }
+        )
         client.send(:dispatch, event)
       end.to change(client.users, :count).by(1)
       expect(client.users['DEADBEEF'].name).to eq 'added'

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

@@ -0,0 +1,15 @@
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::AppsPermissions do
+  let(:client) { Slack::Web::Client.new }
+  context 'apps.permissions_request' do
+    it 'requires scopes' do
+      expect { client.apps_permissions_request(trigger_id: ' ') }.to raise_error ArgumentError, /Required arguments :scopes missing/
+    end
+    it 'requires trigger_id' do
+      expect { client.apps_permissions_request(scopes: ' ') }.to raise_error ArgumentError, /Required arguments :trigger_id missing/
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Conversations do
+  let(:client) { Slack::Web::Client.new }
+  context 'conversations_archive' do
+    it 'requires channel' do
+      expect { client.conversations_archive }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+  context 'conversations_close' do
+    it 'requires channel' do
+      expect { client.conversations_close }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+  context 'conversations_create' do
+    it 'requires name' do
+      expect { client.conversations_create }.to raise_error ArgumentError, /Required arguments :name missing/
+    end
+  end
+  context 'conversations_history' do
+    it 'requires channel' do
+      expect { client.conversations_history }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+  context 'conversations_info' do
+    it 'requires channel' do
+      expect { client.conversations_info }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+  context 'conversations_invite' do
+    it 'requires channel' do
+      expect { client.conversations_invite(users: 'W1234567890,U2345678901,U3456789012') }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+    it 'requires users' do
+      expect { client.conversations_invite(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :users missing/
+    end
+  end
+  context 'conversations_join' do
+    it 'requires channel' do
+      expect { client.conversations_join }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+  context 'conversations_kick' do
+    it 'requires channel' do
+      expect { client.conversations_kick(user: 'W1234567890') }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+    it 'requires user' do
+      expect { client.conversations_kick(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :user missing/
+    end
+  end
+  context 'conversations_leave' do
+    it 'requires channel' do
+      expect { client.conversations_leave }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+  context 'conversations_members' do
+    it 'requires channel' do
+      expect { client.conversations_members }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+  context 'conversations_rename' do
+    it 'requires channel' do
+      expect { client.conversations_rename(name: ' ') }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+    it 'requires name' do
+      expect { client.conversations_rename(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :name missing/
+    end
+  end
+  context 'conversations_replies' do
+    it 'requires channel' do
+      expect { client.conversations_replies(ts: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+    it 'requires ts' do
+      expect { client.conversations_replies(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :ts missing/
+    end
+  end
+  context 'conversations_setPurpose' do
+    it 'requires channel' do
+      expect { client.conversations_setPurpose(purpose: 'My More Special Purpose') }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+    it 'requires purpose' do
+      expect { client.conversations_setPurpose(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :purpose missing/
+    end
+  end
+  context 'conversations_setTopic' do
+    it 'requires channel' do
+      expect { client.conversations_setTopic(topic: 'Apply topically for best effects') }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+    it 'requires topic' do
+      expect { client.conversations_setTopic(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :topic missing/
+    end
+  end
+  context 'conversations_unarchive' do
+    it 'requires channel' do
+      expect { client.conversations_unarchive }.to raise_error ArgumentError, /Required arguments :channel missing/
+    end
+  end
+end

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

@@ -2,6 +2,42 @@ require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Endpoints::Chat do
   let(:client) { Slack::Web::Client.new }
+  context 'chat_postEphemeral' do
+    let(:user) { OpenStruct.new(user: { id: '123' }) }
+    before(:each) do
+      allow(described_class).to receive(:users_id).and_return(user)
+    end
+
+    it 'automatically converts attachments into JSON' do
+      expect(client).to receive(:post).with(
+        'chat.postEphemeral',
+        channel: 'channel',
+        text: 'text',
+        user: '123',
+        attachments: '[]'
+      )
+      client.chat_postEphemeral(channel: 'channel', text: 'text', user: '123', attachments: [])
+    end
+    context 'text and user arguments' do
+      it 'requires text' do
+        expect { client.chat_postEphemeral(channel: 'channel') }.to raise_error ArgumentError, /Required arguments :text 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'))
+        expect { client.chat_postEphemeral(channel: 'channel', text: 'text', user: '123') }.to_not raise_error
+      end
+    end
+    context 'attachments argument' do
+      it 'optional attachments' do
+        expect(client).to receive(:post).with('chat.postEphemeral', hash_including(attachments: '[]'))
+        expect { client.chat_postEphemeral(channel: 'channel', text: 'text', user: '123', attachments: []) }.to_not raise_error
+      end
+    end
+  end
+
   context 'chat_postMessage' do
     it 'automatically converts attachments into JSON' do
       expect(client).to receive(:post).with(
@@ -45,7 +81,7 @@ RSpec.describe Slack::Web::Api::Endpoints::Chat do
     end
     context 'ts arguments' do
       it 'requires ts' do
-        expect { client.chat_update(channel: 'channel') }.to raise_error ArgumentError, /Required arguments :ts missing>/
+        expect { client.chat_update(channel: 'channel', text: 'text') }.to raise_error ArgumentError, /Required arguments :ts missing>/
       end
     end
     context 'text and attachment arguments' do

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Dialog do
+  let(:client) { Slack::Web::Client.new }
+  context 'dialog_open' do
+    it 'automatically converts dialog into JSON' do
+      expect(client).to receive(:post).with(
+        'dialog.open',
+        trigger_id: '12345.98765.abcd2358fdea',
+        dialog: '[]'
+      )
+      client.dialog_open(trigger_id: '12345.98765.abcd2358fdea', dialog: [])
+    end
+
+    context 'arguments' do
+      it 'requires dialog' do
+        expect { client.dialog_open(trigger_id: '123') }.to 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: '[]'))
+        expect { client.dialog_open(dialog: [], trigger_id: '123') }.to_not raise_error
+      end
+    end
+  end
+end

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

@@ -9,15 +9,25 @@ RSpec.describe Slack::Web::Api::Endpoints::Users do
       expect(json.members.size).to eq 9
       expect(json.members.first.presence).to eq 'away'
     end
+    it 'list', vcr: { cassette_name: 'web/paginated_users_list' } do
+      members = []
+      client.users_list(presence: true, limit: 5) do |json|
+        expect(json.ok).to be true
+        members.concat json.members
+      end
+      expect(members.size).to eq 23
+    end
     it 'info', vcr: { cassette_name: 'web/users_info' } do
       json = client.users_info(user: '@aws')
       expect(json.user.name).to eq 'aws'
     end
-    it 'search', vcr: { cassette_name: 'web/users_info' } do
-      json = client.users_search(user: 'aws')
-      expect(json.ok).to be true
-      expect(json.members.size).to eq 1
-      expect(json.members.first.name).to eq 'aws'
-    end if defined?(Picky)
+    if defined?(Picky)
+      it 'search', vcr: { cassette_name: 'web/users_info' } do
+        json = client.users_search(user: 'aws')
+        expect(json.ok).to be true
+        expect(json.members.size).to eq 1
+        expect(json.members.first.name).to eq 'aws'
+      end
+    end
   end
 end

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

@@ -5,12 +5,12 @@ require 'spec_helper'
 RSpec.describe Slack::Web::Api::Endpoints::FilesComments do
   let(:client) { Slack::Web::Client.new }
   context 'files.comments_add' do
-    it 'requires file' do
-      expect { client.files_comments_add(comment: 'Everyone should take a moment to read this file.') }.to raise_error ArgumentError, /Required arguments :file missing/
-    end
     it 'requires comment' do
       expect { client.files_comments_add(file: 'F1234467890') }.to raise_error ArgumentError, /Required arguments :comment missing/
     end
+    it 'requires file' do
+      expect { client.files_comments_add(comment: 'Everyone should take a moment to read this file.') }.to raise_error ArgumentError, /Required arguments :file missing/
+    end
   end
   context 'files.comments_delete' do
     it 'requires file' do
@@ -21,14 +21,14 @@ RSpec.describe Slack::Web::Api::Endpoints::FilesComments do
     end
   end
   context 'files.comments_edit' do
+    it 'requires comment' do
+      expect { client.files_comments_edit(file: 'F1234567890', id: 'Fc1234567890') }.to raise_error ArgumentError, /Required arguments :comment missing/
+    end
     it 'requires file' do
-      expect { client.files_comments_edit(id: 'Fc1234567890', comment: 'Everyone should take a moment to read this file, seriously.') }.to raise_error ArgumentError, /Required arguments :file missing/
+      expect { client.files_comments_edit(comment: 'Everyone should take a moment to read this file, seriously.', id: 'Fc1234567890') }.to raise_error ArgumentError, /Required arguments :file missing/
     end
     it 'requires id' do
-      expect { client.files_comments_edit(file: 'F1234567890', comment: 'Everyone should take a moment to read this file, seriously.') }.to raise_error ArgumentError, /Required arguments :id missing/
-    end
-    it 'requires comment' do
-      expect { client.files_comments_edit(file: 'F1234567890', id: 'Fc1234567890') }.to raise_error ArgumentError, /Required arguments :comment missing/
+      expect { client.files_comments_edit(comment: 'Everyone should take a moment to read this file, seriously.', file: 'F1234567890') }.to raise_error ArgumentError, /Required arguments :id missing/
     end
   end
 end

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

@@ -9,6 +9,14 @@ RSpec.describe Slack::Web::Api::Endpoints::Files do
       expect { client.files_delete }.to raise_error ArgumentError, /Required arguments :file missing/
     end
   end
+  context 'files_edit' do
+    it 'requires file' do
+      expect { client.files_edit(title: 'Brand new title') }.to raise_error ArgumentError, /Required arguments :file missing/
+    end
+    it 'requires title' do
+      expect { client.files_edit(file: 'F2147483862') }.to raise_error ArgumentError, /Required arguments :title missing/
+    end
+  end
   context 'files_info' do
     it 'requires file' do
       expect { client.files_info }.to raise_error ArgumentError, /Required arguments :file missing/
@@ -19,14 +27,17 @@ RSpec.describe Slack::Web::Api::Endpoints::Files do
       expect { client.files_revokePublicURL }.to raise_error ArgumentError, /Required arguments :file missing/
     end
   end
-  context 'files_sharedPublicURL' do
+  context 'files_share' do
     it 'requires file' do
-      expect { client.files_sharedPublicURL }.to raise_error ArgumentError, /Required arguments :file missing/
+      expect { client.files_share(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :file missing/
+    end
+    it 'requires channel' do
+      expect { client.files_share(file: 'F2147483862') }.to raise_error ArgumentError, /Required arguments :channel missing/
     end
   end
-  context 'files_upload' do
-    it 'requires filename' do
-      expect { client.files_upload }.to raise_error ArgumentError, /Required arguments :filename missing/
+  context 'files_sharedPublicURL' do
+    it 'requires file' do
+      expect { client.files_sharedPublicURL }.to raise_error ArgumentError, /Required arguments :file missing/
     end
   end
 end

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

@@ -0,0 +1,12 @@
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Migration do
+  let(:client) { Slack::Web::Client.new }
+  context 'migration_exchange' do
+    it 'requires users' do
+      expect { client.migration_exchange }.to raise_error ArgumentError, /Required arguments :users missing/
+    end
+  end
+end

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

@@ -15,4 +15,15 @@ RSpec.describe Slack::Web::Api::Endpoints::Oauth do
       expect { client.oauth_access(client_id: '4b39e9-752c4', client_secret: '33fea0113f5b1') }.to raise_error ArgumentError, /Required arguments :code missing/
     end
   end
+  context 'oauth_token' do
+    it 'requires client_id' do
+      expect { client.oauth_token(client_secret: '33fea0113f5b1', code: 'ccdaa72ad') }.to raise_error ArgumentError, /Required arguments :client_id missing/
+    end
+    it 'requires client_secret' do
+      expect { client.oauth_token(client_id: '4b39e9-752c4', code: 'ccdaa72ad') }.to raise_error ArgumentError, /Required arguments :client_secret missing/
+    end
+    it 'requires code' do
+      expect { client.oauth_token(client_id: '4b39e9-752c4', client_secret: '33fea0113f5b1') }.to raise_error ArgumentError, /Required arguments :code missing/
+    end
+  end
 end

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

@@ -0,0 +1,17 @@
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::UsersAdmin do
+  let(:client) { Slack::Web::Client.new }
+  context 'users.admin_invite' do
+    it 'requires email' do
+      expect { client.users_admin_invite }.to raise_error ArgumentError, /Required arguments :email missing/
+    end
+  end
+  context 'users.admin_setInactive' do
+    it 'requires user' do
+      expect { client.users_admin_setInactive }.to raise_error ArgumentError, /Required arguments :user missing/
+    end
+  end
+end

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

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

data/spec/slack/web/api/error_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Slack::Web::Api::Error do
   it 'provides access to the response object', vcr: { cassette_name: 'web/auth_test_error' } do
     begin
       client.auth_test
-      fail 'Expected to receive Slack::Web::Api::Error.'
+      raise 'Expected to receive Slack::Web::Api::Error.'
     rescue Slack::Web::Api::Error => e
       expect(e.response).to_not be_nil
       expect(e.response.status).to eq 200

data/spec/slack/web/api/errors/slack_error_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Slack::Web::Api::Errors::SlackError do
   it 'provides access to the response object', vcr: { cassette_name: 'web/auth_test_error' } do
     begin
       client.auth_test
-      fail 'Expected to receive Slack::Web::Api::Errors::SlackError.'
+      raise 'Expected to receive Slack::Web::Api::Errors::SlackError.'
     rescue Slack::Web::Api::Errors::SlackError => e
       expect(e.response).to_not be_nil
       expect(e.response.status).to eq 200

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

@@ -29,9 +29,11 @@ RSpec.describe Slack::Web::Api::Mixins::Users do
       expect { subject.users_id(user: '@foo') }.to raise_error Slack::Web::Api::Errors::SlackError, 'user_not_found'
     end
   end
-  context '#users_search' do
-    it 'finds a user' do
-      expect(subject.users_search(user: 'aws')).to eq('ok' => true, 'members' => [{ 'id' => 'UDEADBEEF', 'name' => 'aws', 'profile' => {} }])
+  if defined?(Picky)
+    context '#users_search' do
+      it 'finds a user' do
+        expect(subject.users_search(user: 'aws')).to eq('ok' => true, 'members' => [{ 'id' => 'UDEADBEEF', 'name' => 'aws', 'profile' => {} }])
+      end
     end
-  end if defined?(Picky)
+  end
 end

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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Pagination::Cursor do
+  let(:client) { Slack::Web::Client.new }
+  context 'default cursor' do
+    let(:cursor) { Slack::Web::Api::Pagination::Cursor.new(client, 'users_list', {}) }
+    it 'provides a default limit' 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' }),
+        Slack::Messages::Message.new
+      )
+      expect(cursor).not_to receive(:sleep)
+      cursor.to_a
+    end
+    context 'with rate limiting' do
+      let(:error) { Slack::Web::Api::Errors::TooManyRequestsError.new(nil) }
+      context 'with default max retries' do
+        it 'sleeps after a TooManyRequestsError' do
+          expect(client).to receive(:users_list).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)
+          expect(error).to receive(:retry_after).once.ordered.and_return(9)
+          expect(cursor).to receive(:sleep).once.ordered.with(9)
+          expect(client).to receive(:users_list).with(limit: 100, cursor: 'next').ordered.and_return(Slack::Messages::Message.new)
+          cursor.to_a
+        end
+      end
+      context 'with a custom max_retries' do
+        let(:cursor) { Slack::Web::Api::Pagination::Cursor.new(client, 'users_list', max_retries: 4) }
+        it 'raises the error after hitting the max retries' do
+          expect(client).to receive(:users_list).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)
+          expect(error).to receive(:retry_after).exactly(4).times.and_return(9)
+          expect(cursor).to receive(:sleep).exactly(4).times.with(9)
+          expect { cursor.to_a }.to raise_error(error)
+        end
+      end
+    end
+  end
+  context 'with a custom limit' do
+    let(:cursor) { Slack::Web::Api::Pagination::Cursor.new(client, 'users_list', limit: 42) }
+    it 'overrides default limit' do
+      expect(client).to receive(:users_list).with(limit: 42, cursor: nil)
+      cursor.first
+    end
+  end
+  context 'with a custom sleep_interval' do
+    let(:cursor) { Slack::Web::Api::Pagination::Cursor.new(client, 'users_list', sleep_interval: 3) }
+    it 'sleeps between requests' do
+      expect(client).to receive(:users_list).exactly(3).times.and_return(
+        Slack::Messages::Message.new(response_metadata: { next_cursor: 'next_a' }),
+        Slack::Messages::Message.new(response_metadata: { next_cursor: 'next_b' }),
+        Slack::Messages::Message.new
+      )
+      expect(cursor).to receive(:sleep).with(3).twice
+      cursor.to_a
+    end
+  end
+end

data/spec/support/queue_with_timeout.rb

@@ -26,7 +26,7 @@ class QueueWithTimeout
       if @queue.empty?
         @recieved.wait(@mutex, timeout) if timeout != 0
         # if we're still empty after the timeout, raise exception
-        fail ThreadError, 'queue empty' if @queue.empty?
+        raise ThreadError, 'queue empty' if @queue.empty?
       end
       @queue.shift
     end

data/spec/support/real_time/concurrency/mock.rb

@@ -6,8 +6,7 @@ module Slack
         end
 
         class Socket < ::Slack::RealTime::Socket
-          def self.close
-          end
+          def self.close; end
 
           def start_async(client)
             reactor = Thread.new {}