rjr 0.19.1 → 0.19.2

data/specs/node_spec.rb

@@ -177,7 +177,9 @@ module RJR
         n = Node.new
         n.on(:error) {}
         n.clear_event_handlers
-        n.connection_event_handlers.should == {:closed => [], :error => []}
+        n.connection_event_handlers.should == { :opened => [],
+                                                :closed => [],
+                                                :error  => [] }
       end
     end
 
@@ -186,7 +188,9 @@ module RJR
         bl = proc{}
         n = Node.new
         n.on(:error, &bl)
-        n.connection_event_handlers.should == {:closed => [], :error => [bl]}
+        n.connection_event_handlers.should == { :opened => [],
+                                                :closed => [],
+                                                :error  => [bl] }
       end
     end
 
@@ -247,6 +251,10 @@ module RJR
           connection = Object.new
           request = Messages::Request.new  :id => 1, :method => 'foo'
           request_str = request.to_s
+          inter = Messages::Intermediate.parse request_str
+          Messages::Intermediate.should_receive(:parse).
+                                 with(request_str).
+                                 and_return(inter)
 
           node = Node.new
           node.tp.should_receive(:<<) { |job|
@@ -254,7 +262,7 @@ module RJR
             job.exec Mutex.new
           }
 
-          node.should_receive(:handle_request).with(request_str, false, connection)
+          node.should_receive(:handle_request).with(inter, false, connection)
           node.send :handle_message, request_str, connection
         end
       end
@@ -264,6 +272,10 @@ module RJR
           connection = Object.new
           notification = Messages::Notification.new  :method => 'foo'
           notification_str = notification.to_s
+          inter = Messages::Intermediate.parse notification_str
+          Messages::Intermediate.should_receive(:parse).
+                                 with(notification_str).
+                                 and_return(inter)
 
           node = Node.new
           node.tp.should_receive(:<<) { |job|
@@ -271,8 +283,7 @@ module RJR
             job.exec Mutex.new
           }
 
-          node.should_receive(:handle_request).
-            with(notification_str, true, connection)
+          node.should_receive(:handle_request).with(inter, true, connection)
           node.send :handle_message, notification_str, connection
         end
       end
@@ -281,9 +292,13 @@ module RJR
         it "handles response" do
           response = Messages::Response.new :result => Result.new
           response_str = response.to_s
+          inter = Messages::Intermediate.parse response_str
+          Messages::Intermediate.should_receive(:parse).
+                                 with(response_str).
+                                 and_return(inter)
 
           node = Node.new
-          node.should_receive(:handle_response).with(response_str)
+          node.should_receive(:handle_response).with(inter)
           node.send :handle_message, response_str
         end
       end
@@ -297,6 +312,14 @@ module RJR
           node.send :handle_message, "{}"
         end
       end
+
+      it "returns intermediate message" do
+        node = Node.new
+        connection = Object.new
+        inter = Messages::Intermediate.new
+        Messages::Intermediate.should_receive(:parse).and_return(inter)
+        node.send(:handle_message, '', connection).should == inter
+      end
     end
 
     describe "#handle_request" do
@@ -305,13 +328,14 @@ module RJR
            Messages::Notification.new :method  => 'rjr_method1',
                                       :args    => ['method', 'args'],
                                       :headers => {'msg' => 'headers'}
-        @notification = notification.to_s
+        notification_str = notification.to_s
+        @intermediate = Messages::Intermediate.parse notification_str
         @node = Node.new
       end
 
       it "invokes dispatcher.dispatch" do
         @node.dispatcher.should_receive(:dispatch)
-        @node.send :handle_request, @notification, true
+        @node.send :handle_request, @intermediate, true
       end
 
       describe "dispatcher.dispatch args" do
@@ -319,21 +343,21 @@ module RJR
           @node.dispatcher.should_receive(:dispatch) { |args|
             args[:rjr_method].should == 'rjr_method1'
           }
-          @node.send :handle_request, @notification, true
+          @node.send :handle_request, @intermediate, 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
+          @node.send :handle_request, @intermediate, 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
+          @node.send :handle_request, @intermediate, true
         end
 
         it "includes :rjr_client_ip => extracted client ip" do
