pomelo-citrus-rpc 0.0.2

data/spec/rpc-client/proxy_spec.rb

@@ -0,0 +1,8 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Proxy do
+end

data/spec/rpc-client/router_spec.rb

@@ -0,0 +1,8 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Router do
+end

data/spec/rpc-client/ws_mailbox_spec.rb

@@ -0,0 +1,144 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 7 July 2014
+
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe WsMailBox do
+
+  dirname = File.expand_path File.dirname(__FILE__)
+  records = [
+    { :namespace => 'user', :server_type => 'area', :path => dirname + '/../mock-remote/area' },
+    { :namespace => 'sys', :server_type => 'connector', :path => dirname + '/../mock-remote/connector' }
+  ]
+
+  port = 3333
+
+  server = { :server_id => 'area-server-1', :host => '127.0.0.1', :port => port }
+
+  value = 1
+  msg = {
+    'namespace' => 'user',
+    'server_type' => 'area',
+    'service' => 'addOneRemote',
+    'method' => 'do',
+    'args' => [value]
+  };
+
+  describe '#create' do
+    it 'should be ok for creating a mailbox and connect to the right remote server' do
+      mailbox = WsMailBox.new server
+      expect(mailbox).to be
+
+      EM.run {
+        Server.new( :records => records, :port => port ).start
+
+        mailbox.connect { |err|
+          expect(err).to be_nil
+          EM.stop_event_loop
+        }
+      }
+    end
+
+    it 'should return an error if connect fail' do
+      bad_server = { :server_id => 'area-server-1', :host => '127.0.0.1', :port => -1000 }
+
+      mailbox = WsMailBox.new bad_server
+      expect(mailbox).to be
+
+      EM.run {
+        mailbox.connect { |err|
+          expect(err).to be
+          EM.stop_event_loop
+        }
+      }
+    end
+  end
+
+  describe '#send' do
+    it 'should send request to the right remote server and get response from callback' do
+      EM.run {
+        Server.new( :records => records, :port => port ).start
+
+        mailbox = WsMailBox.new server
+        expect(mailbox).to be
+
+        mailbox.connect { |err|
+          expect(err).to be_nil
+
+          mailbox.send(msg, nil, proc{ |send_err, err, res|
+            expect(res).to be
+            expect(res).to eql msg['args'][0] + 1
+            EM.stop_event_loop
+          })
+        }
+      }
+    end
+
+    it 'should distinguish different services and keep the right request/response relationship' do
+      callback_count = 0
+
+      value = 1
+      msg1 = {
+        'namespace' => 'user',
+        'server_type' => 'area',
+        'service' => 'addOneRemote',
+        'method' => 'do',
+        'args' => [value]
+      }
+      msg2 = {
+        'namespace' => 'user',
+        'server_type' => 'area',
+        'service' => 'addOneRemote',
+        'method' => 'add_two',
+        'args' => [value]
+      }
+      msg3 = {
+        'namespace' => 'user',
+        'server_type' => 'area',
+        'service' => 'addThreeRemote',
+        'method' => 'do',
+        'args' => [value]
+      }
+
+      EM.run {
+        Server.new( :records => records, :port => port ).start
+
+        mailbox = WsMailBox.new server
+        expect(mailbox).to be
+
+        mailbox.connect { |err|
+          err.should be_nil
+
+          mailbox.send(msg1, nil, proc{ |send_err, err, res|
+            expect(res).to be
+            expect(res).to eql msg1['args'][0] + 1
+            callback_count = callback_count + 1
+          })
+
+          mailbox.send(msg2, nil, proc{ |send_err, err, res|
+            expect(res).to be
+            expect(res).to eql msg2['args'][0] + 2
+            callback_count = callback_count + 1
+          })
+
+          mailbox.send(msg3, nil, proc{ |send_err, err, res|
+            expect(res).to be
+            expect(res).to eql msg3['args'][0] + 3
+            callback_count = callback_count + 1
+          })
+        }
+
+        EM.add_timer(0.1) {
+          expect(callback_count).to eql 3
+          EM.stop_event_loop
+        }
+      }
+    end
+  end
+
+  describe '#close' do
+    it 'should emit a close event when mailbox close' do
+    end
+  end
+end

data/spec/rpc-server/client/mock-tcp-client.rb

@@ -0,0 +1,6 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+class MockTcpClient
+end

