moqueue 0.1.4

data/spec/unit/mock_broker_spec.rb

@@ -0,0 +1,40 @@
+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.size.should == 0
+  end
+  
+  it "should keep a list of direct exchanges" do
+    exchange = MockExchange.new(:direct => "thundercats")
+    @broker.register_direct_exchange(exchange)
+    @broker.find_direct_exchange("thundercats").should equal(exchange)
+  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,168 @@
+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 direct exchanges" do
+    direct_exchange = MockExchange.new(:direct => "thundercats")
+    direct_exchange.direct.should == "thundercats"
+  end
+  
+  it "should register new direct exchanges with the mock broker" do
+    MockBroker.instance.expects(:register_direct_exchange)
+    MockExchange.new(:direct => "lolz")
+  end
+  
+  it "should return a previously created direct exchange when asked to create a new one with the same name" do
+    exchange = MockExchange.new(:direct => "smoochie")
+    MockExchange.new(:direct => "smoochie").should equal(exchange)
+  end
+  
+  it "should determine if routing keys match exactly on the direct exchange" do
+    exchange = MockExchange.new(:direct => "lolz")
+    key = MockExchange::DirectBindingKey
+    key.new("cats").matches?("cats").should be_true
+    key.new("cats").matches?("dogs").should be_false
+    key.new("cats.*").matches?("cats.fridge").should be_false
+    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_false
+  end
+  
+  it "should forward messages to a queue only if the keys match exactly when emulating a direct exchange" do
+    ensure_deferred_block_called
+    exchange = MockExchange.new(:direct => "thundercats")
+    queue = MockQueue.new("ho")
+    queue.bind(exchange, :key=>"cats").subscribe do |msg|
+      msg.should == "ohai"
+      deferred_block_called
+    end
+    exchange.publish("ohai", :key => "cats")
+  end
+  
+  it "should NOT forward messages to a queue if the keys mismatch when emulating a direct exchange" do
+    ensure_deferred_block_skipped
+    exchange = MockExchange.new(:direct => "thundercats")
+    queue = MockQueue.new("ho")
+    queue.bind(exchange, :key=>"cats").subscribe do |msg|
+      msg.should == "ohai"
+      deferred_block_called # should never execute!
+    end
+    exchange.publish("ohai", :key => "cats.attack")
+  end
+  
+  it "should add the routing key to the headers' properties when publishing as a direct exchange" do
+    ensure_deferred_block_called
+    exchange = MockExchange.new(:direct => "thunderdogs")
+    queue = MockQueue.new("dogzh8er").bind(exchange, :key=>"boxers")
+    queue.subscribe do |headers, msg|
+      deferred_block_called
+      headers.routing_key.should == "boxers"
+      msg.should == "Roxie"
+    end
+    exchange.publish("Roxie", :key=>"boxers")
+  end
+  
+  it "should NOT raise an error when publishing to a direct exchange without specifying a key" do
+    exchange = MockExchange.new(:direct => "spike")
+    fail_msg = "you must provide a key when publishing to a topic exchange"
+    lambda {exchange.publish("failtacular")}.should_not raise_error(ArgumentError, fail_msg)
+  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::TopicBindingKey
+    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,151 @@
+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 allow retrieval of the headers for any published messages" do
+    @queue.subscribe { |msg| msg }
+    @exchange.publish("the message")
+    @queue.received_headers.first.should be_kind_of(Moqueue::MockHeaders)
+  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 ignore #prefetch but at least raise an error" do
+    lambda { @queue.prefetch(1337) }.should_not raise_error
+  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

data/spec/unit/moqueue_spec.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Moqueue do
+  
+end

data/spec/unit/object_methods_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe ObjectMethods do
+  
+  before(:each) do
+    reset_broker
+    @queue, @exchange = mock_queue_and_exchange
+  end
+  
+  it "should reset the MockBroker" do
+    MockBroker.instance.expects(:reset!)
+    reset_broker
+  end
+  
+  it "should name the queue ``anonymous-RANDOM_GARBAGE'' if not given a name" do
+    @queue.name.should match(/anonymous\-[0-9a-f]{0,8}/)
+  end
+  
+  it "should name the queue with the name given" do
+    q, exchange = mock_queue_and_exchange("wassup")
+    q.name.should == "wassup"
+    q2 = mock_queue("watup")
+    q2.name.should == "watup"
+  end
+  
+  it "should create a matched mock queue and mock exchange" do
+    ensure_deferred_block_called
+    @queue.subscribe do |message|
+      deferred_block_called
+      message.should == "FTW"
+    end
+    @exchange.publish("FTW")
+  end
+  
+  it "should allow for overloading AMQP and MQ" do
+    overload_amqp
+    defined?(AMQP).should be_true
+    defined?(MQ).should be_true
+  end
+  
+  it "should provide a convenience method for creating mock queues" do
+    mock_queue("Sugary").should be_kind_of(Moqueue::MockQueue)
+  end
+  
+  it "should provide a convenience method for creating mock exchanges" do
+    mock_exchange(:topic => "sweetSugar").should be_kind_of(Moqueue::MockExchange)
+  end
+  
+end

data/spec/unit/overloads_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "AMQP and MQ", "when overloaded by moqueue/overloads" do
+  
+  before(:all) do
+    overload_amqp
+  end
+  
+  it "should make AMQP.start take options and a block without connecting to AMQP broker" do
+    ensure_deferred_block_called
+    AMQP.start(:host => "localhost") do
+      deferred_block_called
+      EM.stop
+    end
+  end
+  
+  it "should run EM in AMQP.start" do
+    EM.expects(:run)
+    AMQP.start { EM.stop }
+  end
+  
+  it "should provide a MQ.queue class method" do
+    MQ.queue('FTW').should be_a(Moqueue::MockQueue)
+  end
+  
+  it "should emulate the behavior of MQ.closing?" do
+    ensure_deferred_block_called
+    AMQP.stop do 
+      deferred_block_called
+      AMQP.should be_closing
+    end
+  end
+  
+  it "should create direct exchanges" do
+    MQ.new.direct("directamundo").should == MockExchange.new(:direct => "directamundo")
+  end
+  
+  it "should create topic exchanges" do
+    MQ.new.topic("lolzFTW").should == MockExchange.new(:topic => "lolzFTW")
+  end
+  
+  it "should provide a MQ.direct class method" do
+    MQ.direct("direct", :durable=>true).should be_a(Moqueue::MockExchange)
+  end
+  
+  it "should provide a MQ.fanout class method" do
+    MQ.fanout("fanout", :durable=>true).should be_a(Moqueue::MockExchange)
+  end
+  
+  it "should create a named fanout queue via MQ.fanout" do
+    fanout = MQ.fanout("SayMyNameSayMyName", :durable=>true)
+    fanout.should be_a(Moqueue::MockExchange)
+    fanout.fanout.should == "SayMyNameSayMyName"
+  end
+  
+end