rjr 0.12.2 → 0.15.1

data/specs/nodes/amqp_spec.rb

@@ -0,0 +1,82 @@
+require 'rjr/nodes/amqp'
+require 'rjr/nodes/missing'
+
+if RJR::Nodes::AMQP == RJR::Nodes::Missing
+puts "Missing AMQP node dependencies, skipping amqp tests"
+
+else
+module RJR::Nodes
+  describe AMQP do
+    describe "#send_msg" do
+      it "should send message to the specified queue"
+    end
+
+    describe "#listen" do
+      it "should listen for messages" do
+        ci = cp = rn = rni = rnt = p = invoked = nil
+        node = AMQP.new :node_id => 'server', :broker => 'localhost'
+        node.dispatcher.handle('test') do |param|
+          ci  = @rjr_client_ip
+          cp  = @rjr_client_port
+          rn  = @rjr_node
+          rni = @rjr_node_id
+          rnt = @rjr_node_type
+          p   = param
+          invoked = true
+        end
+        node.listen
+
+        # issue request
+        AMQP.new(:node_id => 'client',
+                 :broker => 'localhost').invoke 'server-queue',
+                                                'test',
+                                                'myparam'
+        node.halt.join
+        invoked.should be_true
+        ci.should be_nil
+        cp.should be_nil
+        rn.should == node
+        rni.should == 'server'
+        rnt.should == :amqp
+        p.should   == 'myparam'
+      end
+    end
+
+    describe "#invoke" do
+      it "should invoke request" do
+        server = AMQP.new :node_id => 'server', :broker => 'localhost'
+        server.dispatcher.handle('test') do |p|
+          'retval'
+        end
+        server.listen
+
+        client = AMQP.new :node_id => 'client', :broker => 'localhost'
+        res = client.invoke 'server-queue', 'test', 'myparam'
+
+        server.halt.join
+        res.should == 'retval'
+      end
+    end
+
+    describe "#notify" do
+      it "should send notification" do
+        server = AMQP.new :node_id => 'server', :broker => 'localhost'
+        server.dispatcher.handle('test') do |p|
+          'retval'
+        end
+        server.listen
+
+        client = AMQP.new :node_id => 'client', :broker => 'localhost'
+        res = client.notify 'server-queue', 'test', 'myparam'
+
+        server.halt.join
+        res.should == nil
+      end
+    end
+
+    # TODO test callbacks over amqp interface
+    # TODO ensure closed / error event handlers are invoked
+
+  end # describe AMQP
+end # module RJR::Nodes
+end # (!missing)

data/specs/nodes/easy_spec.rb

@@ -0,0 +1,13 @@
+require 'rjr/nodes/easy'
+
+module RJR::Nodes
+  describe Easy do
+    describe "#invoke" do
+      it "should invoke request"
+    end
+
+    describe "#notify" do
+      it "should send notification"
+    end
+  end
+end

data/specs/nodes/local_spec.rb

@@ -0,0 +1,72 @@
+require 'rjr/nodes/local'
+
+module RJR::Nodes
+  describe Local do
+    describe "#send_msg" do
+      it "should dispatch local notification"
+    end
+
+    describe "#invoke" do
+      it "should dispatch local request" do
+        invoked = rn = rni = rnt = p = nil
+        node = Local.new :node_id => 'aaa'
+        node.dispatcher.handle('foobar') { |param|
+          rn  = @rjr_node
+          rni = @rjr_node_id
+          rnt = @rjr_node_type
+          p   = param
+          invoked = true
+          'retval'
+        }
+
+        res = node.invoke 'foobar', 'myparam'
+
+        invoked.should == true
+        res.should == 'retval'
+        rn.should  == node
+        rni.should == 'aaa'
+        rnt.should == :local
+        p.should   == 'myparam'
+      end
+    end
+
+    describe "#notify" do
+      it "should dispatch local notification" do
+        invoked = nil
+        node = Local.new :node_id => 'aaa'
+        node.dispatcher.handle('foobar') { |param|
+          invoked = true
+          'retval'
+        }
+
+        res = node.notify 'foobar', 'myparam'
+        invoked.should == true
+        res.should == nil
+      end
+    end
+
+    it "should invoke callbacks" do
+      node = Local.new
+      cbp = nil
+      foobar_invoked = false
+      callback_invoked = false
+      node.dispatcher.handle('foobar') {
+        foobar_invoked = true
+        @rjr_callback.notify('callback', 'cp')
+      }
+      node.dispatcher.handle('callback') { |param|
+        callback_invoked = true
+        cbp = param
+      }
+
+      node.invoke 'foobar', 'myparam'
+      foobar_invoked.should be_true
+      callback_invoked.should be_true
+      cbp.should == 'cp'
+    end
+
+    # TODO make sure local parameters are not modified if altered
+    # on remote end of invoke/notify
+
+  end # desribe Local
+end  # module RJR::Nodes

