rjr 0.18.2 → 0.19.1

data/specs/messages/notification_spec.rb

@@ -0,0 +1,59 @@
+require 'rjr/messages/notification'
+
+module RJR
+module Messages
+  describe Notification do
+    it "should accept notification parameters" do
+      msg = Notification.new :method => 'test',
+                                    :args   => ['a', 1],
+                                    :headers => {:h => 2}
+      msg.jr_method.should == "test"
+      msg.jr_args.should =~ ['a', 1]
+      msg.headers.should have_key(:h)
+      msg.headers[:h].should == 2
+    end
+
+    it "should return bool indicating if string is a notification msg"
+  
+    it "should produce valid json" do
+      msg = Notification.new :method => 'test',
+                                    :args   => ['a', 1],
+                                    :headers => {:h => 2}
+  
+      msg_string = msg.to_s
+      msg_string.should include('"h":2')
+      msg_string.should include('"method":"test"')
+      msg_string.should include('"params":["a",1]')
+      msg_string.should include('"jsonrpc":"2.0"')
+      msg_string.should_not include('"id":"')
+    end
+  
+    it "should parse notification message string" do
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"method": "test", "params": ["a", 1]}'
+      msg = Notification.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.jr_method.should == 'test'
+      msg.jr_args.should =~ ['a', 1]
+    end
+  
+    it "should extract optional headers from message string" do
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"method": "test", "params": ["a", 1], ' +
+                   '"h": 2}'
+      msg = Notification.new :message => msg_string, :headers => {'f' => 'g'}
+      msg.json_message.should == msg_string
+      msg.headers.should have_key 'h'
+      msg.headers.should have_key 'f'
+      msg.headers['h'].should == 2
+      msg.headers['f'].should == 'g'
+    end
+  
+    it "should fail if parsing invalid message string" do
+      lambda {
+        msg = Notification.new :message => 'foobar'
+      }.should raise_error JSON::ParserError
+    end
+  end # describe Notification
+end # module Messages
+end # module RJR

data/specs/messages/request_spec.rb

@@ -0,0 +1,66 @@
+require 'rjr/common'
+require 'rjr/messages/request'
+
+module RJR
+module Messages
+  describe Request do
+    it "should accept request parameters" do
+      msg = Request.new :method => 'test',
+                               :args   => ['a', 1],
+                               :headers => {:h => 2}
+      msg.jr_method.should == "test"
+      msg.jr_args.should =~ ['a', 1]
+      msg.headers.should have_key(:h)
+      msg.headers[:h].should == 2
+      msg.msg_id.should =~ /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+    end
+
+    it "should return bool indicating if string is a request msg"
+
+    it "should produce valid json" do
+      msg = Request.new :method => 'test',
+                               :args   => ['a', 1],
+                               :headers => {:h => 2}
+
+      msg_string = msg.to_s
+      msg_string.should include('"h":2')
+      msg_string.should include('"method":"test"')
+      msg_string.should include('"params":["a",1]')
+      msg_string.should include('"jsonrpc":"2.0"')
+      msg_string.should include('"id":"'+msg.msg_id+'"')
+    end
+
+    it "should parse request message string" do
+      msg_uuid = gen_uuid 
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"id": "' + msg_uuid + '", ' +
+                   '"method": "test", "params": ["a", 1]}'
+      msg = Request.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.jr_method.should == 'test'
+      msg.jr_args.should =~ ['a', 1]
+      msg.msg_id.should == msg_uuid
+    end
+
+    it "should extract optional headers from message string" do
+      msg_uuid = gen_uuid 
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"id": "' + msg_uuid + '", ' +
+                   '"method": "test", "params": ["a", 1], ' +
+                   '"h": 2}'
+      msg = Request.new :message => msg_string, :headers => {'f' => 'g'}
+      msg.json_message.should == msg_string
+      msg.headers.should have_key 'h'
+      msg.headers.should have_key 'f'
+      msg.headers['h'].should == 2
+      msg.headers['f'].should == 'g'
+    end
+
+    it "should fail if parsing invalid message string" do
+      lambda {
+        msg = Request.new :message => 'foobar'
+      }.should raise_error JSON::ParserError
+    end
+  end # describe Request
+end # module Messages
+end # module RJR