@@ -343,7 +367,7 @@ module RJR
           @node.dispatcher.should_receive(:dispatch) { |args|
             args[:rjr_client_ip].should == '127.0.0.1'
           }
-          @node.send :handle_request, @notification, true, connection
+          @node.send :handle_request, @intermediate, true, connection
         end
 
         it "includes :rjr_client_port => extracted client port" do
@@ -353,14 +377,14 @@ module RJR
           @node.dispatcher.should_receive(:dispatch) { |args|
             args[:rjr_client_port].should == 9999
           }
-          @node.send :handle_request, @notification, true, connection
+          @node.send :handle_request, @intermediate, 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
+          @node.send :handle_request, @intermediate, true
         end
 
         it "includes :rjr_node_id => self.node_id" do
@@ -368,7 +392,7 @@ module RJR
           @node.dispatcher.should_receive(:dispatch) { |args|
             args[:rjr_node_id].should == 'node_id'
           }
-          @node.send :handle_request, @notification, true
+          @node.send :handle_request, @intermediate, true
         end
 
         it "includes :rjr_node_type => self.node_type" do
@@ -376,14 +400,14 @@ module RJR
           @node.dispatcher.should_receive(:dispatch) { |args|
             args[:rjr_node_type].should == :nt
           }
-          @node.send :handle_request, @notification, true
+          @node.send :handle_request, @intermediate, 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
+          @node.send :handle_request, @intermediate, true
         end
 
         describe "specified node callback" do
@@ -391,7 +415,7 @@ module RJR
             @node.dispatcher.should_receive(:dispatch) { |args|
               args[:rjr_callback].node.should == @node
             }
-            @node.send :handle_request, @notification, true
+            @node.send :handle_request, @intermediate, true
           end
 
           it "has a handle to the connection" do
@@ -399,17 +423,18 @@ module RJR
             @node.dispatcher.should_receive(:dispatch) { |args|
               args[:rjr_callback].connection.should == connection
             }
-            @node.send :handle_request, @notification, true, connection
+            @node.send :handle_request, @intermediate, 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
+          request = Messages::Request.new :method  => 'method1',
+                                          :args    => ['method', 'args'],
+                                          :headers => {'msg' => 'headers'}
+          request_str = request.to_s
+          @intermediate = Messages::Intermediate.parse request_str
 
           result = Result.new
           @expected = Messages::Response.new :result  => result,
@@ -426,19 +451,19 @@ module RJR
             response.should == @expected.to_s
             econnection.should == connection
           }
-          @node.send :handle_request, @request, false, connection
+          @node.send :handle_request, @intermediate, false, connection
         end
 
         it "returns response" do
           @node.should_receive(:send_msg) # stub out
-          response = @node.send(:handle_request, @request, false)
+          response = @node.send(:handle_request, @intermediate, 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
+        @node.send(:handle_request, @intermediate, true).should be_nil
       end
     end
 
@@ -448,7 +473,8 @@ module RJR
 
         @result = Result.new :result => 42
          response = Messages::Response.new :id => 'msg1', :result => @result
-        @response = response.to_s
+        response = response.to_s
+        @intermediate = Messages::Intermediate.parse response
       end
 
       it "invokes dispatcher.handle_response with response result" do
@@ -456,11 +482,11 @@ module RJR
           r.should be_an_instance_of(Result)
           r.result.should == 42
         }
-        @node.send :handle_response, @response
+        @node.send :handle_response, @intermediate
       end
 
       it "adds response msg_id and result to response queue" do
-        @node.send :handle_response, @response
+        @node.send :handle_response, @intermediate
         responses = @node.instance_variable_get(:@responses)
         responses.size.should == 1
         responses.first[0].should == 'msg1'
@@ -470,7 +496,7 @@ module RJR
       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
+          @node.send :handle_response, @intermediate
           responses = @node.instance_variable_get(:@responses)
           responses.first[2].should be_an_instance_of(Exception)
         end
@@ -478,7 +504,7 @@ module RJR
 
       it "signals response cv" do
         @node.instance_variable_get(:@response_cv).should_receive(:broadcast)
-        @node.send :handle_response, @response
+        @node.send :handle_response, @intermediate
       end
     end
 
