tom_queue 0.0.1.dev

data/spec/tom_queue/external_consumer_integration_spec.rb

@@ -0,0 +1,225 @@
+require 'tom_queue/helper'
+require 'tom_queue/delayed_job'
+
+describe "External consumers" do
+
+  let(:exchange_name) { "external-exchange-#{Time.now.to_f}" }
+  let(:trace) { [] }
+
+  let(:consumer_class) do
+    Class.new(Object) { include TomQueue::ExternalConsumer }.tap { |k| k.class_exec(trace) do |trace|
+      self::Trace = trace
+      def self.trace(*stuff); self::Trace << stuff; end
+      def trace(*stuff); self.class.trace(*stuff); end
+    end }
+  end
+
+  before do
+    # Hopefully break the core consumer loop out of DJ
+    TomQueue.default_prefix = "test-prefix-#{Time.now.to_f}"
+
+    TomQueue::DelayedJob.handlers.clear
+    TomQueue::DelayedJob.handlers << consumer_class
+  end
+
+  subject { Delayed::Worker.new.work_off(2) }
+
+  it "should be possible to make a consumer using the TomQueue::ExternalConsumer mixin" do
+    consumer_class
+  end
+
+  describe "when a consumer is bound to an exchange without a block" do
+
+    before do
+      consumer_class.class_exec(exchange_name) do |exchange_name|
+
+        bind_exchange(:fanout, exchange_name, :auto_delete => true, :durable => :false)
+
+        def initialize(payload, headers)
+          @payload = payload
+          trace(:init, payload, headers)
+        end
+
+        def perform
+          trace(:perform, @payload)
+        end
+
+      end
+
+      consumer_class.producer.publish('message')
+      subject
+    end
+
+    it "should call the init and perform methods the consumer" do
+      trace.map { |a| a[0] }.should == [:init, :perform]
+    end
+
+    it "should call the init method with the payload and headers" do
+      trace.first.tap do |method, payload, headers|
+        method.should == :init
+        payload.should == 'message'
+        headers.should be_a(Hash)
+      end
+    end
+
+    it "should have serialized the class so ivars from init are available during the perform call" do
+      trace.last.should == [:perform, 'message']
+    end
+  end
+
+  describe "when a block is attached to the bind_exchange call" do
+
+    before do
+      consumer_class.class_exec(exchange_name) do |exchange_name|
+
+        bind_exchange(:fanout, exchange_name, :auto_delete => true, :durable => :false) do |work|
+          trace(:bind_block, work)
+          self.block_method(work)
+        end
+
+        def self.block_method(work)
+          "something other than a delayed job"
+        end
+
+      end
+
+      consumer_class.producer.publish('message')
+    end
+
+    it "should call the block attached to the bind_exchange call" do
+      subject
+      trace.first.first.should == :bind_block
+    end
+
+    it "should pass the TomQueue::Work object to the block" do
+      subject
+      trace.first.last.tap do |work|
+        work.should be_a(TomQueue::Work)
+        work.payload.should == 'message'
+      end
+    end
+
+    describe "if something other than a Delayed::Job instance is returned" do
+      it "should ack the original AMQP message" do
+        pending('...')
+      end
+    end
+
+    describe "if the block returns a Delayed::Job instance" do
+
+      before do
+        consumer_class.class_eval do
+          def self.block_method(work)
+            new('custom-arg').delay.perform
+          end
+
+          def initialize(arg)
+            trace(:init, arg)
+          end
+          def perform
+            trace(:job_performed)
+          end
+        end
+      end
+
+      it "should call the bind block, which calls the init and defers the perform call" do
+        subject
+        trace.map { |a| a[0] }.should == [:bind_block, :init, :job_performed]
+      end 
+
+      it "should be init'd directly with the custom arguments" do
+        subject
+        trace[1].last.should == 'custom-arg'
+      end
+
+      it "should perform the Delayed::Job" do
+        subject
+        trace.last.should == [:job_performed]
+      end
+
+    end
+    
+  end
+
+
+  it "should use the encoder if specified"
+
+
+#   it "should not re-deliver the message once the delayed job has been created"
+
+
+
+
+
+#   it "should raise an exception if you publish a message without having bound the consumer"
+#   it "should raise an exception if you try to bind a consumer twice"
+
+
+#   it "should successfully round-trip a message" do
+#     consumer_class.producer.publish("a message")
+#     Delayed::Worker.new.work_off(1)
+#     consumer_class.messages.should == ["a message"]
+#   end
+
+#   it "should republish a message if an exception is raised" do
+#     consumer_class.producer.publish("asplode")
+#     consumer_class.asplode_count = 1
+#     Delayed::Worker.new.work_off(2)
+#     consumer_class.messages.should == ["asplode"]
+#   end
+
+#   it "should immediately run a job if one is returned out of the block"
+
+
+#   describe "if an exception is thrown by two workers" do
+#     it "should push the message to a dead-letter queue if an exception is raised twice"
+#     it "should trigger a log message"
+#     it "should notify the exception reporter"
+#   end
+
+# end
+
+# describe "temporary unit tests" do
+
+#   it "should clear any priority bindings just in case the priority changes"
+#   it "should not allow multiple bind_exchange calls to the consumer (for now)"
+
+#   describe "exchange options" do
+#     it "should set the auto-delete if specified"
+#     it "should default auto-delete to false"
+
+#     it "should set the durable flag if specified"
+#     it "should default durable to true"
+#   end
+
+#   describe "when a message is received" do
+#     it "should reject the message if an exception is thrown"
+#     it "should ack the message if the block succeeds"
+#     it "should re-deliver the message once"
+#     it "should post the message to a dead-letter queue if the redelivery attempt fails"
+#   end
+
+
+#   describe "when a block is provided" do
+
+#     it "should call the block with received message payload"
+
+#   end
+
+#   describe "when a block isn't provided" do
+
+#     it "should create an instance of the consumer class"
+#     it "should call #perform on the instance"
+#     it "should pass the payload as the first argument to the call"
+
+#   end
+
+
+#   describe "producer call" do
+
+#     it "should return an object that responds to :publish"
+#     it "should publish a message to the exchange when :publish is called"
+
+#   end
+
+end

