oceanex-slanger 0.7.1

data/spec/integration/integration_spec.rb

@@ -0,0 +1,67 @@
+#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,148 @@
+#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,77 @@
+#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,107 @@
+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