rcelery 1.0.0

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe RCelery::Configuration do
+  before :each do
+    @config = RCelery::Configuration.new
+  end
+  it 'defaults the host to localhost' do
+    @config.host.should == 'localhost'
+  end
+
+  it 'defaults the port to 5672' do
+    @config.port.should == 5672
+  end
+
+  it 'defaults the vhost to /' do
+    @config.vhost.should == '/'
+  end
+
+  it 'defaults the username to guest' do
+    @config.username.should == 'guest'
+  end
+
+  it 'defaults the password to guest' do
+    @config.password.should == 'guest'
+  end
+
+  it 'defaults the application to application' do
+    @config.application.should == 'application'
+  end
+
+  # it 'defaults the worker count to 1' do
+    # @config.worker_count.should == 1
+  # end
+
+  it 'defaults eager mode to false' do
+    @config.eager_mode.should == false
+  end
+
+  it 'overrides the default host when a hash is given to initialize' do
+    config = RCelery::Configuration.new(:host => 'otherhost')
+    config.host.should == 'otherhost'
+  end
+
+  it 'overrides the default port when a hash is given to initialize' do
+    config = RCelery::Configuration.new(:port => 1234)
+    config.port.should == 1234
+  end
+
+  it 'overrides the default vhost when a hash is given to initialize' do
+    config = RCelery::Configuration.new(:vhost => '/different')
+    config.vhost.should == '/different'
+  end
+
+  it 'overrides the default username when a hash is given to initialize' do
+    config = RCelery::Configuration.new(:username => 'user')
+    config.username.should == 'user'
+  end
+
+  it 'overrides the default password when a hash is given to initialize' do
+    config = RCelery::Configuration.new(:password => 'password')
+    config.password.should == 'password'
+  end
+
+  it 'overrides the default application when a hash is given to initialize' do
+    config = RCelery::Configuration.new(:application => 'otherapp')
+    config.application.should == 'otherapp'
+  end
+
+  # it 'overrides the default worker count when a hash is given to initialize' do
+    # config = RCelery::Configuration.new(:worker_count => 23)
+    # config.worker_count.should == 23
+  # end
+
+  it 'overrides the eager mode setting' do
+    config = RCelery::Configuration.new(:eager_mode => true)
+    config.eager_mode.should == true
+  end
+
+  it 'has a hash representation' do
+    @config.to_hash.should == {
+      :host => 'localhost',
+      :port => 5672,
+      :vhost => '/',
+      :username => 'guest',
+      :password => 'guest',
+      :application => 'application',
+      :worker_count => 1,
+      :eager_mode => false,
+    }
+  end
+end

data/spec/unit/daemon_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe RCelery::Daemon do
+  include RR::Adapters::RRMethods
+
+  before(:each) do
+    # @channel, @queue = stub_amqp
+  end
+
+  after :each do
+    RCelery.stop if RCelery.running?
+  end
+
+  describe '.new' do
+    it 'sets a config attr' do
+      d = RCelery::Daemon.new([])
+      d.instance_variable_get(:@config).should be_an_instance_of(RCelery::Configuration)
+    end
+  end
+end
+

data/spec/unit/eager_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe RCelery::Task do
+  module Tasks
+    include RCelery::TaskSupport
+
+    task(:name => 'different_name', :ignore_result => false)
+    def add(a,b, options = {})
+      noop(a + b + (options['c'] || 0))
+    end
+
+    task()
+    def ignore
+      'ignore_me'
+    end
+
+    def noop(val)
+      val
+    end
+  end
+
+  before :each do
+    @task = RCelery::Task.all_tasks['different_name']
+  end
+
+  after :each do
+    RCelery.stop
+  end
+
+  describe '#apply_async' do
+    it 'works with just args' do
+      RCelery.start(:eager_mode => true)
+      @task.apply_async(:args => [1,2]).wait.should == 3
+    end
+
+    it 'works with args and kwargs' do
+      RCelery.start(:eager_mode => true)
+      @task.apply_async(:args => [1,2], :kwargs => {'c' => 1}).wait.should == 4
+    end
+
+    it 'json encodes and decodes the args to mimic the over the wire process' do
+      RCelery.start(:eager_mode => true)
+      @task.apply_async(:args => [1,2], :kwargs => {:c => 1}).wait.should == 4
+    end
+  end
+end

