sinatra-rpc 0.1.0

data/spec/sinatra/rpc/serializer/base_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Sinatra::RPC::Serializer::Base do
+
+  before(:all) do
+    @registry = Sinatra::RPC::Serializer.instance_variable_get('@registry').dup
+  end
+
+  after(:all) do
+    Sinatra::RPC::Serializer.instance_variable_set('@registry', @registry)
+  end
+
+  it 'should set the correct response content type' do
+    class B64Serializer < Sinatra::RPC::Serializer::Base
+      content_types 'text/base64'
+    end
+
+    B64Serializer.new.content_type.should == 'text/base64'
+  end
+
+  it 'should set the response content type of the default serializer' do
+    class DefaultSerializer < Sinatra::RPC::Serializer::Base
+      content_types nil, 'application/x-default'
+    end
+
+    class AnotherDefaultSerializer < Sinatra::RPC::Serializer::Base
+      content_types 'application/x-another-default', nil
+    end
+
+    DefaultSerializer.new.content_type.should == 'application/x-default'
+    AnotherDefaultSerializer.new.content_type.should == 'application/x-another-default'
+  end
+
+  it 'should set default content type options' do
+    class OptionsSerializer < Sinatra::RPC::Serializer::Base
+      content_types 'application/x-opt'
+    end
+    OptionsSerializer.new.content_type_options.should == {}
+  end
+
+  it 'should raise an exception if the dump or parse methods are not implemented' do
+    class DummySerializer < Sinatra::RPC::Serializer::Base
+      content_types 'application/x-no-parse'
+    end
+
+    expect { DummySerializer.new.dump(Object.new) }.to raise_error(NotImplementedError)
+    expect { DummySerializer.new.parse("request") }.to raise_error(NotImplementedError)
+  end
+
+end

data/spec/sinatra/rpc/serializer/xmlrpc_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Sinatra::RPC::Serializer::XMLRPC do
+
+  before(:each) do
+    @xmlrpc = Sinatra::RPC::Serializer.find('text/xml').new
+  end
+
+  it 'should parse requests correctly' do
+    req = XMLRPC::Marshal.dump_call('handler.myMethod', 'arg1', 42)
+    @xmlrpc.parse(req).should == ['handler.myMethod', ['arg1', 42]]
+    req = XMLRPC::Marshal.dump_call('simpleMethod', false, 1, 2, 'string')
+    @xmlrpc.parse(req).should == ['simpleMethod', [false, 1, 2, 'string']]
+  end
+
+  it 'should dump responses correctly' do
+    XMLRPC::Marshal.load_response(@xmlrpc.dump('result')).should == 'result'
+    XMLRPC::Marshal.load_response(@xmlrpc.dump([1, 'array'])).should == [1, 'array']
+  end
+end

data/spec/sinatra/rpc/serializer_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Sinatra::RPC::Serializer do
+
+  before(:all) do
+    @registry = Sinatra::RPC::Serializer.instance_variable_get('@registry').dup
+  end
+
+  after(:all) do
+    Sinatra::RPC::Serializer.instance_variable_set('@registry', @registry)
+  end
+
+  it 'should allow registering new classes' do
+    class B64Serializer < Sinatra::RPC::Serializer::Base
+      content_types 'text/base64'
+    end
+
+    Sinatra::RPC::Serializer.find('text/base64').should == B64Serializer
+  end
+
+  it 'should allow registering more than 1 content type' do
+    class MultiSerializer < Sinatra::RPC::Serializer::Base
+      content_types 'application/x-app1', 'application/x-app2'
+    end
+
+    Sinatra::RPC::Serializer.find('application/x-app1').should == MultiSerializer
+    Sinatra::RPC::Serializer.find('application/x-app2').should == MultiSerializer
+  end
+
+  it 'should allow registering a default Serializer' do
+    class DefaultSerializer < Sinatra::RPC::Serializer::Base
+      content_types nil, 'application/x-default'
+    end
+
+    Sinatra::RPC::Serializer.find('application/x-default').should == DefaultSerializer
+    Sinatra::RPC::Serializer.find(nil).should == DefaultSerializer
+  end
+
+  it 'should select the default Serializer when an unsupported content type is specified' do
+    class DefaultSerializer < Sinatra::RPC::Serializer::Base
+      content_types nil, 'application/x-default'
+    end
+
+    Sinatra::RPC::Serializer.find('application/x-unsupported').should == DefaultSerializer
+  end
+
+end

