rjr 0.18.2 → 0.19.1

data/specs/em_adapter_spec.rb

@@ -1,5 +1,5 @@
 require 'thread'
-require 'rjr/em_adapter'
+require 'rjr/util/em_adapter'
 
 module RJR
   describe EMAdapter do
@@ -11,30 +11,43 @@ module RJR
       @em.halt.join
     end
 
-    it "should start the reactor" do
-      @em.start
-      @em.reactor_running?.should be_true
-      ['sleep', 'run'].should include(@em.reactor_thread.status)
-    end
+    describe "#start" do
+      it "should start the reactor" do
+        @em.start
+        @em.reactor_running?.should be_true
+        ['sleep', 'run'].should include(@em.reactor_thread.status)
+      end
 
-    it "should only start the reactor once" do
-      @em.start
+      it "should only start the reactor once" do
+        @em.start
 
-      ot = @em.reactor_thread
-      @em.start
-      @em.reactor_thread.should == ot
+        ot = @em.reactor_thread
+        @em.start
+        @em.reactor_thread.should == ot
+      end
     end
 
-    it "should halt the reactor" do
-      @em.start
+    describe "#stop" do
+      it "should halt the reactor" do
+        @em.start
 
-      @em.halt
-      @em.join
-      @em.reactor_running?.should be_false
-      @em.reactor_thread.should be_nil
+        @em.halt
+        @em.join
+        @em.reactor_running?.should be_false
+        @em.reactor_thread.should be_nil
+      end
+    end
+
+    describe "#join" do
+      it "joins reactor thread" do
+        th = Object.new
+        th.should_receive(:join).twice # XXX also called in after block above
+        @em.instance_variable_set(:@reactor_thread, th)
+        @em.join
+      end
     end
 
-    it "should dispatch all requests to eventmachine" do
+    it "should forward all messages to eventmachine" do
       @em.start
 
       invoked = false

data/specs/handles_methods_spec.rb

@@ -0,0 +1,154 @@
+require 'rjr/util/handles_methods'
+require 'rjr/dispatcher'
+
+module RJR
+  class HandlesMethodsTest
+    include HandlesMethods
+
+    jr_method :method1
+    jr_method :method2, :method3
+
+    jr_method :method4, :custom
+    jr_method :method5, :method6, :custom
+
+    def custom
+      @foo
+    end
+  end
+
+  describe HandlesMethods do
+    before(:each) do
+      @handlers = HandlesMethodsTest.jr_handlers
+      HandlesMethodsTest.jr_handlers = Hash[@handlers] if !!@handlers
+    end
+
+    after(:each) do
+      HandlesMethodsTest.jr_handlers = @handlers
+    end
+
+    describe "#extract_handler_method" do
+      context "args.last is a class method" do
+        it "returns args.last" do
+          result = HandlesMethodsTest.extract_handler_method([:method1, :custom])
+          result[0].should == :custom
+        end
+
+        it "returns argument list with args.last removed" do
+          result = HandlesMethodsTest.extract_handler_method([:method1, :custom])
+          result[1].should == [:method1]
+        end
+      end
+
+      context "args.last is not a class method" do
+        it "returns :handle" do
+          result = HandlesMethodsTest.extract_handler_method([:method1])
+          result[0].should == :handle
+        end
+
+        it "returns argument list" do
+          result = HandlesMethodsTest.extract_handler_method([:method1])
+          result[1].should == [:method1]
+        end
+      end
+    end
+
+    describe "#has_handler_for?" do
+      before(:each) do
+        HandlesMethodsTest.jr_handlers = {:handle => proc{}}
+      end
+
+      context "handler exists" do
+        it "returns true" do
+          HandlesMethodsTest.has_handler_for?(:handle).should be_true
+        end
+      end
+
+      context "handler does not exist" do
+        it "returns false" do
+          HandlesMethodsTest.has_handler_for?(:foobar).should be_false
+        end
+      end
+    end
+
+    describe "#handler_for" do
+      before(:each) do
+        HandlesMethodsTest.jr_handlers = {:custom => 'foobar'}
+      end
+
+      it "returns handler" do
+        HandlesMethodsTest.handler_for(:custom).should == 'foobar'
+      end
+    end
+
+    describe "#create_handler_for" do
+      it "store handler proc in handler registry" do
+        HandlesMethodsTest.create_handler_for(:foobar)
+        HandlesMethodsTest.jr_handlers[:foobar].should be_an_instance_of(Proc)
+      end
+
+      it "returns handler proc" do
+        HandlesMethodsTest.create_handler_for(:foobar).should ==
+          HandlesMethodsTest.jr_handlers[:foobar]
+      end
+
+      describe "handler" do
+        it "instantiates handler class" do
+          HandlesMethodsTest.should_receive(:new).and_call_original
+          HandlesMethodsTest.create_handler_for(:custom).call
+        end
+
+        it "sets local instance_variables on instance" do
+          @foo = 'bar'
+          inst = HandlesMethodsTest.new
+          HandlesMethodsTest.should_receive(:new).and_return(inst)
+          instance_exec &HandlesMethodsTest.create_handler_for(:custom)
+          inst.instance_variable_get(:@foo).should == 'bar'
+        end
+
+        it "invokes handler method with args" do
+          inst = HandlesMethodsTest.new
+          HandlesMethodsTest.should_receive(:new).twice.and_return(inst)
+          inst.should_receive(:custom).twice.with(42)
+          HandlesMethodsTest.create_handler_for(:custom).call 42
+          HandlesMethodsTest.jr_handlers[:custom].call 42
+        end
+
+        it "returns handler return value" do
+          @foo = 'bar'
+          instance_exec(&HandlesMethodsTest.create_handler_for(:custom)).should == @foo
+        end
+      end
+    end
+
+    describe "#jr_method" do
+      it "registers json-rpc methods for later evaluation" do
+        args = HandlesMethodsTest.instance_variable_get(:@jr_method_args)
+        args.should == [[:method1], [:method2, :method3],
+                        [:method4, :custom], [:method5, :method6, :custom]]
+      end
+    end
+
+    describe "#dispatch_to" do
+      it "registers json-rpc method with new handler" do
+        d = Dispatcher.new
+        HandlesMethodsTest.jr_handlers.should be_nil
+        HandlesMethodsTest.dispatch_to(d)
+        HandlesMethodsTest.jr_handlers.size.should == 2
+        HandlesMethodsTest.jr_handlers[:handle].should be_an_instance_of(Proc)
+        HandlesMethodsTest.jr_handlers[:custom].should be_an_instance_of(Proc)
+      end
+
+      it "registers local json rpc methods with dispatcher" do
+        d = Dispatcher.new
+        HandlesMethodsTest.dispatch_to(d)
+
+        d.handler_for('method1').should == HandlesMethodsTest.jr_handlers[:handle]
+        d.handler_for('method2').should == HandlesMethodsTest.jr_handlers[:handle]
+        d.handler_for('method3').should == HandlesMethodsTest.jr_handlers[:handle]
+        d.handler_for('method4').should == HandlesMethodsTest.jr_handlers[:custom]
+        d.handler_for('method5').should == HandlesMethodsTest.jr_handlers[:custom]
+        d.handler_for('method6').should == HandlesMethodsTest.jr_handlers[:custom]
+      end
+    end
+  end
+end

