slack-ruby-client-bhe 0.5.4

data/spec/integration/integration_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+RSpec.describe 'integration test', skip: !ENV['SLACK_API_TOKEN'] && 'missing SLACK_API_TOKEN' do
+  around do |ex|
+    WebMock.allow_net_connect!
+    VCR.turned_off { ex.run }
+    WebMock.disable_net_connect!
+  end
+
+  before do
+    Thread.abort_on_exception = true
+  end
+
+  let(:logger) { Logger.new(STDOUT) }
+
+  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
+    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."
+    end
+
+    client.on :close do
+      # pushes another item to the queue when disconnected
+      queue.push nil
+    end
+  end
+
+  def start_server
+    dt = rand(5) + 1
+    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)
+  end
+
+  def wait_for_server
+    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
+  end
+
+  context 'client connected' do
+    before do
+      start_server
+    end
+
+    let(:channel) { "@#{client.self['name']}" }
+
+    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!'
+        expect(client.started?).to be true
+        client.stop!
+      end
+
+      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!
+    end
+  end
+
+  it 'gets hello' do
+    client.on :hello do |data|
+      logger.debug "client.on :hello, data=#{data}"
+      expect(client.started?).to be true
+      client.stop!
+    end
+
+    start_server
+  end
+end

data/spec/slack/config_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Slack::Config do
+  describe '#configure' do
+    before do
+      Slack.configure do |config|
+        config.token = 'a token'
+      end
+    end
+    it 'sets token' do
+      expect(Slack.config.token).to eq 'a token'
+    end
+  end
+end

data/spec/slack/messages/formatting_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Slack::Messages::Formatting do
+  subject do
+    Slack::Messages::Formatting
+  end
+  context '#unescape' do
+    it 'plain text' do
+      expect(subject.unescape('plain text')).to eq 'plain text'
+    end
+    it 'decodes an HTML-encoded message' do
+      expect(subject.unescape('Hello &amp; &lt;world&gt;')).to eq 'Hello & <world>'
+    end
+    it 'unescapes a user reference' do
+      expect(subject.unescape('Hey <@U024BE7LH|bob>, did you see my file?')).to eq 'Hey @bob, did you see my file?'
+    end
+    it 'unescapes a user reference without a name' do
+      expect(subject.unescape('<@U02BEFY4U> ^^^')).to eq '@U02BEFY4U ^^^'
+    end
+    it 'unescapes a URL without text' do
+      expect(subject.unescape('This message contains a URL <http://foo.com/>')).to eq 'This message contains a URL http://foo.com/'
+    end
+    it 'unescapes a URL with text' do
+      expect(subject.unescape('So does this one: <http://www.foo.com|www.foo.com>')).to eq 'So does this one: www.foo.com'
+    end
+    it 'removes mailto' do
+      expect(subject.unescape('<mailto:bob@example.com|Bob>')).to eq 'Bob'
+    end
+    it 'unlinkifies references' do
+      expect(subject.unescape('Hello <@U123|bob>, say hi to <!everyone> in <#C1234|general>')).to eq 'Hello @bob, say hi to @everyone in #general'
+    end
+    it 'can handle a lone &gt;' do
+      expect(subject.unescape('Hello <@U123|bob> &gt; file.txt')).to eq 'Hello @bob > file.txt'
+    end
+    it 'unescapes a double smart quote' do
+      expect(subject.unescape('“hello”')).to eq '"hello"'
+    end
+    it 'unescapes a single smart quote' do
+      expect(subject.unescape('‘hello’')).to eq "'hello'"
+    end
+  end
+end

data/spec/slack/real_time/api/message_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' } do
+  include_context 'connected client'
+
+  describe '#message' do
+    before do
+      allow(client).to receive(:next_id).and_return(42)
+    end
+    it 'sends message' do
+      expect(socket).to receive(:send_data).with({ type: 'message', id: 42, text: 'hello world', channel: 'channel' }.to_json)
+      client.message(text: 'hello world', channel: 'channel')
+    end
+  end
+end

