ione-rpc 1.0.0.pre0

data/spec/ione/rpc/codec_spec.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Ione
+  module Rpc
+    describe Codec do
+      let :codec do
+        CodecSpec::JsonCodec.new
+      end
+
+      describe '#encode' do
+        let :object do
+          {'foo' => 'bar', 'baz' => 42}
+        end
+
+        let :encoded_message do
+          codec.encode(object, 42)
+        end
+
+        it 'encodes the version in the first byte' do
+          encoded_message[0, 1].unpack('c').should == [1]
+        end
+
+        it 'encodes the channel in the second byte' do
+          encoded_message[1, 1].unpack('c').should == [42]
+        end
+
+        it 'encodes the length of the frame in the following four bytes' do
+          encoded_message[2, 4].unpack('N').should == [22]
+        end
+
+        it 'encodes the object as JSON' do
+          encoded_message[6..-1].should == '{"foo":"bar","baz":42}'
+        end
+      end
+
+      describe '#decode' do
+        let :object do
+          {'foo' => 'bar', 'baz' => 42}
+        end
+
+        let :encoded_message do
+          %(\x01\x2a\x00\x00\x00\x16{"foo":"bar","baz":42})
+        end
+
+        it 'returns a partial message when there are less than five bytes' do
+          _, _, complete = codec.decode(Ione::ByteBuffer.new(encoded_message[0, 4]), nil)
+          complete.should be_false
+        end
+
+        it 'returns a partial message when the combined size of a previous partial message an new data is still less than the full frame size' do
+          buffer = Ione::ByteBuffer.new
+          buffer << encoded_message[0, 10]
+          message, _, _ = codec.decode(buffer, nil)
+          buffer << encoded_message[10, 4]
+          _, _, complete = codec.decode(buffer, message)
+          complete.should be_false
+        end
+
+        it 'returns a message and channel when it gets a full frame in one chunk' do
+          message, channel, complete = codec.decode(Ione::ByteBuffer.new(encoded_message), nil)
+          complete.should be_true
+          message.should == object
+          channel.should == 42
+        end
+
+        it 'returns a message and channel when it gets a full frame in chunks' do
+          buffer = Ione::ByteBuffer.new
+          buffer << encoded_message[0, 4]
+          message, _, _ = codec.decode(buffer, nil)
+          buffer << encoded_message[4, 10]
+          message, _, _ = codec.decode(buffer, message)
+          buffer << encoded_message[14..-1]
+          message, channel, _ = codec.decode(buffer, message)
+          message.should == object
+          channel.should == 42
+        end
+
+        it 'returns a message when it gets more bytes than needed' do
+          buffer = Ione::ByteBuffer.new
+          buffer << encoded_message[0, 10]
+          message, _ = codec.decode(buffer, message)
+          buffer << encoded_message[10..-1]
+          buffer << 'fooooo'
+          message, channel = codec.decode(buffer, message)
+          message.should == object
+          channel.should == 42
+        end
+      end
+
+      context 'when decoding and encoding' do
+        let :message do
+          {'foo' => 'bar', 'baz' => 42}
+        end
+
+        let :channel do
+          42
+        end
+
+        let :frame do
+          %(\x01\x2a\x00\x00\x00\x16{"foo":"bar","baz":42})
+        end
+
+        it 'decoding a encoded frame returns the original message' do
+          frm = codec.encode(message, channel)
+          msg, ch, _ = codec.decode(Ione::ByteBuffer.new(frm), nil)
+          msg.should == message
+          ch.should == channel
+        end
+
+        it 'encoding a message gives the original frame' do
+          msg, ch, _ = codec.decode(Ione::ByteBuffer.new(frame), nil)
+          frm = codec.encode(msg, ch)
+          frm.should == frame
+        end
+      end
+    end
+
+    describe StandardCodec do
+      let :codec do
+        described_class.new(JSON)
+      end
+
+      describe '#encode' do
+        it 'calls #dump on the delegate' do
+          codec.encode({'foo' => 'bar'}, 0)[6..-1].should == '{"foo":"bar"}'
+        end
+      end
+
+      describe '#decode' do
+        it 'calls #load on the delegate' do
+          buffer = Ione::ByteBuffer.new(%(\x01\x00\x00\x00\x00\x0d{"foo":"bar"}))
+          message, _, _ = codec.decode(buffer, nil)
+          message.should eql('foo' => 'bar')
+        end
+      end
+    end
+  end
+end
+
+module CodecSpec
+  class JsonCodec < Ione::Rpc::Codec
+    def encode_message(message)
+      JSON.dump(message)
+    end
+
+    def decode_message(str)
+      JSON.load(str)
+    end
+  end
+end

data/spec/ione/rpc/peer_common.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+shared_examples 'peers' do
+  context 'when setting up' do
+    it 'registers itself to receive notifications when there is new data' do
+      connection.data_listener.should_not be_nil
+    end
+
+    it 'registers itself to receive notifications when the connection closes' do
+      connection.closed_listener.should_not be_nil
+    end
+  end
+
+  context 'when receiving data' do
+    let :empty_frame do
+      double(:empty_frame, :partial? => true)
+    end
+
+    let :partial_frame do
+      double(:partial_frame, :partial? => true)
+    end
+
+    let :complete_frame do
+      double(:complete_frame, :partial? => false)
+    end
+
+    before do
+      channel = 9
+      codec.stub(:decode) do |buffer, previous_frame|
+        if buffer.empty?
+          [empty_frame, channel, false]
+        elsif buffer.index('FAKEPARTIALFRAME') == 0
+          buffer.read(16)
+          [partial_frame, channel, false]
+        elsif buffer.index('FAKEENDOFFRAME') == 0 && previous_frame == partial_frame
+          buffer.read(14)
+          [complete_frame, channel, true]
+        elsif buffer.index('FOO') == 0 || buffer.index('BAR') == 0 || buffer.index('BAZ') == 0
+          buffer.read(3)
+          [complete_frame, channel, true]
+        end
+      end
+    end
+
+    it 'does nothing when it\'s a partial frame' do
+      connection.data_listener.call('FAKEPARTIALFRAME')
+    end
+
+    it 'stiches together frames from fragments' do
+      connection.data_listener.call('FAKEPARTIALFRAME')
+      connection.data_listener.call('FAKEENDOFFRAME')
+      connection.written_bytes.should_not be_nil
+    end
+
+    it 'delivers the decoded frames to #handle_message' do
+      connection.data_listener.call('FAKEPARTIALFRAME')
+      connection.data_listener.call('FAKEENDOFFRAME')
+      peer.messages.should == [[complete_frame, 9]]
+    end
+
+    it 'delivers multiple frames to #handle_message' do
+      connection.data_listener.call('FOOBARBAZ')
+      peer.messages.should have(3).items
+    end
+  end
+
+  context 'when sending data' do
+    before do
+      codec.stub(:encode) do |message, channel|
+        "#{message}@#{channel}"
+      end
+    end
+
+    it 'writes the encoded frame to the connection' do
+      peer.send_message('FUZZBAZZ')
+      codec.should have_received(:encode).with('FUZZBAZZ', 0)
+      connection.written_bytes.should == 'FUZZBAZZ@0'
+    end
+  end
+
+  context 'when the connection closes' do
+    it 'calls the closed listeners' do
+      called1 = false
+      called2 = false
+      peer.on_closed { called1 = true }
+      peer.on_closed { called2 = true }
+      connection.closed_listener.call
+      called1.should be_true
+      called2.should be_true
+    end
+
+    it 'calls the closed listener with the close cause' do
+      cause = nil
+      peer.on_closed { |e| cause = e }
+      connection.closed_listener.call(StandardError.new('foo'))
+      cause.should == StandardError.new('foo')
+    end
+  end
+
+  context 'when closed' do
+    before do
+      connection.stub(:close)
+    end
+
+    it 'closes the connection' do
+      peer.close
+      connection.should have_received(:close)
+    end
+  end
+end
+
+module RpcSpec
+  class FakeConnection
+    attr_reader :written_bytes, :data_listener, :closed_listener, :host, :port
+
+    def initialize
+      @host = 'example.com'
+      @port = 9999
+      @written_bytes = ''
+    end
+
+    def write(bytes)
+      @written_bytes << bytes
+    end
+
+    def on_data(&listener)
+      @data_listener = listener
+    end
+
+    def on_closed(&listener)
+      @closed_listener = listener
+    end
+  end
+end

data/spec/ione/rpc/server_spec.rb

@@ -0,0 +1,214 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Ione
+  module Rpc
+    describe Server do
+      let :server do
+        ServerSpec::TestServer.new(4321, codec, io_reactor: io_reactor, logger: logger)
+      end
+
+      let :codec do
+        double(:codec)
+      end
+
+      let :logger do
+        double(:logger)
+      end
+
+      let :acceptor do
+        double(:acceptor)
+      end
+
+      let :io_reactor do
+        double(:io_reactor)
+      end
+
+      before do
+        io_reactor.stub(:start).and_return(Ione::Future.resolved(io_reactor))
+        io_reactor.stub(:stop).and_return(Ione::Future.resolved(io_reactor))
+        io_reactor.stub(:bind) do |*args, &callback|
+          callback.call(acceptor)
+          Ione::Future.resolved
+        end
+      end
+
+      before do
+        acceptor.stub(:on_accept)
+      end
+
+      before do
+        codec.stub(:encode) { |msg, _| msg }
+      end
+
+      before do
+        logger.stub(:info)
+      end
+
+      describe '#port' do
+        it 'returns the port the server is listening on' do
+          server.port.should == 4321
+        end
+      end
+
+      describe '#start' do
+        it 'starts the reactor' do
+          server.start.value
+          io_reactor.should have_received(:start)
+        end
+
+        it 'starts a server on the specified port' do
+          server.start.value
+          io_reactor.should have_received(:bind).with('0.0.0.0', 4321, 5)
+        end
+
+        it 'starts a server that binds to the specified address' do
+          server = described_class.new(4321, codec, io_reactor: io_reactor, bind_address: '1.1.1.1')
+          server.start.value
+          io_reactor.should have_received(:bind).with('1.1.1.1', 4321, anything)
+        end
+
+        it 'uses the specified queue size' do
+          server = described_class.new(4321, codec, io_reactor: io_reactor, queue_size: 11)
+          server.start.value
+          io_reactor.should have_received(:bind).with(anything, anything, 11)
+        end
+
+        it 'returns a future that resolves to the server' do
+          server.start.value.should equal(server)
+        end
+
+        it 'logs the address and port when listening for connections' do
+          server.start.value
+          logger.should have_received(:info).with('Server listening for connections on 0.0.0.0:4321')
+        end
+      end
+
+      describe '#stop' do
+        it 'stops the reactor' do
+          server.stop.value
+          io_reactor.should have_received(:stop)
+        end
+
+        it 'returns a future that resolves to the server' do
+          server.stop.value.should equal(server)
+        end
+      end
+
+      shared_context 'client_connections' do
+        let :accept_listeners do
+          []
+        end
+
+        let :raw_connection do
+          double(:connection)
+        end
+
+        before do
+          raw_connection.stub(:on_data)
+          raw_connection.stub(:on_closed) { |&listener| raw_connection.stub(:closed_listener).and_return(listener) }
+          raw_connection.stub(:host).and_return('client.example.com')
+          raw_connection.stub(:port).and_return(34534)
+          raw_connection.stub(:write)
+        end
+
+        before do
+          acceptor.stub(:on_accept) do |&listener|
+            accept_listeners << listener
+          end
+        end
+
+        before do
+          server.start.value
+        end
+      end
+
+      context 'when a client connects' do
+        include_context 'client_connections'
+
+        before do
+          accept_listeners.first.call(raw_connection)
+        end
+
+        it 'calls #handle_connection with the client connection' do
+          server.connections.should have(1).item
+          server.connections.first.host.should == raw_connection.host
+        end
+
+        it 'logs that a client connected' do
+          logger.should have_received(:info).with('Connection from client.example.com:34534 accepted')
+        end
+
+        it 'logs when the client is disconnected' do
+          raw_connection.closed_listener.call
+          logger.should have_received(:info).with('Connection from client.example.com:34534 closed')
+        end
+      end
+
+      context 'when a client sends a request' do
+        include_context 'client_connections'
+
+        before do
+          accept_listeners.first.call(raw_connection)
+        end
+
+        it 'calls #handle_request with the request' do
+          server.connections.first.handle_message('FOOBAZ', 42)
+          server.received_messages.first.should == ['FOOBAZ', server.connections.first]
+        end
+
+        it 'responds to the same peer and channel when the future returned by #handle_request is resolved' do
+          promise = Promise.new
+          server.override_handle_request { promise.future }
+          peer = server.connections.first
+          peer.stub(:write_message)
+          peer.handle_message('FOOBAZ', 42)
+          peer.should_not have_received(:write_message)
+          promise.fulfill('BAZFOO')
+          peer.should have_received(:write_message).with('BAZFOO', 42)
+        end
+
+        it 'uses the codec to encode the response' do
+          codec.stub(:encode).with('BAZFOO', 42).and_return('42BAZFOO')
+          server.override_handle_request { Future.resolved('BAZFOO') }
+          peer = server.connections.first
+          peer.handle_message('FOOBAZ', 42)
+          raw_connection.should have_received(:write).with('42BAZFOO')
+        end
+
+        it 'handles that the server fails to process the request'
+      end
+    end
+  end
+end
+
+module ServerSpec
+  class TestServer < Ione::Rpc::Server
+    attr_reader :connections, :received_messages
+
+    def initialize(*)
+      super
+      @connections = []
+      @received_messages = []
+    end
+
+    def handle_connection(peer)
+      @connections << peer
+    end
+
+    def override_handle_request(&handler)
+      @request_handler = handler
+    end
+
+    def handle_request(request, peer)
+      @received_messages << [request, peer]
+      if @request_handler
+        @request_handler.call(request, peer)
+      else
+        super
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+ENV['SERVER_HOST'] ||= '127.0.0.1'.freeze
+
+require 'bundler/setup'
+
+unless ENV['COVERAGE'] == 'no' || RUBY_ENGINE == 'rbx'
+  require 'coveralls'
+  require 'simplecov'
+
+  if ENV.include?('TRAVIS')
+    Coveralls.wear!
+    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  end
+
+  SimpleCov.start do
+    add_group 'Source', 'lib'
+    add_group 'Unit tests', 'spec/ione'
+    add_group 'Integration tests', 'spec/integration'
+  end
+end
+
+require 'ione/rpc'

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: ione-rpc
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre0
+platform: ruby
+authors:
+- Theo Hultberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ione
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+description: A toolkit for building RPC layers using Ione
+email:
+- theo@iconara.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .yardopts
+- README.md
+- lib/ione/rpc.rb
+- lib/ione/rpc/client.rb
+- lib/ione/rpc/client_peer.rb
+- lib/ione/rpc/codec.rb
+- lib/ione/rpc/peer.rb
+- lib/ione/rpc/server.rb
+- lib/ione/rpc/version.rb
+- spec/ione/rpc/client_peer_spec.rb
+- spec/ione/rpc/client_spec.rb
+- spec/ione/rpc/codec_spec.rb
+- spec/ione/rpc/peer_common.rb
+- spec/ione/rpc/server_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/iconara/ione-rpc
+licenses:
+- Apache License 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: RPC toolkit for Ruby
+test_files:
+- spec/ione/rpc/client_peer_spec.rb
+- spec/ione/rpc/client_spec.rb
+- spec/ione/rpc/codec_spec.rb
+- spec/ione/rpc/peer_common.rb
+- spec/ione/rpc/server_spec.rb
+- spec/spec_helper.rb
+has_rdoc: