queueing_rabbit 0.1.0.rc1

data/spec/unit/queueing_rabbit/client/callbacks_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe QueueingRabbit::Client::Callbacks do
+  let!(:klass) { Class.new { extend QueueingRabbit::Client::Callbacks } }
+
+  subject { klass }
+
+  it { should respond_to(:define_callback).with(1).argument }
+  it { should respond_to(:callback).with(1).argument }
+
+  context 'when a callback is being defined' do
+    let(:code_block) { Proc.new {} }
+
+    before do
+      subject.define_callback(:on_some_event, &code_block)
+    end
+
+    it 'saves a provided code block as a callback' do
+      subject.callback(:on_some_event).should == code_block
+    end
+  end
+end

data/spec/unit/queueing_rabbit/configuration_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe QueueingRabbit::Configuration do
+  subject { Class.new { extend QueueingRabbit::Configuration} }
+
+  it { should respond_to(:amqp_uri) }
+  it { should respond_to(:amqp_exchange_name) }
+  it { should respond_to(:amqp_exchange_options) }
+
+  its(:tcp_timeout) { should == 1 }
+  its(:heartbeat) { should == 10 }
+  its(:default_client) { should == QueueingRabbit::Client::Bunny }
+
+  describe "#configure" do
+    it "yields itself to the block" do
+      subject.configure { |obj| obj.should == subject }
+    end
+  end
+end

data/spec/unit/queueing_rabbit/job_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe QueueingRabbit::AbstractJob do
+  subject { QueueingRabbit::AbstractJob }
+  
+  it { should respond_to(:queue).with(2).arguments }
+  it { should respond_to(:queue_name) }
+  it { should respond_to(:queue_options) }
+  it { should respond_to(:channel_options) }
+  it { should respond_to(:channel).with(1).argument }
+
+  its(:queue_name) { should == 'AbstractJob' }
+
+  describe ".queue_size" do
+    let(:size) { mock }
+
+    before do
+      QueueingRabbit.should_receive(:queue_size).with(subject).and_return(size)
+    end
+
+    its(:queue_size) { should == size }
+  end
+end

data/spec/unit/queueing_rabbit/logging_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe QueueingRabbit::Logging do
+  subject { Class.new { extend QueueingRabbit::Logging } }
+
+  %w[fatal error warn info debug].each do |level|
+    it { should respond_to(level).with(1).argument }
+  end
+end

data/spec/unit/queueing_rabbit/serializer_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe QueueingRabbit::Serializer do
+  subject { Class.new { extend QueueingRabbit::Serializer } }
+  let(:args) { {:a => 1, :b => 2, :c => 3} }
+
+  describe ".serialize" do
+    it "serializes arguments to JSON" do
+      subject.serialize(args).should == JSON.dump(args)
+    end
+  end
+
+  describe ".deserialize" do
+    it "deserializes arguments from JSON to symbolized hash" do
+      subject.deserialize(JSON.dump(args)).should == args
+    end
+  end
+
+  describe ".symbolize_keys" do
+    let(:stringified_args) { { "a" => 1, "b" => 2, "c" => 3 } }
+
+    it "symbolizes keys of provided Hash" do
+      subject.send(:symbolize_keys, stringified_args).should == args
+    end
+  end
+end

data/spec/unit/queueing_rabbit/worker_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe QueueingRabbit::Worker do
+  include_context "StringIO logger"
+
+  subject { QueueingRabbit::Worker }
+  let!(:job) {
+    class QueueingRabbitTestJob < QueueingRabbit::AbstractJob
+      def self.perform(arguments = {}); end
+    end
+  }
+  let(:creation) {
+    Proc.new { QueueingRabbit::Worker.new('QueueingRabbitTestJob') }
+  }
+  let(:worker) {
+    creation.call
+  }
+
+  after(:each) do
+    QueueingRabbit.client = QueueingRabbit::Client::Bunny
+  end
+
+  context 'initialization' do
+    context 'when no jobs are provided' do
+      before do
+        subject.any_instance.should_receive(:fatal)
+      end
+
+      it 'raises JobNotPresentError' do
+        expect { subject.new() }
+               .to raise_error(QueueingRabbit::JobNotPresentError)
+      end
+    end
+
+    context 'when nonexistent job is provided' do
+      let(:nonexistent_class_name) { 'SomeNonexistentClassName' }
+
+      before do
+        subject.any_instance.should_receive(:fatal)
+      end
+
+      it 'raises JobNotFoundError' do
+        expect { subject.new(nonexistent_class_name) }
+               .to raise_error(QueueingRabbit::JobNotFoundError)
+      end
+    end
+
+    context 'when valid job is provided' do
+      subject { worker }
+
+      it { should be }
+      it { should respond_to(:jobs) }
+      it 'changes used client to asynchronous' do
+        expect { creation.call }.to change { QueueingRabbit.client.to_s }
+                                    .from(QueueingRabbit::Client::Bunny.to_s)
+                                    .to(QueueingRabbit::Client::AMQP.to_s)
+      end
+    end
+  end
+
+  context 'instance methods' do
+    let(:connection) { mock }
+    let(:channel) { mock }
+    let(:arguments) { mock }
+
+    subject { worker }
+
+    describe '#work' do
+      before do
+        QueueingRabbit.should_receive(:connection).and_return(connection)
+        connection.should_receive(:open_channel).and_yield(channel, nil)
+        connection.should_receive(:listen_queue).and_yield(arguments)
+      end
+
+      it 'listens to queues specified by jobs' do
+        subject.work
+      end
+
+      context "logging" do
+        before do
+          subject.should_receive(:info)
+        end
+
+        it 'writes to the log' do
+          subject.work
+        end
+      end
+
+      describe '#work!' do
+        before do
+          QueueingRabbit::Client::AMQP
+            .should_receive(:join_event_machine_thread)
+        end
+
+        it 'runs #work and joins the eventmachine thread' do
+          subject.work!
+        end
+      end
+    end
+
+    describe "#use_pidfile" do
+      let(:file_name) { mock }
+      let(:file) { mock }
+
+      before do
+        File.should_receive(:open).with(file_name, 'w').and_yield(file)
+        file.should_receive(:<<).with(Process.pid)
+      end
+
+      it 'writes pid to a file' do
+        subject.use_pidfile(file_name)
+      end
+    end
+
+    describe "#remove_pidfile" do
+      let(:file_name) { mock }
+
+      before do
+        subject.instance_variable_set(:@pidfile, file_name)
+        File.should_receive(:exists?).and_return(true)
+        File.should_receive(:delete).with(file_name)
+      end
+
+      it 'removes previously created pidfile' do
+        subject.remove_pidfile
+      end
+    end
+
+    describe "#pid" do
+      its(:pid) { should == Process.pid }
+    end
+  end
+end

data/spec/unit/queueing_rabbit_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe QueueingRabbit do
+  include_context "StringIO logger"
+
+  let(:connection) { mock }
+  let(:queue_name) { mock }
+  let(:queue_options) { { :durable => true} }
+  let(:channel) { mock }
+  let(:channel_options) { { :prefetch => 1, :auto_recovery => true } }
+  let(:job) do
+    qname, qopts, copts = queue_name, queue_options, channel_options
+    Class.new do
+      extend QueueingRabbit::Job
+      queue qname, qopts
+      channel copts
+    end
+  end
+
+  before(:each) { subject.drop_connection }
+
+  it { should respond_to(:logger) }
+  it { should respond_to(:client) }
+
+  its(:logger) { should be_kind_of(Logger) }
+  its(:client) { should be(QueueingRabbit::Client::Bunny) }
+
+  describe ".connect" do
+    before do
+      subject.client.should_receive(:connect).and_return(connection)
+      subject.connect
+    end
+
+    its(:connect) { should == connection }
+    its(:connection) { should == connection }
+  end
+
+  describe ".enqueue" do
+    let(:arguments) { mock }
+
+    before do
+      subject.instance_variable_set(:@connection, connection)
+      connection.should_receive(:open_channel).with(channel_options)
+                .and_yield(channel, nil)
+      connection.should_receive(:define_queue).with(channel,
+                                                    queue_name,
+                                                    queue_options)
+      connection.should_receive(:enqueue).with(channel,
+                                               queue_name, arguments)
+    end
+
+    it 'returns true when a message was enqueued successfully' do
+      subject.enqueue(job, arguments).should be_true
+    end
+
+    context 'logging' do
+      before do
+        subject.should_receive(:info).and_return(nil)
+      end
+
+      it 'keeps the record of enqueued job at info level' do
+        subject.enqueue(job, arguments).should be_true
+      end
+    end
+  end
+
+  describe ".queue_size" do
+    let(:size) { mock }
+    let(:queue) { mock }
+
+    before do
+      subject.instance_variable_set(:@connection, connection)
+      connection.should_receive(:open_channel).with(channel_options)
+                .and_yield(channel, nil)
+      connection.should_receive(:define_queue).with(channel,
+                                                    queue_name,
+                                                    queue_options)
+                                              .and_return(queue)
+      connection.should_receive(:queue_size).with(queue).and_return(size)
+    end
+
+    it 'returns queue size for specific job' do
+      subject.queue_size(job).should == size
+    end
+  end
+
+  describe ".purge_queue" do
+    let(:queue) { mock }
+
+    before do
+      subject.instance_variable_set(:@connection, connection)
+      connection.should_receive(:open_channel).with(channel_options)
+                .and_yield(channel, nil)
+      connection.should_receive(:define_queue).with(channel,
+                                                    queue_name,
+                                                    queue_options)
+                                              .and_return(queue)
+      queue.should_receive(:purge).and_return(true)
+    end
+
+    it 'purges messages from the queue' do
+      subject.purge_queue(job).should be_true
+    end
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: queueing_rabbit
+version: !ruby/object:Gem::Version
+  version: 0.1.0.rc1
+  prerelease: 6
+platform: ruby
+authors:
+- Artem Chistyakov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0.pre7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0.pre7
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    QueueingRabbit is a Ruby library providing convenient object-oriented
+  syntax\n    for managing background jobs using AMQP. All jobs' argumets are serialized\n
+  \   to JSON and transfered to jobs using AMQP message payload. The library\n    implements
+  amqp and bunny gems as adapters making it possible to use\n    synchronous publishing
+  and asynchronous consuming, which might be useful for\n    Rails app running on
+  non-EventMachine based application servers (i. e.\n    Passenger).\n\n    Any Ruby
+  class or Module can be transformed into QueueingRabbit's background\n    job by
+  including QueueingRabbit::Job module. It is also possible to inherit\n    your class
+  from QueueingRabbit::AbstractJob abstract class.\n\n    The library is bundled with
+  a Rake task which is capable of starting a\n    worker processing a specified list
+  of jobs.\n\n    To achieve the required simplicity the gem doesn't try to support
+  all\n    features of AMQP protocol. It uses a restricted subset instead:\n\n    *
+  Only a single direct exchange is used\n    * Every job is consumed using a separate
+  channel\n    * All jobs are consumed with acknowledgements\n    * ACK is only sent
+  to the broker if a job was processed successfully\n    * Currently all messages
+  are published with persistent option\n"
+email:
+- chistyakov.artem@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/queueing_rabbit.rb
+- lib/queueing_rabbit/callbacks.rb
+- lib/queueing_rabbit/client/amqp.rb
+- lib/queueing_rabbit/client/bunny.rb
+- lib/queueing_rabbit/client/callbacks.rb
+- lib/queueing_rabbit/configuration.rb
+- lib/queueing_rabbit/job.rb
+- lib/queueing_rabbit/logging.rb
+- lib/queueing_rabbit/serializer.rb
+- lib/queueing_rabbit/tasks.rb
+- lib/queueing_rabbit/version.rb
+- lib/queueing_rabbit/worker.rb
+- lib/tasks/queueing_rabbit.rake
+- queueing_rabbit.gemspec
+- spec/integration/asynchronous_publishing_and_consuming_spec.rb
+- spec/integration/jobs/print_line_job.rb
+- spec/integration/synchronous_publishing_and_asynchronous_consuming_spec.rb
+- spec/integration/synchronous_publishing_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_contexts.rb
+- spec/support/shared_examples.rb
+- spec/unit/queueing_rabbit/callbacks_spec.rb
+- spec/unit/queueing_rabbit/client/amqp_spec.rb
+- spec/unit/queueing_rabbit/client/bunny_spec.rb
+- spec/unit/queueing_rabbit/client/callbacks_spec.rb
+- spec/unit/queueing_rabbit/configuration_spec.rb
+- spec/unit/queueing_rabbit/job_spec.rb
+- spec/unit/queueing_rabbit/logging_spec.rb
+- spec/unit/queueing_rabbit/serializer_spec.rb
+- spec/unit/queueing_rabbit/worker_spec.rb
+- spec/unit/queueing_rabbit_spec.rb
+homepage: https://github.com/temochka/queueing_rabbit
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1045735451665817642
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: QueueingRabbit is an AMQP-based queueing system
+test_files:
+- spec/integration/asynchronous_publishing_and_consuming_spec.rb
+- spec/integration/jobs/print_line_job.rb
+- spec/integration/synchronous_publishing_and_asynchronous_consuming_spec.rb
+- spec/integration/synchronous_publishing_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_contexts.rb
+- spec/support/shared_examples.rb
+- spec/unit/queueing_rabbit/callbacks_spec.rb
+- spec/unit/queueing_rabbit/client/amqp_spec.rb
+- spec/unit/queueing_rabbit/client/bunny_spec.rb
+- spec/unit/queueing_rabbit/client/callbacks_spec.rb
+- spec/unit/queueing_rabbit/configuration_spec.rb
+- spec/unit/queueing_rabbit/job_spec.rb
+- spec/unit/queueing_rabbit/logging_spec.rb
+- spec/unit/queueing_rabbit/serializer_spec.rb
+- spec/unit/queueing_rabbit/worker_spec.rb
+- spec/unit/queueing_rabbit_spec.rb