moqueue 0.1.4

data/lib/moqueue/mock_headers.rb

@@ -0,0 +1,31 @@
+module Moqueue
+  
+  class MockHeaders
+    attr_accessor :size, :weight
+    
+    def initialize(properties={})
+      @properties = properties
+    end
+    
+    def ack
+      @received_ack = true
+    end
+    
+    def received_ack?
+      @received_ack || false
+    end
+        
+    def properties
+      @properties
+    end
+    
+    def to_frame
+      nil
+    end
+    
+    def method_missing method, *args, &blk
+      @properties.has_key?(method) ? @properties[method] : super
+    end
+  end
+  
+end

data/lib/moqueue/mock_queue.rb

@@ -0,0 +1,138 @@
+module Moqueue
+  
+  class DoubleSubscribeError < StandardError
+  end
+  
+  class MockQueue
+    attr_reader :name
+    
+    class << self
+      
+      def new(name)
+        if existing_queue = MockBroker.instance.find_queue(name)
+          return existing_queue
+        end
+        super
+      end
+      
+    end
+    
+    def initialize(name)
+      @name = name
+      MockBroker.instance.register_queue(self)
+    end
+    
+    def subscribe(opts={}, &block)
+      if @subscribe_block 
+        raise DoubleSubscribeError, "you can't subscribe to the same queue twice"
+      end
+      @subscribe_block = block
+      @ack_msgs = opts[:ack] || false
+      process_unhandled_messages
+    end
+    
+    def receive(message, header_opts={})
+      if callback = message_handler_callback
+        headers = MockHeaders.new(header_opts)
+        callback.call(*(callback.arity == 1 ? [message] : [headers, message]))
+        received_messages_and_headers << {:message => message, :headers => headers}
+      else
+        receive_message_later(message, header_opts)
+      end
+    end
+    
+    def received_message?(message_content)
+      received_messages.include?(message_content)
+    end
+    
+    def received_routing_key?(key)
+      received_messages_and_headers.find { |r| r[:headers] && r[:headers].properties[:routing_key] == key }
+    end
+    
+    def unsubscribe
+      true
+    end
+
+    def prefetch(size)
+      # noop
+    end    
+    
+    def received_ack_for_message?(message_content)
+      acked_messages.include?(message_content)
+    end
+    
+    def publish(message, opts = {})
+      if message_handler_callback
+        receive(message)
+      else
+        deferred_publishing_fibers << Fiber.new do
+          receive(message)
+        end
+      end
+    end
+    
+    def bind(exchange, key=nil)
+      exchange.attach_queue(self, key)
+      self
+    end
+
+    def received_messages_and_headers
+      @received_messages_and_headers ||= []
+    end
+    
+    def received_messages
+      received_messages_and_headers.map{|r| r[:message] }
+    end
+    
+    def received_headers
+      received_messages_and_headers.map{ |r| r[:headers] }
+    end
+    
+    def acked_messages
+      received_messages_and_headers.map do |r|
+        r[:message] if @ack_msgs && r[:headers].received_ack?
+      end
+    end
+    
+    def run_callback(*args)
+      callback = message_handler_callback
+      callback.call(*(callback.arity == 1 ? [args.first] : args))
+    end
+    
+    def callback_defined?
+      !!message_handler_callback
+    end
+    
+    # configures a do-nothing subscribe block to force
+    # received messages to be processed and stored in
+    # #received_messages
+    def null_subscribe
+      subscribe {|msg| nil}
+      self
+    end
+    
+    private
+    
+    def receive_message_later(message, header_opts)
+      deferred_publishing_fibers << Fiber.new do
+        self.receive(message, header_opts)
+      end
+    end
+    
+    def deferred_publishing_fibers
+      @deferred_publishing_fibers ||= []
+    end
+    
+    def message_handler_callback
+      @subscribe_block || @pop_block || false
+    end
+    
+    def process_unhandled_messages
+      while fiber = deferred_publishing_fibers.shift
+        fiber.resume
+      end
+    end
+    
+  end
+  
+end

data/lib/moqueue/object_methods.rb

