slack-ruby-client 0.14.6 → 1.0.0

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+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: 'C019CV63UTC', topic: 'new topic' })
+      expect(rc.channel.topic.value).to eq 'new topic'
+    end
+
+    it 'resolves IDs via conversations_list', vcr: { cassette_name: 'web/conversations_setTopic_one_page' } do
+      rc = subject.conversations_setTopic({ channel: '#1', topic: 'new topic' })
+      expect(rc.channel.topic.value).to eq 'new topic'
+    end
+
+    it 'paginates to resolve IDs', vcr: { cassette_name: 'web/conversations_setTopic_paginated' } do
+      rc = subject.conversations_setTopic({ channel: '#topic', topic: 'new topic' })
+      expect(rc.channel.topic.value).to eq 'new topic'
+    end
+  end
+end

data/spec/slack/web/api/mixins/{channels_spec.rb → conversations_spec.rb}

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

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

@@ -13,7 +13,7 @@ RSpec.describe Slack::Web::Api::Mixins::Users do
   end
 
   before do
-    allow(users).to receive(:users_list).and_return(
+    allow(users).to receive(:users_list).and_yield(
       Slack::Messages::Message.new(
         'members' => [{
           'id' => 'UDEADBEEF',

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

@@ -30,7 +30,7 @@ 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
@@ -43,7 +43,6 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
           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)
@@ -67,7 +66,6 @@ RSpec.describe Slack::Web::Api::Pagination::Cursor do
           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

data/spec/slack/web/client_spec.rb

@@ -150,6 +150,50 @@ RSpec.describe Slack::Web::Client do
       end
     end
 
+    context 'adapter option' do
+      let(:adapter) { Faraday.default_adapter }
+      let(:adapter_class) { Faraday::Adapter::NetHttp }
+
+      around do |ex|
+        previous_adapter = Faraday.default_adapter
+        # ensure default adapter is set for this spec
+        Faraday.default_adapter = :net_http
+        ex.run
+        Faraday.default_adapter = previous_adapter
+      end
+
+      context 'default adapter' do
+        describe '#initialize' 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
+        end
+      end
+
+      context 'non default adapter' do
+        let(:adapter) { :typhoeus }
+        let(:adapter_class) { Faraday::Adapter::Typhoeus }
+
+        before do
+          described_class.configure do |config|
+            config.adapter = adapter
+          end
+        end
+
+        describe '#initialize' 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
+        end
+      end
+    end
+
     context 'timeout options' do
       before do
         described_class.configure do |config|
@@ -182,7 +226,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
 
@@ -205,5 +252,80 @@ RSpec.describe Slack::Web::Client do
         client.users_admin_setInactive(user: 'U092BDCLV')
       end
     end
+
+    context 'persistent capability' do
+      describe '#initialize' do
+        it 'caches the Faraday connection to allow persistent adapters' do
+          first = client.send(:connection)
+          second = client.send(:connection)
+
+          expect(first).to equal second
+        end
+      end
+    end
+
+    context 'server failures' do
+      subject(:request) { client.api_test }
+
+      let(:stub_slack_request) { stub_request(:post, 'https://slack.com/api/api.test') }
+      let(:exception) do
+        request
+      rescue Slack::Web::Api::Errors::ServerError => e
+        return e
+      end
+
+      context 'parsing error' do
+        before {  stub_slack_request.to_return(body: '<html></html>') }
+
+        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)
+        end
+      end
+
+      context 'timeout' do
+        context 'open timeout' do
+          before { stub_slack_request.to_timeout }
+
+          it 'raises TimoutError' do
+            expect { request }.to raise_error(Slack::Web::Api::Errors::TimeoutError).with_message('timeout_error')
+            expect(exception.cause).to be_a(Faraday::ConnectionFailed)
+            expect(exception.cause.cause).to be_a(Net::OpenTimeout)
+          end
+        end
+
+        context 'read timeout' do
+          before { stub_slack_request.to_raise(Net::ReadTimeout) }
+
+          it 'raises TimeoutError' do
+            expect { request }.to raise_error(Slack::Web::Api::Errors::TimeoutError).with_message('timeout_error')
+            expect(exception.cause).to be_a(Faraday::TimeoutError)
+            expect(exception.cause.cause).to be_a(Net::ReadTimeout)
+          end
+        end
+      end
+
+      context '5xx response' do
+        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
+
+        context 'with a HTML response' do
+          before { stub_slack_request.to_return(status: 500, body: '<html></html>') }
+
+          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
   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

@@ -2,16 +2,18 @@
 require 'spec_helper'
 
 RSpec.describe Slack::Web::Faraday::Response::RaiseError do
-  subject(:raise_error_obj) { described_class.new }
+  subject(:raise_error_obj) { described_class.new(app) }
 
-  describe '#on_complete' do
-    let(:status) { 200 }
-    let(:response) { nil }
-    let(:body) { {} }
-    let(:env) { double status: status, response: response, body: body }
+  let(:app) { proc {} }
+  let(:status) { 200 }
+  let(:response) { nil }
+  let(:body) { {} }
+  let(:env) { double status: status, response: response, body: body, success?: true }
 
+  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(

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

data/spec/support/vcr.rb

@@ -5,6 +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.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