pivotal-moqueue 0.1.0.200907241602

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,21 @@
+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
+
+include Moqueue

data/spec/unit/matchers_spec.rb

@@ -0,0 +1,92 @@
+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 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

data/spec/unit/mock_broker_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MockBroker do
+  
+  before(:each) do
+    @broker = MockBroker.instance
+    @broker.reset!
+  end
+  
+  it "should keep a list of named queues" do
+    queue = MockQueue.new("one-mocked-queue")
+    @broker.register_queue(queue)
+    @broker.find_queue("one-mocked-queue").should == queue
+  end
+  
+  it "should reset itself" do
+    @broker.register_queue(MockQueue.new("throwaway"))
+    @broker.reset!
+    @broker.registered_queues.count.should == 0
+  end
+  
+  it "should keep a list of topic exchanges" do
+    exchange = MockExchange.new(:topic => "lolcats")
+    @broker.register_topic_exchange(exchange)
+    @broker.find_topic_exchange("lolcats").should equal(exchange)
+  end
+  
+  it "should keep a list of fanout queues" do
+    exchange = MockExchange.new(:fanout => "joinTheNaniteBorg")
+    @broker.register_fanout_exchange(exchange)
+    @broker.find_fanout_exchange("joinTheNaniteBorg").should equal(exchange)
+  end
+  
+end

data/spec/unit/mock_exchange_spec.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MockExchange do
+  
+  before(:each) do
+    reset_broker
+    @queue, @exchange = mock_queue_and_exchange
+  end
+  
+  it "should manually attach queues" do
+    ensure_deferred_block_called(:times => 2)
+    exchange = mock_exchange
+    one_queue, another_queue = mock_queue("one"), mock_queue("two")
+    exchange.attach_queue(one_queue)
+    exchange.attach_queue(another_queue)
+    one_queue.subscribe do |msg|
+      deferred_block_called && msg.should == "mmm, smoothies"
+    end
+    another_queue.subscribe do |msg|
+      deferred_block_called && msg.should == "mmm, smoothies"
+    end
+    exchange.publish("mmm, smoothies")
+  end
+  
+  it "should accept options for the publish method" do
+    lambda {@exchange.publish("whateva eva", :key=>"foo.bar")}.should_not raise_error(ArgumentError)
+  end
+  
+  it "should emulate topic exchanges" do
+    #pending "support for storing and retrieving topic exchanges in MockBroker"
+    topic_exchange = MockExchange.new(:topic => "lolcats")
+    topic_exchange.topic.should == "lolcats"
+  end
+  
+  it "should register new topic exchanges with the mock broker" do
+    MockBroker.instance.expects(:register_topic_exchange)
+    MockExchange.new(:topic => "lolz")
+  end
+  
+  it "should return a previously created topic exchange when asked to create a new one with the same topic" do
+    exchange = MockExchange.new(:topic => "fails")
+    MockExchange.new(:topic => "fails").should equal exchange
+  end
+  
+  it "should determine if routing keys match" do
+    exchange = MockExchange.new(:topic => "lolz")
+    key = MockExchange::BindingKey
+    key.new("cats").matches?("cats").should be_true
+    key.new("cats").matches?("cats").should be_true
+    key.new("cats").matches?("dogs").should be_false
+    key.new("cats.*").matches?("cats.fridge").should be_true
+    key.new("cats.evil").matches?("cats.fridge").should be_false
+    key.new("cats.*").matches?("cats.fridge.in_urs").should be_false
+    key.new("cats.#").matches?("cats.fridge.in_urs").should be_true
+  end
+  
+  it "should forward messages to a queue only if the keys match when emulating a topic exchange" do
+    ensure_deferred_block_called
+    exchange = MockExchange.new(:topic => "lolz")
+    queue = MockQueue.new("lolz-lover")
+    queue.bind(exchange, :key=>"cats.*").subscribe do |msg|
+      msg.should == "ohai"
+      deferred_block_called
+    end
+    exchange.publish("ohai", :key => "cats.attack")
+  end
+  
+  it "should add the routing key to the headers' properties when publishing as a topic exchange" do
+    ensure_deferred_block_called
+    exchange = MockExchange.new(:topic => "mehDogs")
+    queue = MockQueue.new("dogzLover").bind(exchange, :key=>"boxers.*")
+    queue.subscribe do |headers, msg|
+      deferred_block_called
+      headers.routing_key.should == "boxers.awesome"
+      msg.should == "Roxie"
+    end
+    exchange.publish("Roxie", :key=>"boxers.awesome")
+  end
+  
+  it "should raise an error when publishing to a topic exchange without specifying a key" do
+    exchange = MockExchange.new(:topic=>"failz")
+    fail_msg = "you must provide a key when publishing to a topic exchange"
+    lambda {exchange.publish("failtacular")}.should raise_error(ArgumentError, fail_msg)
+  end
+  
+  it "should allow the fanout exchange name to be queried" do
+    exchange = MockExchange.new(:fanout => "hiMyNameIs")
+    exchange.fanout.should == "hiMyNameIs"
+  end
+  
+  it "should register new fanout exchanges with the MockBroker" do
+    MockBroker.instance.expects(:register_fanout_exchange)
+    MockExchange.new(:fanout => "nanite friendly")
+  end
+  
+  it "should return the exact same fanout exchange if creating one with an identical name" do
+    the_first_fanout = MockExchange.new(:fanout => "pseudo singleton")
+    the_second_one = MockExchange.new(:fanout => "pseudo singleton")
+    the_first_fanout.should equal the_second_one
+  end
+  
+end