data/specs/nodes/multi_spec.rb

@@ -0,0 +1,65 @@
+require 'rjr/nodes/multi'
+require 'rjr/nodes/amqp'
+require 'rjr/nodes/web'
+require 'rjr/nodes/missing'
+
+if RJR::Nodes::AMQP == RJR::Nodes::Missing ||
+   RJR::Nodes::Web  == RJR::Nodes::Missing
+puts "Missing AMQP and/or web node dependencies, skipping multi tests"
+
+else
+module RJR::Nodes
+  describe Multi do
+    describe "#listen" do
+      it "should listen for messages" do
+        invoked1 = invoked2 = false
+        rni1 = rni2 = nil
+        rnt1 = rnt2 = nil
+        p1   = p2   = nil
+        amqp  = AMQP.new  :node_id => 'amqp',
+                          :broker => 'localhost'
+        web   = Web.new   :node_id => 'web',
+                          :host => 'localhost', :port => 9876
+        multi = Multi.new :node_id => 'multi', 
+                          :nodes => [amqp, web]
+
+        multi.dispatcher.handle('method1') { |param|
+          rni1 = @rjr_node_id
+          rnt1 = @rjr_node_type
+          p1   = param
+          invoked1 = true
+          'retval1'
+        }
+        multi.dispatcher.handle('method2') { |param|
+          rni2 = @rjr_node_id
+          rnt2 = @rjr_node_type
+          p2   = param
+          invoked2 = true
+          'retval2'
+        }
+        multi.listen
+        # TODO should wait until we know server is listening
+
+        web_client  = Web.new
+        res = web_client.invoke 'http://localhost:9876', 'method2', 'myparam2'
+        res.should == 'retval2'
+        rni2.should == 'web'
+        rnt2.should == :web
+        p2.should == 'myparam2'
+
+        amqp_client = AMQP.new :node_id => 'client',
+                               :broker => 'localhost'
+        res = amqp_client.invoke 'amqp-queue', 'method1', 'myparam1'
+        res.should == 'retval1'
+        invoked1.should be_true
+        rni1.should == 'amqp'
+        rnt1.should == :amqp
+        p1.should == 'myparam1'
+
+        multi.halt.join
+      end
+    end
+  end # describe Multi
+
+end # module RJR::Nodes
+end # (!missing)

data/specs/nodes/tcp_spec.rb

@@ -0,0 +1,75 @@
+require 'rjr/nodes/tcp'
+
+module RJR::Nodes
+  describe TCP do
+    describe "#send_msg" do
+      it "should send message using the specifed connection"
+    end
+
+    describe "#listen" do
+      it "should listen for messages" do
+        ci = cp = rn = rni = rnt = p = invoked = nil
+        server  = TCP.new :node_id => 'tcp',
+                          :host => 'localhost', :port => 9987
+        server.dispatcher.handle('foobar') { |param|
+          ci  = @rjr_client_ip
+          cp  = @rjr_client_port
+          rn  = @rjr_node
+          rni = @rjr_node_id
+          rnt = @rjr_node_type
+          p   = param
+          invoked = true
+        }
+        server.listen
+
+        # issue request
+        TCP.new.invoke 'jsonrpc://localhost:9987', 'foobar', 'myparam'
+        server.halt.join
+        ci.should == "127.0.0.1"
+        #cp.should == 9987
+        rn.should == server
+        rni.should == 'tcp'
+        rnt.should == :tcp
+        p.should == 'myparam'
+        invoked.should == true
+      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'
+        }
+        server.listen
+
+        client = TCP.new
+        res = client.invoke 'jsonrpc://localhost:9987', 'foobar', 'myparam'
+        server.halt.join
+        res.should == 'retval'
+      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
+
+        client = TCP.new
+        res = client.notify 'jsonrpc://localhost:9987', 'foobar', 'myparam'
+        server.halt.join
+        res.should == nil
+      end
+    end
+
+    # TODO test callbacks over tcp interface
+    # TODO ensure closed / error event handlers are invoked
+  end
+end
+
+

data/specs/nodes/web_spec.rb

@@ -0,0 +1,77 @@
+require 'rjr/nodes/web'
+require 'rjr/nodes/missing'
+
+if RJR::Nodes::Web == RJR::Nodes::Missing
+puts "Missing Web node dependencies, skipping web tests"
+
+else
+module RJR::Nodes
+  describe Web do
+    describe "#send_msg" do
+      it "should send response using the specified connection"
+    end
+
+    describe "#listen" do
+      it "should listen for messages" do
+        ci = cp = rn = rni = rnt = p = invoked = nil
+        node = Web.new :node_id => 'www', :host => 'localhost', :port => 9678
+        node.dispatcher.handle('test') do |param|
+          ci  = @rjr_client_ip
+          cp  = @rjr_client_port
+          rn  = @rjr_node
+          rni = @rjr_node_id
+          rnt = @rjr_node_type
+          p   = param
+          invoked = true
+        end
+        node.listen
+
+        # issue request
+        Web.new.invoke 'http://localhost:9678', 'test', 'myparam'
+        node.halt.join
+        invoked.should be_true
+        ci.should == '127.0.0.1'
+        #cp.should
+        rn.should == node
+        rni.should == 'www'
+        rnt.should == :web
+        p.should   == 'myparam'
+      end
+    end
+
+    describe "#invoke" do
+      it "should invoke request" do
+        server = Web.new :node_id => 'www', :host => 'localhost', :port => 9678
+        server.dispatcher.handle('test') do |p|
+          'retval'
+        end
+        server.listen
+
+        client = Web.new
+        res = client.invoke 'http://localhost:9678', 'test', 'myparam'
+
+        server.halt.join
+        res.should == 'retval'
+      end
+    end
+
+    describe "#notify" do
+      it "should send notification" do
+        server = Web.new :node_id => 'www', :host => 'localhost', :port => 9678
+        server.dispatcher.handle('test') do |p|
+          'retval'
+        end
+        server.listen
+
+        client = Web.new
+        res = client.notify 'http://localhost:9678', 'test', 'myparam'
+
+        server.halt.join
+        res.should == nil
+      end
+    end
+
+    # TODO ensure closed / error event handlers are invoked
+  end # describe Web
+end # module RJR::Nodes
+end # (!missing)

data/specs/nodes/ws_spec.rb

@@ -0,0 +1,78 @@
+require 'rjr/nodes/ws'
+require 'rjr/nodes/missing'
+
+if RJR::Nodes::WS == RJR::Nodes::Missing
+puts "Missing Ws node dependencies, skipping ws tests"
+
+else
+module RJR::Nodes
+  describe WS do
+    describe "#send_msg" do
+      it "should send response using the specified connection"
+    end
+
+    describe "#listen" do
+      it "should listen for messages" do
+        ci = cp = rn = rni = rnt = p = invoked = nil
+        node = WS.new :node_id => 'ws', :host => 'localhost', :port => 9678
+        node.dispatcher.handle('test') do |param|
+          ci  = @rjr_client_ip
+          cp  = @rjr_client_port
+          rn  = @rjr_node
+          rni = @rjr_node_id
+          rnt = @rjr_node_type
+          p   = param
+          invoked = true
+        end
+        node.listen
+
+        # issue request
+        WS.new.invoke 'http://localhost:9678', 'test', 'myparam'
+        node.halt.join
+        invoked.should be_true
+        ci.should == '127.0.0.1'
+        #cp.should
+        rn.should == node
+        rni.should == 'ws'
+        rnt.should == :ws
+        p.should   == 'myparam'
+      end
+    end
+
+    describe "#invoke" do
+      it "should invoke request" do
+        server = WS.new :node_id => 'ws', :host => 'localhost', :port => 9678
+        server.dispatcher.handle('test') do |p|
+          'retval'
+        end
+        server.listen
+
+        client = WS.new
+        res = client.invoke 'http://localhost:9678', 'test', 'myparam'
+
+        server.halt.join
+        res.should == 'retval'
+      end
+    end
+
+    describe "#notify" do
+      it "should send notification" do
+        server = WS.new :node_id => 'ws', :host => 'localhost', :port => 9678
+        server.dispatcher.handle('test') do |p|
+          'retval'
+        end
+        server.listen
+
+        client = WS.new
+        res = client.notify 'http://localhost:9678', 'test', 'myparam'
+
+        server.halt.join
+        res.should == nil
+      end
+    end
+
+    # TODO test callbacks over ws interface
+    # TODO ensure closed / error event handlers are invoked
+  end # describe Ws
+end # module RJR::Nodes
+end # (!missing)

data/specs/stats_spec.rb