data/spec/tom_queue/helper.rb

@@ -0,0 +1,91 @@
+require 'helper'
+require 'bunny'
+require 'rest_client'
+require 'tom_queue'
+require 'tom_queue/delayed_job'
+
+# Patch AR to allow Mock errors to escape after_commit callbacks
+# There is a test to check this hook works in delayed_job_spec.rb
+require 'active_record/connection_adapters/abstract/database_statements'
+module ActiveRecord::ConnectionAdapters::DatabaseStatements
+  alias orig_commit_transaction_records commit_transaction_records
+  def commit_transaction_records
+    records = @_current_transaction_records.flatten
+    @_current_transaction_records.clear
+    unless records.blank?
+      records.uniq.each do |record|
+        begin
+          record.committed!
+        rescue Exception => e
+          if e.class.to_s =~ /^RSpec/
+            raise
+          else
+            record.logger.error(e) if record.respond_to?(:logger) && record.logger
+          end
+        end
+      end
+    end
+  end
+end
+
+begin
+  begin
+    RestClient.delete("http://guest:guest@localhost:15672/api/vhosts/test")
+  rescue RestClient::ResourceNotFound
+  end
+  RestClient.put("http://guest:guest@localhost:15672/api/vhosts/test", "{}", :content_type => :json, :accept => :json)
+  RestClient.put("http://guest:guest@localhost:15672/api/permissions/test/guest", '{"configure":".*","write":".*","read":".*"}', :content_type => :json, :accept => :json)
+  TheBunny = Bunny.new(:host => 'localhost', :vhost => 'test', :user => 'guest', :password => 'guest')
+  TheBunny.start
+rescue Errno::ECONNREFUSED
+  $stderr.puts "\033[1;31mFailed to connect to RabbitMQ, is it running?\033[0m\n\n"
+  raise
+end
+
+RSpec.configure do |r|
+
+  r.before do
+    TomQueue.exception_reporter = Class.new do
+      def notify(exception)
+        puts "Exception reported: #{exception.inspect}"
+        puts exception.backtrace.join("\n")
+      end
+    end.new
+    
+    TomQueue.logger = Logger.new($stdout) if ENV['DEBUG']
+  end
+
+  # Make sure all tests see the same Bunny instance
+  r.before do |test|
+    TomQueue.bunny = TheBunny
+  end
+
+  r.before do
+    TomQueue.logger ||= Logger.new("/dev/null")
+    TomQueue.default_prefix = "test-#{Time.now.to_f}"
+    TomQueue::DelayedJob.apply_hook!
+    Delayed::Job.class_variable_set(:@@tomqueue_manager, nil)
+  end
+
+  # All tests should take < 2 seconds !!
+  r.around do |test|
+    timeout = self.class.metadata[:timeout] || 2
+    if timeout == false
+      test.call
+    else
+      Timeout.timeout(timeout) { test.call }
+    end
+  end
+
+  r.around do |test|
+    begin
+      TomQueue::DeferredWorkManager.reset!
+
+      test.call
+
+    ensure
+      TomQueue::DeferredWorkManager.reset!
+    end
+  end
+
+end