data/spec/sinatra/rpc/utils_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+module UtilsTest
+  class MyClass
+    # This is a test method.
+    def my_method; end
+
+    # Full method doc for greet.
+    # @param folks [String] people to greet
+    # @return [String] the greeting
+    def greet(folks); "Hi, #{folks}!"; end
+
+    # Partially documented.
+    # @param people [String] the people
+    def bye(people); "Bye, #{people}!"; end
+
+    # Partially documented.
+    # @return [String] the result
+    def so_long(people); "So long, #{people}!"; end
+
+    # Multiple types.
+    # @param arg [String, Class] the arg
+    # @return [Array] the result
+    def multi(arg); ["The argument is #{arg}!"]; end  
+  end
+
+  class SimpleClass
+    # This is a test method.
+    def my_method; end
+  end
+
+end
+
+def m(name)
+  UtilsTest::MyClass.instance_method name
+end
+
+describe Sinatra::RPC::Utils do
+
+  context '.camelize' do
+    it 'should convert underscored strings' do
+      Sinatra::RPC::Utils.camelize('my_test_string').should == 'MyTestString'
+      Sinatra::RPC::Utils.camelize('_starts_with_underscore').should == 'StartsWithUnderscore'
+      Sinatra::RPC::Utils.camelize('ends_with_underscore_').should == 'EndsWithUnderscore'
+    end
+
+    it 'should generate strings starting with a lowercase letter' do
+      Sinatra::RPC::Utils.camelize('my_test_string', false).should == 'myTestString'
+    end
+
+    it 'should convert symbols' do
+      Sinatra::RPC::Utils.camelize(:my_test_sym, false).should == 'myTestSym'
+    end
+  end
+
+  context '.underscore' do
+    it 'should convert camelcase strings' do
+      Sinatra::RPC::Utils.underscore('MyTestString').should == 'my_test_string'
+    end
+
+    it 'should convert string starting with a lowercase letter' do
+      Sinatra::RPC::Utils.underscore('myTestString').should == 'my_test_string'
+    end
+  end
+
+  context '.method_help' do
+    it 'should generate a simple help string' do
+      doc = "This is a test method."
+      Sinatra::RPC::Utils.method_help(m(:my_method)).should == doc
+    end
+
+    it 'should include tags in the help string' do
+      doc = %q{
+Full method doc for greet.
+@param folks [String] people to greet
+@return [String] the greeting
+}.strip
+      Sinatra::RPC::Utils.method_help(m(:greet)).should == doc
+    end
+  end
+
+  context '.method_signature' do
+    it 'should extract a valid signature from the documentation' do
+      Sinatra::RPC::Utils.method_signature(m(:greet)).should == [['string', 'string']]
+    end
+
+    it 'should return an empty string if the signature is invalid' do
+      Sinatra::RPC::Utils.method_signature(m(:my_method)).should == [['nil']]
+    end
+
+    it 'should handle partially documented methods' do
+      Sinatra::RPC::Utils.method_signature(m(:bye)).should == [['nil', 'string']]
+      Sinatra::RPC::Utils.method_signature(m(:so_long)).should == [['string']]
+    end
+
+    it 'should handle multiple argument types' do
+      Sinatra::RPC::Utils.method_signature(m(:multi)).should == [['array', 'string']]
+    end
+  end
+
+  context '.rpc_methods' do
+    it 'should correctly generate the RPC method index' do
+      c = UtilsTest::MyClass.new
+      index = {
+        'ns.myMethod' => {
+          handler:   c, 
+          method:    :my_method, 
+          help:      "This is a test method.",
+          signature: [['nil']]
+        },
+        'ns.greet' => {
+          handler:   c, 
+          method:    :greet, 
+          help:      %q{
+Full method doc for greet.
+@param folks [String] people to greet
+@return [String] the greeting
+}.strip,
+          signature: [['string', 'string']]
+        },
+        'ns.bye' => {
+          handler:   c, 
+          method:    :bye, 
+          help:      %q{
+Partially documented.
+@param people [String] the people
+}.strip,
+          signature: [['nil', 'string']]
+        },
+        'ns.soLong' => {
+          handler:   c, 
+          method:    :so_long, 
+          help:      %q{
+Partially documented.
+@return [String] the result
+}.strip,
+          signature: [['string']]
+        },
+        'ns.multi' => {
+          handler:   c, 
+          method:    :multi, 
+          help:      %q{
+Multiple types.
+@param arg [String, Class] the arg
+@return [Array] the result
+}.strip,
+          signature: [['array', 'string']]
+        },
+      }
+      Sinatra::RPC::Utils.rpc_methods('ns', c).should == index
+    end
+
+    it 'should work without specifying a namespace' do
+      c = UtilsTest::SimpleClass.new
+      index = {
+        'myMethod' => {
+          handler:   c, 
+          method:    :my_method, 
+          help:      "This is a test method.",
+          signature: [['nil']]
+        }
+      }
+      Sinatra::RPC::Utils.rpc_methods(c).should == index
+    end
+  end
+end

