slack-ruby-client 0.7.2 → 1.0.0

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,5 +149,183 @@ RSpec.describe Slack::Web::Client do
         end
       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|
+          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
+          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
+          expect(conn.options.open_timeout).to eq 15
+        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
+        request = nil
+        response = conn.post do |r|
+          r.path = 'rtm.start'
+          r.headers = {
+            'Accept' => ['application/json; charset=utf-8'],
+            'Authorization' => ['Bearer <SLACK_API_TOKEN>']
+          }
+          request = r
+        end
+
+        expect(conn).to receive(:post).and_yield(request).and_return(response)
+
+        client.rtm_start(request: { timeout: 3 })
+
+        expect(request.options.timeout).to eq 3
+      end
+    end
+
+    context 'calling undocumented methods' do
+      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).to receive(:post)
+        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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Faraday::Response::RaiseError do
+  subject(:raise_error_obj) { described_class.new(app) }
+
+  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(
+          raise_error(Slack::Web::Api::Errors::TooManyRequestsError)
+        )
+      end
+    end
+
+    context 'with an ok payload in the body' do
+      let(:body) { { 'ok' => 'true' } }
+
+      it 'is nil' do
+        expect(raise_error_obj.on_complete(env)).to eq nil
+      end
+    end
+
+    context 'with a single known error in the body' do
+      let(:body) do
+        {
+          'ok' => false,
+          'error' => 'already_in_channel',
+          'response_metadata' => { 'messages' => [] }
+        }
+      end
+
+      it 'raises an error of the matching type with the error message' do
+        expect { raise_error_obj.on_complete(env) }.to(
+          raise_error(Slack::Web::Api::Errors::AlreadyInChannel, 'already_in_channel')
+        )
+      end
+    end
+
+    context 'with a single unknown error in the body' do
+      let(:body) do
+        {
+          'ok' => false,
+          'error' => 'unknown_error',
+          'response_metadata' => { 'messages' => [] }
+        }
+      end
+
+      it 'raises a SlackError with the error message' do
+        expect { raise_error_obj.on_complete(env) }.to(
+          raise_error(Slack::Web::Api::Errors::SlackError, 'unknown_error')
+        )
+      end
+    end
+
+    context 'with multiple errors in the body' do
+      let(:body) do
+        {
+          'ok' => false,
+          'errors' => [
+            { 'error' => 'already_in_channel' },
+            { 'error' => 'something_else_terrible' }
+          ]
+        }
+      end
+
+      it 'raises a SlackError with the concatenated error messages' do
+        expect { raise_error_obj.on_complete(env) }.to(
+          raise_error(
+            Slack::Web::Api::Errors::SlackError,
+            'already_in_channel,something_else_terrible'
+          )
+        )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,14 +1,21 @@
+# frozen_string_literal: true
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
 
 require 'rubygems'
 require 'rspec'
+require 'timecop'
 
-require 'slack-ruby-client'
+require 'slack_ruby_client'
 
 Dir[File.join(File.dirname(__FILE__), 'support', '**/*.rb')].each do |file|
   require 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|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
 end

data/spec/support/queue_with_timeout.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # http://spin.atomicobject.com/2014/07/07/ruby-queue-pop-timeout/
 class QueueWithTimeout
   def initialize
@@ -6,15 +7,15 @@ class QueueWithTimeout
     @recieved = ConditionVariable.new
   end
 
-  def push(x)
+  def push(item)
     @mutex.synchronize do
-      @queue << x
+      @queue << item
       @recieved.signal
     end
   end
 
-  def <<(x)
-    push(x)
+  def <<(item)
+    push(item)
   end
 
   def pop(non_block = false)
@@ -26,7 +27,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

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

data/spec/support/real_time/connected_client.rb

@@ -1,13 +1,18 @@
+# frozen_string_literal: true
 RSpec.shared_context 'connected client' do |opts|
   let(:client) { Slack::RealTime::Client.new(opts || {}) }
   let(:ws) { double(Slack::RealTime::Concurrency::Mock::WebSocket) }
-  let(:url) { 'wss://ms173.slack-msgs.com/websocket/lqcUiAvrKTP-uuid=' }
+  let(:url) { 'wss://cerberus-xxxx.lb.slack-msgs.com/websocket/uid' }
   let(:socket) { double(Slack::RealTime::Socket, connected?: true) }
+
   before do
     Slack::RealTime.configure do |config|
       config.concurrency = Slack::RealTime::Concurrency::Mock
+      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)
+    allow(Slack::RealTime::Socket).to(
+      receive(:new).with(url, ping: 30, logger: Slack::Logger.default).and_return(socket)
+    )
     allow(socket).to receive(:start_sync)
     allow(socket).to receive(:connect!)
     allow(ws).to receive(:on)

data/spec/support/real_time/event.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     class Event

data/spec/support/token.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 RSpec.configure do |config|
   config.before do
     @old_token = Slack::Config.token

data/spec/support/vcr.rb

@@ -1,9 +1,45 @@
+# frozen_string_literal: true
 require 'vcr'
 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