@@ -513,6 +539,28 @@ module RJR
           node.instance_variable_get(:@response_cv).should_receive(:wait).once
           node.send(:wait_for_result, @msg)
         end
+        it "throws an error if it times out" do
+          node = Node.new :timeout => 0.01
+          node.instance_variable_get(:@response_cv).should_receive(:wait).at_least(:once)
+          expect { node.send(:wait_for_result, @msg) }.to raise_error(Exception)
+        end
+      end
+
+      context "pruning messages" do
+        it "deletes unrequested messages" do
+          responses = [@response, ['foobar', 'baz']]
+          @node.instance_variable_set(:@responses, responses)
+          @node.send :wait_for_result, @msg
+          @node.instance_variable_get(:@responses).should be_empty
+        end
+        it "deletes timed out messages" do
+          responses = [@response, ['foobar', 'baz']]
+          @node.instance_variable_set(:@timeout, 0.01)
+          @node.instance_variable_set(:@pending, { 'foobar' => Time.at(0) })
+          @node.instance_variable_set(:@responses, responses)
+          @node.send :wait_for_result, @msg
+          @node.instance_variable_get(:@responses).should be_empty
+        end
       end
     end
   end # describe Node

data/specs/nodes/amqp_spec.rb

@@ -40,7 +40,7 @@ module RJR::Nodes
                                                 'test',
                                                 'myparam'
         stop_node(node)
-        invoked.should be_true
+        invoked.should be_truthy
         ci.should be_nil
         cp.should be_nil
         rn.should == node

data/specs/nodes/local_spec.rb

@@ -66,8 +66,8 @@ module RJR::Nodes
       }
 
       node.invoke 'foobar', 'myparam'
-      foobar_invoked.should be_true
-      callback_invoked.should be_true
+      foobar_invoked.should be_truthy
+      callback_invoked.should be_truthy
       cbp.should == 'cp'
     end
 

data/specs/nodes/multi_spec.rb

@@ -51,7 +51,7 @@ module RJR::Nodes
                                :broker => 'localhost'
         res = amqp_client.invoke 'amqp-queue', 'method1', 'myparam1'
         res.should == 'retval1'
-        invoked1.should be_true
+        invoked1.should be_truthy
         rni1.should == 'amqp'
         rnt1.should == :amqp
         p1.should == 'myparam1'

data/specs/nodes/tcp_spec.rb

@@ -35,41 +35,130 @@ module RJR::Nodes
       end
     end
 
-    describe "#invoke" do
-      it "should invoke request" do
-        server  = TCP.new :node_id => 'tcp',
-                                   :host => 'localhost', :port => 9987
-        server.dispatcher.handle('foobar') { |param|
-          'retval'
-        }
+    context "simple server" do
+      let(:server) do
+        TCP.new(:node_id => 'tcp',
+                :host => 'localhost',
+                :port => 9987)
+      end
+
+      let(:host) { 'jsonrpc://localhost:9987' }
+
+      let(:client) { TCP.new }
+
+      before(:each) do
+        server.dispatcher.handle('foobar') { |param| 'retval' }
         server.listen
+      end
 
-        client = TCP.new
-        res = client.invoke 'jsonrpc://localhost:9987', 'foobar', 'myparam'
-        server.halt.join
-        res.should == 'retval'
+      describe "#invoke" do
+        it "should invoke request" do
+          res = client.invoke host, 'foobar', 'myparam'
+          server.halt.join
+          res.should == 'retval'
+        end
       end
-    end
 
-    describe "#notify" do
-      it "should send notification" do
-        server  = TCP.new :node_id => 'tcp',
-                                   :host => 'localhost', :port => 9987
-        server.dispatcher.handle('foobar') { |param|
-          'retval'
-        }
-        server.listen
+      describe "#notify" do
+        it "should send notification" do
+          res = client.notify host, 'foobar', 'myparam'
+          server.halt.join
+          res.should == nil
+        end
+      end
 