data/spec/tom_queue/logging_helper_spec.rb

@@ -0,0 +1,152 @@
+require 'tom_queue/helper'
+require 'tempfile'
+
+describe TomQueue::LoggingHelper do
+
+  include TomQueue::LoggingHelper
+
+  let(:file) { Tempfile.new("logfile") }
+  let(:logger) { Logger.new(file.path) }
+  let(:output) { file.flush; File.read(file.path) }
+
+  before do
+    logger.formatter = ::Logger::Formatter.new
+    TomQueue.logger = logger
+  end
+
+  describe "basic behaviour" do
+
+    it "should emit a debug message passed as an argument" do
+      debug "Simple to compute"
+      output.should =~ /^D.+Simple to compute$/
+    end
+
+    it "should emit an info message passed as an argument" do
+      info "Simple to compute"
+      output.should =~ /^I.+Simple to compute$/
+    end
+
+    it "should emit a warning message passed as an argument" do
+      warn "Simple to compute"
+      output.should =~ /^W.+Simple to compute$/
+    end
+
+    it "should emit an error message passed as an argument" do
+      error "Simple to compute"
+      output.should =~ /^E.+Simple to compute$/
+    end
+
+    it "should emit a debug message returned from the block" do
+      debug { "Expensive to compute" }
+      output.should =~ /^D.+Expensive to compute$/
+    end
+
+    it "should emit a info message returned from the block" do
+      info { "Expensive to compute" }
+      output.should =~ /^I.+Expensive to compute$/
+    end
+
+    it "should emit a warn message returned from the block" do
+      warn { "Expensive to compute" }
+      output.should =~ /^W.+Expensive to compute$/
+    end
+
+    it "should emit a error message returned from the block" do
+      error { "Expensive to compute" }
+      output.should =~ /^E.+Expensive to compute$/
+    end
+  end
+
+  describe "when the log level is info" do
+    before do
+      logger.level = Logger::INFO
+    end
+
+    it "should not yield the debug block" do
+      @called = false
+      debug { @called = true }
+      @called.should be_false
+    end
+  end
+
+  describe "when the log level is warn" do
+    before do
+      logger.level = Logger::WARN
+    end
+
+    it "should not yield the debug block" do
+      @called = false
+      debug { @called = true }
+      @called.should be_false
+    end
+    it "should not yield the info block" do
+      @called = false
+      info { @called = true }
+      @called.should be_false
+    end
+  end
+
+  describe "when the log level is error" do
+    before do
+      logger.level = Logger::ERROR
+    end
+
+    it "should not yield the debug block" do
+      @called = false
+      debug { @called = true }
+      @called.should be_false
+    end
+    it "should not yield the info block" do
+      @called = false
+      info { @called = true }
+      @called.should be_false
+    end
+    it "should not yield the warn block" do
+      @called = false
+      warn { @called = true }
+      @called.should be_false
+    end
+  end
+
+  describe "when TomQueue.logger is nil" do
+    before do
+      TomQueue.logger = nil
+    end
+    it "should not yield the debug block" do
+      @called = false
+      debug { @called = true }
+      @called.should be_false
+    end
+    it "should not yield the info block" do
+      @called = false
+      info { @called = true }
+      @called.should be_false
+    end
+    it "should not yield the warn block" do
+      @called = false
+      warn { @called = true }
+      @called.should be_false
+    end
+    it "should not yield the error block" do
+      @called = false
+      error { @called = true }
+      @called.should be_false
+    end
+    it "should drop debug messages silently" do
+      debug "Message"
+    end
+    it "should drop info messages silently" do
+      info "Message"
+    end
+    it "should drop warn messages silently" do
+      warn "Message"
+    end
+    it "should drop error messages silently" do
+      error "Message"
+    end
+  end
+
+  
+
+end
+