data/spec/sinatra/rpc_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'sinatra/base'
+
+describe Sinatra::RPC do
+
+  module RpcTest
+
+    class MyHandler
+      # A greeting method.
+      # @param people [String] the people to greet
+      # @return [String] the greeting
+      def hello(people)
+        raise Sinatra::RPC::NoPeopleFault, "No people!" if people.nil? or people.empty?
+        "Hello, #{people}!"
+      end
+    end
+
+    class MyApp < Sinatra::Base
+      register Sinatra::RPC
+      register_rpc_fault :no_people, 211
+      add_rpc_handler MyHandler
+
+      post '/RPC2' do
+        handle_rpc request
+      end
+    end
+  end
+
+  def app
+    RpcTest::MyApp
+  end
+
+  # This method calls the RPC endpoint.
+  def call(method, *params)
+    request('/RPC2',
+            :method => 'post',
+            :params => XMLRPC::Marshal.dump_call(method, *params)
+            )
+  end
+
+  # Unmarshals the response coming from the RPC endpoint.
+  def parse(response)
+    XMLRPC::Marshal.load_response(response.body)
+  end
+
+  it 'should have a version number' do
+    Sinatra::RPC::VERSION.should_not be_nil
+  end
+
+  context 'using XMLRPC' do
+
+    it 'should reply to RPC requests' do
+      call('system.listMethods')
+      #puts last_response.body
+      last_response.should be_ok
+    end
+
+    it 'should return a 404 error if the method does not exist' do
+      call('fake.method', 'an argument')
+      last_response.status.should == 404
+    end
+
+    context 'with introspection' do
+
+      it 'should have an echo method' do
+        call('test.echo', 'a test string')
+        last_response.should be_ok
+        parse(last_response).should == 'a test string'
+      end
+
+      it 'should list RPC methods' do
+        call('system.listMethods')
+        last_response.should be_ok
+        parse(last_response).should == %w{
+          hello
+          system.listMethods
+          system.methodHelp
+          system.methodSignature
+          test.echo
+        }
+      end
+
+      it 'should show the method help' do
+        call('system.methodHelp', 'hello')
+        last_response.should be_ok
+        parse(last_response).should == %q{
+A greeting method.
+@param people [String] the people to greet
+@return [String] the greeting
+}.strip
+      end
+
+      it 'should show method signatures' do
+        call('system.methodSignature', 'hello')
+        last_response.should be_ok
+        parse(last_response).should == [['string', 'string']]
+      end
+    end
+
+    context 'with a custom handler' do
+      it 'should handle RPC requests' do
+        call('hello', 'World')
+        last_response.should be_ok
+        parse(last_response).should == 'Hello, World!'
+      end
+
+      it 'should handle RPC faults' do
+        call('hello', '')
+        err = parse(last_response)
+        err.faultCode.should == 211
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'coveralls'
+Coveralls.wear!
+#require 'simplecov'
+#SimpleCov.start
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rack/test'
+require 'sinatra/rpc'
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-rpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrea Bernardo Ciddio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: method_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Sinatra extension module providing RPC server functionality
+email:
+- bcandrea@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-version
+- .travis.yml
+- .yardopts
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sinatra/rpc.rb
+- lib/sinatra/rpc/fault.rb
+- lib/sinatra/rpc/handler/echo.rb
+- lib/sinatra/rpc/handler/introspection.rb
+- lib/sinatra/rpc/helpers.rb
+- lib/sinatra/rpc/serializer.rb
+- lib/sinatra/rpc/serializer/base.rb
+- lib/sinatra/rpc/serializer/xmlrpc.rb
+- lib/sinatra/rpc/utils.rb
+- lib/sinatra/rpc/version.rb
+- sinatra-rpc.gemspec
+- spec/sinatra/rpc/fault_spec.rb
+- spec/sinatra/rpc/handler/echo_spec.rb
+- spec/sinatra/rpc/handler/introspection_spec.rb
+- spec/sinatra/rpc/helpers_spec.rb
+- spec/sinatra/rpc/serializer/base_spec.rb
+- spec/sinatra/rpc/serializer/xmlrpc_spec.rb
+- spec/sinatra/rpc/serializer_spec.rb
+- spec/sinatra/rpc/utils_spec.rb
+- spec/sinatra/rpc_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bcandrea/sinatra-rpc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: The Sinatra::RPC module provides an extension that can be used to build RPC
+  endpoints.
+test_files:
+- spec/sinatra/rpc/fault_spec.rb
+- spec/sinatra/rpc/handler/echo_spec.rb
+- spec/sinatra/rpc/handler/introspection_spec.rb
+- spec/sinatra/rpc/helpers_spec.rb
+- spec/sinatra/rpc/serializer/base_spec.rb
+- spec/sinatra/rpc/serializer/xmlrpc_spec.rb
+- spec/sinatra/rpc/serializer_spec.rb
+- spec/sinatra/rpc/utils_spec.rb
+- spec/sinatra/rpc_spec.rb
+- spec/spec_helper.rb
+has_rdoc: