slack-ruby-client 0.12.0 → 0.14.6

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

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Slack::Web::Client do
-  let(:client) { Slack::Web::Client.new }
-  it 'raises a Faraday::ClientError when Slack is unavailable', vcr: { cassette_name: 'web/503_error' } do
+  let(:client) { described_class.new }
+
+  it 'raises a Faraday::ClientError when Slack is unavailable',
+     vcr: { cassette_name: 'web/503_error' } do
     begin
       client.auth_test
       raise 'Expected to receive Faraday::ClientError.'
     rescue Faraday::ClientError => e
-      expect(e.response).to_not be_nil
+      expect(e.response).not_to be_nil
       expect(e.response[:status]).to eq 503
     end
   end

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

@@ -1,14 +1,38 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Errors::SlackError do
   let(:client) { Slack::Web::Client.new }
+
   it 'provides access to the response object', vcr: { cassette_name: 'web/auth_test_error' } do
     begin
       client.auth_test
       raise 'Expected to receive Slack::Web::Api::Errors::SlackError.'
-    rescue Slack::Web::Api::Errors::SlackError => e
-      expect(e.response).to_not be_nil
+    rescue described_class => e
+      expect(e.response).not_to be_nil
+      expect(e.response.status).to eq 200
+      expect(e.message).to eql 'not_authed'
+      expect(e.error).to eql 'not_authed'
+      expect(e.response_metadata).to be_nil
+    end
+  end
+
+  it 'provides access to any response_metadata', vcr: { cassette_name: 'web/views_open_error' } do
+    begin
+      client.views_open(trigger_id: 'trigger_id', view: {})
+      raise 'Expected to receive Slack::Web::Api::Errors::SlackError.'
+    rescue described_class => e
+      expect(e.response).not_to be_nil
       expect(e.response.status).to eq 200
+      expect(e.message).to eql 'invalid_arguments'
+      expect(e.error).to eql 'invalid_arguments'
+      expect(e.response_metadata).to eq(
+        'messages' => [
+          "[ERROR] missing required field: title [json-pointer:\/view]",
+          "[ERROR] missing required field: blocks [json-pointer:\/view]",
+          "[ERROR] missing required field: type [json-pointer:\/view]"
+        ]
+      )
     end
   end
 end

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

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Mixins::Channels do
+  subject(:channels) do
+    klass.new
+  end
+
   let(:klass) do
     Class.new do
       include Slack::Web::Api::Mixins::Channels
     end
   end
-  subject do
-    klass.new
-  end
+
   before do
-    allow(subject).to receive(:channels_list).and_return(
+    allow(channels).to receive(:channels_list).and_return(
       Slack::Messages::Message.new(
         'channels' => [{
           'id' => 'CDEADBEEF',
@@ -19,15 +22,22 @@ RSpec.describe Slack::Web::Api::Mixins::Channels do
       )
     )
   end
+
   context '#channels_id' do
     it 'leaves channels specified by ID alone' do
-      expect(subject.channels_id(channel: 'C123456')).to eq('ok' => true, 'channel' => { 'id' => 'C123456' })
+      expect(channels.channels_id(channel: 'C123456')).to(
+        eq('ok' => true, 'channel' => { 'id' => 'C123456' })
+      )
     end
     it 'translates a channel that starts with a #' do
-      expect(subject.channels_id(channel: '#general')).to eq('ok' => true, 'channel' => { 'id' => 'CDEADBEEF' })
+      expect(channels.channels_id(channel: '#general')).to(
+        eq('ok' => true, 'channel' => { 'id' => 'CDEADBEEF' })
+      )
     end
     it 'fails with an exception' do
-      expect { subject.channels_id(channel: '#invalid') }.to raise_error Slack::Web::Api::Errors::SlackError, 'channel_not_found'
+      expect { channels.channels_id(channel: '#invalid') }.to(
+        raise_error(Slack::Web::Api::Errors::SlackError, 'channel_not_found')
+      )
     end
   end
 end

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

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Mixins::Groups do
+  subject(:groups) do
+    klass.new
+  end
+
   let(:klass) do
     Class.new do
       include Slack::Web::Api::Mixins::Groups
     end
   end
-  subject do
-    klass.new
-  end
+
   before do
-    allow(subject).to receive(:groups_list).and_return(
+    allow(groups).to receive(:groups_list).and_return(
       Slack::Messages::Message.new(
         'groups' => [{
           'id' => 'CDEADBEEF',
@@ -19,15 +22,22 @@ RSpec.describe Slack::Web::Api::Mixins::Groups do
       )
     )
   end
+
   context '#groups_id' do
     it 'leaves groups specified by ID alone' do
-      expect(subject.groups_id(channel: 'C123456')).to eq('ok' => true, 'group' => { 'id' => 'C123456' })
+      expect(groups.groups_id(channel: 'C123456')).to(
+        eq('ok' => true, 'group' => { 'id' => 'C123456' })
+      )
     end
     it 'translates a channel that starts with a #' do
-      expect(subject.groups_id(channel: '#general')).to eq('ok' => true, 'group' => { 'id' => 'CDEADBEEF' })
+      expect(groups.groups_id(channel: '#general')).to(
+        eq('ok' => true, 'group' => { 'id' => 'CDEADBEEF' })
+      )
     end
     it 'fails with an exception' do
-      expect { subject.groups_id(channel: '#invalid') }.to raise_error Slack::Web::Api::Errors::SlackError, 'channel_not_found'
+      expect { groups.groups_id(channel: '#invalid') }.to(
+        raise_error(Slack::Web::Api::Errors::SlackError, 'channel_not_found')
+      )
     end
   end
 end

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

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Mixins::Users do
+  subject(:users) do
+    klass.new
+  end
+
   let(:klass) do
     Class.new do
       include Slack::Web::Api::Mixins::Users
     end
   end
-  subject do
-    klass.new
-  end
+
   before do
-    allow(subject).to receive(:users_list).and_return(
+    allow(users).to receive(:users_list).and_return(
       Slack::Messages::Message.new(
         'members' => [{
           'id' => 'UDEADBEEF',
@@ -20,21 +23,27 @@ RSpec.describe Slack::Web::Api::Mixins::Users do
       )
     )
   end
+
   context '#users_id' do
     it 'leaves users specified by ID alone' do
-      expect(subject.users_id(user: 'U123456')).to eq('ok' => true, 'user' => { 'id' => 'U123456' })
+      expect(users.users_id(user: 'U123456')).to eq('ok' => true, 'user' => { 'id' => 'U123456' })
     end
     it 'translates a user that starts with a #' do
-      expect(subject.users_id(user: '@aws')).to eq('ok' => true, 'user' => { 'id' => 'UDEADBEEF' })
+      expect(users.users_id(user: '@aws')).to eq('ok' => true, 'user' => { 'id' => 'UDEADBEEF' })
     end
     it 'fails with an exception' do
-      expect { subject.users_id(user: '@foo') }.to raise_error Slack::Web::Api::Errors::SlackError, 'user_not_found'
+      expect { users.users_id(user: '@foo') }.to(
+        raise_error(Slack::Web::Api::Errors::SlackError, 'user_not_found')
+      )
     end
   end
+
   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' => {} }])
+        expect(users.users_search(user: 'aws')).to(
+          eq('ok' => true, 'members' => [{ 'id' => 'UDEADBEEF', 'name' => 'aws', 'profile' => {} }])
+        )
       end
     end
   end

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

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
 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', {}) }
+    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)
       cursor.first
@@ -13,7 +16,9 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
       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))
+      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
@@ -26,21 +31,42 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
     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(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)
+          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) }
+        let(:cursor) { described_class.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(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)
@@ -48,15 +74,19 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
       end
     end
   end
+
   context 'with a custom limit' do
-    let(:cursor) { Slack::Web::Api::Pagination::Cursor.new(client, 'users_list', limit: 42) }
+    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)
       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) }
+    let(:cursor) { described_class.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' }),

data/spec/slack/web/client_spec.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Slack::Web::Client do
   before do
     Slack::Config.reset
   end
+
   context 'with defaults' do
-    let(:client) { Slack::Web::Client.new }
+    let(:client) { described_class.new }
+
     describe '#initialize' do
       it 'sets user-agent' do
         expect(client.user_agent).to eq Slack::Web::Config.user_agent
@@ -18,30 +21,36 @@ RSpec.describe Slack::Web::Client do
       end
     end
   end
+
   context 'with custom settings' do
     describe '#initialize' do
       Slack::Web::Config::ATTRIBUTES.each do |key|
-        context key do
-          let(:client) { Slack::Web::Client.new(key => 'custom') }
+        context key.to_s do
+          let(:client) { described_class.new(key => 'custom') }
+
           it "sets #{key}" do
-            expect(client.send(key)).to_not eq Slack::Web::Config.send(key)
+            expect(client.send(key)).not_to eq Slack::Web::Config.send(key)
             expect(client.send(key)).to eq 'custom'
           end
         end
       end
     end
   end
+
   context 'global config' do
     after do
-      Slack::Web::Client.config.reset
+      described_class.config.reset
     end
-    let(:client) { Slack::Web::Client.new }
+
+    let(:client) { described_class.new }
+
     context 'user-agent' do
       before do
-        Slack::Web::Client.configure do |config|
+        described_class.configure do |config|
           config.user_agent = 'custom/user-agent'
         end
       end
+
       describe '#initialize' do
         it 'sets user-agent' do
           expect(client.user_agent).to eq 'custom/user-agent'
@@ -54,38 +63,43 @@ RSpec.describe Slack::Web::Client do
         end
       end
     end
+
     context 'token' do
       before do
         Slack.configure do |config|
           config.token = 'global default'
         end
       end
+
       it 'defaults token to global default' do
-        client = Slack::Web::Client.new
+        client = described_class.new
         expect(client.token).to eq 'global default'
       end
       context 'with web config' do
         before do
-          Slack::Web::Client.configure do |config|
+          described_class.configure do |config|
             config.token = 'custom web token'
           end
         end
+
         it 'overrides token to web config' do
-          client = Slack::Web::Client.new
+          client = described_class.new
           expect(client.token).to eq 'custom web token'
         end
         it 'overrides token to specific token' do
-          client = Slack::Web::Client.new(token: 'local token')
+          client = described_class.new(token: 'local token')
           expect(client.token).to eq 'local token'
         end
       end
     end
+
     context 'proxy' do
       before do
-        Slack::Web::Client.configure do |config|
+        described_class.configure do |config|
           config.proxy = 'http://localhost:8080'
         end
       end
+
       describe '#initialize' do
         it 'sets proxy' do
           expect(client.proxy).to eq 'http://localhost:8080'
@@ -95,13 +109,15 @@ RSpec.describe Slack::Web::Client do
         end
       end
     end
+
     context 'SSL options' do
       before do
-        Slack::Web::Client.configure do |config|
+        described_class.configure do |config|
           config.ca_path = '/ca_path'
           config.ca_file = '/ca_file'
         end
       end
+
       describe '#initialize' do
         it 'sets ca_path and ca_file' do
           expect(client.ca_path).to eq '/ca_path'
@@ -114,13 +130,16 @@ RSpec.describe Slack::Web::Client do
         end
       end
     end
+
     context 'logger option' do
       let(:logger) { Logger.new(STDOUT) }
+
       before do
-        Slack::Web::Client.configure do |config|
+        described_class.configure do |config|
           config.logger = logger
         end
       end
+
       describe '#initialize' do
         it 'sets logger' do
           expect(client.logger).to eq logger
@@ -130,13 +149,15 @@ RSpec.describe Slack::Web::Client do
         end
       end
     end
+
     context 'timeout options' do
       before do
-        Slack::Web::Client.configure do |config|
+        described_class.configure do |config|
           config.timeout = 10
           config.open_timeout = 15
         end
       end
+
       describe '#initialize' do
         it 'sets timeout and open_timeout' do
           expect(client.timeout).to eq 10
@@ -149,13 +170,15 @@ RSpec.describe Slack::Web::Client do
         end
       end
     end
+
     context 'per-request options' do
       it 'applies timeout', vcr: { cassette_name: 'web/rtm_start', 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
+        # get the yielded request to reuse in the next call to
+        # rtm_start so that we can examine request.options later
         request = nil
         response = conn.post do |r|
           r.path = 'rtm.start'
@@ -170,10 +193,14 @@ RSpec.describe Slack::Web::Client do
         expect(request.options.timeout).to eq 3
       end
     end
+
     context 'calling undocumented methods' do
-      let(:client) { Slack::Web::Client.new }
+      let(:client) { described_class.new }
+
       it 'produces a warning' do
-        expect(client.logger).to receive(:warn).with('The users.admin.setInactive method is undocumented.')
+        expect(client.logger).to(
+          receive(:warn).with('The users.admin.setInactive method is undocumented.')
+        )
         expect(client).to receive(:post)
         client.users_admin_setInactive(user: 'U092BDCLV')
       end