stomper 1.0.0 → 2.0.0

data/spec/stomper/receipt_manager_spec.rb

@@ -0,0 +1,91 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper
+  describe ReceiptManager do
+    before(:each) do
+      @connection = mock("connection")
+    end
+    
+    it "should bind to the on_receipt event handler" do
+      receipt = mock('receipt')
+      @connection.should_receive(:on_receipt)
+      @connection.should_receive(:before_disconnect)
+      @receipt_manager = ReceiptManager.new(@connection)
+    end
+    
+    describe "usage" do
+      before(:each) do
+        @connection.extend ::Stomper::Extensions::Events
+        @receipt_manager = ReceiptManager.new(@connection)
+      end
+      
+      it "should add callbacks that are invoked by a matching receipt" do
+        triggered = false
+        @receipt_manager.add('1234', lambda { |r| triggered = true })
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '1234' }))
+        triggered.should be_true
+      end
+      
+      it "should not invoke callbacks that don't match the receipt" do
+        triggered = false
+        @receipt_manager.add('1234', lambda { |r| triggered = true })
+        @receipt_manager.add('5678', lambda { |r| triggered = true })
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '12345' }))
+        triggered.should be_false
+      end
+      
+      it "should not invoke the same callback more than once" do
+        triggered = 0
+        @receipt_manager.add('1234', lambda { |r| triggered += 1 })
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '1234' }))
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '1234' }))
+        triggered.should == 1
+      end
+      
+      it "should allow a receipt handler to be registered within a callback" do
+        triggered = [false, false]
+        callback = lambda do |r|
+          triggered[0] = true
+          @receipt_manager.add('4567', lambda { |r| triggered[1] = true })
+        end
+        @receipt_manager.add('1234', callback)
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '1234' }))
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '4567' }))
+        triggered.should == [true, true]
+      end
+      
+      it "should allow a receipt handler to be registered within a callback in separate threads" do
+        triggered = [false, false]
+        started_r1 = false
+        callback = lambda do |r|
+          triggered[0] = true
+          Thread.stop
+        end
+        @receipt_manager.add('1234', callback)
+        r_1 = Thread.new(@connection) do |c|
+          started_r1 = true
+          Thread.stop
+          c.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '1234' }))
+        end
+        r_2 = Thread.new(@connection) do |c|
+          Thread.pass until triggered[0]
+          @receipt_manager.add('4567', lambda { |r| triggered[1] = true })
+          r_1.run
+          c.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => '4567' }))
+        end
+        Thread.pass until started_r1
+        r_1.run
+        r_1.join
+        r_2.join
+        triggered.should == [true, true]
+      end
+      
+      it "should close a connection when a RECEIPT for the DISCONNECT frame is received" do
+        @connection.__send__(:trigger_before_transmitted_frame, ::Stomper::Frame.new('DISCONNECT', {:receipt => 'd-1234'}))
+        @connection.should_receive(:close)
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('RECEIPT', { :'receipt-id' => 'd-1234' }))
+      end
+    end
+  end
+end

data/spec/stomper/receivers/threaded_spec.rb

@@ -0,0 +1,116 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Receivers
+  describe Threaded do
+    before(:each) do
+      @connection = mock("connection")
+      @receiver = Threaded.new(@connection)
+      @receive_called = false
+      @received_frame = mock('frame')
+    end
+    
+    def mock_receive_call
+      @connection.stub!(:receive).and_return(@received_frame)
+    end
+    
+    def expect_receive_call
+      @connection.should_receive(:receive).at_least(:once).and_return do
+        @receive_called = true
+        @received_frame
+      end
+    end
+    
+    def wait_until_receive_called(reset=true)
+      @receive_called = false if reset
+      Thread.pass until @receive_called
+    end
+    
+    it "should start running when :start is called, creating a new thread" do
+      expect_receive_call
+      initial_threads = Thread.list.size
+      @receiver.start
+      wait_until_receive_called
+      @receiver.running?.should be_true
+      Thread.list.size.should == (initial_threads + 1)
+      @receiver.stop
+    end
+    
+    it "should stop running when :stop is called, joining its run thread" do
+      mock_receive_call
+      initial_threads = Thread.list.size
+      @receiver.start
+      @receiver.stop
+      @receiver.running?.should be_false
+      Thread.list.size.should == initial_threads
+    end
+    
+    it "should receive frames from its connection until it is stopped" do
+      thread_check = false
+      @connection.should_receive(:receive).twice.and_return do
+        Thread.pass until thread_check
+        thread_check = false
+        @received_frame
+      end
+      @receiver.start
+      thread_check = true
+      Thread.pass while thread_check
+      thread_check = true
+      @receiver.stop
+    end
+    
+    it "should not create more than one thread if :start is invoked repeatedly" do
+      expect_receive_call
+      initial_threads = Thread.list.size
+      running_threads = initial_threads+1
+      
+      @receiver.start
+      wait_until_receive_called
+      Thread.list.size.should == running_threads
+      
+      @receiver.start
+      wait_until_receive_called
+      Thread.list.size.should == running_threads
+      
+      @receiver.start
+      wait_until_receive_called
+      Thread.list.size.should == running_threads
+      
+      @receiver.stop
+      Thread.list.size.should == initial_threads
+    end
+    
+    it "should not raise an error if :stop is invoked repeatedly" do
+      expect_receive_call
+      @receiver.start
+      wait_until_receive_called
+
+      @receiver.stop
+      lambda { @receiver.stop }.should_not raise_error
+      lambda { @receiver.stop }.should_not raise_error
+    end
+    
+    it "should stop itself if receiving a frame raises any error" do
+      @connection.should_receive(:receive).and_raise('stopping the receiver')
+      @receiver.start
+      Thread.pass while @receiver.running?
+      lambda { @receiver.stop }.should raise_error('stopping the receiver')
+    end
+    
+    it "should propegate an IOError if the connection is still connected" do
+      @connection.should_receive(:connected?).and_return(true)
+      @connection.should_receive(:receive).and_raise(IOError.new('stopping the receiver'))
+      @receiver.start
+      Thread.pass while @receiver.running?
+      lambda { @receiver.stop }.should raise_error(IOError)
+    end
+    
+    it "should not propegate an IOError if the connection is not connected" do
+      @connection.should_receive(:connected?).and_return(false)
+      @connection.should_receive(:receive).and_raise(IOError.new('stopping the receiver'))
+      @receiver.start
+      Thread.pass while @receiver.running?
+      lambda { @receiver.stop }.should_not raise_error
+    end
+  end
+end

data/spec/stomper/scopes/header_scope_spec.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Scopes
+  describe HeaderScope do
+    before(:each) do
+      @connection = mock("connection", :is_a? => true, :version => '1.1')
+      @headers = { :global_1 => 'turbo', 'global_2' => 'is me', :persistent => true }
+      @connection.stub!(:subscription_manager).and_return(mock('subscription manager', {
+        :subscribed_id? => true
+      }))
+      @scope = HeaderScope.new(@connection, @headers)
+    end
+    
+    it "should apply the headers to any frame generated on its Common interface" do
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'BEGIN'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'UNSUBSCRIBE'))
+      @scope.send("/queue/test", "body of message", { :local_1 => 'my header' })
+      @scope.begin("transaction-1234", { :local_2 => 'other header'})
+      @scope.unsubscribe('no-real-destination')
+    end
+    
+    it "should evaluate a proc through itself if one is provided" do
+      scope_block = lambda do |h|
+        h.abort('transaction-1234')
+        h.subscribe('/queue/test')
+        h.commit('transaction-1234')
+      end
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ABORT'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SUBSCRIBE'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'COMMIT'))
+      @scope.apply_to(scope_block)
+    end
+    
+    it "should override its headers with those passed through the frame methods" do
+      overridden_headers = @headers.merge(:persistent => 'false')
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(overridden_headers, 'SEND'))
+      @scope.send('/queue/test', 'body of message', { :persistent => false })
+    end
+  end
+end

data/spec/stomper/scopes/receipt_scope_spec.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Scopes
+  describe ReceiptScope do
+    before(:each) do
+      @receipt_manager = mock("receipt manager")
+      @connection = mock("connection", :is_a? => true, :version => '1.1')
+      @connection.stub!(:receipt_manager => @receipt_manager)
+      @connection.stub!(:subscription_manager).and_return(mock('subscription manager', {
+        :subscribed_id? => true
+      }))
+      @scope = ReceiptScope.new(@connection, {})
+    end
+    
+    it "should add entries to the connection's receipt manager" do
+      scope_block = lambda do |r|
+      end
+      @scope.apply_to(scope_block)
+      
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers({ :destination => '/queue/test', :receipt => 'receipt-1234' }, 'SEND'))
+      @receipt_manager.should_receive(:add).with('receipt-1234', an_instance_of(Proc)).once
+      @scope.send('/queue/test', 'body of message', { :receipt => 'receipt-1234' })
+      
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers({ :destination => '/queue/test', :receipt => 'receipt-4567' }, 'SUBSCRIBE'))
+      @receipt_manager.should_receive(:add).with('receipt-4567', an_instance_of(Proc)).once
+      @scope.subscribe('/queue/test', { :receipt => 'receipt-4567' })
+    end
+    
+    it "should set up receipt ids automatically when none are specified in the headers" do
+      scope_block = lambda do |r|
+      end
+      @connection.stub!(:transmit) { |f| f }
+      @scope.apply_to(scope_block)
+      
+      frames = []
+      @receipt_manager.should_receive(:add).with('receipt-1234', an_instance_of(Proc)).once
+      frames << @scope.send('/queue/test', 'body of message', { :receipt => 'receipt-1234' })
+      frames.last[:receipt].should == 'receipt-1234'
+      
+      @receipt_manager.should_receive(:add).with(an_instance_of(String), an_instance_of(Proc)).twice
+      frames << @scope.unsubscribe('/queue/test')
+      frames.last[:receipt].should_not be_empty
+      
+      frames << @scope.ack('msg-1234', 'sub-5678')
+      frames.last[:receipt].should_not be_empty
+      
+      frames.map { |r| r[:receipt] }.uniq.should == frames.map { |r| r[:receipt] }
+    end
+  end
+end

data/spec/stomper/scopes/transaction_scope_spec.rb

@@ -0,0 +1,183 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Scopes
+  describe TransactionScope do
+    before(:each) do
+      @connection = mock("connection", :is_a? => true, :version => '1.1')
+      @headers = { :transaction => 'tx-1234' }
+      @connection.stub!(:subscription_manager).and_return(mock('subscription manager', {
+        :subscribed_id? => true
+      }))
+      @scope = TransactionScope.new(@connection, @headers)
+      @connection.should_receive(:transmit).at_most(:once).with(stomper_frame_with_headers(@headers, 'BEGIN'))
+    end
+    
+    it "should generate a transaction ID if one was not provided" do
+      auto_scope = TransactionScope.new(@connection, {})
+      auto_scope_name = auto_scope.transaction
+      auto_scope_name.should_not be_empty
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers({:transaction => auto_scope_name}, 'BEGIN'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers({:transaction => auto_scope_name}, 'SEND'))
+      auto_scope.send('/queue/test', 'body of message')
+    end
+    
+    it "should apply a transaction header to SEND" do
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @scope.send('/queue/test', 'body of message')
+    end
+    
+    it "should apply a transaction header to ACK" do
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ACK'))
+      @scope.ack('msg-001', 'sub-001')
+    end
+    
+    it "should apply a transaction header to COMMIT" do
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'COMMIT'))
+      @scope.commit
+    end
+    
+    it "should apply a transaction header to ABORT" do
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ABORT'))
+      @scope.abort
+    end
+    
+    it "should apply a transaction header to COMMIT" do
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'COMMIT'))
+      @scope.commit
+    end
+    
+    it "should apply a transaction header to NACK" do
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'NACK'))
+      @scope.nack('msg-001', 'sub-001')
+    end
+    
+    it "should not apply a transaction header to SUBSCRIBE, UNSUBSCRIBE" do
+      @connection.stub!(:transmit).and_return { |f| f }
+      subscribe = @scope.subscribe('/queue/test')
+      unsubscribe = @scope.unsubscribe(subscribe)
+      subscribe.headers.has?(:transaction).should be_false
+      unsubscribe.headers.has?(:transaction).should be_false
+    end
+    
+    it "should raise an error when beginning a transaction that has already begun" do
+      @connection.stub!(:transmit).and_return { |f| f }
+      @scope.send('/queue/test', 'body of message')
+      lambda { @scope.begin }.should raise_error
+    end
+    
+    it "should raise an error when aborting a transaction that has already aborted" do
+      @connection.stub!(:transmit).and_return { |f| f }
+      @scope.abort
+      lambda { @scope.abort }.should raise_error
+    end
+    
+    it "should raise an error when aborting a transaction that has already committed" do
+      @connection.stub!(:transmit).and_return { |f| f }
+      @scope.commit
+      lambda { @scope.abort }.should raise_error
+    end
+    
+    it "should raise an error when committing a transaction that has already aborted" do
+      @connection.stub!(:transmit).and_return { |f| f }
+      @scope.abort
+      lambda { @scope.commit }.should raise_error
+    end
+    
+    it "should raise an error when committing a transaction that has already committed" do
+      @connection.stub!(:transmit).and_return { |f| f }
+      @scope.commit
+      lambda { @scope.commit }.should raise_error
+    end
+    
+    it "should evaluate a block as a transaction and commit it if the block does not raise an error" do
+      scope_block = lambda do |t|
+        t.send('/queue/test', 'body of message')
+        t.ack('msg-1234', 'sub-4321')
+        t.nack('msg-5678', 'sub-8765')
+      end
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ACK'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'NACK'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'COMMIT'))
+      @scope.apply_to(scope_block)
+    end
+    
+    it "should evaluate a block as a transaction but do nothing if the transaction never started" do
+      scope_block = lambda do |t|
+      end
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'BEGIN'))
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'COMMIT'))
+      @scope.apply_to(scope_block)
+    end
+    
+    it "should evaluate a block as a transaction and abort the transaction and raise an exception if an exception is raised" do
+      scope_block = lambda do |t|
+        t.send('/queue/test', 'body of message')
+        t.ack('msg-1234', 'sub-4321')
+        raise "Time to abort!"
+        t.nack('msg-5678', 'sub-8765')
+      end
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ACK'))
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'NACK'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ABORT'))
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'COMMIT'))
+      lambda { @scope.apply_to(scope_block) }.should raise_error('Time to abort!')
+    end
+    
+    it "should not commit a transaction block that was manually aborted" do
+      scope_block = lambda do |t|
+        t.send('/queue/test', 'body of message')
+        t.ack('msg-1234', 'sub-4321')
+        t.abort
+      end
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ACK'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ABORT'))
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'COMMIT'))
+      lambda { @scope.apply_to(scope_block) }.should_not raise_error
+    end
+    
+    it "should not re-commit a transaction block that was manually committed" do
+      scope_block = lambda do |t|
+        t.send('/queue/test', 'body of message')
+        t.ack('msg-1234', 'sub-4321')
+        t.commit
+      end
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ACK'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'COMMIT'))
+      lambda { @scope.apply_to(scope_block) }.should_not raise_error
+    end
+    
+    it "should raise an error if further transactionable frames are sent after the transaction has been aborted" do
+      scope_block = lambda do |t|
+        t.send('/queue/test', 'body of message')
+        t.ack('msg-1234', 'sub-4321')
+        t.abort
+        t.nack('msg-5678', 'sub-8765')
+      end
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ACK'))
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'NACK'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ABORT'))
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'COMMIT'))
+      lambda { @scope.apply_to(scope_block) }.should raise_error(::Stomper::Errors::TransactionFinalizedError)
+    end
+    
+    it "should raise an error if further transactionable frames are sent after the transaction has been committed" do
+      scope_block = lambda do |t|
+        t.send('/queue/test', 'body of message')
+        t.ack('msg-1234', 'sub-4321')
+        t.commit
+        t.nack('msg-5678', 'sub-8765')
+      end
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'SEND'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'ACK'))
+      @connection.should_not_receive(:transmit).with(stomper_frame(nil, {}, 'NACK'))
+      @connection.should_receive(:transmit).with(stomper_frame_with_headers(@headers, 'COMMIT'))
+      lambda { @scope.apply_to(scope_block) }.should raise_error(::Stomper::Errors::TransactionFinalizedError)
+    end
+  end
+end