who_can 0.3.4

data/spec/who_can/connection_manager_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+module WhoCan
+  describe 'ConnectionManager' do
+    include EventedSpec::EMSpec
+    default_timeout 3.0
+
+    em_before do
+      @connection1 = ConnectionWrapper.new("amqp://localhost")
+      @connection2 = ConnectionWrapper.new("amqp://localhost")
+      @connection_manager = ConnectionManager.new(@connection1, @connection2)
+    end
+
+    def clean_and_done
+      # logger.debug {"calling test done on next tick"}
+      EM.next_tick do
+        # logger.debug {"test done, closing"}
+        @connection_manager.close do
+          done
+        end
+      end
+    end
+
+    def neuter_connection(connection)
+      flexmock(connection).should_receive(:connect).and_return true
+    end
+
+
+    describe "under totally normal circumstances" do
+
+      it "should enter a usable state after calling start" do
+        @connection_manager.start do
+          # logger.debug {"we DID get the start callback"}
+          @connection_manager.should be_usable
+          clean_and_done
+        end
+      end
+
+      it "should enter the degraded state if #2 never starts" do
+        neuter_connection(@connection2)
+        @connection_manager.start do
+          # logger.debug {"we DID get the start callback for #2 not starting"}
+          @connection_manager.should be_degraded
+          clean_and_done
+        end
+      end
+
+      it "should be useable after grace period if only secondary starts up" do
+        neuter_connection(@connection1)
+        @connection_manager.primary_grace_time = 0.1
+        @connection_manager.start do
+          # logger.debug {"we DID get the start callback for primary not starting"}
+
+          @connection_manager.should be_failed_over
+          @connection_manager.should be_usable
+          clean_and_done
+        end
+      end
+
+    end
+
+    describe "primary failing" do
+      it "should get the 2nd connection after the first goes down and does not come back and #2 is open" do
+        @connection_manager.on_failure do
+          neuter_connection(@connection1)
+          @connection_manager.on_open do
+            @connection_manager.connection.should == @connection2
+            @connection_manager.should be_failed_over
+            clean_and_done
+          end
+        end
+
+        @connection_manager.start do
+          @connection2.on_open do
+            @connection_manager.should be_usable
+            @connection1.ekg.heartbeat_failure!
+          end
+        end
+      end
+
+      it "should failback to primary when it comes back up" do
+        @connection_manager.on_failure do
+          #neuter_connection(@connection1)
+          @connection_manager.on_open do
+            @connection_manager.connection.should == @connection2
+            @connection_manager.should be_failed_over
+
+            #this 2nd on_failure will be triggered by the primary becoming available
+            @connection_manager.on_failure do
+              @connection_manager.on_open do
+                @connection_manager.should be_connected
+                @connection_manager.connection.should == @connection1
+                clean_and_done
+              end
+            end
+          end
+        end
+
+        @connection_manager.start do
+          @connection2.on_open do
+            @connection_manager.should be_usable
+            @connection1.ekg.heartbeat_failure!
+          end
+        end
+      end
+
+      it "should go from degraded to down if primary was up but secondary was not" do
+        neuter_connection(@connection2)
+        @connection_manager.on_failure do
+          @connection_manager.should be_down
+          clean_and_done
+        end
+
+        @connection_manager.start do
+          neuter_connection(@connection1)
+          @connection1.ekg.heartbeat_failure!
+        end
+
+      end
+
+    end
+
+    describe "secondary going down" do
+
+      it "should be degraded when down" do
+        @connection_manager.start do
+          @connection2.on_open do
+            @connection_manager.should be_connected
+
+            @connection2.on_failure do
+              #make sure #2 never comes back up (seriously, that's gross)
+              neuter_connection(@connection2)
+              EM.next_tick do
+                @connection_manager.should be_degraded
+                clean_and_done
+              end
+            end
+
+            #then fail #2
+            @connection2.ekg.heartbeat_failure!
+
+          end
+        end
+      end
+
+      it "should become connected again when it comes back" do
+        @connection_manager.start do
+          @connection2.on_open do
+            @connection_manager.should be_connected
+
+            @connection2.on_failure do
+              # logger.debug {"connection2 failure"}
+              #we failed #2, now wait for it to come back up
+              @connection2.on_open do
+                #it's back up - now make sure we're connected
+                EM.next_tick do
+                  @connection_manager.should be_connected
+                  clean_and_done
+                end
+              end
+            end
+            # logger.debug {"heartbeat failure"}
+            @connection2.ekg.heartbeat_failure!
+          end
+        end
+      end
+
+
+
+    end
+
+    describe "both failing" do
+      it "should enter a failed over state when secondary comes back up" do
+        @connection_manager.on_failure do
+          neuter_connection(@connection1)
+          @connection_manager.should be_failed_over
+          #second failure is from number 2 going down
+          @connection_manager.on_failure do
+            @connection_manager.should be_down
+            #now #2 comes back up
+            @connection_manager.on_open do
+              @connection_manager.should be_failed_over
+              @connection_manager.connection.should == @connection2
+              clean_and_done
+            end
+          end
+        end
+
+        @connection_manager.start do
+          @connection2.on_open do
+            @connection_manager.should be_usable
+            @connection1.ekg.heartbeat_failure!
+            EM.next_tick { @connection2.ekg.heartbeat_failure! }
+          end
+        end
+
+      end
+
+      it "should come back up degraded when primary comes back up" do
+        @connection_manager.on_failure do
+          neuter_connection(@connection2)
+          @connection_manager.should be_failed_over
+          #second failure is from number 2 going down
+          @connection_manager.on_failure do
+            @connection_manager.should be_down
+            #now #1 comes back up
+            @connection_manager.on_open do
+              @connection_manager.should be_degraded
+              @connection_manager.connection.should == @connection1
+              clean_and_done
+            end
+          end
+        end
+
+        @connection_manager.start do
+          @connection2.on_open do
+            @connection_manager.should be_usable
+            @connection1.ekg.heartbeat_failure!
+            EM.next_tick { @connection2.ekg.heartbeat_failure! }
+          end
+        end
+
+      end
+
+
+    end
+
+
+#
+#    describe 'connect!' do
+#      it %[should take a block that will be called back when a connection is ready]
+#      it %[should fire the on_open deferred when ready]
+#      it %[should reset the on_open deferred after it's first fired]
+#
+#      describe 'primary down' do
+#        it %[should time out waiting and use the secondary if the secondary is up]
+#      end
+#
+#      describe 'secondary down' do
+#        it %[should not affect startup]
+#      end
+#    end
+#
+#    describe 'failure' do
+#      describe 'of the primary connection' do
+#        it %[should fire the on_failure deferred]
+#        it %[should fire the on_open deferred when the secondary is ready]
+#      end
+#
+#      describe 'of the secondary connection' do
+#        it %[should not fire the on_failure deferred]
+#      end
+#    end
+#
+#    describe 'fail-back' do
+#    end
+  end
+end
+
+

data/spec/who_can/connection_wrapper_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module WhoCan
+  describe :ConnectionWrapper do
+
+
+    before do
+      @config = 'amqp://localhost'
+      @cw = ConnectionWrapper.new(@config, :reconnect_delay => 0.2)
+#         flexmock(AMQP).should_receive(:connect).with(@config, Hash, Proc)
+    end
+
+    describe :state_machine do
+      it %[should be in state new] do
+        @cw.new?.should be_true
+      end
+    end
+
+
+    describe :connect do
+      include EventedSpec::EMSpec
+      default_timeout 2.0
+
+      def with_connection
+        @cw.connect do
+          # logger.debug { "on_open fired" }
+          yield
+        end
+      end
+
+      def close_and_done
+        # logger.debug { "calling @cw.close!" }
+        @cw.close! { done }
+      end
+
+      describe 'success' do
+        it %[should connect and fire the callbacks] do
+          with_connection do
+            @cw.should be_connected
+            @cw.can_close?.should be_true
+            @cw.amqp_session.should_not be_nil
+            @cw.amqp_session.should be_kind_of(AMQP::Session)
+            @cw.amqp_session.should be_connected
+
+            close_and_done
+          end
+        end
+      end
+
+      describe 'initial connection failure' do
+        before do
+          flexmock(AMQP).should_receive(:connect).with(@config, Hash, Proc).and_return do |conf,opts,blk|
+            # logger.debug { "firing on_tcp_connection_failure callback" }
+            opts[:on_tcp_connection_failure].call(@config)
+          end
+        end
+
+        it %[should enter retrying state] do
+          @cw.on_initial_connection_failure do
+            # logger.debug { "initial connection failed" }
+
+            @cw.should be_retrying
+
+            @cw.close! { done }
+          end
+
+          @cw.connect
+        end
+      end
+
+      describe 'established connection failure' do
+        it %[should enter retrying state] do
+          orig_on_failure = @cw.on_failure
+
+          with_connection do
+            @cw.on_failure do
+              orig_on_failure.should_not == @cw.on_failure
+              @cw.should be_retrying
+
+              close_and_done
+            end
+
+            # logger.debug { "calling heartbeat_failure!" }
+            @cw.ekg.heartbeat_failure!
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/who_can/heartbeater/beat_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module WhoCan::Heartbeater
+  describe 'Heartbeater' do
+    include EventedSpec::AMQPSpec
+    default_timeout 3.0
+    default_options :host => 'localhost'
+
+    describe 'Beat' do
+      before do
+        @beat_id = "beat_0"
+      end
+
+      amqp_before do
+        @chan = AMQP::Channel.new(AMQP.connection)
+        @chan.once_opened do
+          @queue = @chan.queue('', :exclusive => true, :auto_delete => true)
+        end
+      end
+
+      it %[should fire its callback on success] do
+        @chan.once_opened do
+          @chan.should be_open
+
+          beat = Beat.new(@chan, @queue, @beat_id, 0.5)
+          beat.should be_pending
+
+          beat.callback { done }
+
+          beat.start!
+
+          beat.after_publish do
+            beat.ping_received!
+          end
+        end
+      end
+
+      it %[should fire its errback if it times out] do
+        @chan.once_opened do
+          @default_exchange = flexmock(:default_exchange) do |m|
+            m.should_receive(:publish).once.with(String, Hash, Proc).and_return do |_,_,blk| 
+              blk.call 
+            end
+          end
+
+          mchan = flexmock(@chan, :default_exchange => @default_exchange)
+
+          beat = Beat.new(mchan, @queue, @beat_id, 0.25)
+
+          beat.errback do
+            # logger.debug { "errback fired!" }
+            done
+          end
+
+          beat.callback do
+            # logger.debug { "GAH! callback fired! this is bad!" }
+            raise "NO! FAIL!"
+          end
+
+          beat.start!
+        end
+      end
+
+      it %[should be cancelled? after cancel!] do
+        @chan.once_opened do
+          beat = Beat.new(@chan, @queue, @beat_id, 0.5)
+
+          beat.callback do
+            # logger.debug { "I HAVE BEEN CALLED BACK!!" }
+            beat.should be_cancelled
+            done
+          end
+
+          beat.after_publish do
+            beat.cancel!
+          end
+
+          beat.start!
+        end
+      end
+
+      it "should call the errback on a queue opening failure" do
+        @chan.once_opened do
+          beat = Beat.new(@chan, @queue,  @beat_id, 0.25)
+          flexmock(@chan).should_receive(:queue).and_raise(AMQ::Client::ConnectionClosedError)
+
+          beat.errback do
+            # logger.debug { "errback fired!" }
+            done
+          end
+
+          beat.callback do
+            raise "FAIL!"
+          end
+
+          beat.start!
+        end
+      end
+    end
+  end
+end