data/specs/messages/response_spec.rb

@@ -0,0 +1,94 @@
+require 'rjr/common'
+require 'rjr/result'
+require 'rjr/messages/response'
+
+module RJR
+module Messages
+  describe Response do
+    it "should accept response parameters" do
+      msg_id = gen_uuid
+      msg = Response.new :id      => msg_id,
+                                     :result  => Result.new(:result => 'success'),
+                                     :headers => {:h => 2}
+      msg.msg_id.should == msg_id
+      msg.result.result == 'success'
+      msg.headers.should have_key(:h)
+      msg.headers[:h].should == 2
+    end
+
+    it "should return bool indicating if string is a response msg"
+
+    it "should produce valid result response json" do
+      msg_id = gen_uuid
+      msg = Response.new :id      => msg_id,
+                                :result  => RJR::Result.new(:result => 'success'),
+                                :headers => {:h => 2}
+      msg_string = msg.to_s
+      msg_string.should include('"id":"'+msg_id+'"')
+      msg_string.should include('"result":"success"')
+      msg_string.should include('"h":2')
+      msg_string.should include('"jsonrpc":"2.0"')
+    end
+
+    it "should produce valid error response json" do
+      msg_id = gen_uuid
+      msg = Response.new :id      => msg_id,
+                                :result  =>
+                                  RJR::Result.new(:error_code => 404,
+                                                  :error_msg => 'not found',
+                                                  :error_class => ArgumentError),
+                                :headers => {:h => 2}
+      msg_string = msg.to_s
+      msg_string.should include('"id":"'+msg_id+'"')
+      msg_string.should include('"h":2')
+      msg_string.should include('"jsonrpc":"2.0"')
+      msg_string.should include('"error":{')
+      msg_string.should include('"code":404')
+      msg_string.should include('"message":"not found"')
+    end
+
+
+    it "should parse result response message string" do
+      msg_id = gen_uuid
+      msg_string = '{"id":"' + msg_id + '", ' +
+                    '"result":"success","jsonrpc":"2.0"}'
+      msg = Response.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.msg_id.should == msg_id
+      msg.result.success.should == true
+      msg.result.failed.should == false
+      msg.result.result.should == "success"
+    end
+
+    it "should parse error response message string" do
+      msg_id = gen_uuid
+      msg_string = '{"id":"' + msg_id + '", ' +
+                    '"error":{"code":404,"message":"not found","class":"ArgumentError"}, "jsonrpc":"2.0"}'
+      msg = Response.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.msg_id.should == msg_id
+      msg.result.success.should == false
+      msg.result.failed.should == true
+      msg.result.error_code.should == 404
+      msg.result.error_msg.should == "not found"
+      msg.result.error_class.should == 'ArgumentError'
+    end
+
+    it "should extract optional headers from message string" do
+      msg_id = gen_uuid
+      msg_string = '{"id":"' + msg_id + '", ' +
+                    '"result":"success","h":2,"jsonrpc":"2.0"}'
+      msg = Response.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.headers.should have_key 'h'
+      msg.headers['h'].should == 2
+    end
+
+    it "should fail if parsing invalid message string" do
+      lambda {
+        msg = Response.new :message => 'foobar'
+      }.should raise_error JSON::ParserError
+    end
+  end # describe Response
+end # module Messages
+end # module RJR

data/specs/node_callbacks_spec.rb

@@ -0,0 +1,47 @@
+require 'rjr/dispatcher'
+
+require 'rjr/node'
+require 'rjr/node_callback'
+
+module RJR
+  describe NodeCallback do
+    describe "#initialize" do
+      it "sets node" do
+        node = Object.new
+        callback = NodeCallback.new :node => node
+        callback.node.should == node
+      end
+
+      it "sets connection" do
+        connection = Object.new
+        callback = NodeCallback.new :connection => connection
+        callback.connection.should == connection
+      end
+    end
+
+    describe "#notify" do
+      before(:each) do
+        @connection = Object.new
+        @node       = Node.new :headers => {'msg' => 'headers'}
+        @callback  = NodeCallback.new :node => @node,
+                                       :connection => @connection
+      end
+
+      context "node is not persistent" do
+        it "just returns / does not send msg" do
+          @node.should_receive(:persistent?).and_return(false)
+          @node.should_not_receive(:send_msg)
+          @callback.notify('')
+        end
+      end
+
+      it "sends notification via node" do
+        expected = Messages::Notification.new :method  => 'method1',
+                                              :args    => ['method', 'args'],
+                                              :headers => {'msg' => 'headers'}
+        @node.should_not_receive(:send_msg).with(expected.to_s, @connection)
+        @callback.notify('msg')
+      end
+    end
+  end
+end