-        client = TCP.new
-        res = client.notify 'jsonrpc://localhost:9987', 'foobar', 'myparam'
-        server.halt.join
-        res.should == nil
+      describe "a node's connections array" do
+        it "should be updated when a connection is opened" do
+          client.invoke host, 'foobar', 'myparam'
+          server.connections.size.should be == 1
+          client.connections.size.should be == 1
+          server.halt.join
+        end
+
+        it "should be updated when a connection is closed" do
+          client.invoke host, 'foobar', 'myparam'
+          client.connections.first.unbind
+          server.connections.first.unbind
+          server.connections.should be_empty
+          client.connections.should be_empty
+          server.halt.join
+        end
+
+        context "with a client already connected" do
+          let(:another_client) { TCP.new }
+
+          before(:each) do
+            client.invoke host, 'foobar', 'myparam'
+          end
+
+          it "should be updated when a new connection is opened" do
+            another_client.invoke host, 'foobar', 'myparam'
+            server.connections.size.should be == 2
+            client.connections.size.should be == 1
+            another_client.connections.size.should be == 1
+            server.halt.join
+          end
+
+          context "with two clients connected" do
+            before(:each) do
+              client.invoke host, 'foobar', 'myparam'
+              another_client.invoke host, 'foobar', 'myparam'
+            end
+
+            it "should be updated when a connection is closed" do
+              another_client.connections.first.unbind
+              server.connections.last.unbind
+              server.connections.size.should be == 1
+              client.connections.size.should be == 1
+              another_client.connections.should be_empty
+              server.halt.join
+            end
+          end
+        end
+      end
+
+      describe "event handlers" do
+        shared_examples "an event handler" do |event|
+          it "should be invoked when event is triggered" do
+            handler_invoked = false
+            server.on(event) { handler_invoked = true }
+            client.invoke host, 'foobar', 'myparam'
+            server.halt.join
+            handler_invoked.should be_truthy
+          end
+
+          it "should receive the node" do
+            node_received = false
+            server.on(event) do |node|
+              node_received = true if node.is_a?(RJR::Node)
+            end
+            client.invoke host, 'foobar', 'myparam'
+            server.halt.join
+            node_received.should be_truthy
+          end
+
+          it "should receive the connection" do
+            connection_received = false
+            server.on(event) do |_, connection|
+              connection_received = true if connection.is_a?(EM::Connection)
+            end
+            client.invoke host, 'foobar', 'myparam'
+            server.halt.join
+            connection_received.should be_truthy
+          end
+        end
+
+        describe "opened event handler" do
+          it_behaves_like "an event handler", :opened
+        end
+
+        describe "closed event handler" do
+          it_behaves_like "an event handler", :closed
+        end
       end
     end
 
     # TODO test callbacks over tcp interface
-    # TODO ensure closed / error event handlers are invoked
+    # TODO ensure error event handler is invoked
   end
 end
-
-

data/specs/nodes/web_spec.rb

@@ -29,7 +29,7 @@ module RJR::Nodes
         # issue request
         Web.new.invoke 'http://localhost:9678', 'test', 'myparam'
         node.halt.join
-        invoked.should be_true
+        invoked.should be_truthy
         ci.should == '127.0.0.1'
         #cp.should
         rn.should == node

data/specs/nodes/ws_spec.rb

@@ -29,7 +29,7 @@ module RJR::Nodes
         # issue request
         WS.new.invoke 'http://localhost:9678', 'test', 'myparam'
         node.halt.join
-        invoked.should be_true
+        invoked.should be_truthy
         ci.should == '127.0.0.1'
         #cp.should
         rn.should == node

data/specs/request_spec.rb

@@ -63,11 +63,30 @@ module RJR
         request.rjr_args.args.should == args
       end
 
+      it "sets default env to nil" do
+        Request.new.rjr_env.should be_nil
+      end
+
       it "sets default result to nil" do
         Request.new.result.should be_nil
       end
     end
 
+    describe "#set_env" do
+      it "extends request w/ specified module" do
+        request = Request.new
+        request.should_receive(:extend).with('foobar')
+        request.set_env('foobar')
+      end
+
+      it "sets rjr_env" do
+        request = Request.new
+        request.should_receive(:extend)
+        request.set_env('foobar')
+        request.rjr_env.should == 'foobar'
+      end
+    end
+
     describe "#handle" do
       it "invokes the registered handler with args" do
         received = nil