onstomp 1.0.0pre1

data/spec/onstomp/components/scopes/receipt_scope_spec.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Components::Scopes
+  describe ReceiptScope do
+    let(:client) {
+      OnStomp::Client.new("stomp:///")
+    }
+    let(:receipt_back) {
+      lambda { |r| true }
+    }
+    let(:scope) {
+      ReceiptScope.new receipt_back, client
+    }
+    
+    let(:frame_method_interface) { scope }
+    it_should_behave_like "frame method interfaces"
+    
+    describe ".transmit" do
+      it "should add its receipt callback to frames transmitted without one" do
+        frame = OnStomp::Components::Frame.new('COMMAND', {:header2 => 'my value'})
+        client.should_receive(:transmit).with(frame, { :receipt => receipt_back })
+        scope.transmit frame
+      end
+      it "should not add its receipt callback if one was already present" do
+        alt_receipt_back = lambda { |r| false }
+        frame = OnStomp::Components::Frame.new('COMMAND', {:header2 => 'my value'})
+        client.should_receive(:transmit).with(frame, { :receipt => alt_receipt_back })
+        scope.transmit frame, :receipt => alt_receipt_back
+      end
+    end
+  end
+end

data/spec/onstomp/components/scopes/transaction_scope_spec.rb

@@ -0,0 +1,227 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Components::Scopes
+  describe TransactionScope do
+    let(:client) {
+      OnStomp::Client.new("stomp:///").tap do |c|
+        c.stub(:connection => OnStomp::Connections::Stomp_1_1.new(mock('io'), c))
+      end
+    }
+    let(:scope) {
+      TransactionScope.new 't-1234', client
+    }
+    
+    describe ".begin" do
+      it "should use the scope's transaction id by default" do
+        frame = scope.begin :header1 => 'value 1'
+        frame.should have_headers(:header1 => 'value 1',
+          :transaction => 't-1234')
+      end
+      it "should use a supplied transaction ID" do
+        frame = scope.begin 't-5678', :header1 => 'value 1'
+        frame.should have_headers(:header1 => 'value 1',
+          :transaction => 't-5678')
+      end
+      it "should raise an error if the transaction has been started and not finished" do
+        scope.begin :header1 => 'value 1'
+        lambda {
+          scope.begin
+        }.should raise_error(OnStomp::TransactionError)
+      end
+      it "should not raise an error if the transaction has been finished" do
+        scope.begin :header1 => 'value 1'
+        scope.commit
+        lambda {
+          scope.begin
+        }.should_not raise_error
+      end
+      it "should generate a new transaction ID after completing" do
+        scope.begin :header1 => 'value 1'
+        scope.commit
+        next_begin = scope.begin
+        next_begin[:transaction].should_not be_empty
+        next_begin[:transaction].should_not == 't-1234'
+      end
+    end
+    
+    describe ".commit" do
+      it "should use the scope's transaction id" do
+        scope.begin
+        scope.commit('t-5678', :header1 => 'value 1').should have_headers(
+          :header1 => 'value 1',
+          :transaction => 't-1234'
+        )
+      end
+      it "should raise an error if the transaction has not been started" do
+        lambda {
+          scope.commit
+        }.should raise_error(OnStomp::TransactionError)
+      end
+    end
+    
+    describe ".abort" do
+      it "should use the scope's transaction id" do
+        scope.begin
+        scope.abort('t-5678', :header1 => 'value 1').should have_headers(
+          :header1 => 'value 1',
+          :transaction => 't-1234'
+        )
+      end
+      it "should raise an error if the transaction has not been started" do
+        lambda {
+          scope.abort
+        }.should raise_error(OnStomp::TransactionError)
+      end
+    end
+    
+    describe ".send" do
+      it "should generate a SEND frame with the transaction header" do
+        scope.begin
+        scope.send('/queue/test', 'body of message').should have_headers(:transaction => 't-1234')
+      end
+      it "should work with :puts, too!" do
+        scope.begin
+        scope.puts('/queue/test', 'body of message').should have_headers(:transaction => 't-1234')
+      end
+      it "should not include the transaction header if the transaction has not started" do
+        scope.send('/queue/test', 'body of message').should_not have_header_named(:transaction)
+      end
+    end
+    
+    describe ".ack" do
+      it "should generate a SEND frame with the transaction header" do
+        scope.begin
+        scope.ack('m-1234', 's-1234').should have_headers(:transaction => 't-1234')
+      end
+      it "should not include the transaction header if the transaction has not started" do
+        scope.ack('m-1234', 's-1234').should_not have_header_named(:transaction)
+      end
+    end
+    
+    describe ".nack" do
+      it "should generate a NACK frame with the transaction header" do
+        scope.begin
+        scope.nack('m-1234', 's-1234').should have_headers(:transaction => 't-1234')
+      end
+      it "should not include the transaction header if the transaction has not started" do
+        scope.nack('m-1234', 's-1234').should_not have_header_named(:transaction)
+      end
+    end
+
+    describe "non-transactional frames" do
+      it "should not add a transaction header to SUBSCRIBE" do
+        scope.begin
+        scope.subscribe("/queue/test").should_not have_header_named(:transaction)
+      end
+      it "should not add a transaction header to UNSUBSCRIBE" do
+        scope.begin
+        scope.unsubscribe("s-1234").should_not have_header_named(:transaction)
+      end
+      it "should not add a transaction header to DISCONNECT" do
+        scope.begin
+        scope.disconnect.should_not have_header_named(:transaction)
+      end
+      it "should not add a transaction header to heartbeats" do
+        scope.begin
+        scope.beat.should_not have_header_named(:transaction)
+      end
+    end
+    
+    describe ".perform" do
+      it "should begin an un-started transaction and commit it when the block completes" do
+        client.should_receive(:transmit).with(an_onstomp_frame('BEGIN',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('COMMIT',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('SEND',
+          {:destination => '/queue/test', :transaction => 't-1234'},
+          'my body'), an_instance_of(Hash)).and_return { |f| f }
+
+        scope.perform { |t| t.send("/queue/test", "my body") }
+      end
+      it "should not begin an already started transaction" do
+        scope.begin
+        client.should_receive(:transmit).with(an_onstomp_frame('COMMIT',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('SEND',
+          {:destination => '/queue/test', :transaction => 't-1234'},
+          'my body'), an_instance_of(Hash)).and_return { |f| f }
+
+        scope.perform { |t| t.send("/queue/test", "my body") }
+      end
+      it "should not commit an already commited transaction" do
+        client.should_receive(:transmit).with(an_onstomp_frame('BEGIN',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('COMMIT',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('SEND',
+          {:destination => '/queue/test', :transaction => 't-1234'},
+          'my body'), an_instance_of(Hash)).and_return { |f| f }
+
+        scope.perform { |t| t.send("/queue/test", "my body"); t.commit }
+      end
+      it "should not commit an already aborted transaction" do
+        client.should_receive(:transmit).with(an_onstomp_frame('BEGIN',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('ABORT',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('SEND',
+          {:destination => '/queue/test', :transaction => 't-1234'},
+          'my body'), an_instance_of(Hash)).and_return { |f| f }
+
+        scope.perform { |t| t.send("/queue/test", "my body"); t.abort }
+      end
+      it "should abort if the block raises an error, and re-raise it" do
+        client.should_receive(:transmit).with(an_onstomp_frame('BEGIN',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('ABORT',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('SEND',
+          {:destination => '/queue/test', :transaction => 't-1234'},
+          'my body'), an_instance_of(Hash)).and_return { |f| f }
+
+        lambda {
+          scope.perform { |t|
+            t.send("/queue/test", "my body")
+            raise ArgumentError
+          }
+        }.should raise_error(ArgumentError)
+      end
+      it "should not abort if the block raises an error after being aborted" do
+        client.should_receive(:transmit).with(an_onstomp_frame('BEGIN',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('ABORT',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('SEND',
+          {:destination => '/queue/test', :transaction => 't-1234'},
+          'my body'), an_instance_of(Hash)).and_return { |f| f }
+
+        lambda {
+          scope.perform { |t|
+            t.send("/queue/test", "my body")
+            t.abort
+            raise ArgumentError
+          }
+        }.should raise_error(ArgumentError)
+      end
+      it "should not abort if the block raises an error after being committed" do
+        client.should_receive(:transmit).with(an_onstomp_frame('BEGIN',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('COMMIT',
+          :transaction => 't-1234')).and_return { |f| f }
+        client.should_receive(:transmit).with(an_onstomp_frame('SEND',
+          {:destination => '/queue/test', :transaction => 't-1234'},
+          'my body'), an_instance_of(Hash)).and_return { |f| f }
+
+        lambda {
+          scope.perform { |t|
+            t.send("/queue/test", "my body")
+            t.commit
+            raise ArgumentError
+          }
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/onstomp/components/scopes_spec.rb

@@ -0,0 +1,63 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Components
+  describe Scopes do
+    let(:connection) {
+      mock('connection')
+    }
+    let(:scoper) {
+      mock('scoper').tap do |m|
+        m.extend Scopes
+      end
+    }
+    
+    describe ".with_headers" do
+      before(:each) do
+        scoper.stub :connection => connection
+      end
+      it "should create a new Header Scope" do
+        scoper.with_headers(:header1 => 'value 1', 'header2' => 'value 2').
+          should be_a_header_scope(:header1 => 'value 1',
+            'header2' => 'value 2')
+      end
+      it "should yield the scope to a given block" do
+        yielded = nil
+        scoper.with_headers :header1 => 'value 1', 'header2' => 'value 2' do |h|
+          yielded = h
+        end
+        yielded.should be_a_header_scope(:header1 => 'value 1',
+          'header2' => 'value 2')
+      end
+    end
+    
+    describe ".with_receipt" do
+      before(:each) do
+        scoper.stub :connection => connection
+      end
+      it "should create a new Receipt Scope" do
+        callback = lambda { |r| true }
+        scoper.with_receipt(&callback).should be_a_receipt_scope(callback)
+      end
+    end
+    
+    describe ".transaction" do
+      before(:each) do
+        scoper.stub(:connection => OnStomp::Connections::Stomp_1_1.new(
+          mock('io'), scoper))
+      end
+      it "should create a new transaction scope" do
+        scoper.transaction('t-1234').should be_a_transaction_scope('t-1234')
+      end
+      it "should evaluate a given block within the transaction" do
+        performed = nil
+        scoper.should_receive(:transmit).with(an_onstomp_frame('BEGIN'))
+        scoper.should_receive(:transmit).with(an_onstomp_frame('COMMIT'))
+        scoper.transaction('t-5678') do |t|
+          performed = t
+        end
+        performed.should be_a_transaction_scope
+      end
+    end
+  end
+end

data/spec/onstomp/components/subscription_spec.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Components
+  describe Subscription do
+    let(:frame) {
+      mock('frame')
+    }
+    let(:callback) {
+      mock('callback')
+    }
+    let(:subscription) {
+      Subscription.new frame, callback
+    }
+    
+    describe ".initialize" do
+      it "should take a frame and a callback" do
+        subscription.frame.should == frame
+        subscription.callback.should == callback
+      end
+    end
+    
+    describe ".id" do
+      it "should pull the id header from its frame" do
+        frame.stub(:[]).with(:id).and_return('s-1234')
+        subscription.id.should == 's-1234'
+      end
+    end
+    
+    describe ".destination" do
+      it "should pull the destination header from its frame" do
+        frame.stub(:[]).with(:destination).and_return('some.path.to.write')
+        subscription.destination.should == 'some.path.to.write'
+      end
+    end
+    
+    describe ".call" do
+      it "should invoke its callback with the supplied frame" do
+        callback.should_receive(:call).with(frame)
+        subscription.call(frame)
+      end
+    end
+    
+    describe ".include?" do
+      it "should return true if the supplied frame's destination matches its destination" do
+        subscription.stub(:destination => 'some.path.to.write')
+        frame.stub(:[]).with(:destination).and_return('some.path.to.write')
+        subscription.should include(frame)
+      end
+      
+      it "should return false if the supplied frame's destination does not match its destination" do
+        subscription.stub(:destination => 'some.other.path.to.write')
+        frame.stub(:[]).with(:destination).and_return('some.path.to.write')
+        subscription.should_not include(frame)
+      end
+    end
+  end
+end

data/spec/onstomp/components/threaded_processor_spec.rb

@@ -0,0 +1,92 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Components
+  describe ThreadedProcessor do
+    let(:processor) {
+      ThreadedProcessor.new(client)
+    }
+    let(:client) {
+      mock("client", :connection => connection, :connected? => false)
+    }
+    let(:connection) {
+      mock("connection", :io_process => nil)
+    }
+    
+    describe ".start / .stop" do
+      it "should start and stop the processor" do
+        checked_client = false
+        client.stub(:connected?).and_return do
+          checked_client = true
+          Thread.stop
+        end
+        processor.start
+        Thread.pass until checked_client
+        processor.running?.should be_true
+        processor.stop
+        processor.running?.should be_false
+      end
+      it "should raise any IOErrors raised in the thread, if the client is alive" do
+        client.stub(:connected? => true)
+        connection.stub(:io_process) do
+          raise IOError
+        end
+        processor.start
+        Thread.pass while processor.running?
+        lambda { processor.stop }.should raise_error(IOError)
+      end
+      it "should raise any SystemCallErrors raised in the thread, if the client is alive" do
+        client.stub(:connected? => true)
+        connection.stub(:io_process) do
+          raise SystemCallError.new('blather', 13)
+        end
+        processor.start
+        Thread.pass while processor.running?
+        lambda { processor.stop }.should raise_error(SystemCallError)
+      end
+      it "should not raise any IOErrors raised in the thread, if the client is dead" do
+        client.stub(:connected? => true)
+        connection.stub(:io_process) do
+          raise IOError
+        end
+        processor.start
+        Thread.pass while processor.running?
+        client.stub(:connected? => false)
+        lambda { processor.stop }.should_not raise_error
+      end
+      it "should not raise any SystemCallErrors raised in the thread, if the client is dead" do
+        client.stub(:connected? => true)
+        connection.stub(:io_process) do
+          raise SystemCallError.new('blather', 13)
+        end
+        processor.start
+        Thread.pass while processor.running?
+        client.stub(:connected? => false)
+        lambda { processor.stop }.should_not raise_error
+      end
+    end
+    
+    describe ".join" do
+      it "should block the current thread until connection is no longer alive" do
+        joined_properly = false
+        joining = false
+        spun_up = false
+        client_alive = true
+        join_tester = Thread.new do
+          Thread.pass until joining
+          sleep(0.1)
+          client.stub(:connected? => false)
+          joined_properly = true
+        end
+        client.stub(:connected?).and_return do
+          spun_up = true
+        end
+        processor.start
+        Thread.pass until spun_up
+        joining = true
+        processor.join
+        joined_properly.should be_true
+      end
+    end
+  end
+end

data/spec/onstomp/components/uri_spec.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Components
+  describe URI do
+    it "should make stomp:// strings parseable" do
+      ::URI.parse("stomp:///").should be_a_kind_of(OnStomp::Components::URI::STOMP)
+    end
+    it "should make stomp+ssl:// strings parseable" do
+      ::URI.parse("stomp+ssl:///").should be_a_kind_of(OnStomp::Components::URI::STOMP_SSL)
+    end
+    
+    describe URI::STOMP do
+      let(:uri) { ::URI.parse("stomp:///") }
+      it "should have a default port of 61613" do
+        uri.port.should == 61613
+      end
+      it "should have an onstomp_socket_type of :tcp" do
+        uri.onstomp_socket_type.should == :tcp
+      end
+    end
+    
+    describe URI::STOMP_SSL do
+      let(:uri) { ::URI.parse("stomp+ssl:///") }
+      it "should have a default port of 61612" do
+        uri.port.should == 61612
+      end
+      it "should have an onstomp_socket_type of :ssl" do
+        uri.onstomp_socket_type.should == :ssl
+      end
+    end
+  end
+end