data/specs/node_spec.rb

@@ -3,13 +3,6 @@ require 'rjr/node'
 
 module RJR
   describe Node do
-    before(:all) do
-      # was made public in ruby 1.9
-      if RUBY_VERSION < "1.9"
-        RJR::Node.public_class_method(:class_variable_get)
-      end
-    end
-
     describe "::persistent?" do
       context "PERSISTENT_NODE is defined and true" do
         it "returns true" do
@@ -19,11 +12,19 @@ module RJR
         end
       end
 
-      context "PERSISTENT_NODE is not defined or returns false" do
+      context "PERSISTENT_NODE is not defined" do
         it "returns false" do
           Node.should_not be_persistent
         end
       end
+
+      context "PERSISTENT_NODE returns false" do
+        it "returns false" do
+          new_node = Class.new(Node)
+          new_node.const_set(:PERSISTENT_NODE, false)
+          new_node.should_not be_persistent
+        end
+      end
     end
 
     describe "#persistent?" do
@@ -42,69 +43,477 @@ module RJR
       end
     end
 
-    it "should initialize properly from params" do
-      d = Dispatcher.new
-      node = Node.new :node_id => 'foobar',
-                      :headers => {:h => 123},
-                      :dispatcher => d
-      node.node_id.should == 'foobar'
-      node.message_headers[:h].should == 123
-      node.dispatcher.should == d
+    describe "::indirect?" do
+      context "INDIRECT_NODE defined and true" do
+        it "returns true" do
+          new_node = Class.new(Node)
+          new_node.const_set(:INDIRECT_NODE, true)
+          new_node.should be_indirect
+        end
+      end
+
+      context "INDIRECT_NODE not defined" do
+        it "returns false" do
+          Node.should_not be_indirect
+        end
+      end
+
+      context "INDIRECT_NODE false" do
+        it "returns false" do
+          new_node = Class.new(Node)
+          new_node.const_set(:INDIRECT_NODE, false)
+          new_node.should_not be_indirect
+        end
+      end
+    end
+
+    describe "#indirect?" do
+      context "node is indirect" do
+        it "returns true" do
+          new_node = Class.new(Node)
+          new_node.const_set(:INDIRECT_NODE, true)
+          new_node.new.should be_indirect
+        end
+      end
+
+      context "node is direct" do
+        it "returns false" do
+          Node.new.should_not be_indirect
+        end
+      end
+    end
+
+    describe "#node_type" do
+      it "returns NODE_TYPE" do
+        new_node = Class.new(Node)
+        new_node.const_set(:RJR_NODE_TYPE, 'nt')
+        new_node.new.node_type.should == 'nt'
+      end
+    end
+
+    describe "#initialize" do
+      it "sets node id" do
+        node = Node.new :node_id => 'node1'
+        node.node_id.should == 'node1'
+      end
+
+      it "sets dispatcher" do
+        dispatcher = Dispatcher.new
+        node = Node.new :dispatcher => dispatcher
+        node.dispatcher.should == dispatcher
+      end
+
+      context "dispatcher not specified" do
+        it "initializes dispatcher" do
+          Node.new.dispatcher.should be_an_instance_of(Dispatcher)
+        end
+      end
+
+      it "sets message headers" do
+        headers = {:header1 => :val}
+        node = Node.new :headers => headers
+        node.message_headers.should == headers
+      end
+
+      context "headers not specified" do
+        it "initializes blank headers" do
+          Node.new.message_headers.should == {}
+        end
+      end
+
+      it "initializes shared thread pool" do
+        Node.new
+        Node.tp.should_not be_nil
+        orig = Node.tp
+
+        Node.new.tp.should == orig
+        Node.tp.should == orig
+      end
+
+      it "initializes shared em adapter" do
+        Node.new
+        Node.em.should_not be_nil
+        orig = Node.em
+
+        Node.new.em.should == orig
+        Node.em.should == orig
+      end
+
+      it "starts thread pool" do
+        tp = ThreadPool.new
+        Node.should_receive(:tp).and_return(tp)
+        tp.should_receive(:start)
+        Node.new
+      end
+
+      it "starts em adapter" do
+        em = EMAdapter.new
+        Node.should_receive(:em).and_return(em)
+        em.should_receive(:start)
+        Node.new
+      end
     end
 
-    it "should create a new dispatcher" do
-      node = Node.new
-      node.dispatcher.should_not be_nil
-      node.dispatcher.class.should == Dispatcher
+    describe "#join" do
+      it "joins thread pool & em adapter and returns self" do
+        Node.tp.should_receive(:join)
+        Node.em.should_receive(:join)
+        n = Node.new
+        n.join.should == n
+      end
     end
 
-    it "should start the thread pool" do
-      node = Node.new
-      node.class.class_variable_get(:@@tp).should be_running
+    describe "#halt" do
+      it "stops thread pool & em adatper and returns self" do
+        Node.tp.should_receive(:stop)
+        Node.em.should_receive(:stop_event_loop)
+        n = Node.new
+        n.halt.should == n
+      end
     end
 
-    it "should start event machine" do
-      EventMachine.stop_event_loop
-      node = Node.new
-      EventMachine.reactor_running?.should be_true
+    describe "#clear_event_handlers" do
+      it "resets connection event handlers" do
+        n = Node.new
+        n.on(:error) {}
+        n.clear_event_handlers
+        n.connection_event_handlers.should == {:closed => [], :error => []}
+      end
     end
 
-    it "should halt the thread pool" do
-      node = Node.new
-      node.halt.join
-      node.class.class_variable_get(:@@tp).should_not be_running
+    describe "#on" do
+      it "registers new connection event handler" do
+        bl = proc{}
+        n = Node.new
+        n.on(:error, &bl)
+        n.connection_event_handlers.should == {:closed => [], :error => [bl]}
+      end
     end
 
-    it "should halt event machine" do
-      node = Node.new
-      node.halt.join
-      EventMachine.reactor_running?.should be_false
+    describe "#connection_event" do
+      it "invokes event handlers" do
+        bl = proc{}
+        n = Node.new
+        n.on(:error, &bl)
+        bl.should_receive(:call).with(n)
+        n.send :connection_event, :error
+      end
     end
 
-    it "should handle connection events" do
-      node = Node.new
-      closed = false
-      error = false
-      node.on :closed do
-        closed = true
+    describe "#client_for" do
+      context "node is indirect" do
+        it "returns nil" do
+          n = Node.new
+          n.should_receive(:indirect?).and_return(true)
+          n.send(:client_for, 'whatever').should == [nil, nil]
+        end
       end
-      node.on :error do
-        error = true
+
+      context "node is local" do
+        it "returns nil" do
+          n = Node.new
+          n.should_receive(:node_type).and_return(:local)
+          n.send(:client_for, 'whatever').should == [nil, nil]
+        end
       end
-      node.send(:connection_event, :error)
-      error.should be_true
 
-      node.send(:connection_event, :closed)
-      closed.should be_true
+      it "extracts & returns client ip and port from socket connection" do
+        n = Node.new
+        n.should_receive(:node_type).and_return(:tcp)
+
+        c = Object.new
+        c.should_receive(:get_peername).and_return('peername')
+        expected = ['127.0.0.1', 5000]
+        Socket.should_receive(:unpack_sockaddr_in).
+          with('peername').and_return(expected)
+        n.send(:client_for, c).should == expected
+      end
+
+      context "error during ip/port extraction" do
+        it "returns nil" do
+          n = Node.new
+          n.should_receive(:node_type).and_return(:tcp)
+
+          c = Object.new
+          c.should_receive(:get_peername).and_raise(Exception)
+          n.send(:client_for, c).should == [nil, nil]
+        end
+      end
     end
 
