moqueue 0.1.4

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 MyLoggerRulez
+    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 MyLoggerRulez.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 = MyLoggerRulez.new
+      log.debug 'its working!'
+    
+      log = MyLoggerRulez.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 = MyLoggerRulez.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

data/spec/examples/ping_pong_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/example_helper'
+
+describe Moqueue, "when testing the ping pong example" do
+  include ExampleHelper
+  
+  def ping_pong
+    AMQP.start(:host => 'localhost') do
+
+      # AMQP.logging = true
+
+      amq = MQ.new
+      EM.add_periodic_timer(0.1){
+        @counter_val = counter
+        capture_output @counter_val, :sending, 'ping'
+        amq.queue('one').publish('ping')
+      }
+
+      amq = MQ.new
+      amq.queue('one').subscribe{ |msg|
+        capture_output @counter_val, 'one', :received, msg, :sending, 'pong'
+        amq.queue('two').publish('pong')
+      }
+
+      amq = MQ.new
+      amq.queue('two').subscribe{ |msg|
+        capture_output @counter_val, 'two', :received, msg
+      }
+
+    end
+    
+  end
+  
+  before(:all) do
+    overload_amqp
+  end
+  
+  before(:each) do
+    reset!
+  end
+  
+  it "should get the correct result without error" do
+    Timeout::timeout(5) do
+      ping_pong
+    end
+    expected = [[1, :sending, "ping"], [1, "one", :received, "ping", :sending, "pong"], [1, "two", :received, "pong"], 
+                [2, :sending, "ping"], [2, "one", :received, "ping", :sending, "pong"], [2, "two", :received, "pong"]]
+    @captured_output.should ==  expected
+  end
+end

data/spec/examples/stocks_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/example_helper'
+
+describe Moqueue, "when running the stocks example" do
+  include ExampleHelper
+  
+  def run_stocks
+    AMQP.start(:host => 'localhost') do
+
+      def log *args
+        #p [ Time.now, *args ]
+      end
+
+      def publish_stock_prices
+        mq = MQ.new
+        counter = 0
+        EM.add_periodic_timer(0.1){
+          counter += 1
+          EM.stop if counter > 5
+          
+          {:appl => 170+rand(1000)/100.0, :msft => 22+rand(500)/100.0}.each do |stock, price|
+            stock = "usd.#{stock}"
+
+            log :publishing, stock, price
+            mq.topic('stocks').publish(price, :key => stock)
+          end
+        }
+      end
+
+      def watch_appl_stock
+        mq = MQ.new
+        @apple_queue = mq.queue('apple stock')
+        @apple_queue.bind(mq.topic('stocks'), :key => 'usd.appl').subscribe{ |price|
+          log 'apple stock', price
+        }
+      end
+
+      def watch_us_stocks
+        mq = MQ.new
+        @us_stocks = mq.queue('us stocks')
+        @us_stocks.bind(mq.topic('stocks'), :key => 'usd.*').subscribe{ |info, price|
+          log 'us stock', info.routing_key, price
+        }
+      end
+
+      publish_stock_prices
+      watch_appl_stock
+      watch_us_stocks
+
+    end
+  end
+  
+  before(:each) do
+    overload_amqp
+    reset_broker
+  end
+  
+  it "should get the correct results" do
+    run_stocks
+    @us_stocks.should have(12).received_messages
+    @apple_queue.should have(6).received_messages
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+-c -f specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require "rubygems"
+require "spec"
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end
+
+require File.dirname(__FILE__) + "/../lib/moqueue"
+
+# Make sure tests fail if deferred blocks (for susbscribe and pop) don't get called
+def ensure_deferred_block_called(opts={:times=>1})
+  @poke_me = mock("poke_me")
+  @poke_me.expects(:deferred_block_called).times(opts[:times])
+end
+
+def deferred_block_called
+  @poke_me.deferred_block_called
+  true
+end
+
+def ensure_deferred_block_skipped
+  @skip_me = mock("poke_me")
+  @skip_me.expects(:deferred_block_called).times(0)
+end
+
+include Moqueue

