stapfen 2.2.0-java

data/spec/client/jms_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM == 'java'
+  require 'stapfen/client/jms'
+
+  describe Stapfen::Client::JMS, :java => true do
+    let(:config) { {} }
+    subject(:client) { described_class.new(config) }
+
+    it { should respond_to :connect }
+
+    describe '#can_unreceive?' do
+      subject { client.can_unreceive? }
+
+      it { should be true }
+    end
+
+    describe '#unreceive' do
+      let(:body) { 'Some body in string form' }
+      let(:message) { double('Message', :destination => orig_destination, :data => body, :getStringProperty => nil) }
+      let(:max_redeliveries) { 2 }
+      let(:dlq) { '/queue/some_queue/dlq' }
+      let(:unreceive_headers) do
+        { :dead_letter_queue => dlq, :max_redeliveries => max_redeliveries }
+      end
+      let(:orig_destination) { '/queue/some_queue' }
+
+      subject(:unreceive!) { client.unreceive(message, unreceive_headers) }
+
+      context 'with no unreceive[:max_redeliveries] or unreceive[:dead_letter_queue]' do
+        let(:unreceive_headers) { Hash.new }
+
+        it 'should not resend the message' do
+          client.should_not_receive(:publish)
+
+          unreceive!
+        end
+      end
+
+      context 'On a message with no retry_count in the headers' do
+        before :each do
+          message.stub(:getStringProperty).with('retry_count').and_return(nil)
+        end
+
+        it 'should publish it to the same destination with a retry_count of 1' do
+          client.should_receive(:publish) do |dest, the_body, the_headers|
+            expect(dest).to eql orig_destination
+            expect(the_body).to eql body
+            expect(the_headers).to eql({'retry_count' => '1'})
+          end
+
+          unreceive!
+        end
+      end
+
+      context 'On a message with a retry_count in the headers' do
+        before :each do
+          message.stub(:getStringProperty).with('retry_count').and_return(retry_count)
+        end
+
+
+        context 'that is less than max_redeliveries' do
+         let(:retry_count) { max_redeliveries - 1 }
+
+          it 'should publish it to the same destination with a retry_count increased by one' do
+            client.should_receive(:publish) do |dest, the_body, the_headers|
+              expect(dest).to eql orig_destination
+              expect(the_body).to eql body
+
+
+              expect(the_headers).to eql({'retry_count' => (retry_count + 1).to_s})
+            end
+
+            unreceive!
+          end
+        end
+
+        # This is the 'last' attempt to redeliver, so don't send it again
+        context 'that is equal to max_redeliveries' do
+         let(:retry_count) { max_redeliveries }
+
+          it 'should publish it to the DLQ with no retry_count' do
+            client.should_receive(:publish) do |dest, the_body, the_headers|
+              expect(the_body).to eql body
+              expect(dest).to eql dlq
+
+              expect(the_headers).to eql({:original_destination => orig_destination})
+            end
+
+            unreceive!
+          end
+        end
+
+        context 'that is greater than max_redeliveries' do
+         let(:retry_count) { max_redeliveries + 1 }
+
+          it 'should publish it to the DLQ with no retry_count' do
+            client.should_receive(:publish) do |dest, the_body, the_headers|
+              expect(the_body).to eql body
+              expect(dest).to eql dlq
+
+              expect(the_headers).to eql({:original_destination => orig_destination})
+            end
+
+            unreceive!
+          end
+        end
+      end
+    end
+
+    describe '#connect' do
+      subject(:connection) { client.connect }
+      let(:jms_conn) { double('JMS::Connection') }
+
+      before :each do
+        ::JMS::Connection.should_receive(:new).and_return(jms_conn)
+      end
+
+      it 'should start the connection' do
+        jms_conn.should_receive(:start)
+        expect(connection).to eql(jms_conn)
+      end
+    end
+
+    describe '#session' do
+      let(:session) { double('JMS::Session') }
+      let(:connection) { double('JMS::Connection') }
+
+      before :each do
+        client.stub(:connection => connection)
+      end
+
+      context 'without a session already' do
+        it 'should create a new session' do
+          connection.should_receive(:create_session).and_return(session)
+          expect(client.session).to eql(session)
+        end
+      end
+
+      context 'with an existing session' do
+        it 'should return that existing session' do
+          connection.should_receive(:create_session).once.and_return(session)
+          3.times do
+            expect(client.session).to eql(session)
+          end
+        end
+      end
+    end
+
+    describe '#publish' do
+    end
+
+    describe '#closed?' do
+      subject(:result) { client.closed? }
+
+      context 'if a connection exists' do
+        before :each do
+          client.stub(:connection).and_return(double('JMS::Connection'))
+        end
+
+        it { should be false }
+      end
+
+      context 'without a connection' do
+        it { should be true }
+      end
+    end
+
+    describe '#close' do
+      subject(:result) { client.close }
+      let(:connection) { double('JMS::Connection') }
+
+      before :each do
+        client.instance_variable_set(:@connection, connection)
+      end
+
+      context 'without an existing session' do
+        it 'should close the client' do
+          connection.should_receive(:close)
+          expect(result).to be true
+        end
+      end
+
+      context 'with an existing session' do
+        let(:session) { double('JMS::Session') }
+
+        before :each do
+          client.instance_variable_set(:@session, session)
+        end
+
+        it 'should close the client and session' do
+          session.should_receive(:close)
+          connection.should_receive(:close)
+          expect(result).to be true
+        end
+      end
+    end
+  end
+end

