cosmos 3.2.1 → 3.3.0

data/spec/io/io_multiplexer_spec.rb

@@ -19,13 +19,13 @@ module Cosmos
     end
 
     describe "add_stream" do
-      it "should add a single stream" do
+      it "adds a single stream" do
         @io.add_stream(STDOUT)
         expect($stdout).to receive(:puts).with("TEST")
         @io.puts "TEST"
       end
 
-      it "should add multiple streams" do
+      it "adds multiple streams" do
         @io.add_stream(STDOUT)
         @io.add_stream(STDERR)
         expect($stdout).to receive(:puts).with("TEST")
@@ -35,7 +35,7 @@ module Cosmos
     end
 
     describe "remove_stream" do
-      it "should remove the stream from output" do
+      it "removes the stream from output" do
         @io.add_stream(STDOUT)
         @io.add_stream(STDERR)
         @io.remove_stream(STDOUT)
@@ -46,7 +46,7 @@ module Cosmos
     end
 
     describe "print, printf, putc, puts, flush" do
-      it "should defer to the stream" do
+      it "defers to the stream" do
         @io.add_stream(STDOUT)
         expect($stdout).to receive(:print).with("TEST")
         @io.print "TEST"
@@ -62,19 +62,19 @@ module Cosmos
     end
 
     describe "write write_nonblock" do
-      it "should defer to the stream" do
+      it "defers to the stream" do
         @io.add_stream(STDOUT)
         expect($stdout).to receive(:write).with("TEST")
         len = @io.write "TEST"
-        len.should eql 4
+        expect(len).to eql 4
         expect($stdout).to receive(:write_nonblock).with("TEST")
         len = @io.write_nonblock "TEST"
-        len.should eql 4
+        expect(len).to eql 4
       end
     end
 
     describe "remove_default_io" do
-      it "should remove STDOUT and STDERR from the streams" do
+      it "removes STDOUT and STDERR from the streams" do
         f = File.open("unittest.txt",'w')
         @io.add_stream(STDOUT)
         @io.add_stream(STDERR)
@@ -84,7 +84,7 @@ module Cosmos
         f.close
         expect($stdout).not_to receive(:puts).with("TEST")
         expect($stderr).not_to receive(:puts).with("TEST")
-        File.read("unittest.txt").should eql "TEST\n"
+        expect(File.read("unittest.txt")).to eql "TEST\n"
         File.delete("unittest.txt")
       end
     end

data/spec/io/json_drb_object_spec.rb

@@ -15,13 +15,13 @@ module Cosmos
 
   describe JsonDRbObject do
     describe "initialize" do
-      it "should rescue bad hosts" do
+      it "rescues bad hosts" do
         expect { JsonDRbObject.new("blah", 7777) }.to raise_error("Invalid hostname: blah")
       end
     end
 
     describe "method_missing" do
-      it "should call the method on the remote object" do
+      it "calls the method on the remote object" do
         class JsonDRbObjectServer
           def my_method(param)
             param * 2
@@ -31,13 +31,13 @@ module Cosmos
         json = JsonDRb.new
         json.start_service('127.0.0.1', 7777, JsonDRbObjectServer.new)
         obj = JsonDRbObject.new("localhost", 7777)
-        obj.my_method(10).should eql 20
+        expect(obj.my_method(10)).to eql 20
         obj.disconnect
         json.stop_service
         sleep(0.1)
       end
 
-      it "should raise an exception if the remote connection can't be made" do
+      it "raises an exception if the remote connection can't be made" do
         json = JsonDRb.new
         json.start_service('127.0.0.1', 7777, self)
         allow_any_instance_of(Socket).to receive(:connect_nonblock) { raise "Error" }
@@ -48,7 +48,7 @@ module Cosmos
         sleep(0.1)
       end
 
-      it "should retry the request and then raise an exception" do
+      it "retries the request and then raise an exception" do
         class JsonDRbObjectServer
           def my_method(param)
             param * 2
@@ -65,7 +65,7 @@ module Cosmos
         sleep(0.1)
       end
 
-      it "should raise an exception if the remote method returns an error" do
+      it "raises an exception if the remote method returns an error" do
         json = JsonDRb.new
         json.start_service('127.0.0.1', 7777, self)
         obj = JsonDRbObject.new("localhost", 7777)
