slack-ruby-client 0.12.0 → 0.14.6

data/slack-ruby-client.gemspec

@@ -1,4 +1,5 @@
-$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+$LOAD_PATH.push File.expand_path('lib', __dir__)
 require 'slack/version'
 
 Gem::Specification.new do |s|
@@ -26,7 +27,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'json-schema'
   s.add_development_dependency 'rake', '~> 10'
   s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rubocop', '0.58.2'
+  s.add_development_dependency 'rubocop', '~> 0.73.0'
+  s.add_development_dependency 'rubocop-performance', '~> 1.4.1'
+  s.add_development_dependency 'rubocop-rspec', '~> 1.34.0'
+  s.add_development_dependency 'timecop'
   s.add_development_dependency 'vcr'
   s.add_development_dependency 'webmock'
 end

data/spec/fixtures/slack/web/views_open_error.yml

@@ -0,0 +1,76 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: https://slack.com/api/views.open
+    body:
+      encoding: UTF-8
+      string: token=token&trigger_id=trigger_id&view=%7B%7D
+    headers:
+      Accept:
+      - application/json; charset=utf-8
+      User-Agent:
+      - Slack Ruby Client/0.14.6
+      Content-Type:
+      - application/x-www-form-urlencoded
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=utf-8
+      Content-Length:
+      - '154'
+      Connection:
+      - keep-alive
+      Date:
+      - Wed, 19 Feb 2020 17:52:59 GMT
+      Server:
+      - Apache
+      X-Content-Type-Options:
+      - nosniff
+      Expires:
+      - Mon, 26 Jul 1997 05:00:00 GMT
+      Cache-Control:
+      - private, no-cache, no-store, must-revalidate
+      X-Xss-Protection:
+      - '0'
+      Vary:
+      - Accept-Encoding
+      Pragma:
+      - no-cache
+      Access-Control-Allow-Headers:
+      - slack-route, x-slack-version-ts, x-b3-traceid, x-b3-spanid, x-b3-parentspanid,
+        x-b3-sampled, x-b3-flags
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Referrer-Policy:
+      - no-referrer
+      X-Slack-Backend:
+      - h
+      Access-Control-Expose-Headers:
+      - x-slack-req-id, retry-after
+      Access-Control-Allow-Origin:
+      - "*"
+      X-Via:
+      - haproxy-www-ixj4
+      X-Cache:
+      - Miss from cloudfront
+      Via:
+      - 1.1 b6cc1359c0cd55a8339441d8abb6a450.cloudfront.net (CloudFront)
+      X-Amz-Cf-Pop:
+      - JFK51-C1
+      X-Amz-Cf-Id:
+      - fWF96IvY1omctxPC6XwjvZ2TIfpmVLlsT35MsfAWqK7zDChMCpE_oQ==
+    body:
+      encoding: ASCII-8BIT
+      string: '{"ok":false,"error":"invalid_arguments","response_metadata":{"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]"]}}'
+    http_version: null
+  recorded_at: Wed, 19 Feb 2020 17:52:59 GMT
+recorded_with: VCR 5.1.0

data/spec/integration/integration_spec.rb

@@ -1,17 +1,22 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-RSpec.describe 'integration test', skip: (!ENV['SLACK_API_TOKEN'] || !ENV['CONCURRENCY']) && 'missing SLACK_API_TOKEN and/or CONCURRENCY' do
+RSpec.describe 'integration test', skip: ( # rubocop:disable RSpec/DescribeClass
+  (!ENV['SLACK_API_TOKEN'] || !ENV['CONCURRENCY']) && 'missing SLACK_API_TOKEN and/or CONCURRENCY'
+) do
   around do |ex|
     WebMock.allow_net_connect!
     VCR.turned_off { ex.run }
     WebMock.disable_net_connect!
   end
 
+  let(:client) { Slack::RealTime::Client.new(token: ENV['SLACK_API_TOKEN']) }
   let(:logger) do
     logger = Logger.new(STDOUT)
-    logger.level = Logger::DEBUG
+    logger.level = Logger::INFO
     logger
   end
