em-dextras 0.2.0 → 0.3.0

data/spec/em-dextras/chains_spec.rb

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
-describe EMDextras::Chains do 
+describe EMDextras::Chains do
+  class EchoStage
+    def todo(input)
+      EMDextras::Chains::Deferrables.succeeded(input)
+    end
+  end
+
   class ProduceStage
     def initialize(result)
       @result = result
@@ -24,7 +30,13 @@ describe EMDextras::Chains do
 
   class ErrorStage
     def todo(input)
-      EMDextras::Chains::Deferrables.failed "Failed with #{input}"
+      EMDextras::Chains::Deferrables.failed input
+    end
+  end
+
+  class InvalidStage
+    def todo(input)
+      "not-a-deferrable"
     end
   end
 
@@ -43,52 +55,200 @@ describe EMDextras::Chains do
     end
   end
 
-  let(:monitoring) { mock.as_null_object }
-  
-  it "should chain todo stages" do
-    EM.run do 
-      inputs = []
+  class InterruptChainStage
+    def todo(ignored)
+      deferrable = EventMachine::DefaultDeferrable.new
+      deferrable.succeed()
+      deferrable
+    end
+  end
+
+  let(:monitoring) { EMDextras::Spec::Spy.new }
+
+  context " - when all stages succeed -" do
+    it "should chain todo stages" do
+      EM.run do
+        inputs = []
+
+        EMDextras::Chains.pipe("input", monitoring, [
+          SpyStage.new(inputs),
+          SpyStage.new(inputs),
+          StopStage.new
+        ])
+
+        inputs.should == ["input", "input"]
+      end
+    end
 
-      EMDextras::Chains.pipe("input", monitoring, [
-        SpyStage.new(inputs),
-        SpyStage.new(inputs),
-        StopStage.new
-      ])
+    it "should return a deferrable with the result of the last step" do
+      EM.run do
+        result = EMDextras::Chains.pipe("ignored", monitoring, [
+          ProduceStage.new("out")
+        ])
 
-      inputs.should == ["input", "input"]
+        result.should succeed_with("out")
+      end
     end
   end
 
-  it "should notify monitoring of any exceptions" do
-    EM.run do
-      monitoring.should_receive(:inform_exception!) do 
-        EM.stop
+  context " - when a stage fails - " do
+    it "should fail the resulting deferrable" do
+      EM.run do
+        result = EMDextras::Chains.pipe("error", monitoring, [
+          EchoStage.new,
+          ErrorStage.new,
+          ProduceStage.new(42)
+        ])
+
+        result.should fail_with("error")
+      end
+    end
+
+    it "should not proceed with the chain" do
+      EM.run do
+        produced = []
+
+        result = EMDextras::Chains.pipe("in", monitoring, [
+          SpyStage.new(produced),
+          ErrorStage.new,
+          SpyStage.new(produced)
+        ])
+
+        probe_event_machine check: (Proc.new do
+          produced.should == ["in"]
+        end)
       end
+    end
+  end
+
+  context "- interruption -" do
+    it "should interrupt the chain when a stage returns an empty succeeded deferrable" do
+      EM.run do
+        input = []
 
-      EM.add_timer(2) do
-        fail("timeout")
+        EMDextras::Chains.pipe("input", monitoring, [
+          ProduceStage.new("x"),
+          InterruptChainStage.new,
+          SpyStage.new(input)
+        ])
+
+        probe_event_machine check: (Proc.new do
+          input.should == []
+        end)
       end
+    end
 
-      EMDextras::Chains.pipe("anything", monitoring, [ErrorStage.new]);
+    it "should notify the monitor that the chain ended (with nil value)" do
+      EM.run do
+        input = []
+
+        monitoring = EMDextras::Spec::Spy.new
+
+        EMDextras::Chains.pipe("input", monitoring, [
+          ProduceStage.new("x"),
+          InterruptChainStage.new,
+          SpyStage.new(input)
+        ])
+
+        monitoring.received_call!(:end_of_chain!, nil)
+      end
     end
   end
 
