slack-ruby-client 0.16.0 → 1.1.0

data/spec/slack/web/api/endpoints/team_preferences_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::TeamPreferences do
+  let(:client) { Slack::Web::Client.new }
+end

data/spec/slack/web/api/endpoints/tooling_tokens_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::ToolingTokens do
+  let(:client) { Slack::Web::Client.new }
+  context 'tooling.tokens_rotate' do
+    it 'requires refresh_token' do
+      expect { client.tooling_tokens_rotate }.to raise_error ArgumentError, /Required arguments :refresh_token missing/
+    end
+  end
+end

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

@@ -12,10 +12,10 @@ RSpec.describe Slack::Web::Api::Endpoints::UsergroupsUsers do
   end
   context 'usergroups.users_update' do
     it 'requires usergroup' do
-      expect { client.usergroups_users_update(users: %q[U060R4BJ4,U060RNRCZ]) }.to raise_error ArgumentError, /Required arguments :usergroup missing/
+      expect { client.usergroups_users_update(users: %q[]) }.to raise_error ArgumentError, /Required arguments :usergroup missing/
     end
     it 'requires users' do
-      expect { client.usergroups_users_update(usergroup: %q[S0604QSJC]) }.to raise_error ArgumentError, /Required arguments :users missing/
+      expect { client.usergroups_users_update(usergroup: %q[]) }.to raise_error ArgumentError, /Required arguments :users missing/
     end
   end
 end

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

@@ -5,12 +5,10 @@ RSpec.describe Slack::Web::Api::Error 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::Error.'
-    rescue described_class => e
-      expect(e.response).not_to be_nil
-      expect(e.response.status).to eq 200
-    end
+    client.auth_test
+    raise 'Expected to receive Slack::Web::Api::Error.'
+  rescue described_class => e
+    expect(e.response).not_to be_nil
+    expect(e.response.status).to eq 200
   end
 end

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

@@ -5,34 +5,29 @@ 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 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
+    client.auth_test
+    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 'not_authed'
+    expect(e.error).to eql 'not_authed'
+    expect(e.response_metadata).to be_nil
   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
+    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] failed to match all allowed schemas [json-pointer:/view]',
+        '[ERROR] missing required field: type [json-pointer:/view]'
+      ]
+    )
   end
 end

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 RSpec.describe Slack::Web::Client do
   context 'conversations_setTopic' do
     it 'does not invoke conversations_list', vcr: { cassette_name: 'web/conversations_setTopic' } do
-      rc = subject.conversations_setTopic({ channel: 'C018Y6VH39D', topic: 'new topic' })
+      rc = subject.conversations_setTopic({ channel: 'C019CV63UTC', topic: 'new topic' })
       expect(rc.channel.topic.value).to eq 'new topic'
     end
 

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

@@ -8,7 +8,7 @@ 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
@@ -30,24 +30,23 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
       cursor.to_a
     end
     context 'with rate limiting' do
-      let(:error) { Slack::Web::Api::Errors::TooManyRequestsError.new(nil) }
+      let(:error) { Slack::Web::Api::Errors::TooManyRequestsError.new(OpenStruct.new(headers: { 'retry-after' => 9 })) }
 
       context 'with default max retries' 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(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')
+              .with({ limit: 100, cursor: 'next' })
               .ordered
               .and_return(Slack::Messages::Message.new)
           )