data/spec/rpc-server/client/mock-ws-client.rb

@@ -0,0 +1,48 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require 'websocket-eventmachine-client'
+
+class MockWsClient
+  def initialize
+    @cur_id = 0
+    @requests = {}
+  end
+
+  def connect host, port, &block
+    @ws = WebSocket::EventMachine::Client.connect :uri => 'ws://' + host + ':' + port.to_s
+    @ws.onopen {
+      block.call
+    }
+    @ws.onmessage { |msg, type|
+      begin
+        pkg = JSON.parse msg
+      rescue => err
+      end
+
+      pkg_id = pkg['id']
+      pkg_resp = pkg['resp']
+
+      callback = @requests[pkg_id]
+      callback.call *pkg_resp
+
+      @requests.delete pkg_id
+    }
+    @ws.onerror { |err| }
+    @ws.onclose { |code, reason| }
+  end
+
+  def send msg, &callback
+    id = @cur_id
+    @requests[id] = callback
+
+    @cur_id = @cur_id + 1
+
+    @ws.send({ 'id' => id, 'msg' => msg }.to_json)
+  end
+
+  def close
+    @ws.close
+  end
+end

data/spec/rpc-server/dispatcher_spec.rb

@@ -0,0 +1,88 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Dispatcher do
+  include Dispatcher
+
+  services = {}
+  services['user'] = {}
+  services['sys'] = {}
+
+  services['user']['addOneRemote'] = Object.new
+  services['user']['addOneRemote'].define_singleton_method :do, proc{ |num, &block|
+    block.call nil, num + 1
+  }
+
+  services['sys']['addTwoRemote'] = Object.new
+  services['sys']['addTwoRemote'].define_singleton_method :do, proc{ |num, &block|
+    block.call nil, num + 2
+  }
+
+  it 'should dispatch message to the corresponding procedural' do
+    callback_count = 0
+
+    value = 0
+    msg1 = {
+      'namespace' => 'user',
+      'service' => 'addOneRemote',
+      'method' => 'do',
+      'args' => [value]
+    }
+    msg2 = {
+      'namespace' => 'sys', 
+      'service' => 'addTwoRemote',
+      'method' => 'do',
+      'args' => [value]
+    }
+
+    dispatch(msg1, services) { |err, result|
+      expect(err).to be_nil
+      expect(result).to be
+      expect(result).to eql (value + 1)
+      callback_count = callback_count + 1
+    }
+
+    dispatch(msg2, services) { |err, result|
+      expect(err).to be_nil
+      expect(result).to be
+      expect(result).to eql (value + 2)
+      callback_count = callback_count + 1
+    }
+
+    expect(callback_count).to eql 2
+  end
+
+  it 'should return an error if the service or method not exist' do
+    callback_count = 0
+
+    value = 0
+    msg1 = {
+      'namespace' => 'user',
+      'service' => 'addXRemote',
+      'method' => 'do',
+      'args' => [value]
+    }
+    msg2 = {
+      'namespace' => 'user',
+      'service' => 'addOneRemote',
+      'method' => 'foo',
+      'args' => [value] }
+
+    dispatch(msg1, services) { |err, result|
+      expect(err).to be
+      expect(result).to be_nil
+      callback_count = callback_count + 1
+    }
+
+    dispatch(msg2, services) { |err, result|
+      expect(err).to be
+      expect(result).to be_nil
+      callback_count = callback_count + 1
+    }
+
+    expect(callback_count).to eql 2
+  end
+end

data/spec/rpc-server/gateway_spec.rb

