wamp_client 0.0.8 → 0.0.9

data/lib/wamp_client/transport/event_machine_base.rb

@@ -0,0 +1,55 @@
+=begin
+
+Copyright (c) 2016 Eric Chapman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=end
+
+require 'eventmachine'
+require_relative 'base'
+
+module WampClient
+  module Transport
+    class EventMachineBase < Base
+
+      def self.start_event_machine(&block)
+        EM.run do
+          block.call
+        end
+      end
+
+      def self.stop_event_machine
+        EM.stop
+      end
+
+      def self.add_timer(milliseconds, &callback)
+        delay = (milliseconds.to_f/1000.0).ceil
+        EM.add_timer(delay) {
+          callback.call
+        }
+      end
+
+    end
+  end
+end
+

data/lib/wamp_client/transport/faye_web_socket.rb

@@ -0,0 +1,83 @@
+=begin
+
+Copyright (c) 2016 Eric Chapman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=end
+
+require_relative 'event_machine_base'
+
+# This implementation uses the 'faye-websocket' Gem.
+module WampClient
+  module Transport
+    class FayeWebSocket < EventMachineBase
+      attr_accessor :socket
+
+      def initialize(options)
+        super(options)
+        self.socket = nil
+
+        # Only make them include the gem if they are going to use it
+        require 'faye/websocket'
+      end
+
+      def connect
+        options = { :headers => self.headers }
+        options[:proxy] = self.proxy if self.proxy != nil
+        self.socket = Faye::WebSocket::Client.new(self.uri, [self.protocol], options)
+
+        self.socket.on(:open) do |event|
+          self.connected = true
+          @on_open.call if @on_open
+        end
+
+        self.socket.on(:message) do |event|
+          @on_message.call(self.serializer.deserialize(event.data)) if @on_message
+        end
+
+        self.socket.on(:close) do |event|
+          self.connected = false
+          @on_close.call(event.reason) if @on_close
+        end
+
+        self.socket.on(:error) do |event|
+          @on_error.call(event.message) if @on_error
+        end
+      end
+
+      def disconnect
+        self.socket.close
+        self.connected = false
+      end
+
+      def send_message(msg)
+        if self.connected
+          self.socket.send(self.serializer.serialize(msg))
+        else
+          raise RuntimeError, "Socket must be open to call 'send_message'"
+        end
+      end
+
+    end
+  end
+end

data/lib/wamp_client/transport/web_socket_event_machine.rb

@@ -0,0 +1,86 @@
+=begin
+
+Copyright (c) 2016 Eric Chapman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=end
+
+require_relative 'event_machine_base'
+
+# This implementation uses the 'websocket-eventmachine-client' Gem.
+# This is the default if no transport is included
+module WampClient
+  module Transport
+    class WebSocketEventMachine < EventMachineBase
+      attr_accessor :socket
+
+      def initialize(options)
+        super(options)
+        self.socket = nil
+
+        # Only make them include the gem if they are going to use it
+        require 'websocket-eventmachine-client'
+
+        # Raise an exception if proxy was included (not supported)
+        if self.proxy != nil
+          raise RuntimeError, "The WebSocketEventMachine transport does not support 'proxy'.  Try using 'faye-websocket' transport instead"
+        end
+      end
+
+      def connect
+        self.socket = WebSocket::EventMachine::Client.connect(
+            :uri => self.uri,
+            :headers => self.headers
+        )
+
+        self.socket.onopen do
+          self.connected = true
+          @on_open.call if @on_open
+        end
+
+        self.socket.onmessage do |msg, type|
+          @on_message.call(self.serializer.deserialize(msg)) if @on_message
+        end
+
+        self.socket.onclose do |code, reason|
+          self.connected = false
+          @on_close.call(reason) if @on_close
+        end
+      end
+
+      def disconnect
+        self.connected = !self.socket.close  # close returns 'true' if the connection was closed immediately
+      end
+
+      def send_message(msg)
+        if self.connected
+          self.socket.send(self.serializer.serialize(msg), {type: 'text'})
+        else
+          raise RuntimeError, "Socket must be open to call 'send_message'"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/wamp_client/version.rb