@@ -76,7 +76,7 @@ module Cosmos
         sleep(0.1)
       end
 
-      it "should handle the remote not returning a response" do
+      it "handles the remote not returning a response" do
         class JsonDRbObjectServer
           def my_method(param)
             param * 2

data/spec/io/json_drb_spec.rb

@@ -20,60 +20,60 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should set request_count and num_clients to 0" do
-        @json.request_count.should eql 0
-        @json.num_clients.should eql 0
+      it "sets request_count and num_clients to 0" do
+        expect(@json.request_count).to eql 0
+        expect(@json.num_clients).to eql 0
       end
     end
 
     describe "acl" do
-      it "should set the access control list" do
+      it "sets the access control list" do
         acl = ACL.new(['allow','127.0.0.1'], ACL::ALLOW_DENY)
         @json.acl = acl
-        @json.acl.should eql acl
+        expect(@json.acl).to eql acl
       end
     end
 
     describe "method_whitelist" do
-      it "should set the method whitelist" do
+      it "sets the method whitelist" do
         @json.method_whitelist = ['cmd']
-        @json.method_whitelist.should eql ['cmd']
+        expect(@json.method_whitelist).to eql ['cmd']
       end
     end
 
     describe "add_request_time, average_request_time" do
-      it "should add time to the list and return the average" do
+      it "adds time to the list and return the average" do
         @json.add_request_time(1.0)
         @json.add_request_time(2.0)
         @json.add_request_time(3.0)
-        @json.average_request_time.should eql 2.0
+        expect(@json.average_request_time).to eql 2.0
       end
     end
 
     describe "start_service" do
-      it "should do nothing when passed no parameters" do
-        @json.thread.should be_nil
+      it "does nothing when passed no parameters" do
+        expect(@json.thread).to be_nil
         @json.start_service()
-        @json.thread.should be_nil
+        expect(@json.thread).to be_nil
       end
 
-      it "should raise an error when passed incomplete parameters" do
-        @json.thread.should be_nil
+      it "raises an error when passed incomplete parameters" do
+        expect(@json.thread).to be_nil
         expect { @json.start_service('127.0.0.1') }.to raise_error
         expect { @json.start_service('127.0.0.1', 7777) }.to raise_error
-        @json.thread.should be_nil
+        expect(@json.thread).to be_nil
       end
 
-      it "should raise an error when passed a bad host" do
+      it "raises an error when passed a bad host" do
         capture_io do |stdout|
-          @json.thread.should be_nil
+          expect(@json.thread).to be_nil
           system_exit_count = $system_exit_count
           @json.start_service('blah', 7777, self)
           thread = @json.thread
-          $system_exit_count.should eql(system_exit_count + 1)
+          expect($system_exit_count).to eql(system_exit_count + 1)
           sleep 0.1
 
-          stdout.string.should match /listen thread/
+          expect(stdout.string).to match /listen thread/
           @json.stop_service
           sleep(0.1)
         end
@@ -83,16 +83,16 @@ module Cosmos
         end
       end
 
-      it "should create a single listen thread" do
-        @json.thread.should be_nil
+      it "creates a single listen thread" do
+        expect(@json.thread).to be_nil
         @json.start_service('127.0.0.1', 7777, self)
-        @json.thread.alive?.should be_truthy
+        expect(@json.thread.alive?).to be_truthy
         expect { @json.start_service('127.0.0.1', 7777, self) }.to raise_error(/Error binding to port/)
         @json.stop_service
         sleep(0.1)
       end
 
-      it "should rescue listen thread exceptions" do
+      it "rescues listen thread exceptions" do
         capture_io do |stdout|
           allow_any_instance_of(TCPServer).to receive(:accept_nonblock) { raise "BLAH" }
           @json.start_service('127.0.0.1', 7777, self)
@@ -101,7 +101,7 @@ module Cosmos
           @json.stop_service
           sleep(0.1)
 
-          stdout.string.should match /JsonDRb listen thread unexpectedly died/
+          expect(stdout.string).to match /JsonDRb listen thread unexpectedly died/
         end
 
         Dir[File.join(Cosmos::USERPATH,"*_exception.txt")].each do |file|
