micro_q 0.6.1

data/spec/lib/middleware/chain_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+describe MicroQ::Middleware::Chain do
+  describe MicroQ::Middleware::Chain::Base do
+    subject { MicroQ::Middleware::Chain::Base.new }
+
+    class MyMiddleware; end
+    class OtherMiddleware; end
+
+    describe '#add' do
+      before do
+        subject.add MyMiddleware
+      end
+
+      it 'should add the item' do
+        subject.entries.should include(MyMiddleware)
+      end
+
+      it 'should be appended' do
+        subject.entries.last.should == MyMiddleware
+      end
+
+      it 'should only add unique items' do
+        subject.add MyMiddleware
+        subject.add MyMiddleware
+
+        subject.entries.uniq.should == subject.entries
+      end
+    end
+
+    describe '#remove' do
+      before do
+        subject.add MyMiddleware
+
+        subject.entries.should include(MyMiddleware)
+        subject.remove MyMiddleware
+      end
+
+      it 'should remove the item' do
+        subject.entries.should_not include(MyMiddleware)
+      end
+    end
+
+    describe '#clear' do
+      before do
+        subject.add MyMiddleware
+      end
+
+      it 'should remove all entries' do
+        subject.entries.should == [MyMiddleware]
+        subject.clear
+
+        subject.entries.should == []
+      end
+    end
+
+    describe '#add_before' do
+      class MiddleMiddleware; end
+
+      def add_before
+        subject.add_before(OtherMiddleware, MiddleMiddleware)
+      end
+
+      before do
+        subject.clear
+        subject.add MyMiddleware
+        subject.add OtherMiddleware
+      end
+
+      it 'should not add nils' do
+        subject.add_before MyMiddleware
+        subject.entries.should have(2).items
+      end
+
+      it 'should add the middleware in the specified place' do
+        add_before
+
+        subject.entries.should == [
+          MyMiddleware,
+          MiddleMiddleware,
+          OtherMiddleware
+        ]
+      end
+
+      describe 'when relocating middleware' do
+        before do
+          subject.add MiddleMiddleware
+        end
+
+        it 'should move the middleware to the specified place' do
+          subject.entries.should == [
+            MyMiddleware,
+            OtherMiddleware,
+            MiddleMiddleware
+          ]
+
+          add_before
+
+          subject.entries.should == [
+            MyMiddleware,
+            MiddleMiddleware,
+            OtherMiddleware
+          ]
+        end
+      end
+
+      describe 'when adding multiple' do
+        class SecondMiddleMiddleware; end
+
+        def add_before
+          subject.add_before(OtherMiddleware, MiddleMiddleware, SecondMiddleMiddleware)
+        end
+
+        it 'should add the middlewares in the specified place' do
+          add_before
+
+          subject.entries.should == [
+            MyMiddleware,
+            MiddleMiddleware,
+            SecondMiddleMiddleware,
+            OtherMiddleware
+          ]
+        end
+      end
+    end
+
+    describe '#add_after' do
+      class MiddleMiddleware; end
+
+      def add_after
+        subject.add_after(OtherMiddleware, MiddleMiddleware)
+      end
+
+      before do
+        subject.clear
+        subject.add MyMiddleware
+        subject.add OtherMiddleware
+      end
+
+      it 'should not add nils' do
+        subject.add_after MyMiddleware
+        subject.entries.should have(2).items
+      end
+
+      it 'should add the middleware in the specified place' do
+        add_after
+
+        subject.entries.should == [
+          MyMiddleware,
+          OtherMiddleware,
+          MiddleMiddleware
+        ]
+      end
+
+      describe 'when relocating middleware' do
+        before do
+          subject.add_before MyMiddleware, MiddleMiddleware
+        end
+
+        it 'should move the middleware to the specified place' do
+          subject.entries.should == [
+            MiddleMiddleware,
+            MyMiddleware,
+            OtherMiddleware
+          ]
+
+          add_after
+
+          subject.entries.should == [
+            MyMiddleware,
+            OtherMiddleware,
+            MiddleMiddleware
+          ]
+        end
+      end
+
+      describe 'when adding multiple' do
+        class SecondMiddleMiddleware; end
+
+        def add_after
+          subject.add_after(OtherMiddleware, MiddleMiddleware, SecondMiddleMiddleware)
+        end
+
+        it 'should add the middlewares in the specified place' do
+          add_after
+
+          subject.entries.should == [
+            MyMiddleware,
+            OtherMiddleware,
+            MiddleMiddleware,
+            SecondMiddleMiddleware
+          ]
+        end
+      end
+    end
+  end
+
+  describe '.server' do
+    it 'should expose the server middleware' do
+      subject.server.class.should == MicroQ::Middleware::Chain::Server
+    end
+
+    it 'should cache the object' do
+      subject.server.object_id.should == subject.server.object_id
+    end
+
+    describe 'defaults' do
+      [MicroQ::Middleware::Server::Retry].each do |klass|
+        it "should include #{klass}" do
+          subject.server.entries.should include(klass)
+        end
+      end
+
+      it 'should be 1 item long' do
+        subject.server.entries.should have(1).items
+      end
+    end
+  end
+
+  describe '.client' do
+    it 'should expose the server middleware' do
+      subject.client.class.should == MicroQ::Middleware::Chain::Client
+    end
+
+    it 'should cache the object' do
+      subject.client.object_id.should == subject.client.object_id
+    end
+
+    it "should be empty" do
+      subject.client.entries.should == []
+    end
+  end
+
+  describe '.call' do
+    let(:worker) { MyWorker.new }
+    let(:payload) { {'class' => 'MyWorker'} }
+
+    class MyWorker
+    end
+
+    before do
+      @retry = mock(MicroQ::Middleware::Server::Retry)
+      MicroQ::Middleware::Server::Retry.stub(:new).and_return(@retry)
+    end
+
+    describe 'server' do
+      def call
+        subject.server.call(worker, payload)
+      end
+
+      it 'should make a new middleware chain' do
+        subject.server.entries.each do |entry|
+          entry.should_receive(:new).and_return(mock('entry', :call => nil))
+        end
+
+        call
+      end
+
+      it 'should call each item' do
+        @retry.should_receive(:call).with(worker, payload)
+
+        call
+      end
+    end
+  end
+end

data/spec/lib/middleware/server/retry_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe MicroQ::Middleware::Server::Retry, :middleware => true do
+  describe '#call' do
+    let(:foo) { mock("Foo", :bar => nil) }
+    let(:block) { lambda { foo.bar } }
+
+    def call
+      subject.call @worker, @payload, &block
+    end
+
+    it 'should execute the block' do
+      foo.should_receive(:bar)
+
+      call
+    end
+
+    describe 'when the block raises an Exception' do
+      let(:exception) { Exception.new }
+      let(:block) { lambda { raise exception } }
+
+      describe 'when retry is disabled' do
+        before do
+          @payload['retry'] = false
+        end
+
+        it 'should re-raise the error' do
+          expect {
+            call
+          }.to raise_error(exception)
+        end
+      end
+
+      describe 'when retry is enabled' do
+        before do
+          @payload['retry'] = true
+        end
+
+        it 'should re-raise the error' do
+          expect {
+            call
+          }.to raise_error(exception)
+        end
+
+        it 'should increment the number of retries' do
+          @payload['retried'].should be_nil
+
+          safe(:call); @payload['retried']['count'].should == 1
+          safe(:call); @payload['retried']['count'].should == 2
+        end
+
+        it 'should update the retry when time' do
+          Timecop.freeze(DateTime.now) do
+            safe(:call); @payload['retried']['when'].to_i.should == (Time.now + 15).to_i
+
+            Timecop.travel(100)
+            safe(:call); @payload['retried']['when'].to_i.should == (Time.now + 15).to_i
+          end
+        end
+
+        it 'should set the last retry time' do
+          Timecop.freeze do
+            safe(:call)
+
+            @payload['retried']['at'].should == Time.now
+          end
+        end
+
+        it 'should push the message back onto the queue' do
+          MicroQ.should_receive(:push) do |payload, *|
+            payload.should == @payload
+          end
+
+          safe(:call)
+        end
+
+        it 'should enqueue for the next retry time' do
+          Timecop.freeze do
+            MicroQ.should_receive(:push).with(anything, hash_including('when' => (Time.now + 15).to_f))
+
+            safe(:call)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/proxies/base_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe MicroQ::Proxy::Base do
+  class MyModel
+    def self.seed
+    end
+
+    def process
+    end
+  end
+
+  let(:options) { { :class => MyModel } }
+
+  subject { MicroQ::Proxy::Base.new(options) }
+
+  describe '.new' do
+    describe 'when given the :at key' do
+      before do
+        Timecop.freeze
+
+        options[:at] = (Time.now + 60)
+      end
+
+      it 'should store the value' do
+        subject.at.should == (Time.now + 60).to_i
+      end
+    end
+
+    describe 'when given the :after key' do
+      before do
+        Timecop.freeze
+
+        options[:after] = 60
+      end
+
+      it 'should store the at time' do
+        subject.at.should == (Time.now + 60).to_i
+      end
+    end
+  end
+
+  describe 'valid?' do
+    it { should be_valid }
+    it { subject.klass.should == MyModel }
+
+    describe 'class' do
+      it 'should require a class' do
+        options[:class] = nil
+
+        should_not be_valid
+      end
+
+      it 'should require a constant' do
+        options[:class] = 'InvalidClass'
+
+        should_not be_valid
+      end
+
+      describe '#errors' do
+        [nil, 'InvalidClass'].each do |type|
+          it "should have an error for #{type.inspect}" do
+            options[:class] = type
+
+            subject.errors.should include("Proxies require a valid class")
+          end
+        end
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+    it 'should be false' do
+      subject.respond_to?(:not_a_method).should == false
+    end
+
+    describe 'for a method the class responds to' do
+      it 'should be true' do
+        subject.respond_to?(:seed).should == true
+      end
+    end
+
+    describe 'for a method the proxy responds to and the class doesn\'t' do
+      before do
+        @method = (subject.methods - options[:class].methods).first
+      end
+
+      it 'should be true' do
+        options[:class].respond_to?(@method).should == false
+        subject.klass.respond_to?(@method).should == false
+
+        subject.respond_to?(@method).should == true
+      end
+    end
+  end
+
+  describe '#method' do
+    it 'should store the method' do
+      subject.some_method
+
+      subject.method.should == 'some_method'
+    end
+  end
+
+  describe '#args' do
+    let(:args) { [1 ,2, 'value'] }
+
+    it 'should store given arguments' do
+      subject.some_method(*args)
+
+      subject.args.should == [1 ,2, 'value']
+    end
+  end
+
+  describe 'method invocations' do
+    let(:method) { -> { subject.some_method(1, 2) } }
+
+    it 'should push the message' do
+      MicroQ.should_receive(:push)
+
+      method.call
+    end
+
+    it 'should have the class' do
+      MicroQ.should_receive(:push).with(hash_including(:class => MyModel))
+
+      method.call
+    end
+
+    it 'should have the method' do
+      MicroQ.should_receive(:push).with(hash_including(:method => 'some_method'))
+
+      method.call
+    end
+
+    it 'should have the args' do
+      MicroQ.should_receive(:push).with(hash_including(:args => [1, 2]))
+
+      method.call
+    end
+
+    describe 'when given options' do
+      before do
+        options[:loader] = {:method => 'find', :args => [456]}
+        options[:foo] = 'bar'
+      end
+
+      it 'should have the random key' do
+        MicroQ.should_receive(:push).with(hash_including(:foo => 'bar'))
+
+        method.call
+      end
+
+      it 'should have the loader' do
+        MicroQ.should_receive(:push).with(hash_including(:loader => {:method => 'find', :args => [456]}))
+
+        method.call
+      end
+    end
+
+    describe 'when performing at a specific time' do
+      before do
+        options[:at] = Time.now + 60
+      end
+
+      it 'should push with the right \'when\' key' do
+        MicroQ.should_receive(:push).with(anything, :when => (Time.now + 60).to_i)
+
+        method.call
+      end
+    end
+
+    describe 'when performing after a specific time' do
+      before do
+        options[:after] = 120
+      end
+
+      it 'should push with the right \'when\' key' do
+        MicroQ.should_receive(:push).with(anything, :when => (Time.now + 120).to_i)
+
+        method.call
+      end
+    end
+  end
+end

data/spec/lib/proxies/class_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe MicroQ::Proxy::Class do
+  class MyModel
+    def self.configure
+    end
+  end
+  let(:options) { { :class => MyModel } }
+
+  subject { MicroQ::Proxy::Class.new(options) }
+
+  it 'should be a base proxy' do
+    subject.class.ancestors.should include(MicroQ::Proxy::Base)
+  end
+end

data/spec/lib/proxies/instance_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe MicroQ::Proxy::Instance do
+  class MyModel
+    def process
+    end
+  end
+
+  let(:options) { { :class => MyModel } }
+
+  subject { MicroQ::Proxy::Instance.new(options) }
+
+  it 'should be a base proxy' do
+    subject.class.ancestors.should include(MicroQ::Proxy::Base)
+  end
+
+  describe "#respond_to?" do
+    it 'should be false' do
+      subject.respond_to?(:not_a_method).should == false
+    end
+
+    describe 'for a method the instance responds to' do
+      it 'should be true' do
+        subject.respond_to?(:process).should == true
+      end
+    end
+
+    describe 'for a method the proxy responds to and a class instance doesn\'t' do
+      before do
+        @method = (subject.methods - options[:class].new.methods).first
+      end
+
+      it 'should be true' do
+        options[:class].new.respond_to?(@method).should == false
+        subject.klass.new.respond_to?(@method).should == false
+
+        subject.respond_to?(@method).should == true
+      end
+    end
+  end
+end