fd-bertrpc 1.3.0

data/.document

@@ -0,0 +1,5 @@
+README.md
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/History.txt

@@ -0,0 +1,33 @@
+= 1.3.0 / 2010-02-24
+  * Enhancements
+    * Raise BERTRPC::ReadTimeout if remote connection is closed
+
+= 1.2.1 / 2010-02-10
+  * Bug fixes
+    * Restrict to IPv4
+
+= 1.2.0 / 2010-02-09
+  * Enhancements
+    * Better timeouts courtesy of select(2)
+    * BERTRPCError gives self for original_exception if nil
+
+= 1.1.2 / 2009-11-27
+  * Minor Changes
+    * Add useful debugging information to ReadTimeoutError
+    * Switch to using raw socket timeouts over buffered io (Linux only)
+    * Add BERTRPC::VERSION and BERTRPC.version
+
+= 1.1.1 / 2009-10-28
+  Major Changes
+    * Require bert-1.1.0 or greater
+    * Remove dependency on Erlectricity
+
+= 1.1.0 / 2009-10-27
+  * Add read socket timeout
+
+= 1.0.0 / 2009-10-19
+  * No changes. Production ready!
+
+= 0.4.0 / 2009-10-08
+  * Major changes
+    * Convert to use BERT gem.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tom Preston-Werner
+
+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.

data/README.md

@@ -0,0 +1,71 @@
+BERTRPC
+=======
+
+By Tom Preston-Werner (tom@mojombo.com)
+
+BERT-RPC client library for Ruby. Makes it ridiculously simple to interface
+with BERT-RPC servers.
+
+See the full BERT-RPC specification at [bert-rpc.org](http://bert-rpc.org).
+
+This library currently only supports the following BERT-RPC features:
+
+* `call` requests
+* `cast` requests
+
+BERTRPC was developed for GitHub and is currently in production use performing
+millions of RPC requests every day. The stability and performance have been
+exemplary.
+
+
+Installation
+------------
+
+    $ gem install bertrpc -s http://gemcutter.org
+
+
+Examples
+--------
+
+Require the library and create a service:
+
+    require 'bertrpc'
+    svc = BERTRPC::Service.new('localhost', 9999)
+
+Make a call:
+
+    svc.call.calc.add(1, 2)
+    # => 3
+
+The underlying BERT-RPC transaction of the above call is:
+
+    -> {call, calc, add, [1, 2]}
+    <- {reply, 3}
+
+Make a cast:
+
+    svc.cast.stats.incr
+    # => nil
+
+The underlying BERT-RPC transaction of the above cast is:
+
+    -> {cast, stats, incr, []}
+    <- {noreply}
+
+
+Documentation
+-------------
+
+Creating a service:
+
+    # No timeout
+    svc = BERTRPC::Service.new('localhost', 9999)
+    
+    # 10s socket read timeout, raises BERTRPC::ReadTimeoutError
+    svc = BERTRPC::Service.new('localhost', 9999, 10)
+
+
+Copyright
+---------
+
+Copyright (c) 2009 Tom Preston-Werner. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fd-bertrpc"
+    gem.summary = %Q{BERTRPC is a Ruby BERT-RPC client library.}
+    gem.email = "tom@mojombo.com"
+    gem.homepage = "http://github.com/mojombo/bertrpc"
+    gem.authors = ["Tom Preston-Werner"]
+    gem.add_dependency('bert', '>= 1.1.0', '< 2.0.0')
+    # gem is a Gem::Specification...
+    # see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bertrpc #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :console do
+  exec('irb -Ilib -rbertrpc')
+end

data/VERSION

@@ -0,0 +1 @@
+1.3.0

data/bertrpc.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fd-bertrpc}
+  s.version = "1.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tom Preston-Werner"]
+  s.date = %q{2010-02-24}
+  s.email = %q{tom@mojombo.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "History.txt",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "bertrpc.gemspec",
+     "lib/bertrpc.rb",
+     "lib/bertrpc/action.rb",
+     "lib/bertrpc/encodes.rb",
+     "lib/bertrpc/errors.rb",
+     "lib/bertrpc/mod.rb",
+     "lib/bertrpc/request.rb",
+     "lib/bertrpc/service.rb",
+     "test/action_test.rb",
+     "test/encodes_test.rb",
+     "test/error_test.rb",
+     "test/mod_test.rb",
+     "test/request_test.rb",
+     "test/service_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mojombo/bertrpc}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{BERTRPC is a Ruby BERT-RPC client library.}
+  s.test_files = [
+    "test/action_test.rb",
+     "test/encodes_test.rb",
+     "test/error_test.rb",
+     "test/mod_test.rb",
+     "test/request_test.rb",
+     "test/service_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<bert>, [">= 1.1.0", "< 2.0.0"])
+    else
+      s.add_dependency(%q<bert>, [">= 1.1.0", "< 2.0.0"])
+    end
+  else
+    s.add_dependency(%q<bert>, [">= 1.1.0", "< 2.0.0"])
+  end
+end
+

data/lib/bertrpc.rb

@@ -0,0 +1,20 @@
+require 'bert'
+require 'socket'
+require 'net/protocol'
+
+require 'bertrpc/service'
+require 'bertrpc/request'
+require 'bertrpc/mod'
+require 'bertrpc/encodes'
+require 'bertrpc/action'
+require 'bertrpc/errors'
+
+module BERTRPC
+  def self.version
+    File.read(File.join(File.dirname(__FILE__), *%w[.. VERSION])).chomp
+  rescue
+    'unknown'
+  end
+
+  VERSION = self.version
+end

data/lib/bertrpc/action.rb

@@ -0,0 +1,113 @@
+module BERTRPC
+  class Action
+    include Encodes
+
+    def initialize(svc, req, mod, fun, args)
+      @svc = svc
+      @req = req
+      @mod = mod
+      @fun = fun
+      @args = args
+    end
+
+    def execute
+      bert_request = encode_ruby_request(t[@req.kind, @mod, @fun, @args])
+      bert_response = transaction(bert_request)
+      decode_bert_response(bert_response)
+    end
+
+    #private
+
+    def write(sock, bert)
+      sock.write([bert.length].pack("N"))
+      sock.write(bert)
+    end
+
+    def read(sock, len, timeout)
+      data, size = [], 0
+      while size < len
+        r, w, e = IO.select([sock], [], [], timeout)
+        raise Errno::EAGAIN if r.nil?
+        msg, sender = sock.recvfrom(len - size)
+        raise Errno::ECONNRESET if msg.size == 0
+        size += msg.size
+        data << msg
+      end
+      data.join ''
+    end
+
+    def transaction(bert_request)
+      timeout = @svc.timeout && Float(@svc.timeout)
+      sock = connect_to(@svc.host, @svc.port, timeout)
+
+      if @req.options
+        if @req.options[:cache] && @req.options[:cache][0] == :validation
+          token = @req.options[:cache][1]
+          info_bert = encode_ruby_request(t[:info, :cache, [:validation, token]])
+          write(sock, info_bert)
+        end
+
+        if @req.options[:stream]
+          info_bert = encode_ruby_request(t[:info, :stream, []])
+          write(sock, info_bert)
+        end
+      end
+
+      write(sock, bert_request)
+
+      case (@req.options||{})[:stream]
+      when IO then
+        while blob = stream.read(1024)
+          write(sock, blob)
+        end
+        write(sock, "")
+      when String
+        File.open(stream) do |f|
+          while blob = f.read(1024)
+            write(sock, blob)
+          end
+          write(sock, "")
+        end
+      end
+
+      lenheader = read(sock, 4, timeout)
+      raise ProtocolError.new(ProtocolError::NO_HEADER) unless lenheader
+      len = lenheader.unpack('N').first
+      bert_response = read(sock, len, timeout)
+      raise ProtocolError.new(ProtocolError::NO_DATA) unless bert_response
+      sock.close
+      bert_response
+    rescue Errno::ECONNREFUSED
+      raise ConnectionError.new(@svc.host, @svc.port)
+    rescue Errno::EAGAIN
+      raise ReadTimeoutError.new(@svc.host, @svc.port, @svc.timeout)
+    rescue Errno::ECONNRESET
+      raise ReadError.new(@svc.host, @svc.port)
+    end
+
+    # Creates a socket object which does speedy, non-blocking reads
+    # and can perform reliable read timeouts.
+    #
+    # Raises Timeout::Error on timeout.
+    #
+    #   +host+ String address of the target TCP server
+    #   +port+ Integer port of the target TCP server
+    #   +timeout+ Optional Integer (in seconds) of the read timeout
+    def connect_to(host, port, timeout = nil)
+      addr = Socket.getaddrinfo(host, nil, Socket::AF_INET)
+      sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+      sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+      if timeout
+        secs = Integer(timeout)
+        usecs = Integer((timeout - secs) * 1_000_000)
+        optval = [secs, usecs].pack("l_2")
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+      end
+
+      sock.connect(Socket.pack_sockaddr_in(port, addr[0][3]))
+      sock
+    end
+  end
+end

data/lib/bertrpc/encodes.rb

@@ -0,0 +1,38 @@
+module BERTRPC
+  module Encodes
+    def encode_ruby_request(ruby_request)
+      BERT.encode(ruby_request)
+    end
+
+    def decode_bert_response(bert_response)
+      ruby_response = BERT.decode(bert_response)
+      case ruby_response[0]
+        when :reply
+          ruby_response[1]
+        when :noreply
+          nil
+        when :error
+          error(ruby_response[1])
+        else
+          raise
+      end
+    end
+
+    def error(err)
+      level, code, klass, message, backtrace = err
+
+      case level
+        when :protocol
+          raise ProtocolError.new([code, message], klass, backtrace)
+        when :server
+          raise ServerError.new([code, message], klass, backtrace)
+        when :user
+          raise UserError.new([code, message], klass, backtrace)
+        when :proxy
+          raise ProxyError.new([code, message], klass, backtrace)
+        else
+          raise
+      end
+    end
+  end
+end

data/lib/bertrpc/errors.rb

@@ -0,0 +1,76 @@
+module BERTRPC
+  class BERTRPCError < StandardError
+    attr_accessor :code, :original_exception
+
+    def initialize(msg = nil, klass = nil, bt = [])
+      case msg
+        when Array
+          code, message = msg
+        else
+          code, message = [0, msg]
+      end
+
+      if klass
+        self.original_exception = RemoteError.new("#{klass}: #{message}")
+        self.original_exception.set_backtrace(bt)
+      else
+        self.original_exception = self
+      end
+
+      self.code = code
+      super(message)
+    end
+  end
+
+  class RemoteError < StandardError
+
+  end
+
+  class ConnectionError < BERTRPCError
+    attr_reader :host, :port
+    def initialize(host, port)
+      @host, @port = host, port
+      super("Unable to connect to #{host}:#{port}")
+    end
+  end
+
+  # Raised when we don't get a response from a server in a timely
+  # manner. This typically occurs in spite of a successful connection.
+  class ReadTimeoutError < BERTRPCError
+    attr_reader :host, :port, :timeout
+    def initialize(host, port, timeout)
+      @host, @port, @timeout = host, port, timeout
+      super("No response from #{host}:#{port} in #{timeout}s")
+    end
+  end
+
+  # Raised when unexpected EOF is reached on the socket.
+  class ReadError < BERTRPCError
+    attr_reader :host, :port
+    def initialize(host, port)
+      @host, @port = host, port
+      super("Unable to read from #{host}:#{port}")
+    end
+  end
+
+  class ProtocolError < BERTRPCError
+    NO_HEADER = [0, "Unable to read length header from server."]
+    NO_DATA = [1, "Unable to read data from server."]
+  end
+
+  class ServerError < BERTRPCError
+
+  end
+
+  class UserError < BERTRPCError
+
+  end
+
+  class ProxyError < BERTRPCError
+
+  end
+
+  class InvalidOption < BERTRPCError
+
+  end
+end

data/lib/bertrpc/mod.rb

@@ -0,0 +1,14 @@
+module BERTRPC
+  class Mod
+    def initialize(svc, req, mod)
+      @svc = svc
+      @req = req
+      @mod = mod
+    end
+
+    def method_missing(cmd, *args)
+      args = [*args]
+      Action.new(@svc, @req, @mod, cmd, args).execute
+    end
+  end
+end

data/lib/bertrpc/request.rb

@@ -0,0 +1,15 @@
+module BERTRPC
+  class Request
+    attr_accessor :kind, :options
+
+    def initialize(svc, kind, options)
+      @svc = svc
+      @kind = kind
+      @options = options
+    end
+
+    def method_missing(cmd, *args)
+      Mod.new(@svc, self, cmd)
+    end
+  end
+end

data/lib/bertrpc/service.rb

@@ -0,0 +1,40 @@
+module BERTRPC
+  class Service
+    attr_accessor :host, :port, :timeout
+
+    def initialize(host, port, timeout = nil)
+      @host = host
+      @port = port
+      @timeout = timeout
+    end
+
+    def call(options = nil)
+      verify_options(options)
+      Request.new(self, :call, options)
+    end
+
+    def cast(options = nil)
+      verify_options(options)
+      Request.new(self, :cast, options)
+    end
+
+    # private
+
+    def verify_options(options)
+      (options||{}).each do |key, value|
+        case key
+        when :stream
+          unless (String === value and File.file?(value))
+            raise InvalidOption.new("Valid :stream args are IO or path")
+          end
+        when :case
+          unless value[0] == :validation && value[1].is_a?(String)
+            raise InvalidOption.new("Valid :cache args are [:validation, String]")
+          end
+        else
+          raise InvalidOption.new("Valid options are :cache and :stream")
+        end
+      end
+    end
+  end
+end

data/test/action_test.rb

@@ -0,0 +1,126 @@
+require 'test_helper'
+
+class ActionTest < Test::Unit::TestCase
+  context "An Action" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+      @req = @svc.call
+    end
+
+    should "be created with a Service, module name, fun name, and args" do
+      assert BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [1, 2]).is_a?(BERTRPC::Action)
+    end
+  end
+
+  context "An Action instance" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+      @req = @svc.call
+      @enc = Enc.new
+    end
+
+    should "call with single-arity" do
+      req = @enc.encode_ruby_request(t[:call, :mymod, :myfun, [1]])
+      res = @enc.encode_ruby_request(t[:reply, 2])
+      call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [1])
+      call.expects(:transaction).with(req).returns(res)
+      assert_equal 2, call.execute
+    end
+
+    should "call with single-arity array" do
+      req = @enc.encode_ruby_request(t[:call, :mymod, :myfun, [[1, 2, 3]]])
+      res = @enc.encode_ruby_request(t[:reply, [4, 5, 6]])
+      call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [[1, 2, 3]])
+      call.expects(:transaction).with(req).returns(res)
+      assert_equal [4, 5, 6], call.execute
+    end
+
+    should "call with multi-arity" do
+      req = @enc.encode_ruby_request(t[:call, :mymod, :myfun, [1, 2, 3]])
+      res = @enc.encode_ruby_request(t[:reply, [4, 5, 6]])
+      call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [1, 2, 3])
+      call.expects(:transaction).with(req).returns(res)
+      assert_equal [4, 5, 6], call.execute
+    end
+
+    context "sync_request" do
+      setup do
+        @svc = BERTRPC::Service.new('localhost', 9941)
+        @req = @svc.call
+        @call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [])
+      end
+
+      should "read and write BERT-Ps from the socket" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        @call.expects(:read).with(io, 4, nil).returns("\000\000\000\003")
+        @call.expects(:read).with(io, 3, nil).returns("bar")
+        io.expects(:close)
+        @call.expects(:connect_to).returns(io)
+        assert_equal "bar", @call.transaction("foo")
+      end
+
+      should "raise a ProtocolError when the length is invalid" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        @call.expects(:read).with(io, 4, nil).returns(nil)
+        @call.expects(:connect_to).returns(io)
+        begin
+          @call.transaction("foo")
+          fail "Should have thrown an error"
+        rescue BERTRPC::ProtocolError => e
+          assert_equal 0, e.code
+        end
+      end
+
+      should "raise a ProtocolError when the data is invalid" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        @call.expects(:read).with(io, 4, nil).returns("\000\000\000\003")
+        @call.expects(:read).with(io, 3, nil).returns(nil)
+        @call.expects(:connect_to).returns(io)
+         begin
+          @call.transaction("foo")
+          fail "Should have thrown an error"
+        rescue BERTRPC::ProtocolError => e
+          assert_equal 1, e.code
+        end
+      end
+
+      should "raise a ReadTimeoutError when the connection times out" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        @call.expects(:read).with(io, 4, nil).raises(Errno::EAGAIN)
+        @call.expects(:connect_to).returns(io)
+        begin
+          @call.transaction("foo")
+          fail "Should have thrown an error"
+        rescue BERTRPC::ReadTimeoutError => e
+          assert_equal 0, e.code
+          assert_equal 'localhost', e.host
+          assert_equal 9941, e.port
+        end
+      end
+
+      should "raise a ReadError when the socket becomes unreadable" do
+        io = stub()
+        io.expects(:write).with("\000\000\000\003")
+        io.expects(:write).with("foo")
+        @call.expects(:read).with(io, 4, nil).raises(Errno::ECONNRESET)
+        @call.expects(:connect_to).returns(io)
+        begin
+          @call.transaction("foo")
+          fail "Should have thrown an error"
+        rescue BERTRPC::ReadError => e
+          assert_equal 0, e.code
+          assert_equal 'localhost', e.host
+          assert_equal 9941, e.port
+        end
+      end
+    end
+  end
+end