@@ -109,12 +109,12 @@ module Cosmos
         end
       end
 
-      it "should ignore connections via the ACL" do
+      it "ignores connections via the ACL" do
         @json.acl = ACL.new(['deny','127.0.0.1'], ACL::ALLOW_DENY)
         @json.start_service('127.0.0.1', 7777, self)
         socket = TCPSocket.open('127.0.0.1',7777)
         sleep 0.1
-        socket.eof?.should be_truthy
+        expect(socket.eof?).to be_truthy
         socket.close
         @json.stop_service
         sleep(0.1)
@@ -122,7 +122,7 @@ module Cosmos
     end
 
     describe "receive_message" do
-      it "should return nil if 4 bytes of data aren't available" do
+      it "returns nil if 4 bytes of data aren't available" do
         @json.start_service('127.0.0.1', 7777, self)
         socket = TCPSocket.open('127.0.0.1',7777)
         # Stub recv_nonblock so it returns nothing
@@ -130,14 +130,14 @@ module Cosmos
         sleep 0.1
         JsonDRb.send_data(socket, "\x00")
         response_data = JsonDRb.receive_message(socket, '')
-        response_data.should be_nil
+        expect(response_data).to be_nil
         socket.close
         sleep 0.1
         @json.stop_service
         sleep(0.1)
       end
 
-      it "should process success requests" do
+      it "processes success requests" do
         class MyServer1
           def my_method(param)
           end
@@ -150,14 +150,14 @@ module Cosmos
         JsonDRb.send_data(socket, request)
         response_data = JsonDRb.receive_message(socket, '')
         response = JsonRpcResponse.from_json(response_data)
-        response.should be_a(JsonRpcSuccessResponse)
+        expect(response).to be_a(JsonRpcSuccessResponse)
         socket.close
         sleep 0.1
         @json.stop_service
         sleep(0.1)
       end
 
-      it "should process bad methods" do
+      it "processes bad methods" do
         class MyServer2
         end
 
@@ -168,16 +168,16 @@ module Cosmos
         JsonDRb.send_data(socket, request)
         response_data = JsonDRb.receive_message(socket, '')
         response = JsonRpcResponse.from_json(response_data)
-        response.should be_a(JsonRpcErrorResponse)
-        response.error.code.should eql -32601
-        response.error.message.should eql "Method not found"
+        expect(response).to be_a(JsonRpcErrorResponse)
+        expect(response.error.code).to eql -32601
+        expect(response.error.message).to eql "Method not found"
         socket.close
         sleep 0.1
         @json.stop_service
         sleep(0.1)
       end
 
-      it "should process bad parameters" do
+      it "processes bad parameters" do
         class MyServer3
           def my_method(param1, param2)
           end
@@ -190,16 +190,16 @@ module Cosmos
         JsonDRb.send_data(socket, request)
         response_data = JsonDRb.receive_message(socket, '')
         response = JsonRpcResponse.from_json(response_data)
-        response.should be_a(JsonRpcErrorResponse)
-        response.error.code.should eql -32602
-        response.error.message.should eql "Invalid params"
+        expect(response).to be_a(JsonRpcErrorResponse)
+        expect(response.error.code).to eql -32602
+        expect(response.error.message).to eql "Invalid params"
         socket.close
         sleep 0.1
         @json.stop_service
         sleep(0.1)
       end
 
-      it "should handle method exceptions" do
+      it "handles method exceptions" do
         class MyServer4
           def my_method(param)
             raise "Method Error"
@@ -213,16 +213,16 @@ module Cosmos
         JsonDRb.send_data(socket, request)
         response_data = JsonDRb.receive_message(socket, '')
         response = JsonRpcResponse.from_json(response_data)
-        response.should be_a(JsonRpcErrorResponse)
-        response.error.code.should eql -1
-        response.error.message.should eql "Method Error"
+        expect(response).to be_a(JsonRpcErrorResponse)
+        expect(response.error.code).to eql -1
+        expect(response.error.message).to eql "Method Error"
         socket.close
         sleep 0.1
         @json.stop_service
         sleep(0.1)
       end
 
-      it "should not allow dangerous methods" do
+      it "does not allow dangerous methods" do
         @json.start_service('127.0.0.1', 7777, self)
         socket = TCPSocket.open('127.0.0.1',7777)
         sleep 0.1