data/spec/slack/real_time/api/ping_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' } do
+  include_context 'connected client'
+
+  describe '#ping' do
+    before do
+      allow(client).to receive(:next_id).and_return(42)
+    end
+    it 'sends message' do
+      expect(socket).to receive(:send_data).with({ type: 'ping', id: 42 }.to_json)
+      client.ping
+    end
+  end
+end

data/spec/slack/real_time/api/typing_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' } do
+  include_context 'connected client'
+
+  describe '#typing' do
+    before do
+      allow(client).to receive(:next_id).and_return(42)
+    end
+    it 'sends a typing indicator' do
+      expect(socket).to receive(:send_data).with({ type: 'typing', id: 42, channel: 'channel' }.to_json)
+      client.typing(channel: 'channel')
+    end
+  end
+end

data/spec/slack/real_time/client_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+RSpec.describe Slack::RealTime::Client, vcr: { cassette_name: 'web/rtm_start' } do
+  let(:ws) { double(Slack::RealTime::Concurrency::Mock::WebSocket, on: true) }
+  let(:url) { 'wss://ms173.slack-msgs.com/websocket/lqcUiAvrKTP-uuid=' }
+  before do
+    @token = ENV.delete('SLACK_API_TOKEN')
+    Slack::Config.reset
+    Slack::RealTime::Config.reset
+    Slack::RealTime.configure do |config|
+      config.concurrency = Slack::RealTime::Concurrency::Mock
+    end
+  end
+  after do
+    ENV['SLACK_API_TOKEN'] = @token if @token
+  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::RealTime::Client.new
+      expect(client.token).to eq 'global default'
+      expect(client.web_client.token).to eq 'global default'
+    end
+    context 'with real time config' do
+      before do
+        Slack::RealTime::Client.configure do |config|
+          config.token = 'custom real time token'
+        end
+      end
+      it 'overrides token to real time config' do
+        client = Slack::RealTime::Client.new
+        expect(client.token).to eq 'custom real time token'
+        expect(client.web_client.token).to eq 'custom real time token'
+      end
+      it 'overrides token to specific token' do
+        client = Slack::RealTime::Client.new(token: 'local token')
+        expect(client.token).to eq 'local token'
+        expect(client.web_client.token).to eq 'local token'
+      end
+    end
+  end
+  context 'client' do
+    let(:client) { Slack::RealTime::Client.new }
+    context 'started' do
+      describe '#start!' do
+        let(:socket) { double(Slack::RealTime::Socket, connected?: true) }
+        before do
+          allow(Slack::RealTime::Socket).to receive(:new).with(url, ping: 30).and_return(socket)
+          allow(socket).to receive(:connect!)
+          allow(socket).to receive(:start_sync).and_yield
+          client.start!
+        end
+        context 'properties provided upon connection' do
+          it 'sets url' do
+            expect(client.url).to eq url
+          end
+          it 'sets team' do
+            expect(client.team['domain']).to eq 'dblockdotorg'
+          end
+          it 'sets self' do
+            expect(client.self['id']).to eq 'U07518DTL'
+          end
+          it 'sets users' do
+            expect(client.users.count).to eq 7
+            expect(client.users.first['id']).to eq 'U07KECJ77'
+          end
+          it 'sets channels' do
+            expect(client.channels.count).to eq 8
+            expect(client.channels.first['name']).to eq 'demo'
+          end
+          it 'sets ims' do
+            expect(client.ims.count).to eq 2
+            expect(client.ims.first['user']).to eq 'USLACKBOT'
+          end
+          it 'sets bots' do
+            expect(client.bots.count).to eq 5
+            expect(client.bots.first['name']).to eq 'bot'
+          end
+          it 'sets groups' do
+            expect(client.groups.count).to eq 0
+          end
+        end
+        it 'uses web client to fetch url' do
+          expect(client.web_client).to be_a Slack::Web::Client
+        end
+        it 'remembers socket' do
+          expect(client.instance_variable_get('@socket')).to eq socket
+        end
+        it 'cannot be invoked twice' do
+          expect do
+            client.start!
+          end.to raise_error Slack::RealTime::Client::ClientAlreadyStartedError
+        end
+        describe '#stop!' do
+          before do
+            expect(socket).to receive(:disconnect!)
+            client.stop!
+          end
+          it 'cannot be invoked twice' do
+            client.instance_variable_set('@socket', nil) # caused by a :close callback
+            expect do
+              client.stop!
+            end.to raise_error Slack::RealTime::Client::ClientNotStartedError
+          end
+        end
+        describe '#next_id' do
+          it 'increments' do
+            previous_id = client.send(:next_id)
+            expect(client.send(:next_id)).to eq previous_id + 1
+          end
+        end
+      end
+    end
+    context 'with defaults' do
+      describe '#initialize' do
+        it 'sets ping' do
+          expect(client.websocket_ping).to eq 30
+        end
+        it "doesn't set proxy" do
+          expect(client.websocket_proxy).to be nil
+        end
+        Slack::RealTime::Config::ATTRIBUTES.each do |key|
+          it "sets #{key}" do
+            expect(client.send(key)).to eq Slack::RealTime::Config.send(key)
+          end
+        end
+      end
+    end
+  end
+  context 'with custom settings' do
+    describe '#initialize' do
+      Slack::RealTime::Config::ATTRIBUTES.each do |key|
+        context key do
+          let(:client) { Slack::RealTime::Client.new(key => 'custom') }
+          it "sets #{key}" do
+            expect(client.send(key)).to_not eq Slack::RealTime::Config.send(key)
+            expect(client.send(key)).to eq 'custom'
+          end
+        end
+      end
+    end
+  end
+  context 'global config' do
+    after do
+      Slack::RealTime::Client.config.reset
+    end
+    let(:client) { Slack::RealTime::Client.new }
+    context 'ping' do
+      before do
+        Slack::RealTime::Client.configure do |config|
+          config.websocket_ping = 15
+        end
+      end
+      describe '#initialize' do
+        it 'sets ping' do
+          expect(client.websocket_ping).to eq 15
+        end
+        it 'creates a connection with custom ping' do
+          expect(Slack::RealTime::Concurrency::Mock::WebSocket).to receive(:new).with(url, nil, ping: 15).and_return(ws)
+          client.start!
+        end
+      end
+    end
+    context 'proxy' do
+      before do
+        Slack::RealTime::Client.configure do |config|
+          config.websocket_proxy = {
+            origin: 'http://username:password@proxy.example.com',
+            headers: { 'User-Agent' => 'ruby' }
+          }
+        end
+      end
+      describe '#initialize' do
+        it 'sets proxy' do
+          expect(client.websocket_proxy).to eq(
+            origin: 'http://username:password@proxy.example.com',
+            headers: { 'User-Agent' => 'ruby' }
+          )
+        end
+        it 'creates a connection with custom proxy' do
+          expect(Slack::RealTime::Concurrency::Mock::WebSocket).to receive(:new).with(
+            url,
+            nil,
+            ping: 30,
+            proxy: {
+              origin: 'http://username:password@proxy.example.com',
+              headers: { 'User-Agent' => 'ruby' }
+            }).and_return(ws)
+          client.start!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+begin
+  RSpec.describe Slack::RealTime::Concurrency::Celluloid::Socket do
+    context 'with url' do
+      let(:url) { 'wss://echo.websocket.org/websocket/xyz' }
+      subject(:socket) { described_class.new(url, ping: 42) }
+      let(:driver) { WebSocket::Driver::Client }
+      let(:ws) { double(driver) }
+
+      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
+
+        xit 'connects' do
+          expect(socket.driver).to receive(:start)
+
+          socket.connect!
+        end
+
+        xit 'pings every 30s' do
+          expect(driver).to receive(:client).with(socket).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
+        let(:driver) { socket.driver }
+        before do
+          allow(driver).to receive(:start)
+          allow(subject).to receive(:run_loop)
+          socket.connect!
+        end
+
+        it 'sends data' do
+          expect(driver).to receive(:text).with('data')
+          subject.send_data('data')
+        end
+      end
+    end
+  end
+rescue LoadError
+end