stomper 1.0.0 → 2.0.0

data/spec/threaded_receiver_spec.rb

@@ -1,33 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-module Stomper
-  describe ThreadedReceiver do
-    before(:each) do
-      @connection = mock("connection")
-      @connection.extend Stomper::ThreadedReceiver
-    end
-    
-    describe "expected interface" do
-      it "should provide a start method" do
-        @connection.should respond_to(:start)
-      end
-      
-      it "should provide a stop method" do
-        @connection.should respond_to(:stop)
-      end
-    end
-    
-    describe "reading on a thread" do
-      it "should start receiving when started, and stop when stopped." do
-        @connection.should_receive(:connected?).once.and_return(false)
-        @connection.should_receive(:connect).once.and_return(true)
-        @connection.should_receive(:connected?).any_number_of_times.and_return(true)
-        @connection.should_receive(:receive).at_least(:once).and_return(nil)
-        @connection.start
-        sleep(0.5)
-        @connection.stop
-        @connection.should_not_receive(:receive)
-      end
-    end
-  end
-end

data/spec/transaction_spec.rb

@@ -1,139 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-
-module Stomper
-  describe Transaction do
-    before(:each) do
-      @mock_client = mock("client")
-    end
-
-    describe "initialization with blocks" do
-      before(:each) do
-        @mock_client.should_receive(:begin).once.with(an_instance_of(String)).and_return(nil)
-        @mock_client.should_receive(:send).once.with("/queue/test/1","a message", an_instance_of(Hash)).and_return(nil)
-        @mock_client.should_receive(:commit).once.with(an_instance_of(String)).and_return(nil)
-      end
-
-
-      it "should provide a DSL when a block with no arguments is given" do
-        lambda do
-          Transaction.new(@mock_client) do
-            send("/queue/test/1", "a message")
-          end
-        end.should_not raise_error
-      end
-
-      it "should yield itself when a block with arguments is given" do
-        lambda do
-          Transaction.new(@mock_client) do |t|
-            t.send("/queue/test/1", "a message")
-          end
-        end.should_not raise_error
-      end
-    end
-
-    describe "explicitly named" do
-      before(:each) do
-        @transaction_name = "tx-test"
-        @mock_client.should_receive(:begin).once.with(@transaction_name).and_return(nil)
-        @mock_client.should_receive(:send).once.with("/queue/test/1","test message", hash_including(:transaction => @transaction_name)).and_return(nil)
-        @mock_client.should_receive(:commit).once.with(@transaction_name).and_return(nil)
-      end
-
-      it "should use the given transaction ID as the transaction header in stomp messages" do
-        Transaction.new(@mock_client, @transaction_name) do |t|
-          t.send("/queue/test/1", "test message")
-        end
-      end
-    end
-
-    describe "aborting failed transactions" do
-      before(:each) do
-        @transaction_name = "tx-test-2"
-        @mock_client.should_receive(:begin).once.with(@transaction_name).and_return(nil)
-        @mock_client.should_receive(:send).once.with("/queue/test/1","test message", hash_including(:transaction => @transaction_name)).and_return(nil)
-      end
-
-      it "should abort when an exception is raised" do
-        @mock_client.should_receive(:abort).once.with(@transaction_name).and_return(nil)
-        @mock_client.should_not_receive(:commit)
-        lambda do
-          Transaction.new(@mock_client, @transaction_name) do |t|
-            t.send("/queue/test/1", "test message")
-            raise "Never to be completed!"
-          end
-        end.should raise_error(TransactionAborted)
-      end
-
-      it "should abort and raise an error when explicitly aborted" do
-        @mock_client.should_receive(:abort).once.with(@transaction_name).and_return(nil)
-        @mock_client.should_not_receive(:commit)
-        lambda do
-          Transaction.new(@mock_client, @transaction_name) do |t|
-            t.send("/queue/test/1", "test message")
-            t.abort
-            # This should never be reached.
-            t.commit
-          end
-        end.should raise_error(TransactionAborted)
-      end
-
-      it "should not raise an exception when explicitly aborted after a commit" do
-        @mock_client.should_not_receive(:abort)
-        @mock_client.should_receive(:commit).once.with(@transaction_name).and_return(nil)
-        lambda do
-          Transaction.new(@mock_client, @transaction_name) do |t|
-            t.send("/queue/test/1", "test message")
-            t.commit
-            t.abort
-          end
-        end.should_not raise_error(TransactionAborted)
-      end
-    end
-
-    describe "nested transactions" do
-      before(:each) do
-        @transaction_name = "tx-test-3"
-        @inner_transaction_name = "#{@transaction_name}-inner"
-        @inner_inner_transaction_name = "#{@transaction_name}-inner-inner"
-        @mock_client.should_receive(:begin).with(@transaction_name).once.and_return(nil)
-        @mock_client.should_receive(:begin).with(@inner_transaction_name).once.and_return(nil)
-        @mock_client.should_receive(:send).with("/queue/test/1","test message", hash_including(:transaction => @transaction_name)).once.and_return(nil)
-        @mock_client.should_receive(:send).with("/queue/test/2","inner message", hash_including(:transaction => @inner_transaction_name)).once.and_return(nil)
-      end
-      it "no transaction should succeed when an inner one fails" do
-        @mock_client.should_receive(:abort).once.with(@transaction_name).and_return(nil)
-        @mock_client.should_receive(:abort).once.with(@inner_transaction_name).and_return(nil)
-        @mock_client.should_not_receive(:commit)
-        lambda do
-          Transaction.new(@mock_client, @transaction_name) do |t|
-            t.send("/queue/test/1", "test message")
-            t.transaction(@inner_transaction_name) do |nt|
-              nt.send("/queue/test/2", "inner message")
-              raise "failure"
-            end
-          end
-        end.should raise_error(TransactionAborted)
-      end
-      it "no transaction should succeed when an inner one is explicitly aborted" do
-        @mock_client.should_receive(:begin).with(@inner_inner_transaction_name).once.and_return(nil)
-        @mock_client.should_receive(:send).with("/queue/test/3","inner-inner message", hash_including(:transaction => @inner_inner_transaction_name)).once.and_return(nil)
-        @mock_client.should_receive(:abort).once.with(@transaction_name).and_return(nil)
-        @mock_client.should_receive(:abort).once.with(@inner_transaction_name).and_return(nil)
-        @mock_client.should_receive(:abort).once.with(@inner_inner_transaction_name).and_return(nil)
-        @mock_client.should_not_receive(:commit)
-        lambda do
-          Transaction.new(@mock_client, @transaction_name) do |t|
-            t.send("/queue/test/1", "test message")
-            t.transaction(@inner_transaction_name) do |nt|
-              nt.send("/queue/test/2", "inner message")
-              nt.transaction(@inner_inner_transaction_name) do |nnt|
-                nnt.send("/queue/test/3", "inner-inner message")
-                nnt.abort
-              end
-            end
-          end
-        end.should raise_error(TransactionAborted)
-      end
-    end
-  end
-end

