stapfen 2.2.1-java → 3.0.0-java

data/spec/client/kafka_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
-
+require 'hermann/consumer'
 require 'stapfen/client/kafka'
 
+
 describe Stapfen::Client::Kafka, :java => true do
-  let(:config)   { { :topic => 'test', :groupId => 'groupId', :zookeepers => 'foo' } }
-  let(:consumer) { double('Hermann::Consumer') }
+  let(:config)           { { :topic => 'test', :groupId => 'groupId', :zookeepers => 'foo' } }
+  let(:consumer)         { double('Hermann::Consumer') }
 
   subject(:client) { described_class.new(config) }
 
@@ -14,10 +15,20 @@ describe Stapfen::Client::Kafka, :java => true do
 
   it { should respond_to :connect }
 
-
   describe '#initialize' do
     context 'with valid input params' do
+      let(:hermann_opts)     { { :do_retry => false } }
+      let(:opts)             { { :consumer_opts => hermann_opts } }
+      let(:config_with_opts) { config.merge(opts) }
+
+      subject(:client) { described_class.new(config_with_opts) }
+
       it 'should be a object' do
+        expect(Hermann::Consumer).to receive(:new).with(
+          config[:topic],
+          config[:groupId],
+          config[:zookeepers],
+          hermann_opts)
         expect(client).to be_a described_class
       end
     end
@@ -53,6 +64,24 @@ describe Stapfen::Client::Kafka, :java => true do
     end
   end
 
+  describe '#closed?' do
+    subject(:result) { client.closed? }
+
+    context 'if a connection exists' do
+      before :each do
+        allow(client).to receive(:connection) { double('KAFKA::Connection') }
+      end
+      it { should be false }
+    end
+
+    context 'without a connection' do
+      before :each do
+        allow(client).to receive(:connection) { nil }
+      end
+      it { should be true }
+    end
+  end
+
   describe '#subscribe' do
     let(:topic) { 'topic' }
     let(:destination) { double('Destination') }

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '../lib'))
 
+# require 'pry'; binding.pry
 require 'stapfen'
 require 'rspec/its'
 

data/spec/worker_spec.rb

@@ -1,273 +1,418 @@
 require 'spec_helper'
 require 'stapfen/client/stomp'
 
+class ExampleWorker < Stapfen::Worker
+end
+
 describe Stapfen::Worker do
-  subject(:worker) { described_class.new }
 
-  context 'class methods' do
-    subject(:worker) { described_class }
+  after(:each) do
+    # These variables will persist between tests unless they're
+    # explicitly cleared. Also see `set_class_variable_defaults`.
+    described_class.set_class_variable_defaults
+    described_class.consumers = nil
+    if described_class.const_defined?(:RUBY_PLATFORM, false)
+      described_class.send(:remove_const, :RUBY_PLATFORM)
+    end
+  end
 
-    it { should respond_to :run! }
-    it { should respond_to :configure }
-    it { should respond_to :consume }
-    it { should respond_to :log }
-    it { should respond_to :shutdown }
+  describe '.configure' do
+    let(:dummy_proc) { Proc.new { double('Proc') } }
+    let(:example_logger) { double('Logger') }
+    let(:example_protocol) { double('Protocol') }
+    let(:example_connection_options) { double('Connection Options') }
 
-    describe '#use_stomp!' do
-      subject(:result) { worker.use_stomp! }
+    it 'accepts a configuration block' do
+      ExampleWorker.configure &dummy_proc
+      expect(ExampleWorker.instance_configuration).to eq(dummy_proc)
+    end
+  end
 
-      it 'should update the instance variable' do
-        expect(result).to be true
-        expect(worker).to be_stomp
-        expect(worker).not_to be_jms
-      end
+  describe '.run!' do
+    let(:dummy_instance) { double('Instance') }
+    it 'creates a new instance, handle signals, and call run' do
+      expect(ExampleWorker).to receive(:new).and_return dummy_instance
+      expect(ExampleWorker).to receive(:handle_signals)
+      expect(dummy_instance).to receive(:run)
+
+      ExampleWorker.run!
+
+      expect(ExampleWorker.class_variable_get(:@@workers)).to eq [dummy_instance]
     end
+  end
 
-    describe '#use_jms!', :java => true do
-      subject(:result) { worker.use_jms! }
+  describe '.consume(config_overrides={}, &block)' do
+    it 'adds the given block and config to @consumers array' do
+      example_proc = Proc.new {}
+      example_hash = double('hash')
+      described_class.consume(example_hash, &example_proc)
+      expect(described_class.consumers.first).to be_an(Array)
+      expect(described_class.consumers.first.first).to be example_hash
+      expect(described_class.consumers.first.last).to be example_proc
+    end
 
-      after :each do
-        # Reset to the default since we've modified the class
-        worker.use_stomp!
-      end
+    it 'raises a Stapfen::ConsumeError when called without a block' do
+      expect { described_class.consume }.to raise_error(Stapfen::ConsumeError)
+    end
+  end
 
-      it 'should update the instance variable' do
-        expect(result).to be true
-        expect(worker).to be_jms
-        expect(worker).not_to be_stomp
-      end
+  describe '.shutdown(&block)' do
+    it 'sets @destructor' do
+      example_proc = Proc.new {}
+      described_class.shutdown &example_proc
+      expect(described_class.instance_variable_get(:@destructor)).to be(example_proc)
     end
+  end
 
-    describe '#log' do
-      it "should store the block it's passed" do
-        logger = double('Mock Logger')
+  describe '.workers' do
+    it 'returns the array of workers' do
+      expect(described_class.workers).to eq([])
+    end
+  end
 
-        worker.log do
-          logger
-        end
+  describe '.exit_cleanly' do
+    let(:example_worker) { double('ExWorker') }
 
-        expect(worker.logger).to be_instance_of Proc
-      end
+    it 'is false if no workers' do
+      expect(described_class.workers.empty?).to eq(true)
+      expect(described_class.exit_cleanly).to eq(false)
+    end
 
-      after :each do
-        worker.logger = nil
-      end
+    it 'cleanly exits the worker and java environment' do
+      described_class.workers << example_worker
+      expect(Java::JavaLang::System).to receive(:exit).with(0)
+      expect(example_worker).to receive(:exit_cleanly)
+      expect(described_class.exit_cleanly).to eq(true)
     end
 
-    describe '#configure' do
-      let(:config) { {:valid => true} }
-      it 'should error when not passed a block' do
-        expect {
-          worker.configure
-        }.to raise_error(Stapfen::ConfigurationError)
-      end
+    it 'cleanly exits just the worker when not java' do
+      described_class.const_set(:RUBY_PLATFORM, '*not java*')
+      described_class.workers << example_worker
+      expect(Java::JavaLang::System).to_not receive(:exit)
+      expect(example_worker).to receive(:exit_cleanly)
+      expect(described_class.exit_cleanly).to eq(true)
+    end
 
-      it 'should save the return value from the block' do
-        worker.configure do
-          config
-        end
-        expect(worker.configuration.call).to eql(config)
-      end
+    it 'is false if an exception is raised' do
+      expect(Java::JavaLang::System).to receive(:exit).with(0)
+      described_class.workers << example_worker
+      expect(example_worker).to receive(:exit_cleanly).and_raise(StandardError)
+      expect(described_class.exit_cleanly).to eq(false)
     end
+  end
 
-    describe '#exit_cleanly', :java => true do
-      subject(:result) { worker.exit_cleanly }
+  describe '.handle_signals' do
+    it 'traps INT and TERM' do
+      expect(Signal).to receive(:trap).with(:INT)
+      expect(Signal).to receive(:trap).with(:TERM)
+      described_class.handle_signals
+    end
+  end
 
-      before do
-        allow(Java::JavaLang::System).to receive(:exit).with(0)
-      end
+  describe '#use_stomp!' do
+    it 'should require stomp' do
+      expect(subject).to receive(:require).with('stomp')
+      subject.use_stomp!
+      expect(subject.instance_variable_get(:@protocol)).to eq Stapfen::Worker::STOMP
+    end
 