-    it "should handle request messages"
-    it "should handle notification messages"
-    it "should handle response messages"
-    it "should block until reponse is received"
-  end
+    describe "#handle_message" do
+      context "request message" do
+        it "handles request via thread pool" do
+          connection = Object.new
+          request = Messages::Request.new  :id => 1, :method => 'foo'
+          request_str = request.to_s
+
+          node = Node.new
+          node.tp.should_receive(:<<) { |job|
+            job.should be_an_instance_of(ThreadPoolJob)
+            job.exec Mutex.new
+          }
+
+          node.should_receive(:handle_request).with(request_str, false, connection)
+          node.send :handle_message, request_str, connection
+        end
+      end
+
+      context "notification message" do
+        it "handles notification via thread pool" do
+          connection = Object.new
+          notification = Messages::Notification.new  :method => 'foo'
+          notification_str = notification.to_s
 
-  describe NodeCallback do
-    it "should send notifications"
-  end
-end
+          node = Node.new
+          node.tp.should_receive(:<<) { |job|
+            job.should be_an_instance_of(ThreadPoolJob)
+            job.exec Mutex.new
+          }
+
+          node.should_receive(:handle_request).
+            with(notification_str, true, connection)
+          node.send :handle_message, notification_str, connection
+        end
+      end
+
+      context "response message" do
+        it "handles response" do
+          response = Messages::Response.new :result => Result.new
+          response_str = response.to_s
+
+          node = Node.new
+          node.should_receive(:handle_response).with(response_str)
+          node.send :handle_message, response_str
+        end
+      end
+
+      context "anything else" do
+        it "does nothing" do
+          node = Node.new
+          node.tp.should_not_receive(:<<)
+          node.should_not_receive(:handle_request)
+          node.should_not_receive(:handle_response)
+          node.send :handle_message, "{}"
+        end
+      end
+    end
+
+    describe "#handle_request" do
+      before(:each) do
+         notification =
+           Messages::Notification.new :method  => 'rjr_method1',
+                                      :args    => ['method', 'args'],
+                                      :headers => {'msg' => 'headers'}
+        @notification = notification.to_s
+        @node = Node.new
+      end
+
+      it "invokes dispatcher.dispatch" do
+        @node.dispatcher.should_receive(:dispatch)
+        @node.send :handle_request, @notification, true
+      end
+
+      describe "dispatcher.dispatch args" do
+        it "includes :rjr_method => msg.jr_method" do
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_method].should == 'rjr_method1'
+          }
+          @node.send :handle_request, @notification, true
+        end
+
+        it "includes :rjr_method_args => msg.jr_args" do
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_method_args].should == ['method', 'args']
+          }
+          @node.send :handle_request, @notification, true
+        end
+
+        it "includes :rjr_headers => msg.headers" do
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_headers].should == {'msg' => 'headers'}
+          }
+          @node.send :handle_request, @notification, true
+        end
+
+        it "includes :rjr_client_ip => extracted client ip" do
+          connection = Object.new
+          @node.should_receive(:client_for).with(connection).
+            and_return([9999, '127.0.0.1'])
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_client_ip].should == '127.0.0.1'
+          }
+          @node.send :handle_request, @notification, true, connection
+        end
+
+        it "includes :rjr_client_port => extracted client port" do
+          connection = Object.new
+          @node.should_receive(:client_for).with(connection).
+            and_return([9999, '127.0.0.1'])
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_client_port].should == 9999
+          }
+          @node.send :handle_request, @notification, true, connection
+        end
+
+        it "includes :rjr_node => self" do
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_node].should == @node
+          }
+          @node.send :handle_request, @notification, true
+        end
+
+        it "includes :rjr_node_id => self.node_id" do
+          @node.should_receive(:node_id).and_return('node_id')
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_node_id].should == 'node_id'
+          }
+          @node.send :handle_request, @notification, true
+        end
+
+        it "includes :rjr_node_type => self.node_type" do
+          @node.should_receive(:node_type).at_least(:once).and_return(:nt)
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_node_type].should == :nt
+          }
+          @node.send :handle_request, @notification, true
+        end
+
+        it "includes :rjr_callback => constructed node callback" do
+          @node.dispatcher.should_receive(:dispatch) { |args|
+            args[:rjr_callback].should be_an_instance_of(NodeCallback)
+          }
+          @node.send :handle_request, @notification, true
+        end
+
+        describe "specified node callback" do
+          it "has a handle to the node" do
+            @node.dispatcher.should_receive(:dispatch) { |args|
+              args[:rjr_callback].node.should == @node
+            }
+            @node.send :handle_request, @notification, true
+          end
+
+          it "has a handle to the connection" do
+            connection = Object.new
+            @node.dispatcher.should_receive(:dispatch) { |args|
+              args[:rjr_callback].connection.should == connection
+            }
+            @node.send :handle_request, @notification, true, connection
+          end
+        end
+      end
+
+      context "handling request / not a notification" do
+        before(:each) do
+           request = Messages::Request.new :method  => 'method1',
+                                           :args    => ['method', 'args'],
+                                           :headers => {'msg' => 'headers'}
+          @request = request.to_s
+
+          result = Result.new
+          @expected = Messages::Response.new :result  => result,
+                                             :headers => {'msg' => 'headers'},
+                                             :id      => request.msg_id
+
+          # stub out dispatch
+          @node.dispatcher.should_receive(:dispatch).and_return(result)
+        end
+
+        it "sends response msg string via connection" do
+          connection = Object.new
+          @node.should_receive(:send_msg) { |response,econnection|
+            response.should == @expected.to_s
+            econnection.should == connection
+          }
+          @node.send :handle_request, @request, false, connection
+        end
+
+        it "returns response" do
+          @node.should_receive(:send_msg) # stub out
+          response = @node.send(:handle_request, @request, false)
+          response.should be_an_instance_of(Messages::Response)
+          response.to_s.should == @expected.to_s
+        end
+      end
+
+      it "returns nil" do
+        @node.send(:handle_request, @notification, true).should be_nil
+      end
+    end
+
+    describe "#handle_response" do
+      before(:each) do
+        @node = Node.new
+
+        @result = Result.new :result => 42
+         response = Messages::Response.new :id => 'msg1', :result => @result
+        @response = response.to_s
+      end
+
+      it "invokes dispatcher.handle_response with response result" do
+        @node.dispatcher.should_receive(:handle_response) { |r|
+          r.should be_an_instance_of(Result)
+          r.result.should == 42
+        }
+        @node.send :handle_response, @response
+      end
+
+      it "adds response msg_id and result to response queue" do
+        @node.send :handle_response, @response
+        responses = @node.instance_variable_get(:@responses)
+        responses.size.should == 1
+        responses.first[0].should == 'msg1'
+        responses.first[1].should == 42
+      end
+
+      context "response contains error" do
+        it "adds response error to response queue" do
+          @node.dispatcher.should_receive(:handle_response).and_raise(Exception)
+          @node.send :handle_response, @response
+          responses = @node.instance_variable_get(:@responses)
+          responses.first[2].should be_an_instance_of(Exception)
+        end
+      end
+
+      it "signals response cv" do
+        @node.instance_variable_get(:@response_cv).should_receive(:broadcast)
+        @node.send :handle_response, @response
+      end
+    end
+
+    describe "#wait_for_result" do
+      before(:each) do
+        @node = Node.new
+        @msg  = Messages::Request.new :method => 'method1', :args => []
+        @response = [@msg.msg_id, 42]
+      end
+
+      context "response in response queue" do
+        before(:each) do
+          @node.instance_variable_set(:@responses, [@response])
+        end
+
+        it "deletes response from queue" do
+          @node.send :wait_for_result, @msg
+          @node.instance_variable_get(:@responses).should be_empty
+        end
+
+        it "returns response" do
+          @node.send(:wait_for_result, @msg).should == @response
+        end
+      end
+
+      context "response not in response queue" do
+        it "waits on response cv" do
+          node = Node.new
+          node.instance_variable_get(:@response_cv).stub(:wait) {
+            node.instance_variable_set(:@responses, [@response])
+          }
+          node.instance_variable_get(:@response_cv).should_receive(:wait).once
+          node.send(:wait_for_result, @msg)
+        end
+      end
+    end
+  end # describe Node
+end # module RJR