amqp-spec 0.3.3 → 0.3.4

data/HISTORY

@@ -69,3 +69,7 @@
 == 0.3.3 / 2010-11-24
 
 * Spec timeout refactored
+
+== 0.3.4 / 2010-11-26
+
+* amqp_before/after hooks added

data/README.rdoc

@@ -10,20 +10,21 @@ Simple API for writing asynchronous EventMachine/AMQP specs. Supports RSpec and
 
 EventMachine-based code, including synchronous {AMQP library}[http://github.com/tmm1/amqp]
 is notoriously difficult to test. To the point that many people recommend using either
-Mocks[http://github.com/danielsdeleo/moqueue] or {synchronous}[http://github.com/celldee/bunny]
-libraries instead of EM-based libraries in unit tests. This is not always an option, however -
-sometimes your code just has to run inside the event loop, and you want to test a real thing,
-not mocks.
+Mocks[http://github.com/danielsdeleo/moqueue]
+or {synchronous libraries}[http://github.com/celldee/bunny]
+instead of EM-based libraries in unit tests. This is not always an option, however -
+sometimes your code just has to run inside the event loop, and you want to test a real
+thing, not just mocks.
 
 EM-Spec[http://github.com/tmm1/em-spec] gem made it easier to write evented specs, but it
 has several drawbacks. First, it is not easy to manage both EM.run and AMQP.start loops
 at the same time. Second, AMQP is not properly stopped and deactivated upon exceptions and
 timeouts, resulting in state leak between examples and multiple mystereous failures.
 
-AMQP-Spec is based on EM-Spec code but makes it easier to test AMQP event loops specifically.
-API is very similar to EM-Spec's, only a bit extended. The final goal is to make writing AMQP
-specs reasonably pleasant experience and dispel the notion that evented AMQP-based libs are
-impossible to unit-test.
+AMQP-Spec is based on EM-Spec code but makes it easier to test AMQP event loops
+specifically. API is very similar to EM-Spec's, only a bit extended. The final goal is to
+make writing AMQP specs reasonably pleasant experience and dispel the notion that evented
+AMQP-based libs are impossible to unit-test.
 
 Mind you, you still have to properly manage your AMQP broker in order to prevent broker
 state from leaking between examples. You can try to combine AMQP-Spec and
@@ -45,8 +46,15 @@ this is different from EM-Spec where default_timeout is effectively a global set
 
 In order to setup/teardown EM state before/after your examples, you'll need to use
 *em_before* and *em_after* hooks. These hooks are similar to standard RSpec's
-*before/after* hooks but run inside the EM event loop before/after your example block.
-If you are using
+*before*/*after* hooks but run inside the EM event loop before/after your example block.
+If you are using #amqp method, *em_before* hook will run just BEFORE AMQP connection is
+attempted, and *em_after* is run after AMQP is stopped.
+
+Sometimes, may want to setup/teardown state inside AMQP connection (inside block given to
+AMQP.start): for example, to make sure that the connection is established before your
+example runs, or pre-declare some queues and exchanges common for all examples.
+In this case, please use *amqp_before* and *amqp_after* hooks. These hooks run inside
+the AMQP.start block just before/after your example block.
 
   require "amqp-spec/rspec"
 
@@ -96,9 +104,12 @@ will run in its separate EM loop that you'll need to shut down either manually (
 via timeout. Essentially, this means that any EM-related state that you'd like to set up or
 tear down using these hooks will be lost as example itself will run in a different EM loop.
 
-In short, you should avoid using *before/after* if you include AMQP::Spec - instead, use
-*em_before/em_after* hooks that run inside the EM event loop. One more note: you don't need
-to call #done inside *em_before/em_after*, otherwise it'll shut down the reactor.
+In short, you should avoid using *before*/*after* if you include AMQP::Spec - instead, use
+*em_before*/*em_after* or *amqp_before*/*amqp_after* hooks that run inside the EM event
+loop.
+
+One more note: you don't need to call #done inside evented hooks, otherwise it'll shut down
+the EM reactor.
 
 
   describe AMQP do
@@ -133,8 +144,9 @@ to call #done inside *em_before/em_after*, otherwise it'll shut down the reactor
   end
 
 Finally, you can include AMQP::EMSpec in your describe block. This will run all the group
-examples inside em block instead of amqp. Non-evented *before/after* hooks should be finished
-with #done, same as when including AMQP::Spec, and same caution about using them applies.
+examples inside em block instead of amqp. Non-evented *before*/*after* hooks should be
+finished with #done, same as when including AMQP::Spec, and same caution about using them
+applies.
 
   describe AMQP do
     include AMQP::EMSpec
@@ -189,14 +201,14 @@ Take the following spec as an example:
 Seems like a straightforward spec: you subscribe to a message queue, you set expectations
 inside your subscribe block, then you publish into this queue, then you call done. What may
 be wrong with it? Well, if you happen to use this spec against live AMQP broker, everything
-may be wrong. First, communication delays. There is no guarantee that by the time you publish
-your message, the queue have been either created or subscribed to. There is also no guarantee
-that your subscriber received the message by the time you are unsubscribing and deleting your
-queue. Second, sequence of your blocks. Remember, they are delayed callbacks! Don't just
-assume your previous block is already executed when you start your new asynchronous action.
-In this spec, when done is called, it stops everything before your subscribe callback even
-has a chance to fire. As a result, you'll get a PASSING spec even though your expectation
-was never executed!
+may be wrong. First, communication delays. There is no guarantee that by the time you
+publish your message, the queue have been either created or subscribed to. There is also
+no guarantee that your subscriber received the message by the time you are unsubscribing
+and deleting your queue. Second, sequence of your blocks. Remember they are delayed
+callbacks! Don't just assume your previous block is already executed when you start your
+new asynchronous action. In this spec, when done is called, it stops everything before your
+subscribe callback even has a chance to fire. As a result, you'll get a PASSING spec even
+though your expectation was never executed!
 
 How to improve this spec? Allow some time for async actions to finish: either use EM timers
 or pass :nowait=>false to your asynch calls to force them into synchronicity. Keep in mind

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.3.4

data/lib/amqp-spec/evented_example.rb

@@ -57,7 +57,7 @@ module AMQP
       def run_em_loop
         begin
           EM.run do
-            run_em_hooks :before
+            run_em_hooks :em_before
 
             @spec_exception = nil
             timeout(@opts[:spec_timeout]) if @opts[:spec_timeout]
@@ -70,7 +70,7 @@ module AMQP
           end
         rescue Exception => @spec_exception
 #          p "Outside loop, caught #{@spec_exception}"
-          run_em_hooks :after # Event loop broken, but we still need to run em_after hooks
+          run_em_hooks :em_after # Event loop broken, but we still need to run em_after hooks
         ensure
           finish_example
         end
@@ -79,7 +79,7 @@ module AMQP
       # Stops EM event loop. It is called from #done
       #
       def finish_em_loop
-        run_em_hooks :after
+        run_em_hooks :em_after
         EM.stop_event_loop if EM.reactor_running?
       end
 
@@ -88,7 +88,6 @@ module AMQP
       # Descendant classes may redefine to clean up type-specific state.
       #
       def finish_example
-#        p @spec_exception if @spec_exception
         raise @spec_exception if @spec_exception
       end
 
@@ -123,7 +122,10 @@ module AMQP
       # Run @block inside the AMQP.start loop
       def run
         run_em_loop do
-          AMQP.start_connection @opts, &@block
+          AMQP.start_connection @opts, do
+            run_em_hooks :amqp_before
+            @block.call
+          end
         end
       end
 
@@ -134,11 +136,14 @@ module AMQP
         super(delay) do
           yield if block_given?
           EM.next_tick do
+            run_em_hooks :amqp_after
             if AMQP.conn and not AMQP.closing
               AMQP.stop_connection do
+                AMQP.cleanup_state
                 finish_em_loop
               end
             else
+              AMQP.cleanup_state
               finish_em_loop
             end
           end

data/lib/amqp-spec/rspec.rb

@@ -69,21 +69,35 @@ module AMQP
       # Add before hook that will run inside EM event loop
       def em_before scope = :each, &block
         raise ArgumentError, "em_before only supports :each scope" unless :each == scope
-        em_hooks[:before] << block
+        em_hooks[:em_before] << block
       end
 
       # Add after hook that will run inside EM event loop
       def em_after scope = :each, &block
         raise ArgumentError, "em_after only supports :each scope" unless :each == scope
-        em_hooks[:after].unshift block
+        em_hooks[:em_after].unshift block
+      end
+
+      # Add before hook that will run inside AMQP connection (AMQP.start loop)
+      def amqp_before scope = :each, &block
+        raise ArgumentError, "amqp_before only supports :each scope" unless :each == scope
+        em_hooks[:amqp_before] << block
+      end
+
+      # Add after hook that will run inside AMQP connection (AMQP.start loop)
+      def amqp_after scope = :each, &block
+        raise ArgumentError, "amqp_after only supports :each scope" unless :each == scope
+        em_hooks[:amqp_after].unshift block
       end
 
       # Collection of evented hooks for THIS example group
       def em_hooks
         metadata[:em_hooks] ||= {}
         metadata[:em_hooks][self] ||=
-            {before: (superclass.em_hooks[:before].clone rescue []),
-             after: (superclass.em_hooks[:after].clone rescue [])}
+            {em_before: (superclass.em_hooks[:em_before].clone rescue []),
+             em_after: (superclass.em_hooks[:em_after].clone rescue []),
+             amqp_before: (superclass.em_hooks[:amqp_before].clone rescue []),
+             amqp_after: (superclass.em_hooks[:amqp_after].clone rescue [])}
       end
     end
 

data/spec/em_hooks_spec.rb

@@ -1,5 +1,19 @@
 require 'spec_helper'
 
+def hook symbol=nil, reactor, connection
+  @hooks_called << symbol.to_sym if symbol
+  if :reactor_running == reactor
+    EM.reactor_running?.should be_true
+  else
+    EM.reactor_running?.should be_false
+  end
+  if :amqp_connected == connection
+    AMQP.conn.should be_connected
+  else
+    AMQP.conn and AMQP.conn.should_not be_connected
+  end
+end
+
 shared_examples_for 'hooked em specs' do
   it 'should execute em_before' do
     em do
@@ -34,6 +48,8 @@ shared_examples_for 'hooked amqp specs' do
     amqp do
       @hooks_called.should include :em_before
       @hooks_called.should_not include :em_after
+      @hooks_called.should include :amqp_before
+      @hooks_called.should_not include :amqp_after
       done
     end
   end
@@ -65,13 +81,14 @@ describe AMQP::SpecHelper, ".em_before/.em_after" do
     include AMQP::SpecHelper
     default_options AMQP_OPTS if defined? AMQP_OPTS
 
-    before { @hooks_called << :before }
-
-    em_before { @hooks_called << :em_before }
-    em_after { @hooks_called << :em_after }
+    before { hook :before, :reactor_not_running, :amqp_not_connected }
+    em_before { hook :em_before, :reactor_running, :amqp_not_connected }
+    em_after { hook :em_after, :reactor_running, :amqp_not_connected }
 
     context 'for non-evented specs' do
-      after { @hooks_called.should == [:before] }
+      after {
+        @hooks_called.should == [:before]
+        hook :reactor_not_running, :amqp_not_connected }
 
       it 'should NOT execute em_before or em_after' do
         @hooks_called.should_not include :em_before
@@ -90,7 +107,9 @@ describe AMQP::SpecHelper, ".em_before/.em_after" do
     end # context 'for non-evented specs'
 
     context 'for evented specs' do #, pending: true do
-      after { @hooks_called.should include :before, :em_before, :em_after }
+      after {
+        @hooks_called.should include :before, :em_before, :em_after
+        hook :reactor_not_running, :amqp_not_connected }
 
       context 'with em block' do
 
@@ -106,32 +125,35 @@ describe AMQP::SpecHelper, ".em_before/.em_after" do
         it 'should not run hooks from unrelated group' do
           em do
             @hooks_called.should_not include :amqp_context_em_before,
-                                             :amqp_context_before
+                                             :amqp_context_before,
+                                             :amqp_before,
+                                             :context_amqp_before
             done
           end
         end
 
         context 'inside nested example group' do
-          before { @hooks_called << :context_before }
-          em_before { @hooks_called << :context_em_before }
-          em_after { @hooks_called << :context_em_after }
+          before { hook :context_before, :reactor_not_running, :amqp_not_connected }
+          em_before { hook :context_em_before, :reactor_running, :amqp_not_connected }
+          em_after { hook :context_em_after, :reactor_running, :amqp_not_connected }
 
           after { @hooks_called.should include :before,
                                                :context_before,
                                                :em_before,
                                                :context_em_before,
                                                :context_em_after,
-                                               :em_after }
+                                               :em_after
+          hook :reactor_not_running, :amqp_not_connected
+          }
 
           it_should_behave_like 'hooked em specs'
 
-          it 'should fire both nested :before hooks' do
+          it 'should fire all nested :before hooks, but no :after hooks' do
             em do
-              @hooks_called.should include :before,
-                                           :context_before,
-                                           :em_before,
-                                           :context_em_before
-              @hooks_called.should_not include :em_after, :context_em_after
+              @hooks_called.should == [:before,
+                                       :context_before,
+                                       :em_before,
+                                       :context_em_before]
               done
             end
           end
@@ -140,13 +162,16 @@ describe AMQP::SpecHelper, ".em_before/.em_after" do
       end # context 'with em block'
 
       context 'with amqp block' do
+        amqp_before { hook :amqp_before, :reactor_running, :amqp_connected }
+        amqp_after { hook :amqp_after, :reactor_running, :amqp_connected }
 
         it_should_behave_like 'hooked amqp specs'
 
         it 'should not run nested em hooks' do
           amqp do
-            @hooks_called.should_not include :amqp_context_em_before,
-                                             :amqp_context_before
+            @hooks_called.should_not include :amqp_context_before,
+                                             :amqp_context_em_before,
+                                             :context_amqp_before
             done
           end
         end
@@ -159,16 +184,23 @@ describe AMQP::SpecHelper, ".em_before/.em_after" do
         end
 
         context 'inside nested example group' do
-          before { @hooks_called << :amqp_context_before; $debug = true }
-          em_before { @hooks_called << :amqp_context_em_before }
-          em_after { @hooks_called << :amqp_context_em_after }
+          before { hook :amqp_context_before, :reactor_not_running, :amqp_not_connected }
+          em_before { hook :amqp_context_em_before, :reactor_running, :amqp_not_connected }
+          em_after { hook :amqp_context_em_after, :reactor_running, :amqp_not_connected }
+          amqp_before { hook :context_amqp_before, :reactor_running, :amqp_connected }
+          amqp_after { hook :context_amqp_after, :reactor_running, :amqp_connected }
 
           after { @hooks_called.should == [:before,
                                            :amqp_context_before,
                                            :em_before,
                                            :amqp_context_em_before,
+                                           :amqp_before,
+                                           :context_amqp_before,
+                                           :context_amqp_after,
+                                           :amqp_after,
                                            :amqp_context_em_after,
-                                           :em_after] ; $debug = nil}
+                                           :em_after]
+          hook :reactor_not_running, :amqp_not_connected }
 
           it_should_behave_like 'hooked amqp specs'
 
@@ -177,7 +209,9 @@ describe AMQP::SpecHelper, ".em_before/.em_after" do
               @hooks_called.should == [:before,
                                        :amqp_context_before,
                                        :em_before,
-                                       :amqp_context_em_before]
+                                       :amqp_context_em_before,
+                                       :amqp_before,
+                                       :context_amqp_before]
               done
             end
           end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 3
-  version: 0.3.3
+  - 4
+  version: 0.3.4
 platform: ruby
 authors: 
 - Arvicco
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-24 00:00:00 +03:00
+date: 2010-11-26 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency