slack-ruby-client 0.14.5 → 0.17.0

data/spec/slack/web/api/endpoints/custom_specs/conversations_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+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/conversations_info' } do
+      json = client.conversations_info(channel: '#mpdm-dblock--rubybot--player1-1')
+      expect(json.channel.name).to eq 'mpdm-dblock--rubybot--player1-1'
+    end
+  end
+end

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

@@ -7,10 +7,10 @@ RSpec.describe Slack::Web::Api::Endpoints::FilesComments do
   let(:client) { Slack::Web::Client.new }
   context 'files.comments_delete' do
     it 'requires file' do
-      expect { client.files_comments_delete(id: 'Fc1234567890') }.to raise_error ArgumentError, /Required arguments :file missing/
+      expect { client.files_comments_delete(id: %q[Fc1234567890]) }.to raise_error ArgumentError, /Required arguments :file missing/
     end
     it 'requires id' do
-      expect { client.files_comments_delete(file: 'F1234567890') }.to raise_error ArgumentError, /Required arguments :id missing/
+      expect { client.files_comments_delete(file: %q[F1234567890]) }.to raise_error ArgumentError, /Required arguments :id missing/
     end
   end
 end

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

@@ -7,13 +7,13 @@ RSpec.describe Slack::Web::Api::Endpoints::FilesRemote do
   let(:client) { Slack::Web::Client.new }
   context 'files.remote_add' do
     it 'requires external_id' do
