micro_q 0.6.1

data/micro_q.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'micro_q/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "micro_q"
+  gem.version       = MicroQ::VERSION
+  gem.authors       = ["Brian Norton"]
+  gem.email         = ["brian.nort@gmail.com"]
+  gem.description   = ""
+  gem.summary       = ""
+  gem.homepage      = "http://github.com/bnorton/micro-q"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency             "celluloid"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "timecop"
+  gem.add_development_dependency "psych"
+  gem.add_development_dependency "activerecord", "> 3.2.0"
+  gem.add_development_dependency "sqlite3-ruby"
+end

data/spec/helpers/methods_examples.rb

@@ -0,0 +1,45 @@
+shared_examples_for "a_worker" do |method|
+  describe "additions (#{method})" do
+    it 'should add an async proxy' do
+      subject.respond_to?(:async).should == true
+    end
+
+    it 'should proxy to the object' do
+      subject.async.respond_to?(method).should == true
+    end
+
+    describe 'before first calling the _async method' do
+      it 'should not respond to the _async method' do
+        subject.respond_to?(method).should == true
+        subject.respond_to?("#{method}_async").should == false
+      end
+    end
+
+    describe 'after first call' do
+      before do
+        subject.send("#{method}_async")
+      end
+
+      it "should add a _async method" do
+        subject.respond_to?(method).should == true
+        subject.respond_to?("#{method}_async").should == true
+      end
+    end
+  end
+
+  describe 'errors' do
+    describe 'when calling a missing _async method' do
+      it 'should fail' do
+        expect {
+          subject.send("some_method_async")
+        }.to raise_error
+      end
+
+      it 'should raise an undefined method error (without the _async)' do
+        ex = (begin; subject.send("some_method_async"); rescue => e; e end)
+
+        ex.message.should match(/undefined method \`some_method_async\'/)
+      end
+    end
+  end
+end

data/spec/lib/config_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe MicroQ::Config do
+  [[:a_key, 'abc123'], [:key, 'the-value']].each do |(method, value)|
+    describe "##{method}" do
+      before do
+        subject.send("#{method}=", value)
+      end
+
+      it 'should access the given value (:sym)' do
+        subject[method].should == value
+      end
+
+      it 'should access the given value (str)' do
+        subject[method.to_s].should == value
+      end
+
+      it "should have the value at ##{method}" do
+        subject.send(method).should == value
+      end
+    end
+  end
+
+  describe 'defaults' do
+    subject { MicroQ.config }
+
+    it 'should have 3 workers' do
+      subject.workers.should == 3
+    end
+
+    it 'should have a 5 second interval' do
+      subject.interval.should == 5
+    end
+
+    it 'should have a 120 second timeout' do
+      subject.timeout.should == 120
+    end
+
+    it 'should have middleware chain' do
+      subject.middleware.class.should == MicroQ::Middleware::Chain
+    end
+
+    it 'should not have a logfile' do
+      subject.logfile.should == nil
+    end
+  end
+end

data/spec/lib/manager/default_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe MicroQ::Manager::Default do
+  let(:create) { -> { subject } }
+
+  describe '.new' do
+    before do
+      MicroQ.config.workers = 4
+    end
+
+    it 'should create a default queue' do
+      MicroQ::Queue::Default.should_receive(:new)
+
+      create.call
+    end
+
+    it 'should create a worker pool' do
+      MicroQ::Worker::Standard.should_receive(:pool)
+
+      create.call
+    end
+
+    it 'should be a config.workers size pool' do
+      MicroQ::Worker::Standard.should_receive(:pool).with(hash_including(:size => 4))
+
+      create.call
+    end
+  end
+
+  describe '#queue' do
+    it 'should be the queue' do
+      subject.queue.wrapped_object.class.should == MicroQ::Queue::Default
+    end
+  end
+
+  describe '#workers' do
+    it 'should be the workers' do
+      subject.workers.class.should == Celluloid::PoolManager
+      subject.workers.inspect.should match(/MicroQ::Worker::Standard/)
+    end
+  end
+
+  describe '#start' do
+    it 'should not be performing' do
+      subject.workers.should_not_receive(:perform!)
+
+      subject.start
+    end
+
+    describe 'when the queue has dequeue-able items' do
+      before do
+        @item, @other_item = mock(Hash), mock(Hash)
+        @queue = mock(MicroQ::Queue::Default, :dequeue => [@item, @other_item])
+        MicroQ::Queue::Default.stub(:new).and_return(@queue)
+
+        @pool = mock(Celluloid::PoolManager)
+        MicroQ::Worker::Standard.stub(:pool).and_return(@pool)
+      end
+
+      it 'should perform the items' do
+        @pool.should_receive(:perform!).with(@item) do
+          @pool.should_receive(:perform!).with(@other_item)
+        end
+
+        subject.start
+      end
+    end
+  end
+end

data/spec/lib/methods/active_record_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'active_record'
+require 'micro_q/methods/active_record'
+
+describe MicroQ::Methods::ActiveRecord, :active_record => true do
+  class Repository < ActiveRecord::Base
+    def id
+      456
+    end
+
+    def process
+    end
+  end
+
+  shared_examples_for 'an async AR instance' do
+    before do
+      @proxy = mock(MicroQ::Proxy::Instance, :process => nil)
+      MicroQ::Proxy::Instance.stub(:new).and_return(@proxy)
+    end
+
+    it 'should create a proxy' do
+      MicroQ::Proxy::Instance.should_receive(:new).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should have the class' do
+      MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:class => subject.class)).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should have the activerecord find with the record id' do
+      MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:loader => {:method => 'find', :args => [456]})).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should call the method' do
+      @proxy.should_receive(:process)
+
+      method.call
+    end
+
+    it 'should pass arguments' do
+      @proxy.should_receive(:process).with(1, 2, 3)
+
+      method.call(1, 2, 3)
+    end
+  end
+
+  subject { Repository.new }
+
+  it_behaves_like 'a_worker', 'process'
+
+  describe 'when an _async method is called' do
+    let(:method) { lambda {|*args| subject.process_async(*args) } }
+
+    it_behaves_like 'an async AR instance'
+  end
+
+  describe 'when calling to async.method proxy' do
+    let(:method) { lambda {|*args| subject.async.process(*args) } }
+
+    it_behaves_like 'an async AR instance'
+  end
+end

data/spec/lib/methods/class_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe MicroQ::Methods::Class do
+  class MyWorker
+    def self.seed
+    end
+  end
+
+  shared_examples_for 'an async class' do
+    before do
+      @proxy = mock(MicroQ::Proxy::Class, :seed => nil)
+      MicroQ::Proxy::Class.stub(:new).and_return(@proxy)
+    end
+
+    it 'should create a proxy' do
+      MicroQ::Proxy::Class.should_receive(:new).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should have the class' do
+      MicroQ::Proxy::Class.should_receive(:new).with(hash_including(:class => subject)).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should have a loader without a method' do
+      MicroQ::Proxy::Class.should_receive(:new).with(hash_including(:loader => {})).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should call the method' do
+      @proxy.should_receive(:seed)
+
+      method.call
+    end
+
+    it 'should pass arguments' do
+      @proxy.should_receive(:seed).with(1, 2, 3)
+
+      method.call(1, 2, 3)
+    end
+  end
+
+  subject { MyWorker }
+
+  it_behaves_like 'a_worker', 'seed'
+
+  describe 'when an _async method is called' do
+    let(:method) { lambda {|*args| subject.seed_async(*args) } }
+
+    it_behaves_like 'an async class'
+  end
+
+  describe 'when calling to async.method proxy' do
+    let(:method) { lambda {|*args| subject.async.seed(*args) } }
+
+    it_behaves_like 'an async class'
+  end
+end

data/spec/lib/methods/instance_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe MicroQ::Methods::Instance do
+  class MyWorker
+    def process
+    end
+  end
+
+  shared_examples_for 'an async instance' do
+    before do
+      @proxy = mock(MicroQ::Proxy::Instance, :process => nil)
+      MicroQ::Proxy::Instance.stub(:new).and_return(@proxy)
+    end
+
+    it 'should create a proxy' do
+      MicroQ::Proxy::Instance.should_receive(:new).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should have the class' do
+      MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:class => subject.class)).and_return(@proxy)
+
+      method.call
+    end
+
+    it 'should call the method' do
+      @proxy.should_receive(:process)
+
+      method.call
+    end
+
+    it 'should pass arguments' do
+      @proxy.should_receive(:process).with(1, 2, 3)
+
+      method.call(1, 2, 3)
+    end
+  end
+
+  subject { MyWorker.new }
+
+  it_behaves_like 'a_worker', 'process'
+
+  describe 'when an _async method is called' do
+    let(:method) { lambda {|*args| subject.process_async(*args) } }
+
+    it_behaves_like 'an async instance'
+  end
+
+  describe 'when calling to async.method proxy' do
+    let(:method) { lambda {|*args| subject.async.process(*args) } }
+
+    it_behaves_like 'an async instance'
+  end
+end

data/spec/lib/micro_q_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe MicroQ do
+  describe '.configure' do
+    it 'should be the config' do
+      MicroQ.configure {|config| config.class.should == MicroQ::Config }
+    end
+
+    it "should cache the value" do
+      configs = []
+
+      2.times { MicroQ.configure {|c| configs << c } }
+
+      configs[0].should == configs[1]
+    end
+  end
+
+  describe '.config' do
+    it 'should be the config' do
+      MicroQ.config.class.should == MicroQ::Config
+    end
+  end
+
+  describe '.middleware' do
+    it 'should alias the middleware on the config' do
+      MicroQ.middleware.should == MicroQ.config.middleware
+    end
+  end
+
+  describe '.start' do
+    def start
+      MicroQ.start
+    end
+
+    before do
+      @manager = mock(MicroQ::Manager::Default, :start! => nil)
+      MicroQ::Manager::Default.stub(:new).and_return(@manager)
+    end
+
+    it 'should create a queue' do
+      MicroQ::Manager::Default.should_receive(:new).and_return(@manager)
+
+      start
+    end
+
+    it 'should cache the queue' do
+      MicroQ::Manager::Default.should_receive(:new).once.and_return(@manager)
+
+      3.times { start }
+    end
+
+    it 'should asynchronously start the manager (once)' do
+      @manager.should_receive(:start!).once
+
+      start
+    end
+  end
+
+  describe '.push' do
+    let(:args) { [{ :class => 'WorkerClass' }, { :option => 'value' }] }
+
+    def push
+      MicroQ.push(*args)
+    end
+
+    before do
+      @async = mock(Celluloid::AsyncProxy)
+      @manager = mock(MicroQ::Manager::Default, :start! => nil, :queue => mock("Queue", :async => @async))
+      MicroQ::Manager::Default.stub(:new).and_return(@manager)
+
+      MicroQ.start
+    end
+
+    it 'should delegate to the manager\'s queue' do
+      @async.should_receive(:push).with(*args)
+
+      push
+    end
+  end
+end