data/spec/unit/events_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe RCelery::Events do
+  include RR::Adapters::RRMethods
+
+  describe "helper methods" do
+
+    describe ".hostname" do
+      it "returns the hostname" do
+        RCelery::Events.hostname.should == Socket.gethostname
+      end
+    end
+
+    describe ".timestamp" do
+      it "returns the time" do
+        stub(Time).now.returns(6)
+        RCelery::Events.timestamp.should == 6.0
+      end
+    end
+
+  end
+
+  describe "event methods" do
+
+    before(:each) do
+      stub(RCelery::Events).timestamp.returns('the time')
+      stub(RCelery::Events).hostname.returns('hostname')
+    end
+
+    describe '.task_received' do
+      it "publishes a task.received event" do
+        mock(RCelery).publish(:event, {
+          :type => 'task-received',
+          :uuid => 'uuid',
+          :name => 'name',
+          :args => 'args',
+          :kwargs => 'kwargs',
+          :retries => 'retries',
+          :eta => 'eta',
+          :hostname => 'hostname',
+          :timestamp => 'the time',
+        }, :routing_key => 'task.received')
+        RCelery::Events.task_received('uuid', 'name', 'args', 'kwargs', 'retries', 'eta')
+      end
+    end
+
+    describe '.task_started' do
+      it "publishes a task.started event" do
+        mock(RCelery).publish(:event, {
+          :type => 'task-started',
+          :uuid => 'uuid',
+          :hostname => 'hostname',
+          :timestamp => 'the time',
+          :pid => 'pid',
+        }, :routing_key => 'task.started')
+        RCelery::Events.task_started('uuid', 'pid')
+      end
+    end
+
+    describe '.task_succeeded' do
+      it "publishes a task.succeeded event" do
+        mock(RCelery).publish(:event, {
+          :type => 'task-succeeded',
+          :uuid => 'uuid',
+          :result => 'result',
+          :hostname => 'hostname',
+          :timestamp => 'the time',
+          :runtime => 'runtime',
+        }, :routing_key => 'task.succeeded')
+        RCelery::Events.task_succeeded('uuid', 'result', 'runtime')
+      end
+    end
+
+    describe '.task_failed' do
+      it "publishes a task.failed event" do
+        mock(RCelery).publish(:event, {
+          :type => 'task-failed',
+          :uuid => 'uuid',
+          :exception => 'exception',
+          :traceback => 'traceback',
+          :hostname => 'hostname',
+          :timestamp => 'the time',
+        }, :routing_key => 'task.failed')
+        RCelery::Events.task_failed('uuid', 'exception', 'traceback')
+      end
+    end
+
+    describe '.task_retried' do
+      it "publishes a task.retried event" do
+        mock(RCelery).publish(:event, {
+          :type => 'task-retried',
+          :uuid => 'uuid',
+          :exception => 'exception',
+          :traceback => 'traceback',
+          :hostname => 'hostname',
+          :timestamp => 'the time',
+        }, :routing_key => 'task.retried')
+        RCelery::Events.task_retried('uuid', 'exception', 'traceback')
+      end
+    end
+
+    describe '.worker_online' do
+      it "publishes a worker.online event" do
+        mock(RCelery).publish(:event, {
+          :type => "worker-online",
+          :sw_ident => "rcelery",
+          :sw_ver => "1.0",
+          :sw_sys => RUBY_PLATFORM,
+          :hostname => 'hostname',
+          :timestamp => 'the time'
+        }, :routing_key => "worker.online")
+
+        RCelery::Events.worker_online("rcelery", "1.0", RUBY_PLATFORM)
+      end
+    end
+
+    describe '.worker_heartbeat' do
+      it 'publishes a worker.heartbeat event' do
+        mock(RCelery).publish(:event, {
+          :type => "worker-heartbeat",
+          :sw_ident => "rcelery",
+          :sw_ver => "1.0",
+          :sw_sys => RUBY_PLATFORM,
+          :hostname => 'hostname',
+          :timestamp => 'the time'
+        }, :routing_key => "worker.heartbeat")
+
+        RCelery::Events.worker_heartbeat("rcelery", "1.0", RUBY_PLATFORM)
+      end
+    end
+
+    describe '.worker_offline' do
+      it 'publishes a worker.offline event' do
+        mock(RCelery).publish(:event, {
+          :type => "worker-offline",
+          :sw_ident => "rcelery",
+          :sw_ver => "1.0",
+          :sw_sys => RUBY_PLATFORM,
+          :hostname => 'hostname',
+          :timestamp => 'the time'
+        }, :routing_key => "worker.offline")
+
+        RCelery::Events.worker_offline("rcelery", "1.0", RUBY_PLATFORM)
+      end
+    end
+
+  end
+end
+

data/spec/unit/pool_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe RCelery::Pool do
+  include RR::Adapters::RRMethods
+
+  before(:each) do
+    @channel, @queue = stub_amqp
+  end
+
+  after :each do
+    RCelery.stop if RCelery.running?
+  end
+
+  describe '.new' do
+    it 'starts RCelery if it is not running' do
+      mock.proxy(RCelery).start({:host => 'option'})
+      RCelery::Pool.new({:host => 'option'})
+    end
+
+    it 'does not start RCelery if it is running' do
+      RCelery.start
+      dont_allow(RCelery).start({:some => 'option'})
+      RCelery::Pool.new(:some => 'option')
+    end
+  end
+
+  describe '.start' do
+    it 'subscribes to the request queue' do
+      mock(@queue).subscribe(:ack => true)
+      RCelery::Pool.new.start
+    end
+  end
+
+  describe '.stop' do
+    it 'unsubscribes from the queue' do
+      pool = RCelery::Pool.new
+      pool.start
+      mock(@queue).unsubscribe
+      pool.stop
+    end
+  end
+
+  describe '.subscribe' do
+    it 'adds tasks to the task queue' do
+      pool = RCelery::Pool.new
+
+      message = {
+        :id => "blah",
+        :task => "blah task",
+        :args => [],
+        :kwargs => {}
+      }
+
+      stub(@queue).subscribe.yields("hello", message.to_json)
+      stub(RCelery::Events).task_received
+
+      pool.start
+
+      expected_message = {
+        "id" => "blah",
+        "task" => "blah task",
+        "args" => [],
+        "kwargs" => {}
+      }
+
+      pool.poll.should == {:message => expected_message, :header => "hello"}
+    end
+
+    it 'sends a task received event with the correct information' do
+      pool = RCelery::Pool.new
+
+      message = {
+        :id => "blah",
+        :task => "this.task",
+        :args => [1,2,3],
+        :kwargs => {:this => "that"}
+      }
+
+      stub(@queue).subscribe.yields("hello", message.to_json)
+      mock(RCelery::Events).task_received("blah", "this.task", [1,2,3], {"this" => "that"}, nil, nil)
+      pool.start
+    end
+
+    it 'defers a task if the eta is in the future' do
+      pool = RCelery::Pool.new
+      tomorrow = DateTime.now.next
+
+      message = {
+        :id => "blah",
+        :task => "this.task",
+        :args => "hi",
+        :kwargs => "kwargs",
+        :eta => tomorrow.to_s
+      }
+
+      stub(@queue).subscribe.yields("hello", message.to_json)
+      stub(RCelery::Events).task_received
+
+      expected_message = {
+        "id" => "blah",
+        "task" => "this.task",
+        "args" => "hi",
+        "kwargs" => "kwargs",
+        "eta" => tomorrow.to_s
+      }
+
+      mock(pool).defer({:message => expected_message, :header => "hello"})
+      pool.start
+    end
+
+    it 'acks messages that fail parsing' do
+      pool = RCelery::Pool.new
+
+      header = mock!
+      mock(header).ack
+      stub(@queue).subscribe.yields(header, "{blah")
+
+      pool.start
+    end
+
+  end
+
+
+end

data/spec/unit/rcelery_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe RCelery do
+  before :each do
+    stub(AMQP).start
+    stub(AMQP).stop
+
+    @options = { :host => 'host', :port => 1234, :application => 'some_app' }
+    @channel, @queue = stub_amqp
+  end
+
+  after :each do
+    RCelery.stop if RCelery.running?
+  end
+
+  describe '.start' do
+    it 'starts amqp with the connection string based on the options passed less the application option' do
+      stub(RCelery).channel { @channel }
+      mock(AMQP).start(hash_including({
+        :host => 'host',
+        :port => 1234,
+        :username => 'guest',
+        :password => 'guest',
+        :vhost => '/'
+      }))
+
+      RCelery.start(@options)
+    end
+
+    it "doesn't start AMQP if the connection is connected" do
+      stub(RCelery).channel { @channel }
+      connection = stub!.connected? { true }.subject
+      stub(AMQP).connection { connection }
+
+      RCelery.thread.should be_nil
+    end
+
+    it 'sets up the request, results and event exchanges' do
+      channel = mock!.direct('celery', :durable => true) { 'request exchange' }.subject
+      mock(channel).direct('celeryresults', :durable => true, :auto_delete => true) { 'results exchange' }
+      mock(channel).topic('celeryev', :durable => true) { 'events exchange' }
+      stub(channel).queue { @queue }
+
+      stub(RCelery).channel { channel }
+
+      RCelery.start(@options)
+
+      RCelery.exchanges[:request].should == 'request exchange'
+      RCelery.exchanges[:result].should == 'results exchange'
+      RCelery.exchanges[:event].should == 'events exchange'
+    end
+
+    it 'sets up the request queue and binds it to the request exchange correctly' do
+      stub(@channel).direct('celery', anything) { 'request exchange' }
+      mock(@channel).queue('rcelery.some_app', :durable => true) { @queue }
+      mock(@queue).bind('request exchange', :routing_key => 'rcelery.some_app') { @queue }
+      stub(RCelery).channel { @channel }
+      RCelery.start(@options)
+
+      RCelery.queue.should == @queue
+    end
+
+    it 'sets the running flag to true after completion' do
+      stub(RCelery).channel { @channel }
+
+      RCelery.running?.should be_false
+      RCelery.start(@options)
+      RCelery.running?.should be_true
+    end
+
+    it 'returns the self object (RCelery)' do
+      stub(RCelery).channel { @channel }
+      RCelery.start(@options).should == RCelery
+    end
+
+    it "doesn't start anything if eager_mode is set" do
+      RCelery.start(@options.merge(:eager_mode => true))
+      RCelery.running?.should be_true
+    end
+  end
+
+  describe '.stop' do
+    before :each do
+      stub(RCelery).channel { @channel }
+      RCelery.start(@options)
+    end
+
+    it 'stops AMQP' do
+      mock(AMQP).stop
+
+      RCelery.stop
+    end
+
+    describe 'updates various pieces of internal state:' do
+      before :each do
+        RCelery.stop
+      end
+
+      it 'sets the running state to false' do
+        RCelery.running?.should be_false
+      end
+
+      it 'clears the exchanges' do
+        RCelery.exchanges.should be_nil
+      end
+
+      it 'clears the thread' do
+        RCelery.thread.should be_nil
+      end
+
+      it 'clears the request queue' do
+        RCelery.queue.should be_nil
+      end
+    end
+  end
+
+  describe '.publish' do
+    it 'publishes a message to the exchange specified, calling to_json first' do
+      exchange = mock!.publish('some message'.to_json, anything).subject
+      stub(@channel).direct('celery', anything) { exchange }
+      stub(RCelery).channel { @channel }
+      RCelery.start(@options)
+
+      RCelery.publish(:request, 'some message', {:some => 'option'})
+    end
+
+    it 'uses the application name as the routing key if none is given' do
+      exchange = mock!.publish(anything, hash_including({:routing_key => 'rcelery.some_app'})).subject
+      stub(@channel).direct('celery', anything) { exchange }
+      stub(RCelery).channel { @channel }
+      RCelery.start(@options)
+
+      RCelery.publish(:request, 'some message', {:some => 'option'})
+    end
+
+    it 'publishes the message with the application/json content_type' do
+      exchange = mock!.publish(anything, hash_including({:content_type => 'application/json'})).subject
+      stub(@channel).direct('celery', anything) { exchange }
+      stub(RCelery).channel { @channel }
+      RCelery.start(@options)
+
+      RCelery.publish(:request, 'some message', {:some => 'option'})
+    end
+
+    it 'passes any options to the exchange' do
+      exchange = mock!.publish(anything, hash_including({:some => 'option'})).subject
+      stub(@channel).direct('celery', anything) { exchange }
+      stub(RCelery).channel { @channel }
+      RCelery.start(@options)
+
+      RCelery.publish(:request, 'some message', {:some => 'option'})
+    end
+  end
+end