-      after do
-        worker.class_variable_set(:@@workers, [])
+    it 'should raise a LoadError if require fails' do
+      expect(subject).to receive(:require).and_raise(LoadError)
+      expect { subject.use_stomp! }.to raise_error(LoadError)
+    end
+  end
+
+  describe '#stomp?' do
+    it 'is true when the protocol is stomp' do
+      subject.protocol = Stapfen::Worker::STOMP
+      expect(subject.stomp?).to be(true)
+    end
+
+    it 'is false when the protocol is anything else' do
+      subject.protocol = Stapfen::Worker::JMS
+      expect(subject.stomp?).to be(false)
+    end
+  end
+
+  describe '#use_jms!' do
+    it 'should require jms' do
+      described_class.const_set(:RUBY_PLATFORM, 'java')
+      expect(subject).to receive(:require).with('java')
+      expect(subject).to receive(:require).with('jms')
+      subject.use_jms!
+      expect(subject.instance_variable_get(:@protocol)).to eq Stapfen::Worker::JMS
+    end
+
+    it 'should raise a Stapfen::ConfigurationError if require fails' do
+      described_class.const_set(:RUBY_PLATFORM, '*not java*')
+      expect { subject.use_jms! }.to raise_error(Stapfen::ConfigurationError)
+    end
+
+    it 'should raise a LoadError if require fails' do
+      described_class.const_set(:RUBY_PLATFORM, 'java')
+      expect(subject).to receive(:require).and_raise(LoadError)
+      expect { subject.use_jms! }.to raise_error(LoadError)
+    end
+  end
+
+  describe '#jms?' do
+    it 'is true when the protocol is jms' do
+      subject.protocol = Stapfen::Worker::JMS
+      expect(subject.jms?).to be(true)
+    end
+
+    it 'is false when the protocol is anything else' do
+      subject.protocol = Stapfen::Worker::STOMP
+      expect(subject.jms?).to be(false)
+    end
+  end
+
+  describe '#use_kafka!' do
+    it 'should require kafka' do
+      described_class.const_set(:RUBY_PLATFORM, 'java')
+      expect(subject).to receive(:require).with('java')
+      expect(subject).to receive(:require).with('hermann')
+      subject.use_kafka!
+      expect(subject.instance_variable_get(:@protocol)).to eq Stapfen::Worker::KAFKA
+    end
+
+    it 'should raise a Stapfen::ConfigurationError if require fails' do
+      described_class.const_set(:RUBY_PLATFORM, '*not java*')
+      expect { subject.use_kafka! }.to raise_error(Stapfen::ConfigurationError)
+    end
+
+    it 'should raise a LoadError if require fails' do
+      described_class.const_set(:RUBY_PLATFORM, 'java')
+      expect(subject).to receive(:require).and_raise(LoadError)
+      expect { subject.use_kafka! }.to raise_error(LoadError)
+    end
+  end
+
+  describe '#kafka?' do
+    it 'is true when the protocol is kafka' do
+      subject.protocol = Stapfen::Worker::KAFKA
+      expect(subject.kafka?).to be(true)
+    end
+
+    it 'is false when the protocol is anything else' do
+      subject.protocol = Stapfen::Worker::JMS
+      expect(subject.kafka?).to be(false)
+    end
+  end
+
+  describe '#exit_cleanly' do
+    let(:stapfen_client) { double('RSpec Stomp Client') }
+
+    before :each do
+      subject.stub(:stapfen_client).and_return(stapfen_client)
+    end
+
+    it 'should close the stapfen_client' do
+      stapfen_client.stub(:closed?).and_return(false)
+      stapfen_client.should_receive(:close)
+      subject.exit_cleanly
+    end
+
+    context 'with out having connected a stapfen_client yet' do
+      before :each do
+        subject.stub(:stapfen_client).and_return(nil)
       end
 
-      context 'with no worker classes' do
-        it { should be false }
+      it 'should not raise any errors' do
+        expect {
+          subject.exit_cleanly
+        }.not_to raise_error
       end
+    end
+  end
 
-      context 'with a single worker class' do
-        let(:w) { double('Fake worker instance') }
+  describe '.configure' do
+    let(:config_proc) { Proc.new { {:valid => true} } }
+    it 'should error when not passed a block' do
+      expect {
+        described_class.configure
+      }.to raise_error(Stapfen::ConfigurationError)
+    end
 
-        before :each do
-          worker.class_variable_set(:@@workers, [w])
-        end
+    it 'should save the return value from the block' do
+      described_class.configure &config_proc
+      expect(described_class.instance_configuration.call).to eql(config_proc.call)
+    end
+  end
 
-        it "should execute the worker's #exit_cleanly method" do
-          w.should_receive(:exit_cleanly)
-          expect(result).to be true
-        end
+  describe '.exit_cleanly', :java => true do
+    subject(:result) { described_class.exit_cleanly }
 
-        it "should return false if the worker's #exit_cleanly method" do
-          w.should_receive(:exit_cleanly).and_raise(StandardError)
-          expect(result).to be false
-        end
-      end
+    before do
+      allow(Java::JavaLang::System).to receive(:exit).with(0)
+    end
 
-      context 'with multiple worker classes' do
-        let(:w1) { double('Fake Worker 1') }
-        let(:w2) { double('Fake Worker 2') }
+    after do
+      described_class.class_variable_set(:@@workers, [])
+    end
 
-        before do
-          worker.class_variable_set(:@@workers, [w1, w2])
-        end
+    context 'with no worker classes' do
+      it { should be false }
+    end
 