@@ -0,0 +1,59 @@
+require 'rjr/dispatcher'
+require 'rjr/stats'
+
+describe "#select_stats" do
+  before(:each) do
+    @d = RJR::Dispatcher.new
+
+    @req1   = RJR::Request.new :rjr_node_type => :local, :rjr_method => 'foobar'
+    @req1.result = RJR::Result.new :result => true
+
+    @req2   = RJR::Request.new :rjr_node_type => :tcp,   :rjr_method => 'barfoo'
+    @req2.result = RJR::Result.new :error_code => 123
+
+    @req3   = RJR::Request.new :rjr_node_type => :amqp,  :rjr_method => 'foobar'
+    @req3.result = RJR::Result.new :error_code => 123
+
+    # XXX not prettiest but works for now
+    @d.instance_variable_set(:@requests, [@req1, @req2, @req3])
+  end
+
+  it "should get all requests" do
+    requests = select_stats(@d)
+    requests.size.should  == 3
+    requests[0].should == @req1
+    requests[1].should == @req2
+    requests[2].should == @req3
+  end
+
+  it "should get all requests for a node" do
+    requests = select_stats @d, 'on_node', 'local'
+    requests.size.should == 1
+    requests.first.should == @req1
+  end
+
+  it "should get all requests for a method" do
+    requests = select_stats @d, 'for_method', 'foobar'
+    requests.size.should == 2
+    requests.first.should == @req1
+    requests.last.should  == @req3
+  end
+
+  it "should get all successfull/failed requests" do
+    requests = select_stats @d, 'successful'
+    requests.size.should == 1
+    requests.first.should == @req1
+
+    requests = select_stats @d, 'failed'
+    requests.size.should == 2
+    requests.first.should == @req2
+    requests.last.should  == @req3
+  end
+
+  it "should get dispatcher stats meeting multiple criteria" do
+    requests = select_stats @d, 'for_method', 'foobar', 'successful'
+    requests.size.should == 1
+    requests.first.should == @req1
+  end
+
+end

data/specs/thread_pool_spec.rb

@@ -1,41 +1,50 @@
-require 'rjr/dispatcher'
-require 'rjr/thread_pool2'
+require 'thread'
+require 'rjr/thread_pool'
 
 # TODO ? test ThreadPoolJob being_executed?, completed?, exec, handle_timeout!
 
-describe ThreadPool2 do
-  it "should start and stop successfully" do
-    tp = ThreadPool2.new 10, :timeout => 10
-    tp.running?.should be_false
-
-    tp.start
-    tp.running?.should be_true
-    tp.instance_variable_get(:@worker_threads).size.should == 10
-    tp.instance_variable_get(:@manager_thread).should_not be_nil
-    ['run', 'sleep'].should include(tp.instance_variable_get(:@manager_thread).status)
-    sleep 0.5
-
-    tp.stop
-    tp.running?.should be_false
-    tp.instance_variable_get(:@manager_thread).should be_nil
-    tp.instance_variable_get(:@worker_threads).size.should == 0
-  end
-
-  it "should accept and run work" do
-    tp = ThreadPool2.new 10, :timeout => 10
-    tp.start
-
-    tp.instance_variable_get(:@work_queue).size.should == 0
-    jobs_executed = []
-    tp << ThreadPool2Job.new { jobs_executed << 1 }
-    tp << ThreadPool2Job.new { jobs_executed << 2 }
-    tp.instance_variable_get(:@work_queue).size.should == 2
-
-    sleep 0.5
-    jobs_executed.should include(1)
-    jobs_executed.should include(2)
-    tp.instance_variable_get(:@work_queue).size.should == 0
+module RJR
+  describe ThreadPool do
+    after(:each) do
+      ThreadPool.instance.stop
+      ThreadPool.instance.join
+    end
+
+    it "should be a singleton" do
+      tp = ThreadPool.instance
+      ThreadPool.instance.should == tp
+    end
+
+    it "should start the thread pool" do
+      tp = ThreadPool.instance
+      tp.start
+      tp.instance_variable_get(:@worker_threads).size.should == ThreadPool.num_threads
+      tp.should be_running
+    end
+
+    it "should stop the thread pool" do
+      tp = ThreadPool.instance
+      tp.start
+      tp.stop
+      tp.join
+      tp.instance_variable_get(:@worker_threads).size.should == 0
+      tp.should_not be_running
+    end
+
+    it "should run work" do
+      tp = ThreadPool.instance
+      tp.start
+
+      jobs_executed = []
+      m,c = Mutex.new, ConditionVariable.new
+      tp << ThreadPoolJob.new { jobs_executed << 1 ; m.synchronize { c.signal } }
+      tp << ThreadPoolJob.new { jobs_executed << 2 ; m.synchronize { c.signal }  }
+
+      m.synchronize { c.wait m, 0.1 } unless jobs_executed.include?(1)
+      m.synchronize { c.wait m, 0.1 } unless jobs_executed.include?(2)
+      jobs_executed.should include(1)
+      jobs_executed.should include(2)
+    end
 
-    tp.stop
   end
 end