@@ -26,5 +26,5 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 =end
 
 module WampClient
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/spec/connection_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe WampClient::Connection do
+  include RSpec::EM::FakeClock
+
+  before { clock.stub }
+  after { clock.reset }
+
+  before(:each) { SpecHelper::TestTransport.stop_event_machine }
+
+  let(:options) {
+    {
+        uri: 'wss://example.com',
+        realm: 'realm1',
+        transport: SpecHelper::TestTransport,
+    }
+  }
+  let(:connection) { described_class.new(options) }
+  let(:transport) { connection.transport }
+  let(:session) { connection.session }
+
+  def open_connection
+    connection.open
+    clock.tick(1)
+  end
+
+  def open_session_from_server
+    # Send welcome form server
+    welcome = WampClient::Message::Welcome.new(1234, {})
+    transport.receive_message(welcome.payload)
+  end
+
+  def close_session_from_server
+    # Send goodbye from server
+    goodbye = WampClient::Message::Goodbye.new({}, 'felt.like.it')
+    transport.receive_message(goodbye.payload)
+  end
+
+  def check_em_on
+    expect(SpecHelper::TestTransport.event_machine_on?).to eq(true)
+  end
+
+  def check_em_off
+    expect(SpecHelper::TestTransport.event_machine_on?).to eq(false)
+  end
+
+  describe 'transport' do
+    it 'selects the default transport' do
+      connection = described_class.new({})
+      expect(connection.transport_class).to be(WampClient::Transport::WebSocketEventMachine)
+    end
+
+    it 'overrides the default transport' do
+      connection = described_class.new({ transport: WampClient::Transport::FayeWebSocket })
+      expect(connection.transport_class).to be(WampClient::Transport::FayeWebSocket)
+    end
+  end
+
+  it 'opens the transport/session and sends the hello message' do
+    called = false
+    connection.on(:connect) do
+      called = true
+    end
+
+    open_connection
+
+    expect(transport).not_to be_nil
+    expect(session).not_to be_nil
+    expect(transport.messages.count).to eq(1)
+    expect(transport.messages[0][0]).to eq(WampClient::Message::Types::HELLO)
+
+    expect(called).to eq(true)
+  end
+
+  it 'opens the transport/session and joins' do
+    called = false
+    connection.on(:join) do
+      called = true
+    end
+
+    open_connection
+    open_session_from_server
+
+    check_em_on
+    expect(called).to eq(true)
+  end
+
+  it 'closes the connection' do
+    left = false
+    connection.on(:leave) do
+      left = true
+    end
+    disconnected = false
+    connection.on(:disconnect) do
+      disconnected = true
+    end
+
+    open_connection
+    open_session_from_server
+
+    connection.close
+
+    # Nothing happens until the server responds
+    check_em_on
+    expect(left).to eq(false)
+    expect(disconnected).to eq(false)
+
+    close_session_from_server
+
+    check_em_off
+    expect(left).to eq(true)
+    expect(disconnected).to eq(true)
+  end
+
+  it 'retries if the session is closed from the server' do
+    left = false
+    connection.on(:leave) do
+      left = true
+    end
+
+    joined = false
+    connection.on(:join) do
+      joined = true
+    end
+
+    open_connection
+    open_session_from_server
+
+    check_em_on
+    expect(joined).to eq(true)
+    joined = false
+    expect(left).to eq(false)
+
+    close_session_from_server
+
+    check_em_on
+    expect(joined).to eq(false)
+    expect(left).to eq(true)
+    left = false
+
+    clock.tick(5)
+    open_session_from_server
+
+    check_em_on
+
+    expect(joined).to eq(true)
+    joined = false
+    expect(left).to eq(false)
+  end
+end