-        it 'should invoke both #exit_cleanly methods' do
-          expect(w1).to receive(:exit_cleanly)
-          expect(w2).to receive(:exit_cleanly)
-          expect(worker.exit_cleanly).to be true
-        end
+    context 'with a single worker class' do
+      let(:w) { double('Fake worker instance') }
+
+      before :each do
+        described_class.class_variable_set(:@@workers, [w])
+      end
+
+      it "should execute the worker's .exit_cleanly method" do
+        w.should_receive(:exit_cleanly)
+        expect(result).to be true
+      end
+
+      it "should return false if the worker's .exit_cleanly method" do
+        w.should_receive(:exit_cleanly).and_raise(StandardError)
+        expect(result).to be false
       end
     end
 
-    describe 'consume' do
-      context 'if no block is passed' do
-        it 'should raise an error if no block is passed' do
-          expect {
-            worker.consume 'jms.queue.lol'
-          }.to raise_error(Stapfen::ConsumeError)
-        end
+    context 'with multiple worker classes' do
+      let(:w1) { double('Fake Worker 1') }
+      let(:w2) { double('Fake Worker 2') }
+
+      before do
+        described_class.class_variable_set(:@@workers, [w1, w2])
       end
 
-      context 'with just a queue name' do
-        let(:name) { 'jms.queue.lol' }
+      it 'should invoke both .exit_cleanly methods' do
+        expect(w1).to receive(:exit_cleanly)
+        expect(w2).to receive(:exit_cleanly)
+        expect(described_class.exit_cleanly).to be true
+      end
+    end
+  end
 
-        before do
-          worker.instance_variable_set(:@consumers, [])
-        end
+  describe 'detailed consume tests' do
+    context 'if no block is passed' do
+      it 'should raise an error if no block is passed' do
+        expect {
+          described_class.consume 'jms.queue.lol'
+        }.to raise_error(Stapfen::ConsumeError)
+      end
+    end
 
-        it 'should add an entry for the queue name' do
-          worker.consume(name) do |msg|
-            nil
-          end
+    context 'with just a queue name' do
+      let(:name) { 'jms.queue.lol' }
+      let(:client_options) { {:topic => name} }
 
-          worker.consumers.should_not be_empty
-          entry = worker.consumers.first
-          entry.first.should eq(name)
-        end
+      before do
+        described_class.instance_variable_set(:@consumers, [])
       end
 
-      context 'unreceive behavior' do
-        let(:client) do
-          c = double('Mock Stapfen::Client')
-          c.stub(:connect)
-          c.stub(:can_unreceive? => true)
-          c.stub(:runloop)
-          c.stub(:unreceive)
-          c
+      it 'should add an entry for the queue name' do
+        described_class.consume(client_options) do |msg|
+          nil
         end
 
-        let(:name) { '/queue/some_queue' }
-        let(:message) do
-          m = Stomp::Message.new(nil)
-          m.stub(:body => 'rspec msg')
-          m
-        end
+        described_class.consumers.should_not be_empty
+        entry = described_class.consumers.first
+        entry.first.should eq(client_options)
+      end
+    end
 
-        before :each do
-          Stapfen::Client::Stomp.stub(:new).and_return(client)
+    context 'unreceive behavior' do
+      let(:stapfen_client) do
+        c = double('Mock Stapfen::Client')
+        c.stub(:connect)
+        c.stub(:can_unreceive? => true)
+        c.stub(:runloop)
+        c.stub(:unreceive)
+        c
+      end
 
-          # Clear any old consumers out
-          worker.consumers = []
+      let(:name) { '/queue/some_queue' }
+      let(:client_options) { {:topic => name} }
+      let(:message) do
+        m = Stomp::Message.new(nil)
+        m.stub(:body => 'rspec msg')
+        m
+      end
 
-          # Get a subscription?  Call the message handler block.
-          client.stub(:subscribe) do |name, headers, &block|
-            block.call(message)
-          end
+      before :each do
+        Stapfen::Client::Stomp.stub(:new).and_return(stapfen_client)
 
-          config = {:valid => true}
+        # Clear any old consumers out
+        described_class.consumers = []
 
-          worker.configure do
-            config
-          end
+        # Get a subscription?  Call the message handler block.
+        stapfen_client.stub(:subscribe) do |name, headers, &block|
+          block.call(message)
         end
 
-        after do
-          worker.class_variable_set(:@@workers, [])
+        config = {:valid => true}
+
+        described_class.configure do
+          config
         end
+      end
 
-        context 'with just a queue name' do
-          context 'on a failed message' do
-            it 'should not unreceive' do
-              client.should_receive(:unreceive).never
+      after do
+        described_class.class_variable_set(:@@workers, [])
+      end
 
-              worker.consume(name) {|msg| false }
-              worker.new.run
-            end
-          end
-          context 'on a successful message' do
-            it 'should not unreceive' do
-              client.should_receive(:unreceive).never
+      context 'with just a queue name' do
+        context 'on a failed message' do
+          it 'should not unreceive' do
+            stapfen_client.should_receive(:unreceive).never
 
-              worker.consume(name) {|msg| true }
-              worker.new.run
-            end
+            described_class.consume(client_options) {|msg| false }
+            described_class.new.run
           end
         end
+        context 'on a successful message' do
+          it 'should not unreceive' do
+            stapfen_client.should_receive(:unreceive).never
 
-        context 'with a queue name and headers for a dead_letter_queue and max_redeliveries' do
-          let(:unrec_headers) do
-            { :dead_letter_queue => '/queue/foo',
-            :max_redeliveries => 3 }
-          end
-
-          let(:raw_headers) { unrec_headers.merge(:other_header => 'foo!') }
-          context 'on a failed message' do
-            it 'should unreceive' do
-              client.should_receive(:unreceive).once
-
-              worker.consume(name, raw_headers) {|msg| false }
-              worker.new.run
-            end
-            it 'should pass :unreceive_headers through to the unreceive call' do
-              client.should_receive(:unreceive).with(message, unrec_headers).once
-
-              worker.consume(name, raw_headers) {|msg| false }
-              worker.new.run
-            end
-            it 'should not remove the unreceive headers from the consumer' do
-              worker.consume(name, raw_headers) {|msg| false}
-              worker.new.run
-
-              expect(worker.consumers.last[1][:dead_letter_queue]).to eql unrec_headers[:dead_letter_queue]
-              expect(worker.consumers.last[1][:max_redeliveries]).to eql unrec_headers[:max_redeliveries]
-            end
-          end
-          context 'on a successfully handled message' do
-            it 'should not unreceive' do
-              client.should_receive(:unreceive).never
-
-              worker.consume(name, raw_headers) {|msg| true }
-              worker.new.run
-            end
+            described_class.consume(client_options) {|msg| true }
+            described_class.new.run
           end
         end
       end
-    end
-  end
 
-  context 'instance methods' do
-    describe '#exit_cleanly' do
-      let(:client) { double('RSpec Stomp Client') }
+      context 'with a queue name and headers for a dead_letter_queue and max_redeliveries' do
+        let(:unrec_headers) do
+          { :dead_letter_queue => '/queue/foo',
+          :max_redeliveries => 3 }
+        end
 
-      before :each do
-        worker.stub(:client).and_return(client)
-      end
+        let(:raw_headers) { unrec_headers.merge(:other_header => 'foo!') }
+        let(:client_options) { {:topic => name}.merge(raw_headers) }
+        let(:config_overrides) { client_options.merge(unrec_headers) }
+        context 'on a failed message' do
+          it 'should unreceive' do
+            stapfen_client.should_receive(:unreceive).once
 
-      it 'should close the client' do
-        client.stub(:closed?).and_return(false)
-        client.should_receive(:close)
-        worker.exit_cleanly
-      end
+            described_class.consume(config_overrides) {|msg| false }
+            described_class.new.run
+          end
+          it 'should pass :unreceive_headers through to the unreceive call' do
+            stapfen_client.should_receive(:unreceive).with(message, config_overrides).once
 
-      context 'with out having connected a client yet' do
-        before :each do
-          worker.stub(:client).and_return(nil)
+            described_class.consume(config_overrides) {|msg| false }
+            described_class.new.run
+          end
+          it 'should not remove the unreceive headers from the consumer' do
+            described_class.consume(config_overrides) {|msg| false}
+            described_class.new.run
+
+            expect(described_class.consumers.last[0][:dead_letter_queue]).to eql unrec_headers[:dead_letter_queue]
+            expect(described_class.consumers.last[0][:max_redeliveries]).to eql unrec_headers[:max_redeliveries]
+          end
         end
+        context 'on a successfully handled message' do
+          it 'should not unreceive' do
+            stapfen_client.should_receive(:unreceive).never
 
-        it 'should not raise any errors' do
-          expect {
-            worker.exit_cleanly
-          }.not_to raise_error
+            described_class.consume(config_overrides) {|msg| true }
+            described_class.new.run
+          end
         end
       end
     end