pivotal-moqueue 0.1.0.200907241602

data/lib/moqueue/object_methods.rb

@@ -0,0 +1,31 @@
+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
+
+    def mock_queue(name=nil)
+      MockQueue.new(name || "anonymous-#{rand(2**32).to_s(16)}")
+    end
+    
+    def mock_exchange(opts={})
+      MockExchange.new(opts)
+    end
+    
+    def overload_amqp
+      require MOQUEUE_ROOT + "moqueue/overloads"
+    end
+    
+    def reset_broker
+      MockBroker.instance.reset!
+    end
+    
+  end
+  
+end
+
+Object.send(:include, Moqueue::ObjectMethods)

data/lib/moqueue/overloads.rb

@@ -0,0 +1,46 @@
+require "eventmachine"
+
+class MQ
+  
+  class << self
+    def queue(name)
+      Moqueue::MockQueue.new(name)
+    end
+    
+    def fanout(name, opts={})
+      Moqueue::MockExchange.new(opts.merge(:fanout=>name))
+    end
+
+  end
+  
+  def initialize(*args)
+  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
+  
+end

data/moqueue.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{moqueue}
+  s.version = "0.1.0.200907241602"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel DeLeo"]
+  s.date = %q{2009-07-09}
+  s.description = %q{Mocktacular Companion to AMQP Library. Happy TATFTing!}
+  s.email = %q{dan@kallistec.com}
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.files = ["lib", "moqueue.gemspec", "Rakefile", "README.rdoc", "spec", "VERSION.yml", "lib/moqueue", "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", "lib/moqueue.rb", "spec/examples", "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", "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 = ["--inline-source", "--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Mocktacular Companion to AMQP Library. Happy TATFTing!}
+
+  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
+    else
+    end
+  else
+  end
+end

data/spec/examples/ack_spec.rb

@@ -0,0 +1,60 @@
+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
+    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
+          h.ack
+        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
+    end
+    q = MQ.queue('awesome')
+    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

data/spec/examples/basic_usage_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "AMQP", "when mocked out by Moqueue" do
+  
+  before(:each) do
+    reset_broker
+  end
+  
+  it "should have direct exchanges" do
+    queue = mock_queue("direct-exchanges")
+    queue.publish("you are correct, sir!")
+    queue.subscribe { |message| "do something with message" }
+    queue.received_message?("you are correct, sir!").should be_true
+  end
+  
+  it "should have direct exchanges with acks" do
+    queue = mock_queue("direct-with-acks")
+    queue.publish("yessir!")
+    queue.subscribe(:ack => true) { |headers, message| headers.ack  }
+    queue.received_ack_for_message?("yessir!").should be_true
+  end
+  
+  it "should have topic exchanges" do
+    topic = mock_exchange(:topic => "TATFT")
+    queue = mock_queue("rspec-fiend")
+    queue.bind(topic, :key => "bdd.*").subscribe { |msg| "do something" }
+    topic.publish("TATFT FTW", :key=> "bdd.4life")
+    queue.received_message?("TATFT FTW").should be_true
+  end
+  
+  it "should have topic exchanges with acks" do
+    topic = mock_exchange(:topic => "animals")
+    queue = mock_queue("cat-lover")
+    queue.bind(topic, :key => "cats.#").subscribe(:ack => true) do |header, msg|
+      header.ack
+      "do something with message"
+    end
+    topic.publish("OMG kittehs!", :key => "cats.lolz.kittehs")
+    topic.received_ack_for_message?("OMG kittehs!").should be_true
+  end
+  
+  it "should have fanout exchanges with acks" do
+    film = mock_exchange(:fanout => "Godfather")
+    one_actor = mock_queue("Jack Woltz")
+    other_actor = mock_queue("Captain McCluskey")
+    one_actor.bind(film).subscribe(:ack =>true) { |h,msg| h.ack && "horse head" }
+    other_actor.bind(film).subscribe(:ack => true) { |h,msg| h.ack && "dirty cops"  }
+    offer = "you can't refuse"
+    film.publish(offer)
+    one_actor.received_message?(offer).should be_true
+    other_actor.received_message?(offer).should be_true
+    film.should have(2).acked_messages
+  end
+  
+end
+
+describe Moqueue, "with syntax sugar" do
+  
+  before(:each) do
+    reset_broker
+  end
+  
+  it "counts received messages" do
+    queue = mock_queue
+    queue.subscribe { |msg| msg.should_not be_nil }
+    5.times {queue.publish("no moar beers kthxbye")}
+    queue.should have(5).received_messages
+  end
+  
+  it "counts acked messages" do
+    queue = mock_queue
+    queue.subscribe(:ack=>true) { |headers,msg| headers.ack }
+    5.times { queue.publish("time becomes a loop") }
+    queue.should have(5).acked_messages
+  end
+  
+  it "makes the callback (#subscribe) block testable" do
+    emphasis = mock_queue
+    emphasis.subscribe { |msg| @emphasized = "**" + msg + "**" }
+    emphasis.run_callback("show emphasis").should == "**show emphasis**"
+  end
+  
+end
+
+describe Moqueue, "when using custom rspec matchers" do
+  
+  it "should accept syntax like queue.should have_received('a message')" do
+    queue = mock_queue("sugary")
+    queue.subscribe { |msg| "eat the message" }
+    queue.publish("a message")
+    queue.should have_received("a message")
+  end
+  
+  it "should accept syntax like queue_or_exchange.should have_ack_for('a message')" do
+    queue = mock_queue("more sugar")
+    queue.subscribe(:ack => true) { |headers, msg| headers.ack }
+    queue.publish("another message")
+    queue.should have_ack_for("another message")
+  end
+  
+end