data/spec/client/kafka_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+require 'stapfen/client/kafka'
+
+describe Stapfen::Client::Kafka, :java => true do
+  let(:config)   { { :topic => 'test', :groupId => 'groupId', :zookeepers => 'foo' } }
+  let(:consumer) { double('Hermann::Consumer') }
+
+  subject(:client) { described_class.new(config) }
+
+  before do
+    allow(Hermann::Consumer).to receive(:new) { consumer }
+  end
+
+  it { should respond_to :connect }
+
+  describe '#can_unreceive?' do
+    subject { client.can_unreceive? }
+    it { should be false }
+  end
+
+  describe '#close' do
+    subject(:result) { client.close }
+
+    context 'with a connection' do
+      it 'should close the client' do
+        allow(consumer).to receive(:shutdown)
+        expect(result).to be true
+      end
+    end
+    context 'without a connection' do
+      it 'returns false' do
+        expect(Hermann::Consumer).to receive(:new) { nil }
+        expect(consumer).to_not receive(:shutdown)
+        expect(result).to be false
+      end
+    end
+  end
+
+  describe '#subscribe' do
+    let(:topic) { 'topic' }
+    let(:destination) { double('Destination') }
+    let(:msg) { 'foo' }
+    it 'yields to the block and passes in consumed message' do
+      allow(destination).to receive(:as_kafka) { topic }
+      allow(Stapfen::Destination).to receive(:from_string) { destination }
+      allow(consumer).to receive(:consume).with(topic).and_yield(msg)
+
+      expect{ |b|
+        client.subscribe(destination, nil, &b)
+      }.to yield_with_args(msg)
+    end
+  end
+end

data/spec/client/stomp_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'stapfen/client/stomp'
+
+describe Stapfen::Client::Stomp do
+end

data/spec/client_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'stapfen/client'
+
+describe Stapfen::Client do
+end