-      expect { client.files_remote_add(external_url: 'http://example.com/my_cloud_service_file/abc123', title: 'Danger, High Voltage!') }.to raise_error ArgumentError, /Required arguments :external_id missing/
+      expect { client.files_remote_add(external_url: %q[http://example.com/my_cloud_service_file/abc123], title: %q[Danger, High Voltage!]) }.to raise_error ArgumentError, /Required arguments :external_id missing/
     end
     it 'requires external_url' do
-      expect { client.files_remote_add(external_id: '123456', title: 'Danger, High Voltage!') }.to raise_error ArgumentError, /Required arguments :external_url missing/
+      expect { client.files_remote_add(external_id: %q[123456], title: %q[Danger, High Voltage!]) }.to raise_error ArgumentError, /Required arguments :external_url missing/
     end
     it 'requires title' do
-      expect { client.files_remote_add(external_id: '123456', external_url: 'http://example.com/my_cloud_service_file/abc123') }.to raise_error ArgumentError, /Required arguments :title missing/
+      expect { client.files_remote_add(external_id: %q[123456], external_url: %q[http://example.com/my_cloud_service_file/abc123]) }.to raise_error ArgumentError, /Required arguments :title missing/
     end
   end
   context 'files.remote_share' do

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

@@ -12,10 +12,10 @@ RSpec.describe Slack::Web::Api::Endpoints::Files do
   end
   context 'files_edit' do
     it 'requires file' do
-      expect { client.files_edit(title: 'Brand new title') }.to raise_error ArgumentError, /Required arguments :file missing/
+      expect { client.files_edit(title: %q[Brand new title]) }.to raise_error ArgumentError, /Required arguments :file missing/
     end
     it 'requires title' do
-      expect { client.files_edit(file: 'F2147483862') }.to raise_error ArgumentError, /Required arguments :title missing/
+      expect { client.files_edit(file: %q[F2147483862]) }.to raise_error ArgumentError, /Required arguments :title missing/
     end
   end
   context 'files_info' do
@@ -30,10 +30,10 @@ RSpec.describe Slack::Web::Api::Endpoints::Files do
   end
   context 'files_share' do
     it 'requires file' do
-      expect { client.files_share(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :file missing/
+      expect { client.files_share(channel: %q[C1234567890]) }.to raise_error ArgumentError, /Required arguments :file missing/
     end
     it 'requires channel' do
-      expect { client.files_share(file: 'F2147483862') }.to raise_error ArgumentError, /Required arguments :channel missing/
+      expect { client.files_share(file: %q[F2147483862]) }.to raise_error ArgumentError, /Required arguments :channel missing/
     end
   end
   context 'files_sharedPublicURL' do

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

@@ -5,35 +5,4 @@ require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Endpoints::Im do
   let(:client) { Slack::Web::Client.new }
-  context 'im_close' do
-    it 'requires channel' do
-      expect { client.im_close }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-  end
-  context 'im_history' do
-    it 'requires channel' do
-      expect { client.im_history }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-  end
-  context 'im_mark' do
-    it 'requires channel' do
-      expect { client.im_mark(ts: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-    it 'requires ts' do
-      expect { client.im_mark(channel: 'D1234567890') }.to raise_error ArgumentError, /Required arguments :ts missing/
-    end
-  end
-  context 'im_open' do
-    it 'requires user' do
-      expect { client.im_open }.to raise_error ArgumentError, /Required arguments :user missing/
-    end
-  end
-  context 'im_replies' do
-    it 'requires channel' do
-      expect { client.im_replies(thread_ts: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-    it 'requires thread_ts' do
-      expect { client.im_replies(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :thread_ts missing/
-    end
-  end
 end

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

@@ -5,35 +5,4 @@ require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Endpoints::Mpim do
   let(:client) { Slack::Web::Client.new }
-  context 'mpim_close' do
-    it 'requires channel' do
-      expect { client.mpim_close }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-  end
-  context 'mpim_history' do
-    it 'requires channel' do
-      expect { client.mpim_history }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-  end
-  context 'mpim_mark' do
-    it 'requires channel' do
-      expect { client.mpim_mark(ts: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-    it 'requires ts' do
-      expect { client.mpim_mark(channel: 'G1234567890') }.to raise_error ArgumentError, /Required arguments :ts missing/
-    end
-  end
-  context 'mpim_open' do
-    it 'requires users' do
-      expect { client.mpim_open }.to raise_error ArgumentError, /Required arguments :users missing/
-    end
-  end
-  context 'mpim_replies' do
-    it 'requires channel' do
-      expect { client.mpim_replies(thread_ts: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-    it 'requires thread_ts' do
-      expect { client.mpim_replies(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :thread_ts missing/
-    end
-  end
 end

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

@@ -5,26 +5,15 @@ require 'spec_helper'
 
 RSpec.describe Slack::Web::Api::Endpoints::Oauth do
   let(:client) { Slack::Web::Client.new }
-  context 'oauth_access' do
-    it 'requires client_id' do
-      expect { client.oauth_access(client_secret: '33fea0113f5b1', code: 'ccdaa72ad') }.to raise_error ArgumentError, /Required arguments :client_id missing/
-    end
-    it 'requires client_secret' do
-      expect { client.oauth_access(client_id: '4b39e9-752c4', code: 'ccdaa72ad') }.to raise_error ArgumentError, /Required arguments :client_secret missing/
-    end
-    it 'requires code' do
-      expect { client.oauth_access(client_id: '4b39e9-752c4', client_secret: '33fea0113f5b1') }.to raise_error ArgumentError, /Required arguments :code missing/
-    end
-  end
   context 'oauth_token' do
     it 'requires client_id' do
-      expect { client.oauth_token(client_secret: '33fea0113f5b1', code: 'ccdaa72ad') }.to raise_error ArgumentError, /Required arguments :client_id missing/
+      expect { client.oauth_token(client_secret: %q[33fea0113f5b1], code: %q[ccdaa72ad]) }.to raise_error ArgumentError, /Required arguments :client_id missing/
     end
     it 'requires client_secret' do
-      expect { client.oauth_token(client_id: '4b39e9-752c4', code: 'ccdaa72ad') }.to raise_error ArgumentError, /Required arguments :client_secret missing/
+      expect { client.oauth_token(client_id: %q[4b39e9-752c4], code: %q[ccdaa72ad]) }.to raise_error ArgumentError, /Required arguments :client_secret missing/
     end
     it 'requires code' do
-      expect { client.oauth_token(client_id: '4b39e9-752c4', client_secret: '33fea0113f5b1') }.to raise_error ArgumentError, /Required arguments :code missing/
+      expect { client.oauth_token(client_id: %q[4b39e9-752c4], client_secret: %q[33fea0113f5b1]) }.to raise_error ArgumentError, /Required arguments :code missing/
     end
   end
 end

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

@@ -7,10 +7,7 @@ RSpec.describe Slack::Web::Api::Endpoints::Pins do
   let(:client) { Slack::Web::Client.new }
   context 'pins_add' do
     it 'requires channel' do
-      expect { client.pins_add(timestamp: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :channel missing/
-    end
-    it 'requires timestamp' do
-      expect { client.pins_add(channel: 'C1234567890') }.to raise_error ArgumentError, /Required arguments :timestamp missing/
+      expect { client.pins_add }.to raise_error ArgumentError, /Required arguments :channel missing/
     end
   end
   context 'pins_list' do

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

@@ -7,13 +7,13 @@ RSpec.describe Slack::Web::Api::Endpoints::Reactions do
   let(:client) { Slack::Web::Client.new }
   context 'reactions_add' do
     it 'requires channel' do
-      expect { client.reactions_add(name: 'thumbsup', timestamp: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :channel missing/
+      expect { client.reactions_add(name: %q[thumbsup], timestamp: %q[1234567890.123456]) }.to raise_error ArgumentError, /Required arguments :channel missing/
     end
     it 'requires name' do
-      expect { client.reactions_add(channel: 'C1234567890', timestamp: '1234567890.123456') }.to raise_error ArgumentError, /Required arguments :name missing/
+      expect { client.reactions_add(channel: %q[C1234567890], timestamp: %q[1234567890.123456]) }.to raise_error ArgumentError, /Required arguments :name missing/
     end
     it 'requires timestamp' do
-      expect { client.reactions_add(channel: 'C1234567890', name: 'thumbsup') }.to raise_error ArgumentError, /Required arguments :timestamp missing/
+      expect { client.reactions_add(channel: %q[C1234567890], name: %q[thumbsup]) }.to raise_error ArgumentError, /Required arguments :timestamp missing/
     end
   end
   context 'reactions_remove' do

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

@@ -7,10 +7,10 @@ RSpec.describe Slack::Web::Api::Endpoints::Reminders do
   let(:client) { Slack::Web::Client.new }
   context 'reminders_add' do
     it 'requires text' do
-      expect { client.reminders_add(time: '1602288000') }.to raise_error ArgumentError, /Required arguments :text missing/
+      expect { client.reminders_add(time: %q[1602288000]) }.to raise_error ArgumentError, /Required arguments :text missing/
     end
     it 'requires time' do
-      expect { client.reminders_add(text: 'eat a banana') }.to raise_error ArgumentError, /Required arguments :time missing/
+      expect { client.reminders_add(text: %q[eat a banana]) }.to raise_error ArgumentError, /Required arguments :time missing/
     end
   end
   context 'reminders_complete' do

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

@@ -12,10 +12,10 @@ RSpec.describe Slack::Web::Api::Endpoints::UsergroupsUsers do
   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/
+      expect { client.usergroups_users_update(users: %q[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/
+      expect { client.usergroups_users_update(usergroup: %q[S0604QSJC]) }.to raise_error ArgumentError, /Required arguments :users missing/
     end
   end
 end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# This file was auto-generated by lib/tasks/web.rake
+
+require 'spec_helper'
+
+RSpec.describe Slack::Web::Api::Endpoints::Workflows do
+  let(:client) { Slack::Web::Client.new }
+  context 'workflows_stepCompleted' do
+    it 'requires workflow_step_execute_id' do
+      expect { client.workflows_stepCompleted }.to raise_error ArgumentError, /Required arguments :workflow_step_execute_id missing/
+    end
+  end
+  context 'workflows_stepFailed' do
+    it 'requires error' do
+      expect { client.workflows_stepFailed(workflow_step_execute_id: %q[]) }.to raise_error ArgumentError, /Required arguments :error missing/
+    end
+    it 'requires workflow_step_execute_id' do
+      expect { client.workflows_stepFailed(error: %q[]) }.to raise_error ArgumentError, /Required arguments :workflow_step_execute_id missing/
+    end
+  end
+  context 'workflows_updateStep' do
+    it 'requires workflow_step_edit_id' do
+      expect { client.workflows_updateStep }.to raise_error ArgumentError, /Required arguments :workflow_step_edit_id missing/
+    end
+  end
+end

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

@@ -11,6 +11,28 @@ RSpec.describe Slack::Web::Api::Errors::SlackError do
     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
+  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
   end
 end

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

@@ -13,7 +13,7 @@ RSpec.describe Slack::Web::Api::Mixins::Channels do
   end
 
   before do
-    allow(channels).to receive(:channels_list).and_return(
+    allow(channels).to receive(:channels_list).and_yield(
       Slack::Messages::Message.new(
         'channels' => [{
           'id' => 'CDEADBEEF',

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: 'C018Y6VH39D', 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/conversations_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+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::Conversations
+    end
+  end
+
+  before do
+    allow(conversations).to receive(:conversations_list).and_yield(
+      Slack::Messages::Message.new(
+        'channels' => [{
+          'id' => 'CDEADBEEF',
+          'name' => 'general'
+        }]
+      )
+    )
+  end
+
+  describe '#conversations_id' do
+    it 'leaves channels specified by ID alone' do
+      expect(conversations.conversations_id(channel: 'C123456')).to(
+        eq('ok' => true, 'channel' => { 'id' => 'C123456' })
+      )
+    end
+    it 'translates a channel that starts with a #' do
+      expect(conversations.conversations_id(channel: '#general')).to(
+        eq('ok' => true, 'channel' => { 'id' => 'CDEADBEEF' })
+      )
+    end
+    it 'fails with an exception' do
+      expect { conversations.conversations_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

@@ -13,7 +13,7 @@ RSpec.describe Slack::Web::Api::Mixins::Groups do
   end
 
   before do
-    allow(groups).to receive(:groups_list).and_return(
+    allow(groups).to receive(:groups_list).and_yield(
       Slack::Messages::Message.new(
         'groups' => [{
           'id' => 'CDEADBEEF',

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/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|
@@ -205,5 +249,82 @@ 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
+        begin
+          request
+        rescue Slack::Web::Api::Errors::ServerError => e
+          return e
+        end
+      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