data/spec/examples/example_helper.rb

@@ -0,0 +1,16 @@
+module ExampleHelper
+  def capture_output(*args)
+    @captured_output << args
+  end
+  
+  def counter
+    @counter += 1
+    EM.stop {AMQP.stop} if @counter >= 2
+    @counter
+  end
+  
+  def reset!
+    @counter, @captured_output = 0, []
+  end
+  
+end

data/spec/examples/logger_spec.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Moqueue, "when running the logger example" do
+  
+  class Logger
+    def initialize *args, &block
+      opts = args.pop if args.last.is_a? Hash
+      opts ||= {}
+
+      printer(block) if block
+
+      @prop = opts
+      @tags = ([:timestamp] + args).uniq
+    end
+
+    attr_reader :prop
+    alias :base :prop
+
+    def log severity, *args
+      opts = args.pop if args.last.is_a? Hash and args.size != 1
+      opts ||= {}
+      opts = @prop.clone.update(opts)
+
+      data = args.shift
+
+      data = {:type => :exception,
+              :name => data.class.to_s.intern,
+              :backtrace => data.backtrace,
+              :message => data.message} if data.is_a? Exception
+
+      (@tags + args).each do |tag|
+        tag = tag.to_sym
+        case tag
+        when :timestamp
+          opts.update :timestamp => Time.now
+        when :hostname
+          @hostname ||= { :hostname => `hostname`.strip }
+          opts.update @hostname
+        when :process
+          @process_id ||= { :process_id => Process.pid,
+                            :process_name => $0,
+                            :process_parent_id => Process.ppid,
+                            :thread_id => Thread.current.object_id }
+          opts.update :process => @process_id
+        else
+          (opts[:tags] ||= []) << tag
+        end
+      end
+
+      opts.update(:severity => severity,
+                  :msg => data)
+
+      print(opts)
+      unless Logger.disabled?
+        MQ.fanout('logging', :durable => true).publish Marshal.dump(opts)
+      end
+
+      opts
+    end
+    alias :method_missing :log
+
+    def print data = nil, &block
+      if block
+        @printer = block
+      elsif data.is_a? Proc
+        @printer = data
+      elsif data
+        (pr = @printer || self.class.printer) and pr.call(data)
+      else
+        @printer
+      end
+    end
+    alias :printer :print
+    
+    def self.printer &block
+      @printer = block if block
+      @printer
+    end
+
+    def self.disabled?
+      !!@disabled
+    end
+    
+    def self.enable
+      @disabled = false
+    end
+    
+    def self.disable
+      @disabled = true
+    end
+  end
+  
+  
+  before(:all) do
+    overload_amqp
+  end
+  
+  
+  def run_client
+    AMQP.start do
+      log = Logger.new
+      log.debug 'its working!'
+    
+      log = Logger.new do |msg|
+        #require 'pp'
+        #pp msg
+        #puts
+      end
+
+      log.info '123'
+      log.debug [1,2,3]
+      log.debug :one => 1, :two => 2
+      log.error Exception.new('123')
+
+      log.info '123', :process_id => Process.pid
+      log.info '123', :process
+      log.debug 'login', :session => 'abc', :user => 123
+
+      log = Logger.new(:webserver, :timestamp, :hostname, &log.printer)
+      log.info 'Request for /', :GET, :session => 'abc'
+
+      #AMQP.stop{ EM.stop }
+    end
+  end
+  
+  def run_server
+    AMQP.start(:host => 'localhost') do
+      
+      @server_queue = MQ.queue('logger')
+      @server_queue.bind(MQ.fanout('logging', :durable => true)).subscribe do |msg|
+        msg = Marshal.load(msg)
+      end
+    end
+  end
+  
+  it "should get the expected results" do
+    EM.run do
+      threads = []
+      threads << Thread.new do
+        run_server
+      end
+      threads << Thread.new do
+        run_client
+      end
+      
+      EM.add_timer(0.1) do
+        @server_queue.should have(9).received_messages
+        webserver_log = Marshal.load(@server_queue.received_messages.last)
+        webserver_log[:tags].should == [:webserver, :GET]
+        webserver_log[:msg].should == "Request for /"
+        
+        EM.stop
+        threads.each { |t| t.join }
+      end
+      
+    end
+  end
+  
+end