data/specs/has_messages_spec.rb

@@ -0,0 +1,54 @@
+require 'rjr/util/has_messages'
+
+module RJR
+  class HasMessagesTest
+    include HasMessages
+  end
+
+  describe HasMessages do
+    after(:each) do
+      HasMessagesTest.clear_messages
+    end
+
+    describe "#define_message" do
+      it "defines new message" do
+        HasMessagesTest.new.define_message('foobar') { 'barfoo' }
+        HasMessagesTest.message('foobar').should == 'barfoo'
+      end
+    end
+
+    describe "::message" do
+      it "sets/gets message" do
+        HasMessagesTest.message('foobar', 'barfoo')
+        HasMessagesTest.message('foobar').should == 'barfoo'
+      end
+    end
+
+    describe "::clear_messages" do
+      it "clears messages" do
+        HasMessagesTest.message('foobar', 'barfoo')
+        HasMessagesTest.clear_messages
+        HasMessagesTest.message('foobar').should be_nil
+      end
+    end
+
+    describe "#rand_message" do
+      it "returns random message" do
+        msg1 = {}
+        msg2 = {}
+        HasMessagesTest.message('foobar', msg1)
+        HasMessagesTest.message('barfoo', msg2)
+        HasMessagesTest.should_receive(:rand).and_return(1)
+        HasMessagesTest.rand_message.should == msg2
+      end
+
+      it "returns random message matching specified transport" do
+        tcpm  = {:transports => ['tcp']}
+        amqpm = {:transports => ['amqp']}
+        HasMessagesTest.message('foobar', tcpm)
+        HasMessagesTest.message('barfoo', amqpm)
+        HasMessagesTest.rand_message('tcp').should == tcpm
+      end
+    end
+  end # describe HasMessages
+end # module RJR

data/specs/inspect_spec.rb

@@ -1,5 +1,5 @@
+require 'rjr/util/inspect'
 require 'rjr/dispatcher'
-require 'rjr/inspect'
 
 describe "#select_stats" do
   before(:each) do

data/specs/json_parser_spec.rb

