slack-ruby-client 0.11.0 → 2.7.0

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

@@ -1,7 +0,0 @@
-# This file was auto-generated by lib/tasks/web.rake
-
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Endpoints::TeamProfile do
-  let(:client) { Slack::Web::Client.new }
-end

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

@@ -1,7 +0,0 @@
-# This file was auto-generated by lib/tasks/web.rake
-
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Endpoints::Team do
-  let(:client) { Slack::Web::Client.new }
-end

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

@@ -1,27 +0,0 @@
-# This file was auto-generated by lib/tasks/web.rake
-
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Endpoints::Usergroups do
-  let(:client) { Slack::Web::Client.new }
-  context 'usergroups_create' do
-    it 'requires name' do
-      expect { client.usergroups_create }.to raise_error ArgumentError, /Required arguments :name missing/
-    end
-  end
-  context 'usergroups_disable' do
-    it 'requires usergroup' do
-      expect { client.usergroups_disable }.to raise_error ArgumentError, /Required arguments :usergroup missing/
-    end
-  end
-  context 'usergroups_enable' do
-    it 'requires usergroup' do
-      expect { client.usergroups_enable }.to raise_error ArgumentError, /Required arguments :usergroup missing/
-    end
-  end
-  context 'usergroups_update' do
-    it 'requires usergroup' do
-      expect { client.usergroups_update }.to raise_error ArgumentError, /Required arguments :usergroup missing/
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# This file was auto-generated by lib/tasks/web.rake
-
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Endpoints::UsergroupsUsers do
-  let(:client) { Slack::Web::Client.new }
-  context 'usergroups.users_list' do
-    it 'requires usergroup' do
-      expect { client.usergroups_users_list }.to raise_error ArgumentError, /Required arguments :usergroup missing/
-    end
-  end
-  context 'usergroups.users_update' do
-    it 'requires usergroup' do
-      expect { client.usergroups_users_update(users: 'U060R4BJ4,U060RNRCZ') }.to raise_error ArgumentError, /Required arguments :usergroup missing/
-    end
-    it 'requires users' do
-      expect { client.usergroups_users_update(usergroup: 'S0604QSJC') }.to raise_error ArgumentError, /Required arguments :users missing/
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# This file was auto-generated by lib/tasks/web.rake
-
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Endpoints::UsersAdmin do
-  let(:client) { Slack::Web::Client.new }
-  context 'users.admin_invite' do
-    it 'requires email' do
-      expect { client.users_admin_invite }.to raise_error ArgumentError, /Required arguments :email missing/
-    end
-  end
-  context 'users.admin_setInactive' do
-    it 'requires user' do
-      expect { client.users_admin_setInactive }.to raise_error ArgumentError, /Required arguments :user missing/
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-# This file was auto-generated by lib/tasks/web.rake
-
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Endpoints::UsersPrefs do
-  let(:client) { Slack::Web::Client.new }
-end

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