data/spec/unit/mock_headers_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MockHeaders do
+  
+  it "should respond to the same methods as real AMQP::Protocol::Header" do
+    headers = Moqueue::MockHeaders.new
+    headers.should respond_to(:size)
+    headers.should respond_to(:weight)
+    headers.should respond_to(:properties)
+    headers.should respond_to(:to_frame)
+  end
+  
+  it "should add properties given to constructor" do
+    headers = MockHeaders.new({:routing_key=>"lolz.cats.inKitchen"})
+  end
+  
+  it "should lookup unknown methods as keys in the hash" do
+    headers = MockHeaders.new(:wtf_ftw_lolz_yo => "did I really write that?")
+    headers.wtf_ftw_lolz_yo.should == "did I really write that?"
+  end
+  
+end

data/spec/unit/mock_queue_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MockQueue do
+  
+  before(:each) do
+    reset_broker
+    @queue, @exchange = mock_queue_and_exchange
+  end
+  
+  it "should accept options for :ack=>(true|false) :nowait=>(true|false)" do
+    lambda {@queue.subscribe(:ack=>true) { |message| p message}}.should_not raise_error(ArgumentError)
+  end
+  
+  it "should pass mock headers to block when subscribe is given a block w/ 2 arity" do
+    ensure_deferred_block_called
+    @queue.subscribe do |headers, msg|
+      headers.should be_kind_of(Moqueue::MockHeaders)
+      msg.should == "the message"
+      deferred_block_called
+    end
+    @exchange.publish("the message")
+  end
+  
+  it "should create mock headers if pop is given a block w/ 2 arity" do
+    pending
+  end
+  
+  it "should process pending messages after a handler block is defined" do
+    ensure_deferred_block_called
+    @exchange.publish("found!")
+    @queue.subscribe { |msg| deferred_block_called && msg.should == "found!" }
+  end
+  
+  it "should not process pending messages twice" do
+    ensure_deferred_block_called(:times=>2)
+    @exchange.publish("take out the garbage")
+    @queue.subscribe do |msg| 
+      deferred_block_called
+      msg.should match(/take out (.*) garbage/)
+    end
+    @exchange.publish("take out more garbage")
+  end
+    
+  it "should not ack messages when given or defaulting to :ack=>false" do
+    ensure_deferred_block_called
+    @queue.subscribe { |msg| deferred_block_called && msg.should == "hew-row" }
+    @exchange.publish("hew-row")
+    @exchange.received_ack_for_message?("hew-row").should_not be_true
+  end
+  
+  it "should not ack messages when given :ack => true, but headers don't receive #ack" do
+    ensure_deferred_block_called
+    @queue.subscribe(:ack=>true) do |headers, msg|
+      deferred_block_called
+      msg.should == "10-4"
+    end
+    @exchange.publish("10-4")
+    @exchange.received_ack_for_message?("10-4").should be_false
+  end
+  
+  it "should ack messages when subscribe is given :ack=>true and headers are acked" do
+    @queue.subscribe(:ack=>true) do |headers, msg|
+      msg.should == "10-4"
+      headers.ack
+    end
+    @exchange.publish("10-4")
+    @exchange.received_ack_for_message?("10-4").should be_true
+  end
+  
+  it "should provide ability to check for acks when direct exchange is used" do
+    queue = MockQueue.new("direct-ack-check")
+    queue.subscribe(:ack => true) do |headers, msg|
+      msg.should == "ack me"
+      headers.ack
+    end
+    queue.publish("ack me")
+    queue.received_ack_for_message?("ack me").should be_true
+  end
+  
+  it "should store received messages in the queues" do
+    @queue.subscribe { |msg| msg.should == "save me!" }
+    @exchange.publish("save me!")
+    @queue.received_message?("save me!").should be_true
+  end
+  
+  it "should #unsubscribe" do
+    pending ("should really remove the association with exchange")
+    @queue.should respond_to(:unsubscribe)
+  end
+  
+  it "should raise an error on double subscribe" do
+    @queue.subscribe { |msg| "once" }
+    second_subscribe = lambda { @queue.subscribe {|msg| "twice"} }
+    second_subscribe.should raise_error DoubleSubscribeError
+  end
+  
+  it "should emulate direct exchange publishing" do
+    ensure_deferred_block_called
+    @queue.subscribe { |msg|deferred_block_called && msg.should == "Dyrekt" }
+    @queue.publish("Dyrekt")
+  end
+  
+  it "should take an optional name argument" do
+    lambda { MockQueue.new("say-my-name") }.should_not raise_error
+  end
+  
+  it "should register itself with the mock broker if given a name" do
+    MockBroker.instance.expects(:register_queue)
+    queue = MockQueue.new("with-a-name")
+  end
+  
+  it "should return the previously created queue when trying to create a queue with the same name" do
+    queue = MockQueue.new("firsties")
+    MockQueue.new("firsties").should equal(queue)
+  end
+  
+  it "should support binding to a topic exchange" do
+    queue = MockQueue.new("lolz lover")
+    topic_exchange = MockExchange.new(:topic => "lolcats")
+    topic_exchange.expects(:attach_queue).with(queue, :key=>"lolcats.fridges")
+    queue.bind(topic_exchange, :key => "lolcats.fridges") #http://lolcatz.net/784/im-in-ur-fridge-eatin-ur-foodz/
+  end
+  
+  it "should make the callback (#subscribe block) available for direct use" do
+    queue = MockQueue.new("inspect my guts, plz")
+    queue.subscribe { |msg| msg + "yo" }
+    queue.run_callback("hey-").should == "hey-yo"
+  end
+  
+  it "should bind to a fanout exchange" do
+    queue = MockQueue.new("fanouts are cool, too")
+    lambda {queue.bind(MockExchange.new)}.should_not raise_error
+  end
+  
+  it "should provide a null subscribe that does nothing but allows messages to be received" do
+    queue = MockQueue.new("nilly").null_subscribe
+    queue.publish("I'm feelin this")
+    queue.received_message?("I'm feelin this").should be_true
+  end
+  
+end