@@ -230,16 +230,16 @@ module Cosmos
         JsonDRb.send_data(socket, request)
         response_data = JsonDRb.receive_message(socket, '')
         response = JsonRpcResponse.from_json(response_data)
-        response.should be_a(JsonRpcErrorResponse)
-        response.error.code.should eql -1
-        response.error.message.should eql "Cannot call unauthorized methods"
+        expect(response).to be_a(JsonRpcErrorResponse)
+        expect(response.error.code).to eql -1
+        expect(response.error.message).to eql "Cannot call unauthorized methods"
         socket.close
         sleep 0.1
         @json.stop_service
         sleep(0.1)
       end
 
-      it "should handle an invalid JsonDRB request" do
+      it "handles an invalid JsonDRB request" do
         @json.start_service('127.0.0.1', 7777, self)
         socket = TCPSocket.open('127.0.0.1',7777)
         sleep 0.1
@@ -249,9 +249,9 @@ module Cosmos
         JsonDRb.send_data(socket, request)
         response_data = JsonDRb.receive_message(socket, '')
         response = JsonRpcResponse.from_json(response_data)
-        response.should be_a(JsonRpcErrorResponse)
-        response.error.code.should eql -32600
-        response.error.message.should eql "Invalid Request"
+        expect(response).to be_a(JsonRpcErrorResponse)
+        expect(response.error.code).to eql -32600
+        expect(response.error.message).to eql "Invalid Request"
         socket.close
         sleep 0.1
         @json.stop_service
@@ -260,7 +260,7 @@ module Cosmos
     end
 
     describe "send_data" do
-      it "should retry if the socket blocks" do
+      it "retries if the socket blocks" do
         @json.start_service('127.0.0.1', 7777, self)
         socket = TCPSocket.open('127.0.0.1',7777)
         # Stub write_nonblock so it blocks
@@ -281,7 +281,7 @@ module Cosmos
         sleep(0.1)
       end
 
-      it "should eventually timeout if the socket blocks" do
+      it "eventuallies timeout if the socket blocks" do
         @json.start_service('127.0.0.1', 7777, self)
         socket = TCPSocket.open('127.0.0.1',7777)
         # Stub write_nonblock so it blocks
@@ -298,11 +298,11 @@ module Cosmos
     end
 
     describe "debug, debug?" do
-      it "should set the debug level" do
+      it "sets the debug level" do
         JsonDRb.debug = true
-        JsonDRb.debug?.should be_truthy
+        expect(JsonDRb.debug?).to be_truthy
         JsonDRb.debug = false
-        JsonDRb.debug?.should be_falsey
+        expect(JsonDRb.debug?).to be_falsey
       end
     end
 

data/spec/io/json_rpc_spec.rb

@@ -26,26 +26,26 @@ describe Object do
     end
   end
 
-  it "should implement as_json" do
-    Test1.new.as_json.should eql [:@test]
-    Test2.new.as_json.should eql Hash.new("test"=>0)
+  it "implements as_json" do
+    expect(Test1.new.as_json).to eql [:@test]
+    expect(Test2.new.as_json).to eql Hash.new("test"=>0)
   end
 end
 
 describe Struct do
-  it "should implement as_json" do
+  it "implements as_json" do
     s = Struct.new(:test1, :test2)
     instance = s.new(1,2)
     hash = {"test1"=>1,"test2"=>2}
-    instance.as_json.should eql hash
+    expect(instance.as_json).to eql hash
   end
 end
 
 describe String do
-  it "should implement as_json" do
-    "test".as_json.should eql "test"
+  it "implements as_json" do
+    expect("test".as_json).to eql "test"
     hash = {"json_class"=>"String","raw"=>[16]}
-    "\x10".as_json.should eql hash
+    expect("\x10".as_json).to eql hash
   end
 end
 
@@ -58,42 +58,42 @@ describe Enumerable do
     end
   end
 
-  it "should implement as_json" do
-    Test.new.as_json.should eql [1,2]
+  it "implements as_json" do
+    expect(Test.new.as_json).to eql [1,2]
   end
 end
 
 describe Array do
