slack-ruby-client 2.3.0 → 2.5.0

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

@@ -1,102 +0,0 @@
-# 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) { 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
-    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(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 })
-              .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(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) { 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(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) { 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) { 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' }),
-        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/slack/web/client_spec.rb

@@ -1,359 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'faraday/typhoeus'
-
-RSpec.describe Slack::Web::Client do
-  before do
-    Slack::Config.reset
-  end
-
-  context 'with defaults' do
-    let(:client) { described_class.new }
-
-    describe '#initialize' do
-      it 'sets user-agent' do
-        expect(client.user_agent).to eq Slack::Web::Config.user_agent
-        expect(client.user_agent).to include Slack::VERSION
-      end
-
-      (Slack::Web::Config::ATTRIBUTES - [:logger]).each do |key|
-        it "sets #{key}" do
-          expect(client.send(key)).to eq Slack::Web::Config.send(key)
-        end
-      end
-    end
-  end
-
-  context 'with custom settings' do
-    describe '#initialize' do
-      Slack::Web::Config::ATTRIBUTES.each do |key|
-        context key.to_s do
-          let(:client) { described_class.new(key => 'custom') }
-
-          it "sets #{key}" do
-            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
-      described_class.config.reset
-    end
-
-    let(:client) { described_class.new }
-
-    context 'user-agent' do
-      before do
-        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'
-        end
-
-        it 'creates a connection with the custom user-agent' do
-          expect(client.send(:connection).headers).to eq(
-            'Accept' => 'application/json; charset=utf-8',
-            'User-Agent' => 'custom/user-agent'
-          )
-        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 = described_class.new
-        expect(client.token).to eq 'global default'
-      end
-
-      context 'with web config' do
-        before do
-          described_class.configure do |config|
-            config.token = 'custom web token'
-          end
-        end
-
-        it 'overrides token to web config' do
-          client = described_class.new
-          expect(client.token).to eq 'custom web token'
-        end
-
-        it 'overrides token to specific token' do
-          client = described_class.new(token: 'local token')
-          expect(client.token).to eq 'local token'
-        end
-      end
-    end
-
-    context 'proxy' do
-      before do
-        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'
-        end
-
-        it 'creates a connection with the proxy' do
-          expect(client.send(:connection).proxy.uri.to_s).to eq 'http://localhost:8080'
-        end
-      end
-    end
-
-    context 'SSL options' do
-      before do
-        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'
-          expect(client.ca_file).to eq '/ca_file'
-        end
-
-        it 'creates a connection with ssl options' do
-          ssl = client.send(:connection).ssl
-          expect(ssl.ca_path).to eq '/ca_path'
-          expect(ssl.ca_file).to eq '/ca_file'
-        end
-      end
-    end
-
-    context 'logger option' do
-      let(:logger) { Logger.new(STDOUT) }
-
-      before do
-        described_class.configure do |config|
-          config.logger = logger
-        end
-      end
-
-      describe '#initialize' do
-        it 'sets logger' do
-          expect(client.logger).to eq logger
-        end
-
-        it 'creates a connection with a logger' do
-          expect(client.send(:connection).builder.handlers).to include ::Faraday::Response::Logger
-        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_connect', 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.connect so that we can examine request.options later
-        request = nil
-        response = conn.post do |r|
-          r.path = 'rtm.connect'
-          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_connect(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
-        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).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
-
-      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 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
-  end
-end

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

@@ -1,80 +0,0 @@
-# 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

@@ -1,86 +0,0 @@
-# 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 be_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,30 +0,0 @@
-# frozen_string_literal: true
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
-
-require 'rubygems'
-require 'rspec'
-require 'timecop'
-
-require 'simplecov'
-require 'simplecov-lcov'
-SimpleCov::Formatter::LcovFormatter.config do |c|
-  c.report_with_single_file = true
-  c.single_report_path = 'coverage/lcov.info'
-end
-SimpleCov.formatter = SimpleCov::Formatter::LcovFormatter
-SimpleCov.start
-
-require 'slack_ruby_client'
-
-Dir[File.join(File.dirname(__FILE__), 'support', '**/*.rb')].each do |file|
-  require file
-end
-
-Slack.configure do |config|
-  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,35 +0,0 @@
-# frozen_string_literal: true
-# http://spin.atomicobject.com/2014/07/07/ruby-queue-pop-timeout/
-class QueueWithTimeout
-  def initialize
-    @mutex = Mutex.new
-    @queue = []
-    @recieved = ConditionVariable.new
-  end
-
-  def push(item)
-    @mutex.synchronize do
-      @queue << item
-      @recieved.signal
-    end
-  end
-
-  def <<(item)
-    push(item)
-  end
-
-  def pop(non_block = false)
-    pop_with_timeout(non_block ? 0 : nil)
-  end
-
-  def pop_with_timeout(timeout = nil)
-    @mutex.synchronize do
-      if @queue.empty?
-        @recieved.wait(@mutex, timeout) if timeout != 0
-        # if we're still empty after the timeout, raise exception
-        raise ThreadError, 'queue empty' if @queue.empty?
-      end
-      @queue.shift
-    end
-  end
-end