slack-ruby-client-bhe 0.5.4

data/spec/slack/real_time/concurrency/eventmachine_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+begin
+  RSpec.describe Slack::RealTime::Concurrency::Eventmachine::Socket do
+    context 'with url' do
+      let(:url) { 'wss://ms174.slack-msgs.com/websocket/xyz' }
+      let(:socket) { described_class.new(url, ping: 42) }
+      let(:ws) { double(Faye::WebSocket::Client) }
+      describe '#initialize' do
+        it 'sets url' do
+          expect(socket.url).to eq url
+        end
+      end
+      describe '#connect!' do
+        before do
+          allow(ws).to receive(:on).with(:close)
+        end
+        it 'connects' do
+          allow(Faye::WebSocket::Client).to receive(:new).and_return(ws)
+          socket.connect!
+          expect(socket.instance_variable_get('@driver')).to eq ws
+        end
+        it 'pings every 30s' do
+          expect(Faye::WebSocket::Client).to receive(:new).with(url, nil, ping: 42).and_return(ws)
+          socket.connect!
+        end
+      end
+      describe '#disconnect!' do
+        it 'closes and nils the websocket' do
+          socket.instance_variable_set('@driver', ws)
+          expect(ws).to receive(:close)
+          socket.disconnect!
+        end
+      end
+      describe 'send_data' do
+        before do
+          allow(Faye::WebSocket::Client).to receive(:new).and_return(ws)
+          allow(ws).to receive(:on)
+          socket.connect!
+        end
+        it 'sends data' do
+          expect(ws).to receive(:send).with('data')
+          socket.send_data('data')
+        end
+      end
+    end
+  end
+rescue LoadError
+end

data/spec/slack/slack_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Slack do
+  let(:slack) { File.expand_path(File.join(__FILE__, '../../../bin/slack')) }
+  before do
+    @token = ENV.delete('SLACK_API_TOKEN')
+  end
+  after do
+    ENV['SLACK_API_TOKEN'] = @token if @token
+  end
+  describe '#help' do
+    it 'displays help' do
+      help = `"#{slack}" help`
+      expect(help).to include 'slack - Slack client.'
+    end
+  end
+  context 'globals' do
+    it 'enables request and response logging with -d' do
+      output = `"#{slack}" --vcr-cassette-name=web/auth_test_success --slack-api-token=token -d auth test 2>&1`
+      expect(output).to include 'post https://slack.com/api/auth.test'
+      expect(output).to include 'Status: 200'
+    end
+    it 'requires --slack-api-token' do
+      err = `"#{slack}" auth test 2>&1`
+      expect(err).to start_with 'error: parse error: Set Slack API token via --slack-api-token or SLACK_API_TOKEN.'
+    end
+  end
+  describe '#auth' do
+    context 'bad auth' do
+      it 'fails with an exception' do
+        err = `"#{slack}" --vcr-cassette-name=web/auth_test_error --slack-api-token=token auth test 2>&1`
+        expect(err).to eq "error: not_authed\n"
+      end
+    end
+    context 'good auth' do
+      it 'succeeds' do
+        json = JSON.parse `"#{slack}" --vcr-cassette-name=web/auth_test_success --slack-api-token=token auth test 2>&1`
+        expect(json).to eq(
+          'ok' => true,
+          'url' => 'https://rubybot.slack.com/',
+          'team' => 'team_name',
+          'user' => 'user_name',
+          'team_id' => 'TDEADBEEF',
+          'user_id' => 'UBAADFOOD'
+        )
+        expect(json['ok']).to be true
+      end
+    end
+  end
+  describe '#users' do
+    it 'list' do
+      json = JSON.parse `"#{slack}" --vcr-cassette-name=web/users_list --slack-api-token=token users list --presence=true 2>&1`
+      expect(json['ok']).to be true
+      expect(json['members'].size).to eq 9
+      expect(json['members'].first['presence']).to eq 'away'
+    end
+  end
+end

data/spec/slack/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Slack do
+  it 'has a version' do
+    expect(Slack::VERSION).to_not be nil
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Auth do
+  let(:client) { Slack::Web::Client.new }
+  context 'without auth', vcr: { cassette_name: 'web/auth_test_error' } do
+    it 'fails with an exception' do
+      expect { client.auth_test }.to raise_error Slack::Web::Api::Error, 'not_authed'
+    end
+  end
+  context 'with auth', vcr: { cassette_name: 'web/auth_test_success' } do
+    it 'succeeds' do
+      expect { client.auth_test }.to_not raise_error
+    end
+  end
+  context '429 error', vcr: { cassette_name: 'web/429_error' } do
+    it 'fails with an exception' do
+      expect { client.auth_test }.to raise_error Faraday::ClientError
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Channels do
+  let(:client) { Slack::Web::Client.new }
+  context 'channels' do
+    it 'info', vcr: { cassette_name: 'web/channels_info' } do
+      json = client.channels_info(channel: '#general')
+      expect(json['channel']['name']).to eq 'general'
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Chat do
+  let(:client) { Slack::Web::Client.new }
+  context 'chat_postMessage' do
+    it 'automatically converts attachments into JSON' do
+      expect(client).to receive(:post).with(
+        'chat.postMessage',
+        channel: 'channel',
+        text: 'text',
+        attachments: '[]'
+      )
+      client.chat_postMessage(channel: 'channel', text: 'text', attachments: [])
+    end
+    context 'text and attachment arguments' do
+      it 'requires text or attachments' do
+        expect { client.chat_postMessage(channel: 'channel') }.to raise_error ArgumentError, /Required arguments :text or :attachments missing/
+      end
+      it 'only text' do
+        expect(client).to receive(:post).with('chat.postMessage', hash_including(text: 'text'))
+        expect { client.chat_postMessage(channel: 'channel', text: 'text') }.to_not raise_error
+      end
+      it 'only attachments' do
+        expect(client).to receive(:post).with('chat.postMessage', hash_including(attachments: '[]'))
+        expect { client.chat_postMessage(channel: 'channel', attachments: []) }.to_not raise_error
+      end
+      it 'both text and attachments' do
+        expect(client).to receive(:post).with('chat.postMessage', hash_including(text: 'text', attachments: '[]'))
+        expect { client.chat_postMessage(channel: 'channel', text: 'text', attachments: []) }.to_not raise_error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Groups do
+  let(:client) { Slack::Web::Client.new }
+  context 'groups' do
+    it 'info', vcr: { cassette_name: 'web/groups_info' } do
+      json = client.groups_info(channel: '#mpdm-dblock--rubybot--player1-1')
+      expect(json['group']['name']).to eq 'mpdm-dblock--rubybot--player1-1'
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Users do
+  let(:client) { Slack::Web::Client.new }
+  context 'users' do
+    it 'list', vcr: { cassette_name: 'web/users_list' } do
+      json = client.users_list(presence: true)
+      expect(json['ok']).to be true
+      expect(json['members'].size).to eq 9
+      expect(json['members'].first['presence']).to eq 'away'
+    end
+    it 'info', vcr: { cassette_name: 'web/users_info' } do
+      json = client.users_info(user: '@aws')
+      expect(json['user']['name']).to eq 'aws'
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+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
+      fail '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/mixins/channels_spec.rb

@@ -0,0 +1,31 @@
+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(
+      '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::Error, 'channel_not_found'
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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(
+      '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::Error, 'channel_not_found'
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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(
+      'members' => [{
+        'id' => 'UDEADBEEF',
+        'name' => 'aws'
+      }]
+    )
+  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::Error, 'user_not_found'
+    end
+  end
+end

data/spec/slack/web/client_spec.rb

@@ -0,0 +1,134 @@
+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.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
+  end
+end