+  let!(:queue) { @queue = QueueWithTimeout.new }
 
   before do
     Thread.abort_on_exception = true
@@ -19,77 +24,69 @@ RSpec.describe 'integration test', skip: (!ENV['SLACK_API_TOKEN'] || !ENV['CONCU
     Slack.configure do |slack|
       slack.logger = logger
     end
-  end
-
-  after do
-    Slack.config.reset
-  end
 
-  let(:queue) { QueueWithTimeout.new }
-
-  let(:client) { Slack::RealTime::Client.new(token: ENV['SLACK_API_TOKEN']) }
-
-  let(:connection) do
-    # starts the client and pushes an item on a queue when connected
-    client.start_async do |driver|
-      driver.on :open do |data|
-        logger.debug "connection.on :open, data=#{data}"
-        queue.push nil
-      end
+    client.on :hello do
+      logger.info(
+        "Successfully connected, welcome '#{client.self.name}' to " \
+        "the '#{client.team.name}' team at https://#{client.team.domain}.slack.com."
+      )
     end
-  end
 
-  before do
-    client.on :hello do
-      logger.info "Successfully connected, welcome '#{client.self.name}' to the '#{client.team.name}' team at https://#{client.team.domain}.slack.com."
+    client.on :message do |event|
+      logger.info " #{event.class}"
     end
 
     client.on :close do
+      logger.info 'Disconnecting ...'
       # pushes another item to the queue when disconnected
-      queue.push nil
+      queue.push :closed
     end
   end
 
+  after do
+    Slack.config.reset
+    wait_for_server # wait for :closed to be pushed on queue
+    @server.join if @server.is_a?(::Thread)
+  end
+
   def start_server
-    dt = rand(5) + 2
+    dt = rand(10..20)
     logger.debug "#start_server, waiting #{dt} second(s)"
     sleep dt # prevent Slack 429 rate limit errors
-    # start server and wait for on :open
-    c = connection
-    logger.debug "connection is #{c}"
-    queue.pop_with_timeout(5)
+    # starts the client and pushes an item on a queue when connected
+    @server = client.start_async do |driver|
+      driver.on :open do |data|
+        logger.debug "connection.on :open, data=#{data}"
+        queue.push :opened
+      end
+
+      driver.on :hello do |data|
+        logger.debug "connection.on :hello, data=#{data}"
+      end
+    end
+    logger.debug "started #{@server}"
+    expect(queue.pop_with_timeout(5)).to eq :opened
   end
 
   def wait_for_server
+    return unless @queue
+
     logger.debug '#wait_for_server'
     queue.pop_with_timeout(5)
     logger.debug '#wait_for_server, joined'
-  end
-
-  def stop_server
-    logger.debug '#stop_server'
-    client.stop!
-    logger.debug '#stop_server, stopped'
-  end
-
-  after do
-    wait_for_server
+    @queue = nil
   end
 
   context 'client connected' do
-    before do
-      start_server
-    end
-
-    let(:channel) { "@#{client.self.name}" }
+    let(:channel) { "@#{client.self.id}" }
+    let(:message) { SecureRandom.hex }
 
     it 'responds to message' do
-      message = SecureRandom.hex
-
       client.on :message do |data|
         logger.debug data
         # concurrent execution of tests causes messages to arrive in any order
         next unless data.text == message
+
         expect(data.text).to eq message
         expect(data.subtype).to eq 'bot_message'
         logger.debug 'client.stop!'
@@ -97,13 +94,19 @@ RSpec.describe 'integration test', skip: (!ENV['SLACK_API_TOKEN'] || !ENV['CONCU
         client.stop!
       end
 
+      start_server
+
       logger.debug "chat_postMessage, channel=#{channel}, message=#{message}"
       client.web_client.chat_postMessage channel: channel, text: message
     end
 
     it 'sends message' do
-      client.message(channel: channel, text: 'Hello world!')
-      client.stop!
+      client.on :hello do
+        expect(client.message(channel: channel, text: message)).to be true
+        client.stop!
+      end
+
+      start_server
     end
   end
 
@@ -117,6 +120,72 @@ RSpec.describe 'integration test', skip: (!ENV['SLACK_API_TOKEN'] || !ENV['CONCU
     start_server
   end
 
+  context 'with websocket_ping set' do
+    before do
+      client.websocket_ping = 5
+    end
+
+    it 'sends pings' do
+      @reply_to = nil
+      client.on :pong do |data|
+        @reply_to = data.reply_to
+        queue.push :pong
+        client.stop!
+      end
+
+      start_server
+
+      queue.pop_with_timeout(10)
+      expect(@reply_to).to eq 1
+    end
+
+    it 'rebuilds the websocket connection when dropped' do
+      @reply_to = nil
+      client.on :pong do |data|
+        logger.info data
+        @reply_to = data.reply_to
+        if @reply_to == 1
+          client.instance_variable_get(:@socket).close
+          queue.push :close
+        else
+          expect(@reply_to).to eq 2
+          queue.push :pong
+          client.stop!
+        end
+      end
+
+      start_server
+
+      4.times do |i|
+        queue.pop_with_timeout(10)
+        client.logger.info "Pop #{i}"
+      end
+    end
+  end
+
+  context 'with websocket_ping not set' do
+    before do
+      client.websocket_ping = 0
+    end
+
+    it 'does not send pings' do
+      @reply_to = nil
+
+      client.on :pong do |data|
+        @reply_to = data.reply_to
+      end
+
+      client.on :hello do
+        client.stop!
+      end
+
+      start_server
+      wait_for_server
+
+      expect(@reply_to).to be nil
+    end
+  end
+
   it 'gets close, followed by closed' do
     client.on :hello do
       expect(client.started?).to be true
@@ -125,7 +194,6 @@ RSpec.describe 'integration test', skip: (!ENV['SLACK_API_TOKEN'] || !ENV['CONCU
 
     client.on :close do |data|
       logger.debug "client.on :close, data=#{data}"
-      expect(client.started?).to be true
       @close_called = true
     end
 

data/spec/slack/config_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Slack::Config do
@@ -7,6 +8,7 @@ describe Slack::Config do
         config.token = 'a token'
       end
     end
+
     it 'sets token' do
       expect(Slack.config.token).to eq 'a token'
     end

data/spec/slack/events/config_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Slack::Events::Config do
+  before do
+    ENV['SLACK_SIGNING_SECRET'] = 'secret'
+    described_class.reset
+  end
+
+  after do
+    ENV.delete 'SLACK_SIGNING_SECRET'
+  end
+
+  it 'defaults signing secret to ENV[SLACK_SIGNING_SECRET]' do
+    expect(Slack::Events.config.signing_secret).to eq 'secret'
+  end
+  it 'defaults signature expiration to 5 minutes' do
+    expect(Slack::Events.config.signature_expires_in).to eq 5 * 60
+  end
+  context 'configured' do
+    before do
+      Slack::Events.configure do |config|
+        config.signing_secret = 'custom'
+        config.signature_expires_in = 45
+      end
+    end
+
+    it 'uses the configured values' do
+      expect(Slack::Events.config.signing_secret).to eq 'custom'
+      expect(Slack::Events.config.signature_expires_in).to eq 45
+    end
+  end
+end

data/spec/slack/events/request_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Slack::Events::Request do
+  subject(:request) do
+    described_class.new(http_request)
+  end
+
+  before do
+    Slack::Events.configure do |config|
+      config.signing_secret = signing_secret
+      config.signature_expires_in = 30
+    end
+  end
+
+  let(:signing_secret) { 'ade6ca762ade4db0e7d31484cd616b9c' }
+  let(:signature) { 'v0=91177eea054d65de0fc0f9b4ec57714307bc0ce2c5f3bf0d28b1b720c8f92ba2' }
+  let(:timestamp) { '1547933148' }
+  let(:body) do
+    '{"token":"X34FAqCu8tmGEkEEpoDncnja","challenge":' \
+    '"P7sFXA4o3HV2hTx4zb4zcQ9yrvuQs8pDh6EacOxmMRj0tJaXfQFF","type":"url_verification"}'
+  end
+  let(:http_request) do
+    double(
+      headers: {
+        'X-Slack-Request-Timestamp' => timestamp,
+        'X-Slack-Signature' => signature
+      },
+      body: double(
+        read: body
+      )
+    )
+  end
+
+  after do
+    Slack::Events.config.reset
+  end
+
+  it 'reads http request' do
+    expect(request.signature).to eq signature
+    expect(request.body).to eq body
+    expect(request.timestamp).to eq timestamp
+    expect(request.version).to eq 'v0'
+  end
+  context 'time' do
+    after do
+      Timecop.return
+    end
+
+    context 'with an invalid signature' do
+      let(:signature) { 'v0=invalid' }
+
+      before do
+        Timecop.freeze(Time.at(timestamp.to_i))
+      end
+
+      it 'is invalid but not expired' do
+        expect(request).not_to be_valid
+        expect(request).not_to be_expired
+      end
+    end
+
+    context 'with an invalid body' do
+      let(:body) { 'invalid' }
+
+      before do
+        Timecop.freeze(Time.at(timestamp.to_i))
+      end
+
+      it 'is invalid but not expired' do
+        expect(request).not_to be_valid
+        expect(request).not_to be_expired
+      end
+    end
+
+    context 'with an invalid signing secret' do
+      before do
+        Slack::Events.configure do |config|
+          config.signing_secret = 'invalid'
+        end
+        Timecop.freeze(Time.at(timestamp.to_i))
+      end
+
+      it 'is invalid but not expired' do
+        expect(request).not_to be_valid
+        expect(request).not_to be_expired
+      end
+    end
+
+    context 'within time window' do
+      before do
+        Timecop.freeze(Time.at(timestamp.to_i) + Slack::Events.config.signature_expires_in - 1)
+      end
+
+      it 'is valid' do
+        expect(request).to be_valid
+        expect(request).not_to be_expired
+      end
+      it 'does not raise an error and returns true' do
+        expect(request.verify!).to be true
+      end
+    end
+
+    context 'after time window' do
+      before do
+        Timecop.freeze(Time.at(timestamp.to_i) + Slack::Events.config.signature_expires_in + 1)
+      end
+
+      it 'is valid but expired' do
+        expect(request).to be_valid
+        expect(request).to be_expired
+      end
+      it 'raises an error on verify!' do
+        expect { request.verify! }.to raise_error Slack::Events::Request::TimestampExpired
+      end
+    end
+
+    context 'before time but within window' do
+      before do
+        Timecop.freeze(Time.at(timestamp.to_i) - Slack::Events.config.signature_expires_in + 1)
+      end
+
+      it 'is valid and not expired' do
+        expect(request).to be_valid
+        expect(request).not_to be_expired
+      end
+      it 'does not raise an error on verify!' do
+        expect(request.verify!).to be true
+      end
+    end
+
+    context 'before time window' do
+      before do
+        Timecop.freeze(Time.at(timestamp.to_i) - Slack::Events.config.signature_expires_in - 1)
+      end
+
+      it 'is valid but expired' do
+        expect(request).to be_valid
+        expect(request).to be_expired
+      end
+      it 'raises an error on verify!' do
+        expect { request.verify! }.to raise_error Slack::Events::Request::TimestampExpired
+      end
+    end
+  end
+
+  context 'without global config' do
+    before do
+      Slack::Events.config.reset
+    end
+
+    context 'without a signing secret parameter' do
+      subject(:request) do
+        described_class.new(http_request)
+      end
+
+      it 'raises MissingSigningSecret' do
+        expect { request.valid? }.to raise_error Slack::Events::Request::MissingSigningSecret
+      end
+    end
+
+    context 'with a signing secret parameter' do
+      subject(:request) do
+        described_class.new(http_request,
+                            signing_secret: signing_secret,
+                            signature_expires_in: 30)
+      end
+
+      before do
+        Timecop.freeze(Time.at(timestamp.to_i))
+      end
+
+      it 'is valid and not expired' do
+        expect(request).to be_valid
+        expect(request).not_to be_expired
+      end
+    end
+  end
+end