data/test/encodes_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class EncodesTest < Test::Unit::TestCase
+  context "An Encodes includer" do
+    setup do
+      @enc = Enc.new
+    end
+
+    context "ruby request encoder" do
+      should "return BERT-RPC encoded request" do
+        bert = "\203h\004d\000\004calld\000\005mymodd\000\005myfunl\000\000\000\003a\001a\002a\003j"
+        assert_equal bert, @enc.encode_ruby_request(t[:call, :mymod, :myfun, [1, 2, 3]])
+      end
+    end
+
+    context "bert response decoder" do
+      should "return response when reply" do
+        req = @enc.encode_ruby_request(t[:reply, [1, 2, 3]])
+        res = @enc.decode_bert_response(req)
+        assert_equal [1, 2, 3], res
+      end
+
+      should "return nil when noreply" do
+        req = @enc.encode_ruby_request(t[:noreply])
+        res = @enc.decode_bert_response(req)
+        assert_equal nil, res
+      end
+
+      should "raise a ProtocolError error when protocol level error is returned" do
+        req = @enc.encode_ruby_request(t[:error, [:protocol, 1, "class", "invalid", []]])
+        assert_raises(BERTRPC::ProtocolError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+
+      should "raise a ServerError error when server level error is returned" do
+        req = @enc.encode_ruby_request(t[:error, [:server, 1, "class", "invalid", []]])
+        assert_raises(BERTRPC::ServerError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+
+      should "raise a UserError error when user level error is returned" do
+        req = @enc.encode_ruby_request([:error, [:user, 1, "class", "invalid", []]])
+        assert_raises(BERTRPC::UserError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+
+      should "raise a ProxyError error when proxy level error is returned" do
+        req = @enc.encode_ruby_request([:error, [:proxy, 1, "class", "invalid", []]])
+        assert_raises(BERTRPC::ProxyError) do
+          @enc.decode_bert_response(req)
+        end
+      end
+    end
+  end
+end

data/test/error_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class ErrorTest < Test::Unit::TestCase
+  context "Errors in general" do
+    should "be creatable with just a message string" do
+      begin
+        raise BERTRPC::BERTRPCError.new('msg')
+      rescue Object => e
+        assert_equal "msg", e.message
+        assert_equal 0, e.code
+      end
+    end
+
+    should "be creatable with a [code, message] array" do
+      begin
+        raise BERTRPC::BERTRPCError.new([7, 'msg'])
+      rescue Object => e
+        assert_equal "msg", e.message
+        assert_equal 7, e.code
+      end
+    end
+
+    should "record the original exception" do
+      begin
+        raise BERTRPC::BERTRPCError.new('msg', 'Error', ['foo', 'bar'])
+      rescue Object => e
+        assert_equal "msg", e.message
+        assert_equal "Error: msg", e.original_exception.message
+        assert_equal ['foo', 'bar'], e.original_exception.backtrace
+      end
+    end
+  end
+end

data/test/mod_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class ModTest < Test::Unit::TestCase
+  context "A Mod" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+      @req = @svc.call
+    end
+
+    should "be created with a Service, request and module name" do
+      assert BERTRPC::Mod.new(@svc, @req, :mymod).is_a?(BERTRPC::Mod)
+    end
+  end
+
+  context "A Mod instance" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+      @req = @svc.call
+      @mod = BERTRPC::Mod.new(@svc, @req, :mymod)
+    end
+
+    should "call execute on the type" do
+      m = mock(:execute => nil)
+      BERTRPC::Action.expects(:new).with(@svc, @req, :mymod, :myfun, [1, 2, 3]).returns(m)
+      @mod.myfun(1, 2, 3)
+
+      m = mock(:execute => nil)
+      BERTRPC::Action.expects(:new).with(@svc, @req, :mymod, :myfun, [1]).returns(m)
+      @mod.myfun(1)
+    end
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class RequestTest < Test::Unit::TestCase
+  context "A Request" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+    end
+
+    should "be created with a Service and type" do
+      assert BERTRPC::Request.new(@svc, :call, nil).is_a?(BERTRPC::Request)
+    end
+  end
+
+  context "A Request instance" do
+    setup do
+      svc = BERTRPC::Service.new('localhost', 9941)
+      @req = BERTRPC::Request.new(@svc, :call, nil)
+    end
+
+    should "return a Mod instance" do
+      assert @req.myfun.is_a?(BERTRPC::Mod)
+    end
+  end
+end

data/test/service_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class ServiceTest < Test::Unit::TestCase
+  context "A Service" do
+    should "be creatable with host and port" do
+      svc = BERTRPC::Service.new('localhost', 9941)
+      assert svc.is_a?(BERTRPC::Service)
+    end
+
+    should "be creatable with host, port, and timeout" do
+      svc = BERTRPC::Service.new('localhost', 9941, 5)
+      assert svc.is_a?(BERTRPC::Service)
+    end
+  end
+
+  context "A Service Instance's" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+    end
+
+    context "accessors" do
+      should "return it's host" do
+        assert_equal 'localhost', @svc.host
+      end
+
+      should "return it's port" do
+        assert_equal 9941, @svc.port
+      end
+    end
+
+    context "call method" do
+      should "return a call type Request" do
+        req = @svc.call
+        assert req.is_a?(BERTRPC::Request)
+        assert_equal :call, req.kind
+      end
+    end
+
+    context "cast method" do
+      should "return a cast type Request" do
+        req = @svc.cast
+        assert req.is_a?(BERTRPC::Request)
+        assert_equal :cast, req.kind
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bertrpc'
+
+class Enc
+  include BERTRPC::Encodes
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: fd-bertrpc
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 3
+  - 0
+  version: 1.3.0
+platform: ruby
+authors: 
+- Tom Preston-Werner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-01 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bert
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+    - - <
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: tom@mojombo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- History.txt
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bertrpc.gemspec
+- lib/bertrpc.rb
+- lib/bertrpc/action.rb
+- lib/bertrpc/encodes.rb
+- lib/bertrpc/errors.rb
+- lib/bertrpc/mod.rb
+- lib/bertrpc/request.rb
+- lib/bertrpc/service.rb
+- test/action_test.rb
+- test/encodes_test.rb
+- test/error_test.rb
+- test/mod_test.rb
+- test/request_test.rb
+- test/service_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/mojombo/bertrpc
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: BERTRPC is a Ruby BERT-RPC client library.
+test_files: 
+- test/action_test.rb
+- test/encodes_test.rb
+- test/error_test.rb
+- test/mod_test.rb
+- test/request_test.rb
+- test/service_test.rb
+- test/test_helper.rb