@@ -0,0 +1,41 @@
+module Moqueue
+  
+  module ObjectMethods
+    def mock_queue_and_exchange(name=nil)
+      queue = mock_queue(name)
+      exchange = mock_exchange
+      exchange.attached_queues << queue
+      [queue, exchange]
+    end
+
+    # Takes a string name as a parameter. Each queue name may only be used
+    # once. Multiple calls to #mock_queue with the same +name+ will return 
+    # the same object.
+    def mock_queue(name=nil)
+      MockQueue.new(name || "anonymous-#{rand(2**32).to_s(16)}")
+    end
+    
+    # Takes a hash to specify the exchange type and its name.
+    #
+    #  topic = mock_exchange(:topic => 'topic exchange')
+    def mock_exchange(opts={})
+      MockExchange.new(opts)
+    end
+    
+    # Overloads the class-level method calls typically used by AMQP code
+    # such as MQ.direct, MQ.queue, MQ.topic, etc.
+    def overload_amqp
+      require MOQUEUE_ROOT + "moqueue/overloads"
+    end
+    
+    # Deletes all exchanges and queues from the mock broker. As a consequence of
+    # removing queues, all bindings and subscriptions are also deleted.
+    def reset_broker
+      MockBroker.instance.reset!
+    end
+    
+  end
+  
+end
+
+Object.send(:include, Moqueue::ObjectMethods)

data/lib/moqueue/overloads.rb

@@ -0,0 +1,60 @@
+require "eventmachine"
+
+class MQ
+  
+  class << self
+    def queue(name)
+      Moqueue::MockQueue.new(name)
+    end
+    
+    def direct(name, opts={})
+      Moqueue::MockExchange.new(opts.merge(:direct=>name))
+    end
+    
+    def fanout(name, opts={})
+      Moqueue::MockExchange.new(opts.merge(:fanout=>name))
+    end
+
+  end
+  
+  def initialize(*args)
+  end
+
+  def direct(name, opts = {})
+    Moqueue::MockExchange.new(opts.merge(:direct => name))
+  end
+
+  def fanout(name, opts = {})
+    Moqueue::MockExchange.new(opts.merge(:fanout => name))
+  end
+  
+  def queue(name, opts = {})
+    Moqueue::MockQueue.new(name)
+  end
+  
+  def topic(topic_name)
+    Moqueue::MockExchange.new(:topic=>topic_name)
+  end
+  
+end
+
+module AMQP
+  
+  class << self
+    attr_reader :closing
+    alias :closing? :closing
+  end
+  
+  def self.start(opts={},&block)
+    EM.run(&block)
+  end
+  
+  def self.stop
+    @closing = true
+    yield if block_given?
+    @closing = false
+  end
+  
+  def self.connect(*args)
+  end
+end

data/moqueue.gemspec