@@ -0,0 +1,206 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 5 July 2014
+
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../client/mock-ws-client', __FILE__)
+
+describe Gateway do
+
+  services = {}
+  services['user'] = {}
+
+  services['user']['addOneRemote'] = Object.new
+  services['user']['addOneRemote'].define_singleton_method :do, proc{ |num, &block|
+    block.call nil, num + 1
+  }
+
+  services['user']['addTwoRemote'] = Object.new
+  services['user']['addTwoRemote'].define_singleton_method :do, proc{ |num, &block|
+    block.call nil, num + 2
+  }
+
+  port = 3333
+  args = { :services => services, :port => port }
+
+  describe '#start' do
+    it 'should be ok when listening on a valid port and closed event should be emitted when stopped' do
+      error_count = 0
+      close_count = 0
+
+      gateway = Gateway.new args
+      expect(gateway).to be
+
+      gateway.on(:error) { |err| error_count = error_count + 1 }
+      gateway.on(:closed) { |err| close_count = close_count + 1 }
+
+      EM.run {
+        gateway.start
+        gateway.stop
+
+        EM.add_timer(0.1) {
+          expect(error_count).to eql 0
+          expect(close_count).to eql 1
+          EM.stop_event_loop
+        }
+      }
+    end
+
+    it 'should emit an error when listening on a port in use' do
+      error_count = 0
+
+      gateway = Gateway.new :services => services, :port => 80
+      expect(gateway).to be
+
+      gateway.on(:error) { |err|
+        expect(err).to be
+        error_count = error_count + 1
+      }
+
+      EM.run {
+        gateway.start
+
+        EM.add_timer(0.1) {
+          expect(error_count).to eql 1
+          EM.stop_event_loop
+        }
+      }
+    end
+  end
+
+  describe '#service' do
+    it 'should provide rpc service to remote clients' do
+      callback_count = 0
+      value = 1
+      msg = {
+        'namespace' => 'user',
+        'service' => 'addOneRemote',
+        'method' => 'do',
+        'args' => [value]
+      }
+
+      gateway = Gateway.new args
+      expect(gateway).to be
+
+      EM.run {
+        gateway.start
+
+        client = MockWsClient.new
+        client.connect('127.0.0.1', port) {
+          client.send(msg) { |err, resp|
+            expect(resp).to eql (value + 1)
+            callback_count = callback_count + 1
+          }
+        }
+
+        EM.add_timer(0.1) {
+          expect(callback_count).to eql 1
+          EM.stop_event_loop
+        }
+      }
+    end
+
+    it "should send back an error if service doesn't exist" do
+      callback_count = 0
+      value = 1
+      msg = {
+        'namespace' => 'user',
+        'service' => 'addXRemote',
+        'method' => 'do',
+        'args' => [value]
+      }
+
+      gateway = Gateway.new args
+      expect(gateway).to be
+
+      EM.run do
+        gateway.start
+
+        client = MockWsClient.new
+        client.connect('127.0.0.1', port) {
+          client.send(msg) { |err, resp|
+            expect(err).to be
+            expect(resp).to be_nil
+            callback_count = callback_count + 1
+          }
+        }
+
+        EM.add_timer(0.1) {
+          expect(callback_count).to eql 1
+          EM.stop_event_loop
+        }
+      end
+    end
+
+    it 'should keep relationship with the request and response' do
+      callback_count = 0
+
+      value1 = 1
+      msg1 = {
+        'namespace' => 'user',
+        'service' => 'addOneRemote',
+        'method' => 'do',
+        'args' => [value1]
+      }
+
+      value2 = 2
+      msg2 = {
+        'namespace' => 'user',
+        'service' => 'addOneRemote',
+        'method' => 'do',
+        'args' => [value2]
+      }
+
+      value3 = 3
+      msg3 = {
+        'namespace' => 'user',
+        'service' => 'addTwoRemote',
+        'method' => 'do',
+        'args' => [value3]
+      }
+
+      value4 = 4
+      msg4 = {
+        'namespace' => 'user',
+        'service' => 'addTwoRemote',
+        'method' => 'do',
+        'args' => [value4]
+      }
+
+      gateway = Gateway.new args
+      expect(gateway).to be
+
+      EM.run {
+        gateway.start
+
+        client = MockWsClient.new
+        client.connect('127.0.0.1', port) {
+          client.send(msg1) { |err, resp|
+            expect(resp).to eql (value1 + 1)
+            callback_count = callback_count + 1
+          }
+
+          client.send(msg2) { |err, resp|
+            expect(resp).to eql (value2 + 1)
+            callback_count = callback_count + 1
+          }
+
+          client.send(msg3) { |err, resp|
+            expect(resp).to eql (value3 + 2)
+            callback_count = callback_count + 1
+          }
+
+          client.send(msg4) { |err, resp|
+            expect(resp).to eql (value4 + 2)
+            callback_count = callback_count + 1
+          }
+        }
+
+        EM::Timer.new(0.1) {
+          expect(callback_count).to eql 4
+          EM.stop_event_loop
+        }
+      }
+    end
+  end
+end