-  it "should implement as_json" do
-    [1,2,3].as_json.should eql [1,2,3]
+  it "implements as_json" do
+    expect([1,2,3].as_json).to eql [1,2,3]
   end
 end
 
 describe Hash do
-  it "should implement as_json" do
+  it "implements as_json" do
     hash = {"true"=>1,"false"=>0}
-    hash.as_json.should eql hash
+    expect(hash.as_json).to eql hash
   end
 end
 
 describe Time do
-  it "should implement as_json" do
+  it "implements as_json" do
     time = Time.new(2020,01,31,12,20,10)
-    time.as_json.should match "2020-01-31 12:20:10"
+    expect(time.as_json).to match "2020-01-31 12:20:10"
   end
 end
 
 describe Date do
-  it "should implement as_json" do
+  it "implements as_json" do
     date = Date.new(2020,01,31)
-    date.as_json.should eql "2020-01-31"
+    expect(date.as_json).to eql "2020-01-31"
   end
 end
 
 describe DateTime do
-  it "should implement as_json" do
+  it "implements as_json" do
     dt = DateTime.new(2020,01,31,12,20,10)
-    dt.as_json.should match "2020-01-31T12:20:10"
+    expect(dt.as_json).to match "2020-01-31T12:20:10"
   end
 end
 
@@ -105,26 +105,26 @@ describe Exception do
     end
   end
 
-  it "should implement as_json" do
+  it "implements as_json" do
     json = TestError.new("Error").as_json
-    json["class"].should eql "TestError"
-    json["message"].should eql "Error"
+    expect(json["class"]).to eql "TestError"
+    expect(json["message"]).to eql "Error"
     hash = {"@test"=>"test"}
-    json["instance_variables"].should eql hash
+    expect(json["instance_variables"]).to eql hash
   end
 
-  it "should call as_json from to_json" do
-    TestError.new("Error").to_json.should be_a String
+  it "calls as_json from to_json" do
+    expect(TestError.new("Error").to_json).to be_a String
   end
 
-  it "should create an object from a hash" do
+  it "creates an object from a hash" do
     json = TestError.new("Error").as_json
     error = Exception.from_hash(json)
-    error.should be_a TestError
-    error.message.should eql "Error"
+    expect(error).to be_a TestError
+    expect(error.message).to eql "Error"
   end
 
-  it "should rescue creating an object" do
+  it "rescues creating an object" do
     json = TestError.new("Error").as_json
     json["class"] = "ClassWhichDoesNotExist"
     json["message"] = "Error"
@@ -137,48 +137,48 @@ module Cosmos
 
   describe JsonRpcRequest do
     describe "method" do
-      it "should return the method" do
-        JsonRpcRequest.new("puts","test",10).method.should eql "puts"
+      it "returns the method" do
+        expect(JsonRpcRequest.new("puts","test",10).method).to eql "puts"
       end
     end
 
     describe "params" do
-      it "should return the parameters" do
-        JsonRpcRequest.new("puts",nil,10).params.should eql []
-        JsonRpcRequest.new("puts","test",10).params.should eql "test"
-        JsonRpcRequest.new("puts",["test",1],10).params.should eql ["test",1]
+      it "returns the parameters" do
+        expect(JsonRpcRequest.new("puts",nil,10).params).to eql []
+        expect(JsonRpcRequest.new("puts","test",10).params).to eql "test"
+        expect(JsonRpcRequest.new("puts",["test",1],10).params).to eql ["test",1]
       end
     end
 
     describe "id" do
-      it "should return the request id" do
-        JsonRpcRequest.new("puts",nil,10).id.should eql 10
+      it "returns the request id" do
+        expect(JsonRpcRequest.new("puts",nil,10).id).to eql 10
       end
     end
 
     describe "as_json" do
-      it "should return the json hash" do
+      it "returns the json hash" do
         json = JsonRpcRequest.new("puts","test",10).as_json
-        json["jsonrpc"].should eql "2.0"
-        json["method"].should eql "puts"
-        json["params"].should eql "test"
-        json["id"].should eql 10
+        expect(json["jsonrpc"]).to eql "2.0"
+        expect(json["method"]).to eql "puts"
+        expect(json["params"]).to eql "test"
+        expect(json["id"]).to eql 10
       end
     end
 
     describe "to_json" do
