slangerq 0.6.1

data/spec/integration/integration_spec.rb

@@ -0,0 +1,68 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe 'Integration' do
+
+  before(:each) { start_slanger }
+
+  context "connecting with invalid credentials" do
+    it "sends an error message" do
+      messages = em_stream(key: 'bogus_key') do |websocket, messages|
+        websocket.callback { EM.stop }
+      end
+      expect(messages).to have_attributes count: 1, last_event: 'pusher:error',
+        connection_established: false, id_present: false
+      messages.first['data'] == 'Could not find app by key bogus_key'
+    end
+  end
+
+  context "connecting with valid credentials" do
+    it "should succeed and include activity_timeout value in handshake" do
+      messages = em_stream do |websocket, messages|
+        websocket.callback { EM.stop }
+      end
+      expect(messages).to have_attributes activity_timeout: Slanger::Config.activity_timeout,
+        connection_established: true, id_present: true
+    end
+  end
+
+  context "connect with valid protocol version" do
+    it "should connect successfuly" do
+      messages = em_stream do |websocket, messages|
+        websocket.callback { EM.stop }
+      end
+      expect(messages).to have_attributes connection_established: true, id_present: true
+    end
+  end
+
+  context "connect with invalid protocol version" do
+    it "should not connect successfuly with version bigger than supported" do
+      messages = em_stream(protocol: "20") do |websocket, messages|
+        websocket.callback { EM.stop }
+      end
+      expect(messages).to have_attributes connection_established: false, id_present: false,
+        last_event: 'pusher:error'
+    end
+
+    it "should not connect successfuly without specified version" do
+      messages = em_stream(protocol: nil) do |websocket, messages|
+        websocket.callback { EM.stop }
+      end
+      expect(messages).to have_attributes connection_established: false, id_present: false,
+        last_event: 'pusher:error'
+    end
+  end
+
+  context "given invalid JSON as input" do
+    it 'should not crash' do
+      messages  = em_stream do |websocket, messages|
+        websocket.callback do
+          websocket.send("{ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }23123")
+          EM.next_tick { EM.stop }
+        end
+      end
+
+      EM.run { new_websocket.tap { |u| u.stream { EM.next_tick { EM.stop } } }}
+    end
+  end
+end

data/spec/integration/presence_channel_spec.rb