data/spec/unit/matchers_spec.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Matchers do
+  class MatcherHarness
+    include Moqueue::Matchers
+  end
+  
+  before(:each) do
+    @matchable = MatcherHarness.new
+    @mock_moqueue = mock("mock Moqueue::MockQueue")
+    @failure_exception = Spec::Expectations::ExpectationNotMetError
+  end
+  
+  it "should include matchers in describe blocks automatically when using rspec" do
+    self.class.include?(Moqueue::Matchers).should be_true
+  end
+  
+  it "should implement Object#should have_received_message" do
+    @mock_moqueue.expects(:received_message?).with("matchtacular").returns(true)
+    @mock_moqueue.should have_received_message("matchtacular")
+  end
+  
+  it "should implement Object#should_not have_received_message" do
+    @mock_moqueue.expects(:received_message?).with("no match").returns(false)
+    @mock_moqueue.should_not have_received_message("no match")
+  end
+  
+  it "should implement Object#should have_exact_routing_key(key)" do
+    @mock_moqueue.expects(:received_routing_key?).with("routing.key").returns(true)
+    @mock_moqueue.should have_received_exact_routing_key("routing.key")
+  end
+  
+  it "should implement Object#should_not have_exact_routing_key(key)" do
+    @mock_moqueue.expects(:received_routing_key?).with("routing.key").returns(false)
+    @mock_moqueue.should_not have_received_exact_routing_key("routing.key")
+  end
+  
+  it "should have a useful failure message" do
+    @mock_moqueue.expects(:received_message?).with("this fails").returns(false)
+    failing_example = lambda {@mock_moqueue.should have_received_message("this fails")}
+    error_message = "expected #{@mock_moqueue.inspect} to have received message ``this fails''"
+    failing_example.should raise_error(@failure_exception, error_message)
+  end
+  
+  it "should have a useful negative failure message" do
+    @mock_moqueue.expects(:received_message?).with("FAIL").returns(true)
+    failing_example = lambda{@mock_moqueue.should_not have_received_message("FAIL")}
+    error_message = "expected #{@mock_moqueue.inspect} to not have received message ``FAIL''"
+    failing_example.should raise_error(@failure_exception, error_message)
+  end
+  
+  it "should fail gracefully if object being tested for #have_received doesn't respond to #received_message?" do
+    begin
+      Object.new.should have_received_message("foo")
+    rescue => e
+    end
+    e.should be_a(NoMethodError)
+    e.message.should match(/you can't use \`\`should have_received_message\'\' on #\<Object/)
+  end
+  
+  it "should alias #have_received_message as #have_received for less verbosity" do
+    @matchable.should respond_to(:have_received)
+  end
+  
+  it "should alias #have_received_ack_for as #have_ack_for for less verbosity" do
+    @matchable.should respond_to(:have_ack_for)
+  end
+  
+  it "should implement Object#should have_received_ack_for(msg_text)" do
+    @mock_moqueue.expects(:received_ack_for_message?).with("foo bar").returns(true)
+    @mock_moqueue.should have_received_ack_for("foo bar")
+  end
+  
+  it "should implement Object#should_not have_received_ack_for(msg_text)" do
+    @mock_moqueue.expects(:received_ack_for_message?).with("bar baz").returns(false)
+    @mock_moqueue.should_not have_received_ack_for("bar baz")
+  end
+  
+  it "should have a helpful failure message" do
+    @mock_moqueue.expects(:received_ack_for_message?).with("foo baz").returns(false)
+    failure = lambda {@mock_moqueue.should have_received_ack_for("foo baz")}
+    fail_msg = "expected #{@mock_moqueue.inspect} to have received an ack for the message ``foo baz''"
+    failure.should raise_error(@failure_exception, fail_msg)
+  end
+  
+  it "should have a helpful negative failure message" do
+    @mock_moqueue.expects(:received_ack_for_message?).with("bar foo").returns(true)
+    failure = lambda {@mock_moqueue.should_not have_received_ack_for("bar foo")}
+    fail_msg = "expected #{@mock_moqueue.inspect} to not have received an ack for the message ``bar foo''"
+    failure.should raise_error(@failure_exception, fail_msg)
+  end
+  
+  it "should fail gracefully if object being tested for #have_received_ack_for doesn't respond to #received_ack_for_message?" do
+    begin
+      Object.new.should have_received_message("foo")
+    rescue => e
+    end
+    e.should be_a(NoMethodError)
+    e.message.should match(/you can't use \`\`should have_received_message\'\' on #\<Object/)
+  end
+  
+end