@@ -0,0 +1,86 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{moqueue}
+  s.version = "0.1.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel DeLeo"]
+  s.date = %q{2009-09-21}
+  s.description = %q{Mocktacular Companion to AMQP Library. Happy TATFTing!}
+  s.email = %q{dan@kallistec.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "CONTRIBUTORS.rdoc",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "lib/moqueue.rb",
+     "lib/moqueue/fibers18.rb",
+     "lib/moqueue/matchers.rb",
+     "lib/moqueue/mock_broker.rb",
+     "lib/moqueue/mock_exchange.rb",
+     "lib/moqueue/mock_headers.rb",
+     "lib/moqueue/mock_queue.rb",
+     "lib/moqueue/object_methods.rb",
+     "lib/moqueue/overloads.rb",
+     "moqueue.gemspec",
+     "spec/examples/ack_spec.rb",
+     "spec/examples/basic_usage_spec.rb",
+     "spec/examples/example_helper.rb",
+     "spec/examples/logger_spec.rb",
+     "spec/examples/ping_pong_spec.rb",
+     "spec/examples/stocks_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/unit/matchers_spec.rb",
+     "spec/unit/mock_broker_spec.rb",
+     "spec/unit/mock_exchange_spec.rb",
+     "spec/unit/mock_headers_spec.rb",
+     "spec/unit/mock_queue_spec.rb",
+     "spec/unit/moqueue_spec.rb",
+     "spec/unit/object_methods_spec.rb",
+     "spec/unit/overloads_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/danielsdeleo/moqueue}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{moqueue}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Mocktacular Companion to AMQP Library. Happy TATFTing!}
+  s.test_files = [
+    "spec/examples/ack_spec.rb",
+     "spec/examples/basic_usage_spec.rb",
+     "spec/examples/example_helper.rb",
+     "spec/examples/logger_spec.rb",
+     "spec/examples/ping_pong_spec.rb",
+     "spec/examples/stocks_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/unit/matchers_spec.rb",
+     "spec/unit/mock_broker_spec.rb",
+     "spec/unit/mock_exchange_spec.rb",
+     "spec/unit/mock_headers_spec.rb",
+     "spec/unit/mock_queue_spec.rb",
+     "spec/unit/moqueue_spec.rb",
+     "spec/unit/object_methods_spec.rb",
+     "spec/unit/overloads_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<amqp>, [">= 0"])
+    else
+      s.add_dependency(%q<amqp>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<amqp>, [">= 0"])
+  end
+end

data/spec/examples/ack_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/example_helper'
+
+# NOTE: moqueue currently does not mimic AMQP's behavior of:
+# 1) requiring graceful shutdown for acks to be delivered
+# 2) returning messages to the queue if not acked
+# 3) not processing messages when AMQP isn't "running"
+#
+# This causes the result of this test to differ from the actual result when run
+# with a real broker. The true behavior should be that the 3rd message 
+# published should be unacknowledged and returned to the queue. In this test,
+# all messages get acknowleged
+describe Moqueue, "when running the ack example" do
+  include ExampleHelper
+  
+  def run_ack_example(&perform_ack)
+    AMQP.start(:host => 'localhost') do
+      MQ.queue('awesome').publish('Totally rad 1')
+      MQ.queue('awesome').publish('Totally rad 2')
+      MQ.queue('awesome').publish('Totally rad 3')
+
+      i = 0
+
+      # Stopping after the second item was acked will keep the 3rd item in the queue
+      MQ.queue('awesome').subscribe(:ack => true) do |h,m|
+        if (i+=1) == 3
+          #puts 'Shutting down...'
+          AMQP.stop{ EM.stop }
+        end
+
+        if AMQP.closing?
+          #puts "#{m} (ignored, redelivered later)"
+        else
+          #puts "received message: " + m
+          perform_ack.call(h)
+        end
+      end
+    end
+    
+  end
+  
+  before(:all) do
+    overload_amqp
+  end
+  
+  before(:each) do
+    reset_broker
+    reset!
+  end
+  
+  it "should get the correct result without errors" do
+    Timeout::timeout(2) do
+      run_ack_example {|h| h.ack }
+    end
+    q = MQ.queue('awesome')
+    q.should have(3).acked_messages
+    q.received_ack_for_message?('Totally rad 1').should be_true
+    q.received_ack_for_message?('Totally rad 2').should be_true
+    q.received_ack_for_message?('Totally rad 3').should be_true
+  end
+
+  it "should be able to ack in an EM.next_tick" do
+    Timeout::timeout(2) do
+      run_ack_example do |h|
+        EM.next_tick { h.ack }
+      end
+    end
+    q = MQ.queue('awesome')
+    q.should have(3).acked_messages
+    q.received_ack_for_message?('Totally rad 1').should be_true
+    q.received_ack_for_message?('Totally rad 2').should be_true
+    q.received_ack_for_message?('Totally rad 3').should be_true
+  end
+
+  it "should be able to ack in an EM.defer callback" do
+    Timeout::timeout(2) do
+      run_ack_example do |h|
+        EM.defer(proc {
+            1337
+          },
+          proc { |result|
+            result.should == 1337
+            h.ack
+          })
+      end
+    end
+    q = MQ.queue('awesome')
+    q.should have(3).acked_messages
+    q.received_ack_for_message?('Totally rad 1').should be_true
+    q.received_ack_for_message?('Totally rad 2').should be_true
+    q.received_ack_for_message?('Totally rad 3').should be_true
+  end
+end