-  it "should pass a 'context' object if given and the stage takes one" do
-    contextual_stage = ContextualStage.new
-    
-    EM.run do 
-      EMDextras::Chains.pipe("anything", monitoring, [
-        contextual_stage,
-        StopStage.new
-      ], :context => "the context")
+  context "- monitoring -" do
+    it "should notify monitoring of any exceptions" do
+      EM.run do
+        EMDextras::Chains.pipe("anything", monitoring, [ErrorStage.new]);
+
+        monitoring.received_call!(:inform_exception!, any_args)
+      end
+    end
+
+    it "should pass the context to monitoring.inform_exception if given" do
+      EM.run do 
+        error_stage = ErrorStage.new
+
+        EMDextras::Chains.pipe("input", monitoring, [
+          error_stage
+        ], context: "the context")
+
+        monitoring.received_call!(:inform_exception!, "input", error_stage, "the context")
+      end
+    end
+
+    it "should notify monitoring of the end of the pipeline" do
+      EM.run do
+        monitoring = EMDextras::Spec::Spy.new
+        EMDextras::Chains.pipe("x", monitoring, [
+          ProduceStage.new("y"),
+          SpyStage.new([]),
+          ProduceStage.new("z")
+        ])
+
+        monitoring.received_call!(:end_of_chain!, "z")
+      end
+    end
+
+    it "should notify monitoring of the end of the pipeline even when a stage fails" do
+      EM.run do
+        monitoring = EMDextras::Spec::Spy.new
+
+        EMDextras::Chains.pipe("x", monitoring, [
+          ProduceStage.new("y"),
+          ErrorStage.new,
+          ProduceStage.new("z")
+        ])
+
+        monitoring.received_call!(:end_of_chain!, "y")
+      end
+    end
+
+    context 'when monitoring does not respond to end_of_chain' do
+      it 'does not to try to call that method' do
+        EM.run do
+          monitoring = EMDextras::Spec::Spy.new only_respond_to: [:this_method]
+
+          EMDextras::Chains.pipe('x', monitoring, [
+            ProduceStage.new('y'),
+            SpyStage.new([]),
+            ProduceStage.new('z')
+          ])
+
+          monitoring.not_received_call!(:end_of_chain!, 'z')
+        end
+      end
+    end
+  end
+
+  context " - context - " do
+    it "should pass a 'context' object if given and the stage takes one" do
+      contextual_stage = ContextualStage.new
+
+      EM.run do
+        EMDextras::Chains.pipe("anything", monitoring, [
+          contextual_stage,
+          StopStage.new
+        ], :context => "the context")
+
+        probe_event_machine :check => lambda {|x|
+          contextual_stage.context.should == "the context"
+        }
+      end
+    end
+
+    it "should pass the contect object to monitoring if given" do
+      EM.run do
+        monitoring = EMDextras::Spec::Spy.new
+        EMDextras::Chains.pipe("x", monitoring, [
+          ProduceStage.new("y"),
+        ], context: "the context")
 
-      probe_event_machine :check => lambda {|x|
-        contextual_stage.context.should == "the context"
-      }
+        monitoring.received_call!(:end_of_chain!, "y", "the context")
+      end
     end
   end
 
-  context "when given a :split stage" do 
+  context "when given a :split stage" do
     context "and the input is enumberable" do
       it "should invoke the next step the given number of times" do
         EM.run do
@@ -105,6 +265,26 @@ describe EMDextras::Chains do
         end
       end
 
+      it "successive splits should recursively divide the pipeline" do
+        EM.run do
+          final_inputs = []
+          intermediate_inputs = []
+
+          EMDextras::Chains.pipe("anything", monitoring, [
+            ProduceStage.new([1,2]),
+            :split,
+            SpyStage.new(intermediate_inputs),
+            ProduceStage.new([3,4]),
+            :split,
+            SpyStage.new(final_inputs),
+            StopStage.new
+          ])
+
+          intermediate_inputs.should =~ [1,2]
+          final_inputs.should =~ [3,4,3,4]
+        end
+      end
+
       it "should split the given context" do
         before = ContextualStage.new
         after = ContextualStage.new
@@ -114,7 +294,7 @@ describe EMDextras::Chains do
 
         first_context.stub(:split).and_return second_context
 
-        EM.run do 
+        EM.run do
           EMDextras::Chains.pipe("anything", monitoring, [
             before,
             ProduceStage.new([1,2]),
@@ -128,27 +308,127 @@ describe EMDextras::Chains do
           }
         end
       end
-    end
+      
+      it "should return a deferrable acccumulating the results of the last step" do
+        EM.run do
+          result = EMDextras::Chains.pipe("anything", monitoring, [
+            ProduceStage.new([1,2]),
+            :split,
+            SpyStage.new([])
+          ])
 
-    context "and the input is not enumberable" do
-      it "will terminate the chain and report the error as an exception" do
-        EM.run do 
-          monitoring.should_receive(:inform_exception!) do 
-            EM.stop
+          result.should succeed_with([1,2])
+        end
+      end
+
+      it "should return a deferrable with the result of the last step, accumulating results for multiple splits" do
+        EM.run do
+          result = EMDextras::Chains.pipe("anything", monitoring, [
+            ProduceStage.new([1,2]),
+            :split,
+            ProduceStage.new([3,4]),
+            :split,
+            SpyStage.new([])
+          ])
+
+          result.should succeed_with([[3,4],[3,4]])
+        end
+      end
+
+      context " - corner cases -" do
+        it "should handle a split as first chain element" do
+          EM.run do
+            results = []
+            EMDextras::Chains.pipe([1,2,3], monitoring, [
+              :split,
+              SpyStage.new(results)
+            ])
+            probe_event_machine :check => (lambda {|x|
+              results.should == [1,2,3]
+            })
+          end
+        end
+
+        it "should return the deferrable result even if split is the first argument" do
+          EM.run do
+            res = EMDextras::Chains.pipe([1,2,3], monitoring, [
+              :split,
+              EchoStage.new
+            ])
+
+            res.should succeed_with([1,2,3])
           end
+        end
 
-          EM.add_timer(2) do
-            fail("timeout")
+        it "should handle a split as last chain element" do
+          EM.run do
+            result = EMDextras::Chains.pipe('ignored', monitoring, [
+              ProduceStage.new([1,2,3]),
+              :split
+            ])
+
+            result.should succeed_with([1,2,3])
           end
+        end
+      end
+
+      context " - splits and monitoring - " do
+        it "should inform monitoring that the pipeline ended only once" do
+          EM.run do
+            monitoring = EMDextras::Spec::Spy.new
 
+            EMDextras::Chains.pipe("anything", monitoring, [
+              ProduceStage.new([1,2]),
+              :split,
+              ProduceStage.new([3,4]),
+              :split,
+              SpyStage.new([])
+            ])
+
+            monitoring.received_n_calls!(1, :end_of_chain!, [[3,4],[3,4]])
+          end
+        end
+
+        it "should inform monitoring that the pipeline ended with context if given" do
+          EM.run do
+            monitoring = EMDextras::Spec::Spy.new
+
+            EMDextras::Chains.pipe("anything", monitoring, [
+              ProduceStage.new([1,2]),
+              :split,
+              ProduceStage.new([3,4]),
+              :split,
+              SpyStage.new([])
+            ], context: :the_context)
+
+            monitoring.received_n_calls!(1, :end_of_chain!, [[3,4],[3,4]], :the_context)
+          end
+        end
+      end
+    end
+
+    context "and the input is not enumberable" do
+      it "will terminate the chain and report the error as an exception" do
+        EM.run do
           EMDextras::Chains.pipe("anything", monitoring, [
             ProduceStage.new(:not_enumberable_input),
             :split,
             SpyStage.new([]),
             StopStage.new
           ])
+          monitoring.received_call!(:inform_exception!, any_args)
         end
       end
     end
   end
+
+  context " - input validation - " do
+    it "should raise an exception when a stage doesn't return a deferrable" do
+      expect {EM.run do
+        EMDextras::Chains.pipe("the input", monitoring, [
+          InvalidStage.new
+        ])
+      end}.to raise_error(EMDextras::Chains::InvalidStage, /.*'InvalidStage'.*'the input'.*'not-a-deferrable'.*/)
+    end
+  end
 end

data/spec/em-dextras/extension/object/deferrable_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'em-dextras/extension/object/deferrable'
+
+describe "EventMachine::Deferrable extensions"  do
+  context "when the deferrable is succeeded" do
+    it 'returns a new one deferrable with a yielded value' do
+      EM.run do
+        deferrable = EventMachine::DefaultDeferrable.new
+
+        result_deferrable = deferrable.map do |parameter|
+          "transformed-#{parameter}"
+        end
+
+        deferrable.succeed('from-succeed')
+
+        result_deferrable.should succeed_with('transformed-from-succeed')
+      end
+    end
+  end
+
+  context "when the deferrable fails" do
+    it 'returns a new one failed deferrable' do
+      EM.run do
+        deferrable = EventMachine::DefaultDeferrable.new
+
+        result_deferrable = deferrable.map do |parameter|
+          "transformed-#{parameter}"
+        end
+
+        deferrable.fail('from-fail')
+
+        result_deferrable.should fail_with('from-fail')
+      end
+    end
+  end
+end

data/spec/em-dextras/spec/spec_matchers_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe 'Spec Matchers' do
+  describe :succeed_with do
+    it "should accept a successful deferrable with the given value" do
+      EM.run do
+        success = EMDextras::Chains::Deferrables.succeeded("ok")
+        success.should succeed_with("ok")
+      end
+    end
+
+    it "should accept a deferrable if it eventually succeeds" do
+      EM.run do
+        deferrable = EventMachine::DefaultDeferrable.new
+        EM.next_tick do
+          deferrable.succeed("ok")
+        end
+        deferrable.should succeed_with("ok")
+      end
+    end
+
+    it "should reject a successful deferrable with a different value" do
+      expect {EM.run do
+        success = EMDextras::Chains::Deferrables.succeeded("not ok")
+        success.should succeed_with("ok")
+      end}.to raise_error
+    end
+
+    it "should reject a failed deferrable" do
+      expect {EM.run do
+        success = EMDextras::Chains::Deferrables.failed("any")
+        success.should succeed_with("ok")
+      end}.to raise_error
+    end
+  end
+
+  describe :fail_with do
+    it "should accept a failure with the expected value" do
+      EM.run do
+        failure = EMDextras::Chains::Deferrables.failed("expected")
+        failure.should fail_with("expected")
+      end
+    end
+
+    it "should reject a success" do
+      expect {EM.run do
+        presumed_failure = EMDextras::Chains::Deferrables.succeeded("expected")
+        presumed_failure.should fail_with("expected")
+      end}.to raise_error
+    end
+
+    it "should timeout if nothing happens" do
+      expect {EM.run do
+        presumed_failure = EventMachine::DefaultDeferrable.new
+        presumed_failure.should fail_with("expected")
+      end}.to raise_error
+    end
+    
+  end
+  
+  describe :succeed_according_to do
+    it "should accept if the block eventually yields without raising" do
+      EM.run do
+        deferrable = EventMachine::DefaultDeferrable.new
+        EM.next_tick { deferrable.succeed("ok") }
+        deferrable.should succeed_according_to(lambda do |value|
+          value.should == "ok"
+        end)
+      end
+    end
+
+    it "should reject if the block never yields without raising while probing" do
+      expect {EM.run do
+        deferrable = EventMachine::DefaultDeferrable.new
+        deferrable.should succeed_according_to(lambda do |value|
+          value.should == "ok"
+        end)
+      end}.to raise_error
+    end
+  end
+end

data/spec/em-dextras/spec/spy_spec.rb

@@ -2,19 +2,20 @@ require 'spec_helper'
 
 describe EMDextras::Spec::Spy do
   subject { described_class.new }
+
   describe :"called?" do
     it "should record calls" do
       subject.foo(1, :a => "b")
-    
+
       subject.called?(:foo, 1, :a => "b").should be_true
       subject.called?(:bar, 1, :a => "b").should be_false
       subject.called?(:foo, 1, :a => "c").should be_false
-    end  
+    end
   end
 
   describe "default return value" do
     it "returns nil if no default return value is defined" do
-      spy = EMDextras::Spec::Spy.new 
+      spy = EMDextras::Spec::Spy.new
       spy.some_method.should == nil
     end
 
@@ -23,9 +24,36 @@ describe EMDextras::Spec::Spy do
       spy.some_method.should == "default"
     end
   end
+
+  describe :respond_to? do
+    context 'without respond parameter' do
+      let(:spy) { described_class.new }
+
+      it 'always returns true' do
+        spy.respond_to?(:method_name).should be_true
+      end
+    end
+
+    context 'with respond parameter on initialize' do
+      let(:spy) { described_class.new only_respond_to: [:foo] }
+
+      context 'and asking if it respond for the same method of initialize' do
+        it 'returns true' do
+          spy.respond_to?(:foo).should be_true
+        end
+      end
+
+      context 'and asking if it respond for the a method different of the initialize' do
+        it 'returns false' do
+          spy.respond_to?(:bar).should be_false
+        end
+      end
+    end
+  end
+
   describe :received_call! do
     it "should do nothing if the call was really received" do
-      EM.run do 
+      EM.run do
         subject.foo(1, :a => "b")
 
         subject.received_call!(:foo, 1, :a => "b")
@@ -34,25 +62,96 @@ describe EMDextras::Spec::Spy do
 
     it "should raise an exception if the call was not received" do
       expect {
-        EM.run do 
+        EM.run do
           subject.foo(1, :a => "b")
-        
+
           subject.received_call!(:bar, 1, :a => "b")
         end
       }.to raise_error(/bar.*foo/)
     end
 
+    context " - rspec argument matchers - " do
+      it "should accept rspec specific argument matchers"  do
+        subject.foo(1, "banana")
+
+        EM.run { subject.received_call!(:foo, 1, /ba(na)*/) } #doesn't raise
+        EM.run { subject.received_call!(:foo, 1, instance_of(String)) } #doesn't raise
+        expect {EM.run { subject.received_call!(:foo, 1, /apple/) } }.to raise_error
+      end
+
+      it "should accept rspec general matchers" do
+        subject.foo(1, "banana")
+
+        EM.run { subject.received_call!(:foo, any_args) } #doesn't raise
+      end
+    end
+
+    it "should be able to assert that a method will receive nil" do
+      EM.run do
+        subject.foobar(nil)
+
+        subject.received_call!(:foobar, nil)
+      end
+    end
+
     context "when the method is triggered asynchronously" do
       it "should should probe until the call is received" do
         EM.run do
-          EM.next_tick do 
+          EM.next_tick do
             subject.foo(1,2,3)
           end
-  
+
           subject.received_call!(:foo, 1,2,3)
         end
       end
     end
   end
 
+  describe :received_n_calls! do
+    it "should do nothing if the call was received the given number of tiems" do
+      EM.run do
+        subject.foo(42, :a => "b")
+        subject.foo(42, :a => "b")
+
+        subject.received_n_calls!(2, :foo, 42, :a => "b")
+      end
+    end
+
+    it "should raise an exception if the call was not received" do
+      expect {
+        EM.run do
+          subject.received_n_calls!(1, :bar, :a => "b")
+        end
+      }.to raise_error(/1.*0/)
+    end
+
+    it "should raise an exception if the call was received a number of times less than what was expected" do
+      expect {
+        EM.run do
+          subject.foo(:a => "b")
+
+          subject.received_n_calls!(2, :foo, :a => "b")
+        end
+      }.to raise_error(/2.*1/)
+    end
+
+  end
+
+   describe :not_received_call! do
+    it 'does not be called' do
+      EM.run do
+        subject.not_received_call!(:foo, a: 'b')
+      end
+    end
+
+    it 'raises an exception if the call was received' do
+      expect {
+        EM.run do
+          subject.foo(a: 'b')
+
+          subject.not_received_call!(:foo, a: 'b')
+        end
+      }.to raise_error
+    end
+  end
 end