@@ -1,7 +0,0 @@
-# This file was auto-generated by lib/tasks/web.rake
-
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Endpoints::UsersProfile do
-  let(:client) { Slack::Web::Client.new }
-end

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

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-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 Slack::Web::Api::Error => e
-      expect(e.response).to_not be_nil
-      expect(e.response.status).to eq 200
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-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
-      expect(e.response.status).to eq 200
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Mixins::Channels do
-  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(Slack::Messages::Message.new(
-                                                           'channels' => [{
-                                                             'id' => 'CDEADBEEF',
-                                                             'name' => 'general'
-                                                           }]
-    ))
-  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' })
-    end
-    it 'translates a channel that starts with a #' do
-      expect(subject.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'
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Mixins::Groups do
-  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(Slack::Messages::Message.new(
-                                                         'groups' => [{
-                                                           'id' => 'CDEADBEEF',
-                                                           'name' => 'general'
-                                                         }]
-    ))
-  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' })
-    end
-    it 'translates a channel that starts with a #' do
-      expect(subject.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'
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Slack::Web::Api::Mixins::Users do
-  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(Slack::Messages::Message.new(
-                                                        'members' => [{
-                                                          'id' => 'UDEADBEEF',
-                                                          'name' => 'aws',
-                                                          'profile' => {}
-                                                        }]
-    ))
-  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' })
-    end
-    it 'translates a user that starts with a #' do
-      expect(subject.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'
-    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' => {} }])
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-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', {}) }
-    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(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(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)
-          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) }
-        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(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
-      end
-    end
-  end
-  context 'with a custom limit' do
-    let(:cursor) { Slack::Web::Api::Pagination::Cursor.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) }
-    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,174 +0,0 @@
-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 }
-    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 do
-          let(:client) { Slack::Web::Client.new(key => 'custom') }
-          it "sets #{key}" do
-            expect(client.send(key)).to_not 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
-    end
-    let(:client) { Slack::Web::Client.new }
-    context 'user-agent' do
-      before do
-        Slack::Web::Client.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 = Slack::Web::Client.new
-        expect(client.token).to eq 'global default'
-      end
-      context 'with web config' do
-        before do
-          Slack::Web::Client.configure do |config|
-            config.token = 'custom web token'
-          end
-        end
-        it 'overrides token to web config' do
-          client = Slack::Web::Client.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')
-          expect(client.token).to eq 'local token'
-        end
-      end
-    end
-    context 'proxy' do
-      before do
-        Slack::Web::Client.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
-        Slack::Web::Client.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
-        Slack::Web::Client.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 'timeout options' do
-      before do
-        Slack::Web::Client.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.body = { token: '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
-  end
-end

data/spec/spec_helper.rb

@@ -1,14 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
-
-require 'rubygems'
-require 'rspec'
-
-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']
-end

data/spec/support/queue_with_timeout.rb

@@ -1,34 +0,0 @@
-# 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(x)
-    @mutex.synchronize do
-      @queue << x
-      @recieved.signal
-    end
-  end
-
-  def <<(x)
-    push(x)
-  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

data/spec/support/real_time/concurrency/mock.rb

@@ -1,30 +0,0 @@
-module Slack
-  module RealTime
-    module Concurrency
-      module Mock
-        class WebSocket
-        end
-
-        class Socket < ::Slack::RealTime::Socket
-          def self.close; end
-
-          def start_async(client)
-            reactor = Thread.new {}
-            client.run_loop
-            reactor
-          end
-
-          def send_data(message)
-            driver.send(message)
-          end
-
-          protected
-
-          def connect
-            @driver = WebSocket.new(url, nil, options)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/real_time/connected_client.rb

@@ -1,21 +0,0 @@
-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
-    Slack::RealTime.config.store_class == Slack::RealTime::Stores::Store ?
-      'wss://ms173.slack-msgs.com/websocket/lqcUiAvrKTP-uuid=' :
-      'wss://mpmulti-w5tz.slack-msgs.com/websocket/uid'
-  end
-  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(socket).to receive(:start_sync)
-    allow(socket).to receive(:connect!)
-    allow(ws).to receive(:on)
-    client.start!
-  end
-end

data/spec/support/real_time/event.rb

@@ -1,11 +0,0 @@
-module Slack
-  module RealTime
-    class Event
-      attr_accessor :data
-
-      def initialize(data)
-        @data = data.to_json
-      end
-    end
-  end
-end

data/spec/support/token.rb

@@ -1,10 +0,0 @@
-RSpec.configure do |config|
-  config.before do
-    @old_token = Slack::Config.token
-  end
-  config.after do
-    Slack::Config.token = @old_token
-    Slack::Web::Config.reset
-    Slack::RealTime::Config.reset
-  end
-end

data/spec/support/vcr.rb

@@ -1,9 +0,0 @@
-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!
-end