jimson-reloaded 0.12.0

data/lib/jimson/version.rb

@@ -0,0 +1,3 @@
+module Jimson
+  VERSION = '0.12.0'
+end

data/spec/client_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+module Jimson
+  describe Client do
+    BOILERPLATE = {'jsonrpc' => '2.0', 'id' => 1}
+
+    before(:each) do
+      @resp_mock = double('http_response')
+      ClientHelper.stub(:make_id).and_return(1)
+    end
+
+    after(:each) do
+    end
+
+    describe "hidden methods" do
+      it "should reveal inspect" do
+        Client.new(SPEC_URL).inspect.should match /Jimson::Client/
+      end
+
+      it "should reveal to_s" do
+        Client.new(SPEC_URL).to_s.should match /Jimson::Client/
+      end
+    end
+
+    describe "#[]" do
+      before(:each) do
+        @client = Client.new(SPEC_URL)
+      end
+
+      context "when using a symbol to specify a namespace" do
+        it "sends the method prefixed with the namespace in the request" do
+          expected = MultiJson.encode({
+           'jsonrpc' => '2.0',
+           'method'  => 'foo.sum',
+           'params'  => [1,2,3],
+           'id'      => 1
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          @client[:foo].sum(1, 2, 3).should == 42
+        end
+
+        context "when the namespace is nested" do
+          it "sends the method prefixed with the full namespace in the request" do
+            expected = MultiJson.encode({
+             'jsonrpc' => '2.0',
+             'method'  => 'foo.bar.sum',
+             'params'  => [1,2,3],
+             'id'      => 1
+            })
+            response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+            RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+            @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+            @client[:foo][:bar].sum(1, 2, 3).should == 42
+          end
+        end
+      end
+
+      context "when sending positional arguments" do
+        it "sends a request with the correct method and args" do
+          expected = MultiJson.encode({
+           'jsonrpc' => '2.0',
+           'method'  => 'foo',
+           'params'  => [1,2,3],
+           'id'      => 1
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          @client['foo', 1, 2, 3].should == 42
+        end
+
+        context "when one of the args is an array" do
+          it "sends a request with the correct method and args" do
+            expected = MultiJson.encode({
+             'jsonrpc' => '2.0',
+             'method'  => 'foo',
+             'params'  => [[1,2],3],
+             'id'      => 1
+            })
+            response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+            RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+            @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+            @client['foo', [1, 2], 3].should == 42
+          end
+        end
+      end
+    end
+
+    describe "sending a single request" do
+      context "when using positional parameters" do
+        before(:each) do
+          @expected = MultiJson.encode({
+                       'jsonrpc' => '2.0',
+                       'method'  => 'foo',
+                       'params'  => [1,2,3],
+                       'id'      => 1
+          })
+        end
+        it "sends a valid JSON-RPC request and returns the result" do
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: @expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL)
+          client.foo(1,2,3).should == 42
+        end
+
+        it "sends a valid JSON-RPC request with custom options" do
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: @expected, headers: {:content_type => 'application/json', :timeout => 10000}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL, :timeout => 10000)
+          client.foo(1,2,3).should == 42
+        end
+
+        it "sends a valid JSON-RPC request with custom content_type" do
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: @expected, headers: {:content_type => 'application/json-rpc', :timeout => 10000}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL, :timeout => 10000, :content_type => 'application/json-rpc')
+          client.foo(1,2,3).should == 42
+        end
+
+        it "adds RestClient::Request parameters if given" do
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: @expected, headers: {:content_type => 'application/json-rpc', :timeout => 10000}, ssl_ca_file: 'myca.pem').and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL, {:timeout => 10000, :content_type => 'application/json-rpc'}, '', {ssl_ca_file: 'myca.pem'})
+          client.foo(1,2,3).should == 42
+        end
+      end
+
+      context "when one of the parameters is an array" do
+        it "sends a correct JSON-RPC request (array is preserved) and returns the result" do
+          expected = MultiJson.encode({
+            'jsonrpc' => '2.0',
+            'method'  => 'foo',
+            'params'  => [[1,2],3],
+            'id'      => 1
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL)
+          client.foo([1,2],3).should == 42
+        end
+      end
+      
+      context "when one of the parameters is a hash" do
+        it "sends a correct JSON-RPC request (array is preserved with hash) and returns the results" do
+          expected = MultiJson.encode({
+            'jsonrpc' => '2.0',
+            'method'  => 'foo',
+            'params'  => [1,{'bar' => 'baz'},3],
+            'id'      => 1
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL)
+          client.foo(1, {'bar' => 'baz'}, 3).should == 42
+        end
+      end
+      
+      context "when using named parameters" do
+        it "sends a correct JSON-RPC request (named parameters are preserved) and returns the result" do
+          expected = MultiJson.encode({
+            'jsonrpc' => '2.0',
+            'method'  => 'foo',
+            'params'  => {'bar' => 'baz'},
+            'id'      => 1 
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: expected, headers: {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL)
+          client.foo({'bar' => 'baz'}).should == 42
+        end
+      end
+    end
+
+    describe "sending a batch request" do
+      it "sends a valid JSON-RPC batch request and puts the results in the response objects" do
+        batch = MultiJson.encode([
+          {"jsonrpc" => "2.0", "method" => "sum", "params" => [1,2,4], "id" => "1"},
+          {"jsonrpc" => "2.0", "method" => "subtract", "params" => [42,23], "id" => "2"},
+          {"jsonrpc" => "2.0", "method" => "foo_get", "params" => [{"name" => "myself"}], "id" => "5"},
+          {"jsonrpc" => "2.0", "method" => "get_data", "id" => "9"}
+        ])
+
+        response = MultiJson.encode([
+          {"jsonrpc" => "2.0", "result" => 7, "id" => "1"},
+          {"jsonrpc" => "2.0", "result" => 19, "id" => "2"},
+          {"jsonrpc" => "2.0", "error" => {"code" => -32601, "message" => "Method not found."}, "id" => "5"},
+          {"jsonrpc" => "2.0", "result" => ["hello", 5], "id" => "9"}
+        ])
+
+        ClientHelper.stub(:make_id).and_return('1', '2', '5', '9')
+        RestClient::Request.should_receive(:execute).with(method: :post, url: SPEC_URL, payload: batch, headers: {:content_type => 'application/json'}, ssl_ca_file: 'myca.pem').and_return(@resp_mock)
+        @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+        client = Client.new(SPEC_URL, {}, '', {ssl_ca_file: 'myca.pem'})
+
+        sum = subtract = foo = data = nil
+        Jimson::Client.batch(client) do |batch|
+          sum = batch.sum(1,2,4)
+          subtract = batch.subtract(42,23)
+          foo = batch.foo_get('name' => 'myself')
+          data = batch.get_data
+        end
+
+        sum.succeeded?.should be true
+        sum.is_error?.should be false
+        sum.result.should == 7
+
+        subtract.result.should == 19
+
+        foo.is_error?.should be true
+        foo.succeeded?.should be false
+        foo.error['code'].should == -32601
+
+        data.result.should == ['hello', 5]
+      end
+    end
+
+    describe "error handling" do
+      context "when an error occurs in the Jimson::Client code" do
+        it "tags the raised exception with Jimson::Client::Error" do
+          client_helper = ClientHelper.new(SPEC_URL)
+          ClientHelper.stub(:new).and_return(client_helper)
+          client = Client.new(SPEC_URL)
+          client_helper.stub(:send_single_request).and_raise "intentional error"
+          lambda { client.foo }.should raise_error(Jimson::Client::Error)
+        end
+      end
+    end
+
+  end
+end

data/spec/handler_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module Jimson
+  describe Handler do
+
+    class FooHandler
+      extend Jimson::Handler
+
+      jimson_expose :to_s, :bye
+
+      jimson_exclude :hi, :bye
+
+      def hi
+        'hi'
+      end
+
+      def bye
+        'bye'
+      end
+
+      def to_s
+        'foo'
+      end
+
+      def so_exposed
+        "I'm so exposed!"
+      end
+    end
+
+    let(:foo) { FooHandler.new }
+
+    describe "#jimson_expose" do
+      it "exposes a method even if it was defined on Object" do
+        foo.class.jimson_exposed_methods.should include('to_s')
+      end
+    end
+
+    describe "#jimson_exclude" do
+      context "when a method was not explicitly exposed" do
+        it "excludes the method" do
+          foo.class.jimson_exposed_methods.should_not include('hi')
+        end
+      end
+      context "when a method was explicitly exposed" do
+        it "does not exclude the method" do
+          foo.class.jimson_exposed_methods.should include('bye')
+        end
+      end
+    end
+
+    describe "#jimson_exposed_methods" do
+      it "doesn't include methods defined on Object" do
+        foo.class.jimson_exposed_methods.should_not include('object_id')
+      end
+      it "includes methods defined on the extending class but not on Object" do
+        foo.class.jimson_exposed_methods.should include('so_exposed')
+      end
+    end
+
+  end
+end
+

data/spec/router_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+module Jimson
+  describe Router do
+
+    let(:router) { Router.new(opts) }
+    let(:opts) { {} }
+
+    class RouterFooHandler
+      extend Jimson::Handler
+
+      def hi
+        'hi'
+      end
+    end
+
+    class RouterBarHandler
+      extend Jimson::Handler
+
+      def bye 
+        'bye'
+      end
+    end
+
+    class RouterBazHandler
+      extend Jimson::Handler
+
+      def meh 
+        'mehkayla'
+      end
+    end
+
+
+    describe '#draw' do
+      context 'when given non-nested namespaces' do
+        it 'takes a block with a DSL to set the root and namespaces' do
+          router.draw do
+            root RouterFooHandler
+            namespace 'ns', RouterBarHandler
+          end
+
+          router.handler_for_method('hi').should be_a(RouterFooHandler)
+          router.handler_for_method('ns.hi').should be_a(RouterBarHandler)
+        end
+      end
+
+      context 'when given nested namespaces' do
+        before {
+          router.draw do
+            root RouterFooHandler
+            namespace 'ns1' do
+              root RouterBazHandler
+              namespace 'ns2', RouterBarHandler
+            end
+          end
+        }
+        context 'default ns_sep' do
+          it 'takes a block with a DSL to set the root and namespaces' do
+            router.handler_for_method('hi').should be_a(RouterFooHandler)
+            router.handler_for_method('ns1.hi').should be_a(RouterBazHandler)
+            router.handler_for_method('ns1.ns2.hi').should be_a(RouterBarHandler)
+          end
+        end
+        context 'custom ns_sep' do
+          let(:opts) { {ns_sep: '::'} }
+          it 'takes a block with a DSL to set the root and namespaces' do
+            router.handler_for_method('hi').should be_a(RouterFooHandler)
+            router.handler_for_method('ns1::hi').should be_a(RouterBazHandler)
+            router.handler_for_method('ns1::ns2::hi').should be_a(RouterBarHandler)
+          end
+        end
+
+      end
+    end
+
+    describe '#jimson_methods' do
+      before {
+        router.draw do
+          root RouterFooHandler
+          namespace 'foo', RouterBarHandler
+        end
+      }
+      context 'default ns_sep' do
+        it 'returns an array of namespaced method names from all registered handlers' do
+          router.jimson_methods.sort.should == ['hi', 'foo.bye'].sort
+        end
+      end
+      context 'custom ns_sep' do
+        let(:opts) { {ns_sep: '::'} }
+        it 'returns an array of namespaced method names from all registered handlers' do
+          router.jimson_methods.sort.should == ['hi', 'foo::bye'].sort
+        end
+      end
+    end
+
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,466 @@
+require 'spec_helper'
+require 'rack/test'
+
+module Jimson
+    describe Server do
+      include Rack::Test::Methods
+
+      class TestHandler
+        extend Jimson::Handler
+
+        def subtract(a, b = nil)
+          if a.is_a?(Hash)
+            return a['minuend'] - a['subtrahend']
+          else 
+            return a - b
+          end
+        end
+
+        def sum(a,b,c)
+          a + b + c
+        end
+
+        def car(array)
+          array.first
+        end
+
+        def notify_hello(*args)
+          # notification, doesn't do anything
+        end
+
+        def update(*args)
+          # notification, doesn't do anything
+        end
+
+        def get_data
+          ['hello', 5]
+        end
+
+        def ugly_method
+          raise RuntimeError
+        end
+      end
+
+      class OtherHandler
+        extend Jimson::Handler
+
+        def multiply(a,b)
+          a * b
+        end
+      end
+
+      INVALID_RESPONSE_EXPECTATION = {
+                                        'jsonrpc' => '2.0',
+                                        'error'   => {
+                                                        'code' => -32600,
+                                                        'message' => 'The JSON sent is not a valid Request object.'
+                                                      },
+                                        'id'      => nil
+                                      }
+      let(:router) do
+        router = Router.new.draw do
+          root TestHandler.new
+          namespace 'other', OtherHandler.new
+        end
+      end
+
+      let(:app) do
+        Server.new(router, :environment => "production")
+      end
+
+      def post_json(hash)
+        post '/', MultiJson.encode(hash), {'Content-Type' => 'application/json'}
+      end
+      
+      before(:each) do
+        @url = SPEC_URL
+      end
+
+      it "exposes the given options" do
+        app.opts.should == { :environment => "production" }
+      end
+
+      describe "receiving a request with positional parameters" do
+        context "when no errors occur" do
+          it "returns a response with 'result'" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'subtract',
+                    'params'  => [24, 20],
+                    'id'      => 1
+                  }
+            post_json(req)
+
+            last_response.should be_ok
+            resp = MultiJson.decode(last_response.body)
+            resp.should == {
+                             'jsonrpc' => '2.0',
+                             'result'  => 4,
+                             'id'      => 1
+                           }
+          end
+
+          it "handles an array in the parameters" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'car',
+                    'params'  => [['a', 'b']],
+                    'id'      => 1
+                  }
+            post_json(req)
+
+            last_response.should be_ok
+            resp = MultiJson.decode(last_response.body)
+            resp.should == {
+                             'jsonrpc' => '2.0',
+                             'result'  => 'a',
+                             'id'      => 1
+                           }
+          end
+
+          it "handles integer" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'subtract',
+                    'params'  => [24, 20],
+                    'id'      => 123456789_123456789_123456789
+                  }
+            post_json(req)
+
+            last_response.should be_ok
+            resp = MultiJson.decode(last_response.body)
+            resp.should == {
+                             'jsonrpc' => '2.0',
+                             'result'  => 4,
+                             'id'      => 123456789_123456789_123456789
+                           }
+          end
+        end
+      end
+
+      describe "receiving a request with named parameters" do
+        context "when no errors occur" do
+          it "returns a response with 'result'" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'subtract',
+                    'params'  => {'subtrahend'=> 20, 'minuend' => 24},
+                    'id'      => 1
+                  }
+            post_json(req)
+            
+            last_response.should be_ok
+            resp = MultiJson.decode(last_response.body)
+            resp.should == {
+                             'jsonrpc' => '2.0',
+                             'result'  => 4,
+                             'id'      => 1
+                           }
+          end
+        end
+      end
+
+      describe "receiving a notification" do
+        context "when no errors occur" do
+          it "returns no response" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'update',
+                    'params'  => [1,2,3,4,5]
+                  }
+            post_json(req)
+            last_response.body.should be_empty
+          end
+        end
+      end
+
+      describe "receiving a call for a non-existent method" do
+        it "returns an error response" do
+          req = {
+                  'jsonrpc' => '2.0',
+                  'method'  => 'foobar',
+                  'id'      => 1
+                }
+          post_json(req)
+
+          resp = MultiJson.decode(last_response.body)
+          resp.should == {
+                            'jsonrpc' => '2.0',
+                            'error'   => {
+                                            'code' => -32601,
+                                            'message' => "Method 'foobar' not found."
+                                          },
+                            'id'      => 1
+                          }
+        end
+      end
+
+      describe "receiving a call for a method which exists but is not exposed" do
+        it "returns an error response" do
+          req = {
+                  'jsonrpc' => '2.0',
+                  'method'  => 'object_id',
+                  'id'      => 1
+                }
+          post_json(req)
+
+          resp = MultiJson.decode(last_response.body)
+          resp.should == {
+                            'jsonrpc' => '2.0',
+                            'error'   => {
+                                            'code' => -32601,
+                                            'message' => "Method 'object_id' not found."
+                                          },
+                            'id'      => 1
+                          }
+        end
+      end
+
+      describe "receiving a call with the wrong number of params" do
+        it "returns an error response" do
+          req = {
+                  'jsonrpc' => '2.0',
+                  'method'  => 'subtract',
+                  'params'  => [1,2,3],
+                  'id'      => 1
+                }
+          post_json(req)
+
+          resp = MultiJson.decode(last_response.body)
+          resp.should == {
+                            'jsonrpc' => '2.0',
+                            'error'   => {
+                                            'code' => -32602,
+                                            'message' => 'Invalid method parameter(s).'
+                                          },
+                            'id'      => 1
+                          }
+        end
+      end
+
+      describe "receiving a call for ugly method" do
+        context "by default" do
+          it "returns only global error without stack trace" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'ugly_method',
+                    'id'      => 1
+                  }
+            post_json(req)
+
+            resp = MultiJson.decode(last_response.body)
+            resp.should == {
+                              'jsonrpc' => '2.0',
+                              'error'   => {
+                                              'code' => -32099,
+                                              'message' => 'Server application error'
+                                            },
+                              'id'      => 1
+                            }
+          end
+        end
+
+        context "with 'show_errors' enabled" do
+          it "returns an error name and first line of the stack trace" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'ugly_method',
+                    'id'      => 1
+                  }
+
+            app = Server.new(router, :environment => "production", :show_errors => true)
+
+            # have to make a new Rack::Test browser since this server is different than the normal one
+            browser = Rack::Test::Session.new(Rack::MockSession.new(app))
+            browser.post '/', MultiJson.encode(req), {'Content-Type' => 'application/json'}
+
+            resp = MultiJson.decode(browser.last_response.body)
+            resp.should == {
+                              'jsonrpc' => '2.0',
+                              'error'   => {
+                                              'code' => -32099,
+                                              'message' => "Server application error: RuntimeError at #{__FILE__}:40:in `ugly_method'"
+                                            },
+                              'id'      => 1
+                            }
+          end
+        end
+      end
+
+      describe "receiving invalid JSON" do
+        it "returns an error response" do
+          req = MultiJson.encode({
+            'jsonrpc' => '2.0',
+            'method'  => 'foobar',
+            'id'      => 1
+          })
+          req += '}' # make the json invalid
+          post '/', req, {'Content-type' => 'application/json'}
+
+          resp = MultiJson.decode(last_response.body)
+          resp.should == {
+                            'jsonrpc' => '2.0',
+                            'error'   => {
+                                            'code' => -32700,
+                                            'message' => 'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.'
+                                          },
+                            'id'      => nil
+                          }
+        end
+      end
+
+      describe "receiving an invalid request" do
+        context "when the request is not a batch" do
+          it "returns an error response" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 1 # method as int is invalid
+                  }
+            post_json(req)
+            resp = MultiJson.decode(last_response.body)
+            resp.should == INVALID_RESPONSE_EXPECTATION 
+          end
+        end
+
+        context "when the request is an empty batch" do
+          it "returns an error response" do
+            req = []
+            post_json(req)
+            resp = MultiJson.decode(last_response.body)
+            resp.should == INVALID_RESPONSE_EXPECTATION
+          end
+        end
+
+        context "when the request is an invalid batch" do
+          it "returns an error response" do
+            req = [1,2]
+            post_json(req)
+            resp = MultiJson.decode(last_response.body)
+            resp.should == [INVALID_RESPONSE_EXPECTATION, INVALID_RESPONSE_EXPECTATION] 
+          end
+        end
+      end
+
+      describe "receiving a valid batch request" do
+        context "when not all requests are notifications" do
+          it "returns an array of responses" do
+            reqs = [
+                      {'jsonrpc' => '2.0', 'method' => 'sum', 'params' => [1,2,4], 'id' => '1'},
+                      {'jsonrpc' => '2.0', 'method' => 'notify_hello', 'params' => [7]},
+                      {'jsonrpc' => '2.0', 'method' => 'subtract', 'params' => [42,23], 'id' => '2'},
+                      {'foo' => 'boo'},
+                      {'jsonrpc' => '2.0', 'method' => 'foo.get', 'params' => {'name' => 'myself'}, 'id' => '5'},
+                      {'jsonrpc' => '2.0', 'method' => 'get_data', 'id' => '9'} 
+                   ]
+            post_json(reqs)
+            resp = MultiJson.decode(last_response.body)
+            resp.should == [
+                    {'jsonrpc' => '2.0', 'result' => 7, 'id' => '1'},
+                    {'jsonrpc' => '2.0', 'result' => 19, 'id' => '2'},
+                    {'jsonrpc' => '2.0', 'error' => {'code' => -32600, 'message' => 'The JSON sent is not a valid Request object.'}, 'id' => nil},
+                    {'jsonrpc' => '2.0', 'error' => {'code' => -32601, 'message' => "Method 'foo.get' not found."}, 'id' => '5'},
+                    {'jsonrpc' => '2.0', 'result' => ['hello', 5], 'id' => '9'}
+            ]
+          end
+        end
+
+        context "when all the requests are notifications" do
+          it "returns no response" do
+            req = [
+                    {
+                      'jsonrpc' => '2.0',
+                      'method'  => 'update',
+                      'params'  => [1,2,3,4,5]
+                    },
+                    {
+                      'jsonrpc' => '2.0',
+                      'method'  => 'update',
+                      'params'  => [1,2,3,4,5]
+                    }
+                  ]
+            post_json(req)
+            last_response.body.should be_empty
+          end
+        end
+      end
+
+      describe "receiving a 'system.' request" do
+        context "when the request is 'isAlive'" do
+          it "returns response 'true'" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'system.isAlive',
+                    'params'  => [],
+                    'id'      => 1
+                  }
+            post_json(req)
+
+            last_response.should be_ok
+            resp = MultiJson.decode(last_response.body)
+            resp.should == {
+                             'jsonrpc' => '2.0',
+                             'result'  => true,
+                             'id'      => 1
+                           }
+          end
+        end
+        context "when the request is 'system.listMethods'" do
+          it "returns response with all jimson_exposed_methods on the handler(s) as strings" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'system.listMethods',
+                    'params'  => [],
+                    'id'      => 1
+                  }
+            post_json(req)
+
+            last_response.should be_ok
+            resp = MultiJson.decode(last_response.body)
+            resp['jsonrpc'].should == '2.0'
+            resp['id'].should == 1
+            expected = ['get_data', 'notify_hello', 'subtract', 'sum', 'car', 'ugly_method', 'update', 'system.isAlive', 'system.listMethods', 'other.multiply']
+            (resp['result'] - expected).should == []
+          end
+        end
+      end
+
+      describe ".with_routes" do
+        it "creates a server with a router by passing the block to Router#draw" do
+          app = Server.with_routes do
+            root TestHandler.new
+            namespace 'foo', OtherHandler.new
+          end
+
+          # have to make a new Rack::Test browser since this server is different than the normal one
+          browser = Rack::Test::Session.new(Rack::MockSession.new(app))
+
+          req = {
+                  'jsonrpc' => '2.0',
+                  'method'  => 'foo.multiply',
+                  'params'  => [2, 3],
+                  'id'      => 1
+                }
+          browser.post '/', MultiJson.encode(req), {'Content-Type' => 'application/json'}
+
+          browser.last_response.should be_ok
+          resp = MultiJson.decode(browser.last_response.body)
+          resp.should == {
+                           'jsonrpc' => '2.0',
+                           'result'  => 6,
+                           'id'      => 1
+                         }
+        end
+
+        context "when opts are given" do
+          it "passes the opts to the new server" do
+            app = Server.with_routes(:show_errors => true) do
+              root TestHandler.new
+              namespace 'foo', OtherHandler.new
+            end
+
+            app.show_errors.should be true
+          end
+        end
+      end
+  end
+end