qu 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+gemspec :name => 'qu'
+
+Dir['qu-*.gemspec'].each do |gemspec|
+  plugin = gemspec.scan(/qu-(.*)\.gemspec/).to_s
+
+  group plugin do
+    gemspec(:name => "qu-#{plugin}", :development_group => plugin)
+  end
+end
+
+group :test do
+  gem 'SystemTimer', :platform => :mri_18
+  gem 'ruby-debug',  :platform => :mri_18
+  gem 'rake'
+  gem 'rspec', '~> 2.0'
+  gem 'guard-rspec'
+  gem 'guard-bundler'
+end

data/Guardfile

@@ -0,0 +1,12 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/qu/backend/spec\.rb$})   { |m| "spec/qu/backend" }
+  watch('spec/spec_helper.rb')        { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})  { "spec" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end

data/README.md

@@ -0,0 +1,140 @@
+# Qu
+
+Qu is a Ruby library for queuing and processing background jobs. It is heavily inspired by delayed_job and Resque.
+
+Qu was created to overcome some shortcomings in the existing queuing libraries that we experienced at [Ordered List](http://orderedlist.com) while building [SpeakerDeck](http://speakerdeck.com), [Gaug.es](http://get.gaug.es) and [Harmony](http://get.harmonyapp.com). The advantages of Qu are:
+
+* Multiple backends (redis, mongo)
+* Jobs are requeued when worker is killed
+* Resque-like API
+
+## Information & Help
+
+* Find more information on the [Wiki](https://github.com/bkeepers/qu/wiki).
+* Post to the [Google Group](http://groups.google.com/group/qu-users) for help or questions.
+* See the [issue tracker](https://github.com/bkeepers/qu/issues) for known issues or to report an issue.
+
+## Installation
+
+### Rails
+
+Decide which backend you want to use and add the gem for it to your `Gemfile`.
+
+``` ruby
+gem 'qu-redis'
+```
+
+That's all you need to do!
+
+## Usage
+
+Jobs are any class that responds to the `.perform` method:
+
+``` ruby
+class ProcessPresentation
+  def self.perform(presentation_id)
+    presentation = Presentation.find(presentation_id)
+    presentation.process!
+  end
+end
+```
+
+You can add a job to the queue by calling the `enqueue` method:
+
+``` ruby
+job = Qu.enqueue ProcessPresentation, @presentation.id
+puts "Enqueued job #{job.id}"
+```
+
+Any additional parameters passed to the `enqueue` method will be passed on to the `perform` method of your job class. These parameters will be stored in the backend, so they must be simple types that can easily be serialized and unserialized. So don't try to pass in an ActiveRecord object.
+
+Processing the jobs on the queue can be done with a Rake task:
+
+``` sh
+$ bundle exec rake qu:work
+```
+
+You can easily inspect the queue or clear it:
+
+``` ruby
+puts "Jobs on the queue:", Qu.length
+Qu.clear
+```
+
+### Queues
+
+The `default` queue is used, um…by default. Jobs that don't specify a queue will be placed in that queue, and workers that don't specify a queue will work on that queue.
+
+However, if you have some background jobs that are more or less important, or some that take longer than others, you may want to consider using multiple queues. You can have workers dedicated to specific queues, or simply tell all your workers to work on the most important queue first.
+
+Jobs can be placed in a specific queue by setting the queue variable:
+
+``` ruby
+class CallThePresident
+  @queue = :urgent
+
+  def self.perform(message)
+    # …
+  end
+end
+```
+
+You can then tell workers to work on this queue by passing an environment variable
+
+``` sh
+$ bundle exec rake qu:work QUEUES=urgent,default
+```
+
+Note that if you still want your worker to process the default queue, you must specify it. Queues will be process in the order they are specified.
+
+You can also get the length or clear a specific queue:
+
+``` ruby
+Qu.length(:urgent)
+Qu.clear(:urgent)
+```
+
+## Configuration
+
+Most of the configuration for Qu should be automatic. It will also automatically detect ENV variables from Heroku for backend connections, so you shouldn't need to do anything to configure the backend.
+
+However, if you do need to customize it, you can by calling the `Qu.configure`:
+
+``` ruby
+Qu.configure do |c|
+  c.connection = Redis::Namespace.new('myapp:qu', :redis => Redis.connect)
+end
+```
+
+## Why another queuing library?
+
+Resque and delayed_job are both great, but both of them have shortcomings that can be frustrating in production applications.
+
+delayed_job was a brilliantly simple pioneer in the world of database-backed queues. While most asynchronous queuing systems were tending toward overly complex, it made use of your existing database and just worked. But there are a few flaws:
+
+* Occasionally fails silently.
+* Use of priority instead of separate named queues.
+* Contention in the ActiveRecord backend with multiple workers. Occasionally the same job gets performed by multiple workers.
+
+Resque, the wiser relative of delayed_job, fixes most of those issues. But in doing so, it forces some of its beliefs on you, and sometimes those beliefs just don't make sense for your environment. Here are some of the flaws of Resque:
+
+* Redis is a great queue backend, but it doesn't make sense for every environment.
+* Workers lose jobs when they are forced to quit. This has especially been an issue on Heroku.
+* Forking before each job prevents memory leaks, but it is terribly inefficient in environments with a lot of fast jobs (the resque-jobs-per-fork plugin alleviates this)
+
+Those shortcomings lead us to write Qu. It is not perfect, but we hope to overcome the issues we faced with other queuing libraries.
+
+## Contributing
+
+If you find what looks like a bug:
+
+1. Search the [mailing list](http://groups.google.com/group/qu-users) to see if anyone else had the same issue.
+2. Check the [GitHub issue tracker](http://github.com/bkeepers/qu/issues/) to see if anyone else has reported issue.
+3. If you don't see anything, create an issue with information on how to reproduce it.
+
+If you want to contribute an enhancement or a fix:
+
+1. Fork the project on GitHub.
+2. Make your changes with tests.
+3. Commit the changes without making changes to the Rakefile, Gemfile, gemspec, or any other files that aren't related to your enhancement or fix
+4. Send a pull request.

data/Rakefile

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "qu/version"
+
+desc 'Build gem into the pkg directory'
+task :build do
+  FileUtils.rm_rf('pkg')
+  Dir['*.gemspec'].each do |gemspec|
+    system "gem build #{gemspec}"
+  end
+  FileUtils.mkdir_p('pkg')
+  FileUtils.mv(Dir['*.gem'], 'pkg')
+end
+
+desc 'Tags version, pushes to remote, and pushes gem'
+task :release => :build do
+  sh "git tag v#{Qu::VERSION}"
+  sh "git push origin master"
+  sh "git push origin v#{Qu::VERSION}"
+  sh "ls pkg/*.gem | xargs gem push"
+end
+
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+  t.verbose = false
+end
+
+namespace :spec do
+  Backends = %w(mongo redis)
+
+  Backends.each do |backend|
+    desc "Run specs for #{backend} backend"
+    RSpec::Core::RakeTask.new(backend) do |t|
+      t.rspec_opts = %w[--color]
+      t.verbose = false
+      t.pattern = "spec/qu/backend/#{backend}_spec.rb"
+    end
+  end
+
+  task :backends => Backends
+end
+
+task :default => :spec

data/lib/qu.rb

@@ -0,0 +1,27 @@
+require 'qu/version'
+require 'qu/failure'
+require 'qu/job'
+require 'qu/backend/base'
+
+require 'forwardable'
+
+module Qu
+  autoload :Worker, 'qu/worker'
+
+  extend SingleForwardable
+  extend self
+
+  attr_accessor :backend, :failure
+
+  def_delegators :backend, :enqueue, :length, :queues, :reserve, :clear, :connection=
+
+  def backend
+    @backend || raise("Qu backend not configured. Install one of the backend gems like qu-redis.")
+  end
+
+  def configure(&block)
+    block.call(self)
+  end
+end
+
+require 'qu/railtie' if defined?(Rails)

data/lib/qu/backend/base.rb

@@ -0,0 +1,19 @@
+require 'multi_json'
+
+module Qu
+  module Backend
+    class Base
+      attr_accessor :connection
+
+    private
+
+      def encode(data)
+        MultiJson.encode(data) if data
+      end
+
+      def decode(data)
+        MultiJson.decode(data) if data
+      end
+    end
+  end
+end

data/lib/qu/backend/spec.rb

@@ -0,0 +1,265 @@
+class SimpleJob
+  def self.perform
+  end
+end
+
+class CustomQueue
+  @queue = :custom
+end
+
+shared_examples_for 'a backend' do
+  let(:worker) { Qu::Worker.new('default') }
+
+  before(:all) do
+    Qu.backend = described_class.new
+  end
+
+  before do
+    subject.clear
+    subject.clear_workers
+  end
+
+  describe 'enqueue' do
+    it 'should return a job id' do
+      subject.enqueue(SimpleJob).should be_instance_of(Qu::Job)
+    end
+
+    it 'should add a job to the queue' do
+      job = subject.enqueue(SimpleJob)
+      job.queue.should == 'default'
+      subject.length(job.queue).should == 1
+    end
+
+    it 'should add queue to list of queues' do
+      subject.queues.should == []
+      job = subject.enqueue(SimpleJob)
+      subject.queues.should == [job.queue]
+    end
+
+    it 'should assign a different job id for the same job enqueue multiple times' do
+      subject.enqueue(SimpleJob).id.should_not == subject.enqueue(SimpleJob).id
+    end
+  end
+
+  describe 'length' do
+    it 'should use the default queue by default' do
+      subject.length.should == 0
+      subject.enqueue(SimpleJob)
+      subject.length.should == 1
+    end
+  end
+
+  describe 'clear' do
+    it 'should clear jobs for given queue' do
+      job = subject.enqueue SimpleJob
+      subject.length(job.queue).should == 1
+      subject.clear(job.queue)
+      subject.length(job.queue).should == 0
+      subject.queues.should_not include(job.queue)
+    end
+
+    it 'should not clear jobs for a different queue' do
+      job = subject.enqueue SimpleJob
+      subject.clear('other')
+      subject.length(job.queue).should == 1
+    end
+
+    it 'should clear all queues without any args' do
+      subject.enqueue(SimpleJob).queue.should == 'default'
+      subject.enqueue(CustomQueue).queue.should == 'custom'
+      subject.length('default').should == 1
+      subject.length('custom').should == 1
+      subject.clear
+      subject.length('default').should == 0
+      subject.length('custom').should == 0
+    end
+
+    it 'should clear failed queue without any args' do
+      job = subject.enqueue SimpleJob
+      subject.failed(job, Exception.new)
+      subject.length('failed').should == 1
+      subject.clear
+      subject.length('failed').should == 0
+    end
+
+    it 'should not clear failed queue with specified queues' do
+      job = subject.enqueue SimpleJob
+      subject.failed(job, Exception.new)
+      subject.length('failed').should == 1
+      subject.clear('default')
+      subject.length('failed').should == 1
+    end
+  end
+
+  describe 'reserve' do
+    before do
+      @job = subject.enqueue SimpleJob
+    end
+
+    it 'should return next job' do
+      subject.reserve(worker).id.should == @job.id
+    end
+
+    it 'should not return an already reserved job' do
+      another_job = subject.enqueue SimpleJob
+      subject.reserve(worker).id.should_not == subject.reserve(worker).id
+    end
+
+    it 'should return next job in given queues' do
+      subject.enqueue SimpleJob
+      job = subject.enqueue CustomQueue
+      subject.enqueue SimpleJob
+
+      worker = Qu::Worker.new('custom', 'default')
+
+      subject.reserve(worker).id.should == job.id
+    end
+
+    it 'should not return job from different queue' do
+      worker = Qu::Worker.new('video')
+      timeout { subject.reserve(worker) }.should be_nil
+    end
+
+    it 'should block by default if no jobs available' do
+      subject.clear
+      timeout(1) do
+        subject.reserve(worker)
+        fail("#reserve should block")
+      end
+    end
+
+    it 'should not block if :block option is set to false' do
+      timeout(1) do
+        subject.reserve(worker, :block => false)
+        true
+      end.should be_true
+    end
+
+    def timeout(count = 0.1, &block)
+      SystemTimer.timeout(count, &block)
+    rescue Timeout::Error
+      nil
+    end
+  end
+
+  describe 'failed' do
+    let(:job) { Qu::Job.new('1', SimpleJob, []) }
+
+    it 'should add to failure queue' do
+      subject.failed(job, Exception.new)
+      subject.length('failed').should == 1
+    end
+
+    it 'should not add failed queue to the list of queues' do
+      subject.failed(job, Exception.new)
+      subject.queues.should_not include('failed')
+    end
+  end
+
+  describe 'completed' do
+    it 'should be defined' do
+      subject.respond_to?(:completed).should be_true
+    end
+  end
+
+  describe 'release' do
+    before do
+      subject.enqueue SimpleJob
+    end
+
+    it 'should add the job back on the queue' do
+      job = subject.reserve(worker)
+      subject.length(job.queue).should == 0
+      subject.release(job)
+      subject.length(job.queue).should == 1
+    end
+  end
+
+  describe 'requeue' do
+    context 'with a failed job' do
+      before do
+        subject.enqueue(SimpleJob)
+        @job = subject.reserve(worker)
+        subject.failed(@job, Exception.new)
+      end
+
+      it 'should add the job back on the queue' do
+        subject.length(@job.queue).should == 0
+        subject.requeue(@job.id)
+        subject.length(@job.queue).should == 1
+
+        job = subject.reserve(worker)
+        job.should be_instance_of(Qu::Job)
+        job.id.should == @job.id
+        job.klass.should == @job.klass
+        job.args.should == @job.args
+      end
+
+      it 'should remove the job from the failed jobs' do
+        subject.length('failed').should == 1
+        subject.requeue(@job.id)
+        subject.length('failed').should == 0
+      end
+
+      it 'should return the job' do
+        subject.requeue(@job.id).id.should == @job.id
+      end
+    end
+
+    context 'without a failed job' do
+      it 'should return false' do
+        subject.requeue('1').should be_false
+      end
+    end
+  end
+
+  describe 'register_worker' do
+    let(:worker) { Qu::Worker.new('default') }
+
+    it 'should add worker to array of workers' do
+      subject.register_worker(worker)
+      subject.workers.size.should == 1
+      subject.workers.first.attributes.should == worker.attributes
+    end
+  end
+
+  describe 'clear_workers' do
+    before { subject.register_worker Qu::Worker.new('default') }
+
+    it 'should remove workers' do
+      subject.workers.size.should == 1
+      subject.clear_workers
+      subject.workers.size.should == 0
+    end
+  end
+
+  describe 'unregister_worker' do
+    before { subject.register_worker Qu::Worker.new('default') }
+
+    it 'should remove worker' do
+      subject.unregister_worker(worker.id)
+      subject.workers.size.should == 0
+    end
+
+    it 'should not remove other workers' do
+      other_worker = Qu::Worker.new('other')
+      subject.register_worker(other_worker)
+      subject.workers.size.should == 2
+      subject.unregister_worker(other_worker.id)
+      subject.workers.size.should == 1
+      subject.workers.first.id.should == worker.id
+    end
+  end
+
+  describe 'connection=' do
+    it 'should allow setting the connection' do
+      connection = mock('a connection')
+      subject.connection = connection
+      subject.connection.should == connection
+    end
+
+    it 'should provide a default connection' do
+      subject.connection.should_not be_nil
+    end
+  end
+end

data/lib/qu/failure.rb

@@ -0,0 +1,4 @@
+module Qu
+  module Failure
+  end
+end

data/lib/qu/job.rb

@@ -0,0 +1,37 @@
+module Qu
+  class Job
+    attr_accessor :id, :klass, :args
+
+    def initialize(id, klass, args)
+      @id, @args = id, args
+
+      @klass = klass.is_a?(Class) ? klass : constantize(klass)
+    end
+
+    def queue
+      (klass.instance_variable_get(:@queue) || 'default').to_s
+    end
+
+    def perform
+      klass.perform(*args)
+      Qu.backend.completed(self)
+    rescue Qu::Worker::Abort
+      Qu.backend.release(self)
+      raise
+    rescue Exception => e
+      Qu.failure.create(self, e) if Qu.failure
+      Qu.backend.failed(self, e)
+    end
+
+  protected
+
+    def constantize(class_name)
+      constant = Object
+      class_name.split('::').each do |name|
+        constant = constant.const_get(name) || constant.const_missing(name)
+      end
+      constant
+    end
+
+  end
+end

data/lib/qu/railtie.rb

@@ -0,0 +1,9 @@
+require 'qu'
+
+module Qu
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "qu/tasks.rb"
+    end
+  end
+end

data/lib/qu/tasks.rb

@@ -0,0 +1,7 @@
+namespace :qu do
+  desc "Start a worker"
+  task :work  => :environment do
+    queues = (ENV['QUEUES'] || ENV['QUEUE'] || 'default').to_s.split(',')
+    Qu::Worker.new(*queues).start
+  end
+end

data/lib/qu/version.rb

@@ -0,0 +1,3 @@
+module Qu
+  VERSION = "0.1.0"
+end

data/lib/qu/worker.rb

@@ -0,0 +1,63 @@
+module Qu
+  class Worker
+    attr_accessor :queues
+
+    class Abort < Exception
+    end
+
+    def initialize(*queues)
+      @queues = queues.flatten
+      self.attributes = @queues.pop if @queues.last.is_a?(Hash)
+      @queues << 'default' if @queues.empty?
+    end
+
+    def attributes=(attrs)
+      attrs.each do |attr, value|
+        self.instance_variable_set("@#{attr}", value)
+      end
+    end
+
+    def attributes
+      {'hostname' => hostname, 'pid' => pid, 'queues' => queues}
+    end
+
+    def handle_signals
+      %W(INT TERM).each do |sig|
+        trap(sig) { raise Abort }
+      end
+    end
+
+    def work_off
+      while job = Qu.reserve(self, :block => false)
+        job.perform
+      end
+    end
+
+    def work
+      job = Qu.reserve(self)
+      job.perform
+    end
+
+    def start
+      handle_signals
+      Qu.backend.register_worker(self)
+      loop { work }
+    rescue Abort => e
+      # Ok, we'll shut down, but give us a sec
+    ensure
+      Qu.backend.unregister_worker(self)
+    end
+
+    def id
+      "#{hostname}:#{pid}:#{queues.join(',')}"
+    end
+
+    def pid
+      @pid ||= Process.pid
+    end
+
+    def hostname
+      @hostname ||= `hostname`.strip
+    end
+  end
+end

data/qu.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "qu/version"
+
+plugins = Dir['qu-*.gemspec'].map {|gemspec| gemspec.scan(/qu-(.*)\.gemspec/).to_s }.join('\|')
+
+Gem::Specification.new do |s|
+  s.name        = "qu"
+  s.version     = Qu::VERSION
+  s.authors     = ["Brandon Keepers"]
+  s.email       = ["brandon@opensoul.org"]
+  s.homepage    = "http://github.com/bkeepers/qu"
+  s.summary     = %q{}
+  s.description = %q{}
+
+  s.files         = `git ls-files | grep -v '#{plugins}'`.split("\n")
+  s.test_files    = `git ls-files -- spec | grep -v '#{plugins}'`.split("\n")
+  s.executables   = `git ls-files -- bin`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'multi_json'
+end

data/spec/qu/job_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Qu::Job do
+  class MyJob
+    @queue = :custom
+  end
+
+  describe 'queue' do
+    it 'should default to "default"' do
+      Qu::Job.new('1', SimpleJob, []).queue.should == 'default'
+    end
+
+    it 'should get queue from job instance variable' do
+      Qu::Job.new('1', MyJob, []).queue.should == 'custom'
+    end
+  end
+
+  describe 'klass' do
+    it 'should constantize string' do
+      Qu::Job.new('1', 'MyJob', []).klass.should == MyJob
+    end
+
+    it 'should find namespaced jobs' do
+      Qu::Job.new('1', 'Qu::Job', []).klass.should == Qu::Job
+    end
+  end
+
+  describe 'perform' do
+    subject { Qu::Job.new('1', SimpleJob, []) }
+
+    it 'should call .perform on job class with args' do
+      subject.args = ['a', 'b']
+      SimpleJob.should_receive(:perform).with('a', 'b')
+      subject.perform
+    end
+
+    it 'should call completed on backend' do
+      Qu.backend.should_receive(:completed)
+      subject.perform
+    end
+
+    context 'when being aborted' do
+      before do
+        SimpleJob.stub(:perform).and_raise(Qu::Worker::Abort)
+      end
+
+      it 'should release the job and re-raise the error' do
+        Qu.backend.should_receive(:release).with(subject)
+        lambda { subject.perform }.should raise_error(Qu::Worker::Abort)
+      end
+    end
+
+    context 'when the job raises an error' do
+      let(:error) { Exception.new("Some kind of error") }
+
+      before do
+        SimpleJob.stub!(:perform).and_raise(error)
+      end
+
+      it 'should call failed on backend' do
+        Qu.backend.should_receive(:failed).with(subject, error)
+        subject.perform
+      end
+
+      it 'should not call completed on backend' do
+        Qu.backend.should_not_receive(:completed)
+        subject.perform
+      end
+
+      it 'should call create on failure backend' do
+        Qu.failure = mock('a failure backend')
+        Qu.failure.should_receive(:create).with(subject, error)
+        subject.perform
+      end
+    end
+
+  end
+end

data/spec/qu/worker_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Qu::Worker do
+  let(:job) { Qu::Job.new('1', SimpleJob, []) }
+
+  describe 'queues' do
+    it 'should use default if none specified' do
+      Qu::Worker.new.queues.should == ['default']
+      Qu::Worker.new('default').queues.should == ['default']
+      Qu::Worker.new(['default']).queues.should == ['default']
+    end
+  end
+
+  describe 'work' do
+    before do
+      Qu.stub!(:reserve).and_return(job)
+    end
+
+    it 'should reserve a job' do
+      Qu.should_receive(:reserve).with(subject).and_return(job)
+      subject.work
+    end
+
+    it 'should perform the job' do
+      job.should_receive(:perform)
+      subject.work
+    end
+  end
+
+  describe 'work_off' do
+    it 'should work all jobs off the queue' do
+      Qu.should_receive(:reserve).exactly(4).times.with(subject, :block => false).and_return(job, job, job, nil)
+      subject.work_off
+    end
+  end
+
+  describe 'start' do
+    before do
+      subject.stub(:loop)
+    end
+
+    it 'should register worker' do
+      Qu.backend.should_receive(:register_worker).with(subject)
+      subject.start
+    end
+
+    context 'when aborting' do
+      before do
+        subject.stub(:loop).and_raise(Qu::Worker::Abort)
+      end
+
+      it 'should unregister worker' do
+        Qu.backend.should_receive(:unregister_worker).with(subject)
+        subject.start
+      end
+    end
+  end
+
+  describe 'pid' do
+    it 'should equal process id' do
+      subject.pid.should == Process.pid
+    end
+
+    it 'should use provided pid' do
+      Qu::Worker.new(:pid => 1).pid.should == 1
+    end
+  end
+
+  describe 'id' do
+    it 'should return hostname, pid, and queues' do
+      worker = Qu::Worker.new('a', 'b', :hostname => 'quspec', :pid => 123)
+      worker.id.should == 'quspec:123:a,b'
+    end
+
+    it 'should not expand star in queue names' do
+      Qu::Worker.new('a', '*').id.should =~ /a,*/
+    end
+  end
+
+  describe 'hostname' do
+    it 'should get hostname' do
+      subject.hostname.should_not be_empty
+    end
+
+    it 'should use provided hostname' do
+      Qu::Worker.new(:hostname => 'quspec').hostname.should == 'quspec'
+    end
+  end
+
+  describe 'attributes' do
+    let(:attrs) do
+      {'hostname' => 'omgbbq', 'pid' => 987, 'queues' => ['a', '*']}
+    end
+
+    it 'should return hash of attributes' do
+      Qu::Worker.new(attrs).attributes.should == attrs
+    end
+  end
+end

data/spec/qu_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Qu do
+  %w(enqueue length queues reserve clear connection=).each do |method|
+    it "should delegate #{method} to backend" do
+      Qu.backend.should_receive(method).with(:arg)
+      Qu.send(method, :arg)
+    end
+  end
+
+  describe 'configure' do
+    it 'should yield Qu' do
+      Qu.configure do |c|
+        c.should == Qu
+      end
+    end
+  end
+
+  describe 'backend' do
+    it 'should raise error if backend not configured' do
+      Qu.backend = nil
+      lambda { Qu.backend }.should raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler.require :default, :test
+require 'qu'
+require 'qu/backend/spec'
+
+RSpec.configure do |config|
+  config.before do
+    Qu.backend = mock('a backend', :reserve => nil, :failed => nil, :completed => nil,
+      :register_worker => nil, :unregister_worker => nil)
+    Qu.failure = nil
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: qu
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Brandon Keepers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-23 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: multi_json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: ""
+email: 
+- brandon@opensoul.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/qu.rb
+- lib/qu/backend/base.rb
+- lib/qu/backend/spec.rb
+- lib/qu/failure.rb
+- lib/qu/job.rb
+- lib/qu/railtie.rb
+- lib/qu/tasks.rb
+- lib/qu/version.rb
+- lib/qu/worker.rb
+- qu.gemspec
+- spec/qu/job_spec.rb
+- spec/qu/worker_spec.rb
+- spec/qu_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/bkeepers/qu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: 
+- spec/qu/job_spec.rb
+- spec/qu/worker_spec.rb
+- spec/qu_spec.rb
+- spec/spec_helper.rb