data/spec/transactor_spec.rb

@@ -1,46 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-
-module Stomper
-  describe Transactor do
-    class MockConcreteTransactor
-      include Stomper::Transactor
-    end
-
-    before(:each) do
-      @client = MockConcreteTransactor.new
-    end
-    
-    describe "expected interface" do
-      it "should provide a transaction method" do
-        @client.should respond_to(:transaction)
-      end
-      it "should provide a begin method" do
-        @client.should respond_to(:begin)
-        @client.should_receive(:transmit).with(an_instance_of(Stomper::Frames::Begin)).once.and_return(nil)
-        @client.begin("tx-001")
-      end
-      it "should proivde an abort method" do
-        @client.should respond_to(:abort)
-        @client.should_receive(:transmit).with(an_instance_of(Stomper::Frames::Abort)).once.and_return(nil)
-        @client.abort("tx-001")
-      end
-      it "should provide a commit method" do
-        @client.should respond_to(:commit)
-        @client.should_receive(:transmit).with(an_instance_of(Stomper::Frames::Commit)).once.and_return(nil)
-        @client.commit("tx-001")
-      end
-    end
-
-    describe "transactions" do
-      it "should provide a transaction method that generates a new Transaction" do
-        @client.should_receive(:begin)
-        @client.should_receive(:commit)
-        @evaluated = false
-        @client.transaction do |t|
-          @evaluated = true
-        end
-        @evaluated.should be_true
-      end
-    end
-  end
-end