@@ -0,0 +1,157 @@
+#encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Integration' do
+
+  before(:each) { start_slanger }
+
+  describe 'presence channels:' do
+    context 'subscribing without channel data' do
+      context 'and bogus authentication credentials' do
+        it 'sends back an error message' do
+          messages  = em_stream do |websocket, messages|
+            case messages.length
+            when 1
+              websocket.send({ event: 'pusher:subscribe', data: { channel: 'presence-channel', auth: 'bogus' } }.to_json)
+            else
+              EM.stop
+            end
+          end
+
+          expect(messages).to have_attributes connection_established: true, id_present: true,
+            count: 2,
+            last_event: 'pusher:error'
+
+          expect(JSON.parse(messages.last['data'])['message']).to match /^Invalid signature: Expected HMAC SHA256 hex digest of/
+        end
+      end
+    end
+
+    context 'subscribing with channel data' do
+      context 'and bogus authentication credentials' do
+        it 'sends back an error message' do
+          messages  = em_stream do |websocket, messages|
+            case messages.length
+            when 1
+              websocket.send({ event: 'pusher:subscribe', data: {
+                channel: 'presence-lel',
+                auth: 'boog',
+                channel_data: {
+                  user_id: "barry",
+                }
+              }.to_json }.to_json)
+           else
+              EM.stop
+            end
+          end
+
+          expect(messages).to have_attributes first_event: 'pusher:connection_established', count: 2,
+            id_present: true
+
+          # Channel id should be in the payload
+          expect(messages.last['event']).to eq('pusher:error')
+          expect(JSON.parse(messages.last['data'])['message']).to match /^Invalid signature: Expected HMAC SHA256 hex digest of/
+        end
+      end
+
+      context 'with genuine authentication credentials'  do
+        it 'sends back a success message' do
+          messages  = em_stream do |websocket, messages|
+            case messages.length
+            when 1
+              send_subscribe( user: websocket,
+                              user_id: '0f177369a3b71275d25ab1b44db9f95f',
+                              name: 'SG',
+                              message: messages.first)
+            else
+              EM.stop
+            end
+          end
+
+          expect(messages).to have_attributes connection_established: true, count: 2
+
+          expect(messages.last).to eq({"channel"=>"presence-channel",
+                                   "event"  =>"pusher_internal:subscription_succeeded",
+                                   "data"   => "{\"presence\":{\"count\":1,\"ids\":[\"0f177369a3b71275d25ab1b44db9f95f\"],\"hash\":{\"0f177369a3b71275d25ab1b44db9f95f\":{\"name\":\"SG\"}}}}"})
+        end
+
+
+
+
+        context 'with more than one subscriber subscribed to the channel' do
+          it 'sends a member added message to the existing subscribers' do
+            messages  = em_stream do |user1, messages|
+              case messages.length
+              when 1
+                send_subscribe(user: user1,
+                               user_id: '0f177369a3b71275d25ab1b44db9f95f',
+                               name: 'SG',
+                               message: messages.first)
+
+              when 2
+                new_websocket.tap do |u|
+                  u.stream do |message|
+                    message = JSON.parse(message)
+                    if message['event'] == 'pusher:connection_established'
+                      send_subscribe \
+                        user: u, user_id: '37960509766262569d504f02a0ee986d',
+                        name: 'CHROME', message: message
+                    end
+                  end
+                end
+              else
+                EM.stop
+              end
+
+            end
+
+            expect(messages).to have_attributes connection_established: true, count: 3
+            # Channel id should be in the payload
+            expect(messages[1]).to eq({"channel"=>"presence-channel", "event"=>"pusher_internal:subscription_succeeded",
+                                       "data"=>"{\"presence\":{\"count\":1,\"ids\":[\"0f177369a3b71275d25ab1b44db9f95f\"],\"hash\":{\"0f177369a3b71275d25ab1b44db9f95f\":{\"name\":\"SG\"}}}}"})
+
+            expect(messages.last).to eq({"channel"=>"presence-channel", "event"=>"pusher_internal:member_added",
+                                         "data"=>{"user_id"=>"37960509766262569d504f02a0ee986d", "user_info"=>{"name"=>"CHROME"}}})
+          end
+
+          it 'does not send multiple member added and member removed messages if one subscriber opens multiple connections, i.e. multiple browser tabs.' do
+            messages  = em_stream do |user1, messages|
+              case messages.length
+              when 1
+                send_subscribe(user: user1,
+                               user_id: '0f177369a3b71275d25ab1b44db9f95f',
+                               name: 'SG',
+                               message: messages.first)
+
+              when 2
+                10.times do
+                  new_websocket.tap do |u|
+                    u.stream do |message|
+                      # remove stream callback
+                      ## close the connection in the next tick as soon as subscription is acknowledged
+                      u.stream { EM.next_tick { u.close_connection } }
+
+                      send_subscribe({ user: u,
+                         user_id: '37960509766262569d504f02a0ee986d',
+                         name: 'CHROME',
+                         message: JSON.parse(message)})
+                    end
+                  end
+                end
+              when 4
+                EM.next_tick { EM.stop }
+              end
+
+            end
+
+            # There should only be one set of presence messages sent to the refernce user for the second user.
+            expect(messages.one? { |message| message['event'] == 'pusher_internal:member_added'   && message['data']['user_id'] == '37960509766262569d504f02a0ee986d' }).to eq(true)
+            expect(messages.one? { |message| message['event'] == 'pusher_internal:member_removed' && message['data']['user_id'] == '37960509766262569d504f02a0ee986d' }).to eq(true)
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/private_channel_spec.rb

@@ -0,0 +1,79 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe 'Integration' do
+
+  before(:each) { start_slanger }
+
+  describe 'private channels' do
+    context 'with valid authentication credentials:' do
+      it 'accepts the subscription request' do
+        messages  = em_stream do |websocket, messages|
+          case messages.length
+          when 1
+            private_channel websocket, messages.first
+          else
+            EM.stop
+          end
+        end
+
+        expect(messages).to have_attributes connection_established: true,
+          count: 2,
+          id_present: true,
+          last_event: 'pusher_internal:subscription_succeeded'
+      end
+    end
+
+    context 'with bogus authentication credentials:' do
+      it 'sends back an error message' do
+        messages  = em_stream do |websocket, messages|
+          case messages.length
+          when 1
+            websocket.send({ event: 'pusher:subscribe',
+                             data: { channel: 'private-channel',
+                                     auth: 'bogus' } }.to_json)
+          else
+            EM.stop
+          end
+        end
+
+        expect(messages).to have_attributes connection_established: true, count: 2, id_present: true, last_event:
+          'pusher:error'
+
+        expect(JSON.parse(messages.last['data'])['message']).to match /^Invalid signature: Expected HMAC SHA256 hex digest of/
+      end
+    end
+
+    describe 'client events' do
+      it "sends event to other channel subscribers" do
+        client1_messages, client2_messages  = [], []
+
+        em_thread do
+          client1, client2 = new_websocket, new_websocket
+          client2_messages, client1_messages = [], []
+
+          stream(client1, client1_messages) do |message|
+            case client1_messages.length
+            when 1
+              private_channel client1, client1_messages.first
+            when 3
+              EM.next_tick { EM.stop }
+            end
+          end
+
+          stream(client2, client2_messages) do |message|
+            case client2_messages.length
+            when 1
+              private_channel client2, client2_messages.first
+            when 2
+              client2.send({ event: 'client-something', data: { some: 'stuff' }, channel: 'private-channel' }.to_json)
+            end
+          end
+        end
+
+        expect(client1_messages.one?  { |m| m['event'] == 'client-something' }).to eq(true)
+        expect(client2_messages.none? { |m| m['event'] == 'client-something' }).to eq(true)
+      end
+    end
+  end
+end