data/spec/session_spec.rb

@@ -1115,6 +1115,11 @@ describe WampClient::Session do
     end
 
     context 'timeout' do
+      include RSpec::EM::FakeClock
+
+      before { clock.stub }
+      after { clock.reset }
+
       it 'does not cancel a call if no timeout specified' do
         @defer = WampClient::Defer::ProgressiveCallDefer.new
 
@@ -1123,7 +1128,7 @@ describe WampClient::Session do
           count += 1
         end
 
-        expect(transport.timer_callback).to be_nil
+        clock.tick(2)
         expect(transport.messages.count).to eq(1)
       end
 
@@ -1135,8 +1140,7 @@ describe WampClient::Session do
           count += 1
         end
 
-        expect(transport.timer_callback).not_to be_nil
-        transport.timer_callback.call
+        clock.tick(2)
 
         expect(transport.messages.count).to eq(2)
 

data/spec/spec_helper.rb

@@ -9,12 +9,13 @@ if ENV['CODECOV_TOKEN']
 end
 
 require 'wamp_client'
+require "rspec/em"
 
 module SpecHelper
 
-  class TestTransport < WampClient::Transport::Base
-
-    attr_accessor :messages, :timer_callback
+  class TestTransport < WampClient::Transport::EventMachineBase
+    @@event_machine_on = false
+    attr_accessor :messages
 
     def initialize(options)
       super(options)
@@ -23,7 +24,27 @@ module SpecHelper
     end
 
     def connect
+      self.add_timer(1000) do
+        @on_open.call if @on_open
+      end
+    end
+
+    def disconnect
+      @connected = false
+      @on_close.call if @on_close
+    end
+
+    def self.start_event_machine(&block)
+      @@event_machine_on = true
+      block.call
+    end
+
+    def self.stop_event_machine
+      @@event_machine_on = false
+    end
 
+    def self.event_machine_on?
+      @@event_machine_on
     end
 
     def send_message(msg)
@@ -37,13 +58,91 @@ module SpecHelper
       deserialize = self.serializer.deserialize(serialize)
 
       # Call the received message
-      @on_message.call(deserialize) unless @on_message.nil?
+      @on_message.call(deserialize) if @on_message
+    end
+
+  end
+
+  class WebSocketEventMachineClientStub
+    attr_accessor :last_message
+
+    def initialize
+      EM.add_timer(1) {
+        @onopen.call if @onopen != nil
+      }
+    end
+
+    @onopen
+    def onopen(&onopen)
+      @onopen = onopen
+    end
+
+    @onmessage
+    def onmessage(&onmessage)
+      @onmessage = onmessage
+    end
+
+    @onclose
+    def onclose(&onclose)
+      @onclose = onclose
     end
 
-    def timer(milliseconds, &callback)
-      self.timer_callback = callback
+    def close
+      @onclose.call if @onclose != nil
+      true
+    end
+
+    def send(message, type)
+      self.last_message = message
+    end
+
+    def receive(message)
+      @onmessage.call(message, {type:'text'}) if @onmessage != nil
     end
 
   end
 
+  class FayeWebSocketClientStub
+    class Event
+      attr_accessor :data, :reason
+    end
+
+    attr_accessor :last_message
+
+    def initialize
+      EM.add_timer(1) {
+        @on_open.call(Event.new) if @on_open != nil
+      }
+    end
+
+    @on_open
+    @on_message
+    @on_close
+    def on(event, &block)
+      if event == :open
+        @on_open = block
+      elsif event == :close
+        @on_close = block
+      elsif event == :message
+        @on_message = block
+      end
+    end
+
+    def close
+      event = Event.new
+      event.reason = 'closed'
+      @on_close.call(event) if @on_close != nil
+    end
+
+    def send(message)
+      self.last_message = message
+    end
+
+    def receive(message)
+      event = Event.new
+      event.data = message
+      @on_message.call(event) if @on_message != nil
+    end
+
+  end
 end