@@ -61,13 +60,12 @@ 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(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
@@ -79,7 +77,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
@@ -226,7 +227,10 @@ RSpec.describe Slack::Web::Client do
         request = nil
         response = conn.post do |r|
           r.path = 'rtm.start'
-          r.body = { token: 'token' }
+          r.headers = {
+            'Accept' => ['application/json; charset=utf-8'],
+            'Authorization' => ['Bearer <SLACK_API_TOKEN>']
+          }
           request = r
         end
 
@@ -250,21 +254,6 @@ RSpec.describe Slack::Web::Client do
       end
     end
 
-    context 'when calling deprecated methods' do
-      let(:client) { described_class.new }
-
-      it 'produces a warning' do
-        expect(client.logger).to receive(:warn).with(/
-          ^channels\.archive:\ This\ method\ is\ deprecated
-          .+
-          Alternative\ methods:\ conversations\.archive\.
-        /x)
-
-        expect(client).to receive(:post)
-        client.channels_archive(channel: 'test')
-      end
-    end
-
     context 'persistent capability' do
       describe '#initialize' do
         it 'caches the Faraday connection to allow persistent adapters' do
@@ -281,21 +270,34 @@ RSpec.describe Slack::Web::Client do
 
       let(:stub_slack_request) { stub_request(:post, 'https://slack.com/api/api.test') }
       let(:exception) do
-        begin
-          request
-        rescue Slack::Web::Api::Errors::ServerError => e
-          return e
-        end
+        request
+      rescue Slack::Web::Api::Errors::ServerError => e
+        return e
       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.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('<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('{')
+            expect(exception.cause).to be_a(Faraday::ParsingError)
+            expect(exception.cause.cause).to be_a(JSON::ParserError)
+          end
         end
       end
 
@@ -322,12 +324,24 @@ RSpec.describe Slack::Web::Client do
       end
 
       context '5xx response' do
-        before { stub_slack_request.to_return(status: 500, body: '{}') }
+        context 'with a JSON body' do
+          before { stub_slack_request.to_return(status: 500, body: '{}') }
+
+          it 'raises UnavailableError' do
+            expect { request }.to raise_error(Slack::Web::Api::Errors::UnavailableError).with_message('unavailable_error')
+            expect(exception.response.status).to eq(500)
+          end
+        end
 
-        it 'raises UnavailableError' do
-          expect { request }.to raise_error(Slack::Web::Api::Errors::UnavailableError).with_message('unavailable_error')
-          expect(exception.cause).to be_a(Faraday::ServerError)
-          expect(exception.response.status).to eq(500)
+        context 'with a HTML response' do
+          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')
+            expect(exception.response.status).to eq(500)
+          end
         end
       end
     end

data/spec/slack/web/faraday/request_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+class DummyClient
+  include Slack::Web::Faraday::Connection
+  include Slack::Web::Faraday::Request
+
+  attr_reader :token
+
+  def initialize(token)
+    @token = token
+  end
+end
+
+RSpec.describe Slack::Web::Faraday::Request do
+  let(:token) { 'by-the-power-of-grayskull' }
+  let(:client) { DummyClient.new(token) }
+
+  before do
+    Slack::Config.reset
+  end
+
+  context 'authorization' do
+    let(:path) { '/any-path' }
+    let(:options) { {} }
+    let(:connection) { instance_double('Faraday::Connection') }
+    let(:request) { instance_double('Faraday::Request') }
+    let(:headers) { instance_double('Faraday::Utils::Headers') }
+    let(:response) { instance_double('Faraday::Response', body: '') }
+
+    before do
+      allow(client).to receive(:connection).and_return(connection)
+      allow(request).to receive(:url).with(path, options)
+      allow(request).to receive(:path=).with(path)
+      allow(request).to receive(:headers).and_return(headers)
+      allow(connection).to receive(:send)
+        .with(method).and_yield(request).and_return(response)
+    end
+
+    describe '#get' do
+      let(:method) { :get }
+
+      it 'sets authorization header' do
+        expect(headers).to receive(:[]=)
+          .with('Authorization', "Bearer #{token}")
+        client.send(method, path, options)
+      end
+    end
+
+    describe '#post' do
+      let(:method) { :post }
+
+      it 'sets authorization header' do
+        expect(headers).to receive(:[]=)
+          .with('Authorization', "Bearer #{token}")
+        client.send(method, path, options)
+      end
+    end
+
+    describe '#put' do
+      let(:method) { :put }
+
+      it 'sets authorization header' do
+        expect(headers).to receive(:[]=)
+          .with('Authorization', "Bearer #{token}")
+        client.send(method, path, options)
+      end
+    end
+
+    describe '#delete' do
+      let(:method) { :delete }
+
+      it 'sets authorization header' do
+        expect(headers).to receive(:[]=)
+          .with('Authorization', "Bearer #{token}")
+        client.send(method, path, options)
+      end
+    end
+  end
+end

data/spec/slack/web/faraday/response/raise_error_spec.rb

@@ -13,6 +13,7 @@ RSpec.describe Slack::Web::Faraday::Response::RaiseError do
   describe '#on_complete' do
     context 'with status of 429' do
       let(:status) { 429 }
+      let(:response) { OpenStruct.new(headers: { 'retry-after' => 10 }) }
 
       it 'raises a TooManyRequestsError' do
         expect { raise_error_obj.on_complete(env) }.to(
@@ -25,7 +26,7 @@ RSpec.describe Slack::Web::Faraday::Response::RaiseError do
       let(:body) { { 'ok' => 'true' } }
 
       it 'is nil' do
-        expect(raise_error_obj.on_complete(env)).to eq nil
+        expect(raise_error_obj.on_complete(env)).to be_nil
       end
     end
 

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ Dir[File.join(File.dirname(__FILE__), 'support', '**/*.rb')].each do |file|
 end
 
 Slack.configure do |config|
-  config.token = ENV['SLACK_API_TOKEN']
+  config.token = '<SLACK_API_TOKEN>' # ENV['SLACK_API_TOKEN']
 end
 
 RSpec.configure do |config|

data/spec/support/real_time/connected_client.rb

@@ -2,13 +2,7 @@
 RSpec.shared_context 'connected client' do |opts|
   let(:client) { Slack::RealTime::Client.new(opts || {}) }
   let(:ws) { double(Slack::RealTime::Concurrency::Mock::WebSocket) }
-  let(:url) do
-    if Slack::RealTime.config.store_class == Slack::RealTime::Stores::Store
-      'wss://ms173.slack-msgs.com/websocket/lqcUiAvrKTP-uuid='
-    else
-      'wss://mpmulti-w5tz.slack-msgs.com/websocket/uid'
-    end
-  end
+  let(:url) { 'wss://cerberus-xxxx.lb.slack-msgs.com/websocket/uid' }
   let(:socket) { double(Slack::RealTime::Socket, connected?: true) }
 
   before do
@@ -17,7 +11,7 @@ RSpec.shared_context 'connected client' do |opts|
       config.store_class = (opts || {})[:store_class] || Slack::RealTime::Stores::Store
     end
     allow(Slack::RealTime::Socket).to(
-      receive(:new).with(url, ping: 30, logger: Slack::Logger.default).and_return(socket)
+      receive(:new).with(url, { ping: 30, logger: Slack::Logger.default }).and_return(socket)
     )
     allow(socket).to receive(:start_sync)
     allow(socket).to receive(:connect!)

data/spec/support/vcr.rb

@@ -5,10 +5,41 @@ require 'webmock/rspec'
 VCR.configure do |config|
   config.cassette_library_dir = 'spec/fixtures/slack'
   config.hook_into :webmock
-  # config.default_cassette_options = { record: :new_episodes }
   config.configure_rspec_metadata!
+  if ENV.key?('SLACK_API_TOKEN')
+    config.filter_sensitive_data('<SLACK_API_TOKEN>') do
+      ENV['SLACK_API_TOKEN']
+    end
+  end
   config.before_record do |i|
-    i.request.body.gsub!(ENV['SLACK_API_TOKEN'], 'token') if ENV.key?('SLACK_API_TOKEN')
     i.response.body.force_encoding('UTF-8')
   end
+  config.register_request_matcher :client_headers do |recorded, actual|
+    authorizations = ENV.key?('SLACK_API_TOKEN') ? actual.headers['Authorization'].map do |auth|
+      auth.gsub(ENV['SLACK_API_TOKEN'], '<SLACK_API_TOKEN>')
+    end : actual.headers['Authorization']
+    actual.headers['Accept'] == recorded.headers['Accept'] &&
+      authorizations == recorded.headers['Authorization']
+  end
+  config.default_cassette_options = {
+    match_requests_on: %i[method uri body client_headers]
+    # record: :new_episodes
+  }
+end
+
+module VCR
+  module Errors
+    class UnhandledHTTPRequestError
+      private
+
+      # Force unhandled HTTP error reports to include the headers
+      # for our custom matcher `client_headers`.
+      #
+      # This patch can be removed if https://github.com/vcr/vcr/issues/912
+      # is ever resolved.
+      def match_request_on_headers?
+        true
+      end
+    end
+  end
 end