data/spec/integration/replaced_handler_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'lib/slanger/handler.rb'
+
+class ReplacedHandler < Slanger::Handler
+  def authenticate
+    super
+    send_payload nil, 'pusher:info', { message: "Welcome!" }
+  end
+end
+
+describe 'Replacable handler' do
+  it 'says welcome' do
+    start_slanger_with_options socket_handler: ReplacedHandler
+
+    msgs = em_stream do |websocket, messages|
+      if messages.length == 2
+        EM.stop
+      end
+    end
+
+    expect(msgs.last).to eq({ "event" => "pusher:info", "data" =>"{\"message\":\"Welcome!\"}" })
+  end
+end

data/spec/integration/ssl_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Integration' do
+  describe 'Slanger when configured to use SSL' do
+    it 'encrypts the connection' do
+      start_slanger_with_options tls_options: {
+        cert_chain_file:  'spec/server.crt',
+        private_key_file: 'spec/server.key'
+      }
+
+      socket                 = TCPSocket.new('0.0.0.0', 8080)
+      expected_cert          = OpenSSL::X509::Certificate.new(File.open('spec/server.crt'))
+      ssl_socket             = OpenSSL::SSL::SSLSocket.new(socket)
+      ssl_socket.connect
+      expect(ssl_socket.peer_cert.to_s).to eq(expected_cert.to_s)
+    end
+  end
+end

data/spec/server.crt

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIBvzCCASgCCQCsMkmDVYNDETANBgkqhkiG9w0BAQUFADAkMQswCQYDVQQGEwJE
+RTEVMBMGA1UEAwwMc2xhbmdlci50ZXN0MB4XDTEyMDQxMTE2NDMwNloXDTE5MDIx
+NDE2NDMwNlowJDELMAkGA1UEBhMCREUxFTATBgNVBAMMDHNsYW5nZXIudGVzdDCB
+nzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAmlTxrcqXw+hbdjnpNENgx4p6T+x7
+SgN/5ti3+gr5ZJElebEdJdGymM/KK817GFhLuYSEv72oEVitC1ISCfo/iOu4S71Y
+sGsrdyPVl3cDswSkvmo27J3rtAbY1fNDs68YFAQGH8wlQtPSPvd9KBKg0klafsDU
+VvDYjQ+XZ2+ZKZECAwEAATANBgkqhkiG9w0BAQUFAAOBgQCHGqUddcsTfvV0Nk3F
+zZ5kGvAiZ02MUourZ4GVs5uBYtkIrQ7HAlQbHAbC8d7e0UVgcTwUKgwpw/RfNR/O
+Ho/zn7lPciLQ7VMnOZ2+MfbJ2HIFgZL6qH1gTcQpBW4s3gKR5hFpaGJ+8l/cmEWj
+AvywaOcSLex+q0OwZaiusiDorg==
+-----END CERTIFICATE-----

data/spec/server.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQCaVPGtypfD6Ft2Oek0Q2DHinpP7HtKA3/m2Lf6CvlkkSV5sR0l
+0bKYz8orzXsYWEu5hIS/vagRWK0LUhIJ+j+I67hLvViwayt3I9WXdwOzBKS+ajbs
+neu0BtjV80OzrxgUBAYfzCVC09I+930oEqDSSVp+wNRW8NiND5dnb5kpkQIDAQAB
+AoGABGzBDSGM3mIQFUCtzgDMiowO27HFCyc0iJLYG4QrCFYdA/MvCcGMZFM40a6v
+g9AsQ6JoB/NRGUY4l+V/fOe+4Iuycf8+vN1mrSVR1lTjy/mOwj900pc4ff6cDv6S
+bI/hm4BNiuj8OD11R+ZK07Lo1iCzBkAy53RkTFcBk74MYgECQQDMyAMT0DhlRBqD
+4vrPF+GZ+rMYpeTjuNDOZphIwzxpv70uyh2RNg+7F6U91Qxz6vpbIkz8Zf4TgdwM
+u/rroktxAkEAwO6wyzidm2yrPMPtnwxDIYnH/ETdNraa3JyHsjXsQwGAIG80+hCv
+QfCA/LmvNOm/Mpe1EyiAeI1/YJp4a2xwIQJBAKysFpQ1ZehVtbnxwaSwMWXiE/Q7
+pjYyl7cCoXPxVFai+8WhXa8dE8Shmo75v2dbAsGnuZy177jJLiB6vYjFL7ECQQCI
+Zri7lLVo8zVFasgO0F6N0ZmAMzeqvQNTwZ72UcVNwjvRso3j1fPyTJUFGEpUwIWa
+wUMV3mal1HQf2lYUrL/BAkBBtXqOLFHINHUmffdRSV/2HECYXHazb6lAnL8nnQX0
+vin2ujCli9mcYWnrY7zwlXdAxgQv5Q2ByQT9Fd8S7FjA
+-----END RSA PRIVATE KEY-----

data/spec/slanger_helper_methods.rb

@@ -0,0 +1,109 @@
+module SlangerHelperMethods
+  def start_slanger_with_options options={}
+    # Fork service. Our integration tests MUST block the main thread because we want to wait for i/o to finish.
+    @server_pid = EM.fork_reactor do
+      Thin::Logging.silent = true
+
+      opts = { host:             '0.0.0.0',
+               api_port:         '4567',
+               websocket_port:   '8080',
+               app_key:          '765ec374ae0a69f4ce44',
+               secret:           'your-pusher-secret',
+               activity_timeout: 100
+             }
+
+      Slanger::Config.load opts.merge(options)
+
+      Slanger::Service.run
+    end
+    wait_for_slanger
+  end
+
+  alias start_slanger start_slanger_with_options
+
+  def stop_slanger
+    # Ensure Slanger is properly stopped. No orphaned processes allowed!
+     Process.kill 'SIGKILL', @server_pid
+     Process.wait @server_pid
+  end
+
+  def wait_for_slanger opts = {}
+    opts = { port: 8080 }.update opts
+    begin
+      TCPSocket.new('0.0.0.0', opts[:port]).close
+    rescue
+      sleep 0.005
+      retry
+    end
+  end
+
+  def new_websocket opts = {}
+    opts = { key: Pusher.key, protocol: 7 }.update opts
+    uri = "ws://0.0.0.0:8080/app/#{opts[:key]}?client=js&version=1.8.5&protocol=#{opts[:protocol]}"
+
+    EM::HttpRequest.new(uri).get.tap { |ws| ws.errback &errback }
+  end
+
+  def em_stream opts = {}
+    messages = []
+
+    em_thread do
+      websocket = new_websocket opts
+
+      stream(websocket, messages) do |message|
+        yield websocket, messages
+      end
+    end
+
+    return messages
+  end
+
+  def em_thread
+    Thread.new do
+      EM.run do
+        yield
+      end
+    end.join
+  end
+
+  def stream websocket, messages
+    websocket.stream do |message|
+      messages << JSON.parse(message)
+
+      yield message
+    end
+  end
+
+  def send_subscribe options
+    info      = { user_id: options[:user_id], user_info: { name: options[:name] } }
+    socket_id = JSON.parse(options[:message]['data'])['socket_id']
+    to_sign   = [socket_id, 'presence-channel', info.to_json].join ':'
+
+    digest = OpenSSL::Digest::SHA256.new
+
+    options[:user].send({
+      event: 'pusher:subscribe',
+      data: {
+        auth: [Pusher.key, OpenSSL::HMAC.hexdigest(digest, Pusher.secret, to_sign)].join(':'),
+        channel_data: info.to_json,
+        channel: 'presence-channel'
+      }
+    }.to_json)
+  end
+
+  def private_channel websocket, message
+    socket_id = JSON.parse(message['data'])['socket_id']
+    to_sign   = [socket_id, 'private-channel'].join ':'
+
+    digest = OpenSSL::Digest::SHA256.new
+
+    websocket.send({
+      event: 'pusher:subscribe',
+      data: {
+        auth: [Pusher.key, OpenSSL::HMAC.hexdigest(digest, Pusher.secret, to_sign)].join(':'),
+        channel: 'private-channel'
+      }
+    }.to_json)
+
+  end
+end