@@ -0,0 +1,169 @@
+require 'rjr/util/json_parser'
+
+module RJR
+describe JSONParser do
+  describe "#extract_json_from" do
+    it "returns first json object from string" do
+      json = '{"foo":"bar"}'
+      JSONParser.extract_json_from(json).should == [json, '']
+    end
+
+    it "returns remaining portion of string" do
+      json = '{"foo":"bar"}'
+      complete = "#{json}remaining"
+      JSONParser.extract_json_from(complete).should == [json, 'remaining']
+    end
+  end
+
+  describe "#invalid_json_class?" do
+    before(:each) do
+      @orig_whitelist = Class.whitelist_json_classes
+    end
+
+    after(:each) do
+      Class.whitelist_json_classes = @orig_whitelist
+    end
+
+    context "json class whitelisting enabled" do
+      before(:each) do
+        Class.whitelist_json_classes = true
+      end
+
+      context "class not on permitted classes list" do
+        it "returns true" do
+          Class.should_receive(:permitted_json_classes).and_return([])
+          JSONParser.invalid_json_class?('foobar').should be_true
+        end
+      end
+
+      context "class on permitted classes list" do
+        it "returns false" do
+          Class.should_receive(:permitted_json_classes).and_return(['foobar'])
+          JSONParser.invalid_json_class?('foobar').should be_false
+        end
+      end
+    end
+
+    context "json class whitelisting not enabled" do
+      before(:each) do
+        Class.whitelist_json_classes = false
+      end
+
+      context "class not on ruby heirarchy" do
+        it "returns true" do
+          JSONParser.invalid_json_class?('Foobar').should be_true
+        end
+      end
+
+      context "class on ruby heirarchy" do
+        it "returns false" do
+          JSONParser.invalid_json_class?('Integer').should be_false
+        end
+      end
+    end
+  end
+
+  describe "#validate_json_hash" do
+    context "a hash key is the JSON.create_id and value is invalid class" do
+      it "raises argument error" do
+        hash = {JSON.create_id => 'foobar'}
+        JSONParser.should_receive(:invalid_json_class?).
+                   with('foobar').and_return(true)
+        lambda{
+          JSONParser.validate_json_hash(hash)
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context "a value is an array" do
+      it "validates json array" do
+        arr  = []
+        hash = {'foobar' => arr}
+        JSONParser.should_receive(:validate_json_array).with(arr)
+        JSONParser.validate_json_hash(hash)
+      end
+    end
+
+    context "a value is a hash" do
+      it "validates json hash" do
+        inner  = {}
+        hash = {'foobar' => inner}
+        JSONParser.should_receive(:validate_json_hash).with(hash).and_call_original
+        JSONParser.should_receive(:validate_json_hash).with(inner)
+        JSONParser.validate_json_hash(hash)
+      end
+    end
+  end
+
+  describe "#validate_json_array" do
+    context "a value is an array" do
+      it "validates json array" do
+        inner = []
+        array = [inner]
+        JSONParser.should_receive(:validate_json_array).with(array).and_call_original
+        JSONParser.should_receive(:validate_json_array).with(inner)
+        JSONParser.validate_json_array(array)
+      end
+    end
+
+    context "a value is a hash" do
+      it "validates json hash" do
+        inner = {}
+        array = [inner]
+        JSONParser.should_receive(:validate_json_hash).with(inner)
+        JSONParser.validate_json_array(array)
+      end
+    end
+  end
+
+  describe "#parse" do
+    before(:each) do
+      @json = '{"foo":"bar"}'
+    end
+
+    it "safely parses json" do
+      JSON.should_receive(:parse).
+           with(@json, :create_additions => false).and_call_original
+      JSON.should_receive(:parse).once
+      JSONParser.parse(@json)
+    end
+
+    context "json is an array" do
+      it "validates json array" do
+        arr = []
+        JSON.should_receive(:parse).and_return(arr)
+        JSON.should_receive(:parse).once
+        JSONParser.should_receive(:validate_json_array).with(arr)
+        JSONParser.parse(@json)
+      end
+    end
+
+    context "json is a hash" do
+      it "validates json hash" do
+        hash = {}
+        JSON.should_receive(:parse).and_return(hash)
+        JSON.should_receive(:parse).once
+        JSONParser.should_receive(:validate_json_hash).with(hash)
+        JSONParser.parse(@json)
+      end
+    end
+
+    context "json is not a array/hash" do
+      it "returns value" do
+        JSON.should_receive(:parse).and_return(42)
+        JSONParser.parse(@json).should == 42
+      end
+    end
+
+    it "parses json, creating classes" do
+      njs = {}
+      JSON.should_receive(:parse).
+           with(@json, :create_additions => false).and_call_original
+      JSON.should_receive(:parse).
+           with(@json, :create_additions => true).
+           and_return(njs)
+      JSONParser.parse(@json).should == njs
+    end
+  end
+end # describe JSONParser
+end # module RJR