slack-ruby-client 0.13.0 → 0.17.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,78 +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
-    connection.join
+    @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!'
@@ -98,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
 
@@ -118,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
@@ -126,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,184 @@
+# 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
+    request_double = double(
+      body: StringIO.new(body)
+    )
+
+    allow(request_double).to receive(:get_header).with('HTTP_X_SLACK_REQUEST_TIMESTAMP') { timestamp }
+    allow(request_double).to receive(:get_header).with('HTTP_X_SLACK_SIGNATURE') { signature }
+
+    request_double
+  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
+
+  it 'rewinds the request body after reading it' do
+    expect(request.body).to eq body
+    expect(http_request.body.read).to eq body
+  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