-      it "should return the json string" do
-        json = JsonRpcRequest.new("puts","test",10).to_json.should be_a String
+      it "returns the json string" do
+        json = expect(JsonRpcRequest.new("puts","test",10).to_json).to be_a String
       end
     end
 
     describe "from_json" do
-      it "should create a request from the json string" do
+      it "creates a request from the json string" do
         request = JsonRpcRequest.new("puts","test",10)
-        request.should == JsonRpcRequest.from_json(request.to_json)
+        expect(request).to eq(JsonRpcRequest.from_json(request.to_json))
       end
 
-      it "should rescue a bad json string" do
+      it "rescues a bad json string" do
         json = JsonRpcRequest.new("puts","test",10).to_json
         json.gsub!("jsonrpc","version")
         json.gsub!("2.0","1.1")
@@ -188,71 +188,71 @@ module Cosmos
     end
 
     describe "from_hash" do
-      it "should create a request from the hash" do
+      it "creates a request from the hash" do
         request = JsonRpcRequest.new("puts","test",10)
-        request.should == JsonRpcRequest.from_hash(request.as_json)
+        expect(request).to eq(JsonRpcRequest.from_hash(request.as_json))
       end
     end
   end
 
   describe JsonRpcResponse do
     describe "as_json" do
-      it "should return the json hash" do
+      it "returns the json hash" do
         json = JsonRpcResponse.new(10).as_json
-        json["jsonrpc"].should eql "2.0"
-        json["id"].should eql 10
+        expect(json["jsonrpc"]).to eql "2.0"
+        expect(json["id"]).to eql 10
       end
     end
 
     describe "to_json" do
-      it "should return the json string" do
-        json = JsonRpcResponse.new(10).to_json.should be_a String
+      it "returns the json string" do
+        json = expect(JsonRpcResponse.new(10).to_json).to be_a String
       end
     end
 
     describe "from_json" do
-      it "should create a success response from the json string" do
+      it "creates a success response from the json string" do
         json = JsonRpcResponse.new(10).as_json
         json['result'] = "true"
         response = JsonRpcResponse.from_json(json.to_json)
-        response.should be_a JsonRpcSuccessResponse
-        response.result.should eql "true"
+        expect(response).to be_a JsonRpcSuccessResponse
+        expect(response.result).to eql "true"
       end
 
-      it "should create a error response from the json string" do
+      it "creates a error response from the json string" do
         json = JsonRpcResponse.new(10).as_json
         json['error'] = {"code"=>-1, "message"=>"error", "data"=>{"message"=>"problem"}}
         response = JsonRpcResponse.from_json(json.to_json)
-        response.should be_a JsonRpcErrorResponse
-        response.error.code.should eql -1
-        response.error.message.should eql "error"
-        response.error.data['message'].should eql "problem"
+        expect(response).to be_a JsonRpcErrorResponse
+        expect(response.error.code).to eql -1
+        expect(response.error.message).to eql "error"
+        expect(response.error.data['message']).to eql "problem"
       end
 
-      it "should report an error if there is no 'result' or 'error' key" do
+      it "reports an error if there is no 'result' or 'error' key" do
         json = JsonRpcResponse.new(10).as_json
         expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
       end
 
-      it "should report an error if the version isn't 2.0" do
+      it "reports an error if the version isn't 2.0" do
         json = JsonRpcResponse.new(10).as_json
         json['jsonrpc'] = "1.1"
         json['result'] = "true"
         expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
       end
 
-      it "should report an error if there is both a 'result' and 'error' key" do
+      it "reports an error if there is both a 'result' and 'error' key" do
         json = JsonRpcResponse.new(10).as_json
         json['result'] = "true"
         json['error'] = {"code"=>-1, "message"=>"error"}
         expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
       end
 
-      it "should report an error if it is not json" do
+      it "reports an error if it is not json" do
         expect { JsonRpcResponse.from_json(Object.new) }.to raise_error("Invalid JSON-RPC 2.0 Response")
       end
 
-      it "should report an error if the error hash is bad" do
+      it "reports an error if the error hash is bad" do
         json = JsonRpcResponse.new(10).as_json
         json['error'] = {"code"=>-1}
         expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Error")