data/spec/destination_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'stapfen/destination'
+
+describe Stapfen::Destination do
+  it { should respond_to :name }
+  it { should respond_to :type }
+
+  describe '#as_kafka' do
+    let(:name) { 'topic' }
+    subject(:destination) do
+      d = described_class.new
+      d.type = :topic
+      d.name = name
+      d.as_kafka
+    end
+
+    it { should be_instance_of String }
+    it { should eql "topic" }
+  end
+
+  describe '#as_jms' do
+    let(:name) { 'rspec/dlq' }
+    subject(:destination) do
+      d = described_class.new
+      d.type = :queue
+      d.name = name
+      d.as_jms
+    end
+
+    it { should be_instance_of String }
+    it { should eql "queue://#{name}" }
+  end
+
+  describe '#as_stomp' do
+    let(:name) { 'rspec/dlq' }
+
+    subject(:destination) do
+      d = described_class.new
+      d.type = :queue
+      d.name = name
+      d.as_stomp
+    end
+
+    it { should be_instance_of String }
+    it { should eql "/queue/#{name}" }
+  end
+
+  context 'class methods' do
+    describe '#from_string' do
+      subject(:destination) { described_class.from_string(name) }
+
+      context 'a simple queue' do
+        let(:name) { '/queue/rspec' }
+        its(:name) { should eql 'rspec' }
+        its(:type) { should eql :queue }
+      end
+
+      context 'a queue with slashes' do
+        let(:name) { '/queue/rspec/dlq' }
+        its(:name) { should eql 'rspec/dlq' }
+        its(:type) { should eql :queue }
+      end
+
+      context 'a complex topic' do
+        let(:name) { '/topic/rspec/dlq' }
+        its(:name) { should eql 'rspec/dlq' }
+        its(:type) { should eql :topic }
+      end
+    end
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Stapfen::Logger do
+  let(:mixin) do
+    Class.new do
+      include Stapfen::Logger
+    end
+  end
+
+  subject(:logger) { mixin.new }
+
+  context 'instance methods' do
+    it { should respond_to :info }
+    it { should respond_to :debug }
+    it { should respond_to :warn }
+    it { should respond_to :error }
+
+    context 'without an initialized logger' do
+      before :each do
+        logger.class.stub(:logger)
+      end
+
+      it 'should discard info messages' do
+        expect(logger.info('rspec')).to be false
+      end
+    end
+
+    context 'with an initialized logger' do
+      let(:plogger) { double('RSpec Logger') }
+
+      before :each do
+        logger.class.stub(:logger).and_return(lambda { plogger })
+      end
+
+      it 'should pass info messages along' do
+        plogger.should_receive(:info)
+        expect(logger.info('rspec')).to be true
+      end
+    end
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'stapfen/message'
+
+if RUBY_PLATFORM == 'java'
+  require 'java'
+  require File.expand_path('./activemq-all-5.8.0.jar')
+end
+
+describe Stapfen::Message do
+  context 'accessors' do
+    it { should respond_to :message_id }
+    it { should respond_to :body }
+    it { should respond_to :original }
+    it { should respond_to :destination }
+  end
+
+  describe '#initialize' do
+    it 'should accept :body' do
+      body = 'hello'
+      m = described_class.new(:body => body)
+      expect(m.body).to eql(body)
+    end
+  end
+
+  context 'class methods' do
+    let(:body) { 'hello stapfen' }
+    let(:destination) { '/queue/rspec' }
+    let(:message_id) { rand.to_s }
+
+    describe '#from_stomp' do
+      subject(:result) { described_class.from_stomp(message) }
+
+      context 'when passed something other than a Stomp::Message' do
+        let(:message) { 'hello' }
+
+        it 'should raise an error' do
+          expect { result }.to raise_error(Stapfen::InvalidMessageError)
+        end
+      end
+
+      context 'when passed a Stomp::Message' do
+        let(:message) do
+          m = Stomp::Message.new('') # empty frame
+          m.body = body
+          headers = {'destination' => destination,
+                     'message-id' => message_id}
+          m.headers = headers
+          m
+        end
+
+        it 'should create an instance' do
+          expect(result).to be_instance_of Stapfen::Message
+        end
+
+        its(:body) { should eql body }
+        its(:destination) { should eql destination }
+        its(:message_id) { should eql message_id }
+        its(:original) { should be message }
+      end
+    end
+
+    describe '#from_jms', :java => true do
+      subject(:result) { described_class.from_jms(message) }
+
+      context 'when passed something other than a JMS message' do
+        let(:message) { 'hello' }
+
+        it 'should raise an error' do
+          expect { result }.to raise_error(Stapfen::InvalidMessageError)
+        end
+      end
+
+      context 'when passed an ActiveMQBytesMessage' do
+        let(:destination) { 'queue://rspec' }
+
+        let(:message) do
+          m = Java::OrgApacheActivemqCommand::ActiveMQBytesMessage.new
+          m.stub(:jms_destination => double('ActiveMQDestination mock', :getQualifiedName => destination))
+          m.stub(:jms_message_id => message_id)
+          m.stub(:data => body)
+          m
+        end
+
+        it 'should create an instance' do
+          expect(result).to be_instance_of Stapfen::Message
+        end
+
+        its(:body) { should eql body }
+        its(:destination) { should eql destination }
+        its(:message_id) { should eql message_id }
+        its(:original) { should be message }
+
+      end
+    end
+  end
+end