amqp 0.7.0.pre → 0.7.0

data/spec/unit/amqp/frame_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+
+require "spec_helper"
+require "amqp/frame"
+
+describe AMQP::Frame do
+  include AMQP
+
+  it 'should handle basic frame types' do
+    Frame::Method.new.id.should == 1
+    Frame::Header.new.id.should == 2
+    Frame::Body.new.id.should == 3
+  end
+
+  it 'should convert method frames to binary' do
+    meth = Protocol::Connection::Secure.new :challenge => 'secret'
+
+    frame = Frame::Method.new(meth)
+    frame.to_binary.should be_kind_of Buffer
+    frame.to_s.should == [1, 0, meth.to_s.length, meth.to_s, 206].pack('CnNa*C')
+  end
+
+  it 'should convert binary to method frames' do
+    orig = Frame::Method.new Protocol::Connection::Secure.new(:challenge => 'secret')
+
+    copy = Frame.parse(orig.to_binary)
+    copy.should == orig
+  end
+
+  it 'should ignore partial frames until ready' do
+    frame = Frame::Method.new Protocol::Connection::Secure.new(:challenge => 'secret')
+    data = frame.to_s
+
+    buf = Buffer.new
+    Frame.parse(buf).should == nil
+
+    buf << data[0..5]
+    Frame.parse(buf).should == nil
+
+    buf << data[6..-1]
+    Frame.parse(buf).should == frame
+
+    Frame.parse(buf).should == nil
+  end
+
+  it 'should convert header frames to binary' do
+    head = Protocol::Header.new(Protocol::Basic, :priority => 1)
+
+    frame = Frame::Header.new(head)
+    frame.to_s.should == [2, 0, head.to_s.length, head.to_s, 206].pack('CnNa*C')
+  end
+
+  it 'should convert binary to header frame' do
+    orig = Frame::Header.new Protocol::Header.new(Protocol::Basic, :priority => 1)
+
+    copy = Frame.parse(orig.to_binary)
+    copy.should == orig
+  end
+end

data/spec/unit/amqp/misc_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+require 'amqp'
+
+module MockClientModule
+  def my_mock_method
+  end
+end
+
+class MockClient
+  include AMQP::Client
+end
+
+describe AMQP, 'class object' do
+  context 'has class accessors, with default values' do
+    subject { AMQP }
+
+    its(:logging) { should be_false }
+    its(:connection) { should be_nil }
+    its(:conn) { should be_nil } # Alias for #connection
+    its(:closing) { should be_false }
+    its(:settings) { should == {:host    => "127.0.0.1",
+                                :port    => 5672,
+                                :user    => "guest",
+                                :pass    => "guest",
+                                :vhost   => "/",
+                                :timeout => nil,
+                                :logging => false,
+                                :ssl     => false} }
+
+    its(:client) { should == AMQP::BasicClient }
+  end
+
+
+
+  describe '.client=' do
+    after(:all) { AMQP.client = AMQP::BasicClient }
+
+    it 'is used to change default client module' do
+      AMQP.client = MockClientModule
+      AMQP.client.should == MockClientModule
+      MockClientModule.ancestors.should include AMQP
+    end
+
+    describe 'new default client module' do
+      it 'sticks around after being assigned' do
+        AMQP.client.should == MockClientModule
+      end
+
+      it 'extends any object that includes AMQP::Client' do
+        @client = MockClient.new
+        @client.should respond_to :my_mock_method
+      end
+    end
+  end # .client
+
+
+
+
+  describe 'logging' do
+    after(:all) do
+      AMQP.logging = false
+    end
+
+    it 'is silent by default' do
+      AMQP.logging.should be_false
+    end
+  end # .logging=
+
+
+
+
+  describe '.start' do
+    context 'inside EM loop' do
+      include AMQP::SpecHelper
+      em_after { AMQP.cleanup_state }
+
+      it 'yields to given block AFTER connection is established' do
+        em do
+          AMQP.start AMQP_OPTS do
+            @block_fired = true
+            AMQP.connection.should be_connected
+          end
+          done(0.1) { @block_fired.should be_true }
+        end
+      end
+    end # context 'inside EM loop'
+  end # .start
+
+
+
+
+  describe '.stop' do
+    it 'is noop if connection is not established' do
+      expect { @res = AMQP.stop }.to_not raise_error
+      @res.should be_nil
+    end
+
+    context 'with established AMQP connection' do
+      include AMQP::Spec
+      after { AMQP.cleanup_state; done }
+      default_options AMQP_OPTS
+
+      it 'unsets AMQP.connection property. Mind the delay!' do
+        AMQP.start(AMQP_OPTS)
+        AMQP.connection.should be_connected
+
+        AMQP.stop
+        AMQP.connection.should_not be_nil
+        done(0.1) { AMQP.connection.should be_nil }
+      end
+
+      it 'yields to given block AFTER disconnect (BUT before AMQP.conn is cleared!)' do
+        AMQP.stop do
+          @block_fired = true
+          AMQP.connection.should_not be_nil
+          AMQP.instance_variable_get(:@closing).should be_true
+        end
+        done(0.1) { @block_fired.should be_true }
+      end
+    end # context 'with established AMQP connection'
+  end # .stop
+end

data/spec/unit/amqp/protocol_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "amqp/protocol"
+
+describe AMQP::Protocol do
+  include AMQP
+
+  it 'should instantiate methods with arguments' do
+    meth = Protocol::Connection::StartOk.new nil, 'PLAIN', nil, 'en_US'
+    meth.locale.should == 'en_US'
+  end
+
+  it 'should instantiate methods with named parameters' do
+    meth = Protocol::Connection::StartOk.new :locale => 'en_US',
+                                             :mechanism => 'PLAIN'
+    meth.locale.should == 'en_US'
+  end
+
+  it 'should convert methods to binary' do
+    meth = Protocol::Connection::Secure.new :challenge => 'secret'
+    meth.to_binary.should be_kind_of Buffer
+
+    meth.to_s.should == [10, 20, 6, 'secret'].pack('nnNa*')
+  end
+
+  it 'should convert binary to method' do
+    orig = Protocol::Connection::Secure.new :challenge => 'secret'
+    copy = Protocol.parse orig.to_binary
+    orig.should == copy
+  end
+
+  it 'should convert headers to binary' do
+    head = Protocol::Header.new Protocol::Basic,
+                                size = 5,
+                                weight = 0,
+                                :content_type => 'text/json',
+                                :delivery_mode => 1,
+                                :priority => 1
+    head.to_s.should ==
+        [60, weight, 0, size, 0b1001_1000_0000_0000, 9, 'text/json', 1, 1].pack('nnNNnCa*CC')
+  end
+
+  it 'should convert binary to header' do
+    orig = Protocol::Header.new Protocol::Basic,
+                                size = 5,
+                                weight = 0,
+                                :content_type => 'text/json',
+                                :delivery_mode => 1,
+                                :priority => 1
+    Protocol::Header.new(orig.to_binary).should == orig
+  end
+end

data/spec/unit/mq/channel_close_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe MQ, "#close(&callback)" do
+  include AMQP::EMSpec
+
+  default_timeout 5
+
+  it "takes a callback which will run when we get back Channel.Close-Ok" do
+    MQ.new.close do |amq|
+      done
+    end
+  end
+end

data/spec/unit/mq/collection_spec.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "mq/collection"
+
+Item = Struct.new(:name)
+
+describe MQ::Collection do
+  before do
+    @items = 3.times.map { |int| Item.new("name-#{int}") }
+    @collection = MQ::Collection.new(@items)
+  end
+
+  it "provides access to items by name" do
+    @collection["name-1"].should_not be_nil
+    @collection["name-1"].should eql(@items[1])
+  end
+
+  it "DOES NOT allow modification of existing items" do
+    lambda { @collection["name-1"] = Item.new("test") }.should raise_error(NoMethodError)
+  end
+
+
+  describe "#<<" do
+    it "should raise IncompatibleItemError if the argument doesn't have method :name" do
+      lambda { @collection << nil }.should raise_error(MQ::Collection::IncompatibleItemError)
+    end
+
+    it "should add an item into the collection" do
+      length = @collection.length
+      @collection << Item.new("test")
+      @collection.length.should eql(length + 1)
+    end
+
+    context "when another item with given name already exists and the name IS NOT nil" do
+      it "should not add an item to the collection" do
+        @collection << Item.new("test")
+        length = @collection.length
+        @collection << Item.new("test")
+        @collection.length.should eql(length)
+      end # it
+    end # context
+
+
+    context "when another item with given name already exists and the name IS nil" do
+      it "should add an item to the collection" do
+        @collection << Item.new(nil)
+        length = @collection.length
+        @collection << Item.new(nil)
+        @collection.length.should eql(length + 1)
+      end # it
+    end # context
+
+    it "should return the item" do
+      item = Item.new("test")
+      (@collection << item).should eql item
+    end
+
+    context "when adding new item with duplicate name" do
+      before do
+        @original_item = Item.new("test")
+        @new_item = Item.new("test")
+        @collection << @original_item
+      end
+
+      it "keeps item already in collection" do
+        @collection << @new_item
+        @collection['test'].should eql @original_item
+      end
+
+      it "returns item already in collection" do
+        (@collection << @new_item).should eql @original_item
+      end
+    end
+
+    context "when item we add already exists in the collection" do
+      it "should return the item" do
+        item = Item.new("test")
+        @collection << item
+        (@collection << item).should eql item
+      end # it
+    end # context
+  end # describe
+
+
+
+
+  describe "#add!" do
+    context "when the argument doesn't respond to :name" do
+      it "should raise IncompatibleItemError " do
+        lambda { @collection.add!(nil) }.should raise_error(MQ::Collection::IncompatibleItemError)
+      end # it
+    end
+
+    context "when another item with given name already exists" do
+      it "should add an item to the collection" do
+        @collection.add! Item.new("test")
+        lambda do
+          @collection.add!(Item.new("test"))
+        end.should change(@collection, :length).by(1)
+      end # it
+    end # context
+
+    it "should return the item" do
+      item = Item.new("test")
+      (@collection.add! item).should eql(item)
+    end # it
+  end # describe
+
+
+
+
+
+  describe "#<<" do
+    context "when the argument doesn't respond to :name" do
+      it "should raise IncompatibleItemError " do
+        lambda { @collection << nil }.should raise_error(MQ::Collection::IncompatibleItemError)
+      end # it
+    end # context
+
+    context "when the argument DOES respond to :name" do
+      it "should add an item into the collection" do
+        lambda do
+          @collection << Item.new("test")
+        end.should change(@collection, :length).by(1)
+      end
+    end # context
+  end # describe
+end # describe MQ::Collection

data/spec/unit/mq/exchange_declaration_spec.rb

@@ -0,0 +1,524 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe MQ do
+
+  #
+  # Environment
+  #
+
+  include AMQP::Spec
+
+  default_timeout 10
+
+  amqp_before do
+    @channel = MQ.new
+  end
+
+
+  #
+  # Examples
+  #
+
+  describe "#direct" do
+    context "when exchange name is specified" do
+      it 'declares a new direct exchange with that name' do
+        @channel.direct('name').name.should == 'name'
+
+        done
+      end
+
+      it "declares direct exchange as transient (non-durable)" do
+        exchange = @channel.direct('name')
+
+        exchange.should_not be_durable
+        exchange.should be_transient
+
+        done
+      end
+
+      it "declares direct exchange as non-auto-deleted" do
+        exchange = @channel.direct('name')
+
+        exchange.should_not be_auto_deleted
+
+        done
+      end
+    end
+
+
+    context "when exchange name is omitted" do
+      it 'uses amq.direct' do
+        @channel.direct.name.should == 'amq.direct'
+        done
+      end # it
+    end # context
+
+
+    context "when exchange name was specified as a blank string" do
+      it 'returns direct exchange with server-generated name' do
+        pending <<-EOF
+      This has to be fixed in RabbitMQ first
+      https://bugzilla.rabbitmq.com/show_bug.cgi?id=23509
+    EOF
+        @channel.direct("") do |exchange|
+          exchange.name.should_not be_empty
+          done
+        end
+      end
+    end # context
+
+
+    context "when passive option is used" do
+      context "and exchange with given name already exists" do
+        it "silently returns" do
+          name = "a_new_direct_exchange declared at #{Time.now.to_i}"
+
+          original_exchange = @channel.direct(name)
+          exchange          = @channel.direct(name, :passive => true)
+
+          exchange.should == original_exchange
+
+          done
+        end # it
+      end
+
+      context "and exchange with given name DOES NOT exist" do
+        it "raises an exception" do
+          pending "Not yet supported"
+
+          expect {
+            exchange = @channel.direct("direct exchange declared at #{Time.now.to_i}", :passive => true)
+          }.to raise_error
+
+          done
+        end # it
+      end # context
+    end # context
+
+
+    context "when exchange is declared as durable" do
+      it "returns a new durable direct exchange" do
+        exchange = @channel.direct("a_new_durable_direct_exchange", :durable => true)
+        exchange.should be_durable
+        exchange.should_not be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as non-durable" do
+      it "returns a new NON-durable direct exchange" do
+        exchange = @channel.direct("a_new_non_durable_direct_exchange", :durable => false)
+        exchange.should_not be_durable
+        exchange.should be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted direct exchange" do
+        exchange = @channel.direct("a new auto-deleted direct exchange", :auto_delete => true)
+
+        exchange.should be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted direct exchange" do
+        exchange = @channel.direct("a new non-auto-deleted direct exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared without explicit :nowait parameter" do
+      it "is declared with :nowait by default" do
+        exchange = @channel.direct("a new non-auto-deleted direct exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is re-declared with parameters different from original declaration" do
+      it "raises an exception" do
+        @channel.direct("previously.declared.durable.direct.exchange", :durable => true)
+
+        expect {
+          @channel.direct("previously.declared.durable.direct.exchange", :durable => false)
+        }.to raise_error(MQ::IncompatibleOptionsError)
+
+        done
+      end # it
+    end # context
+  end # describe
+
+
+
+
+  describe "#fanout" do
+    context "when exchange name is specified" do
+      let(:name) { "new.fanout.exchange" }
+
+      it "declares a new fanout exchange with that name" do
+        exchange = @channel.fanout(name)
+
+        exchange.name.should == name
+
+        done
+      end
+    end # context
+
+    context "when exchange name is omitted" do
+      it "uses amq.fanout" do
+        exchange = @channel.fanout
+        exchange.name.should == "amq.fanout"
+        exchange.name.should_not == "amq.fanout2"
+
+        done
+      end
+    end # context
+
+    context "when passive option is used" do
+      context "and exchange with given name already exists" do
+        it "silently returns" do
+          name = "a_new_fanout_exchange declared at #{Time.now.to_i}"
+
+          original_exchange = @channel.fanout(name)
+          exchange          = @channel.fanout(name, :passive => true)
+
+          exchange.should == original_exchange
+
+          done
+        end # it
+      end
+
+      context "and exchange with given name DOES NOT exist" do
+        it "raises an exception" do
+          pending "Not yet supported"
+
+          expect {
+            exchange = @channel.fanout("fanout exchange declared at #{Time.now.to_i}", :passive => true)
+          }.to raise_error
+
+          done
+        end # it
+      end # context
+    end # context
+
+
+    context "when exchange is declared as durable" do
+      it "returns a new durable fanout exchange" do
+        exchange = @channel.fanout("a_new_durable_fanout_exchange", :durable => true)
+        exchange.should be_durable
+        exchange.should_not be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as non-durable" do
+      it "returns a new NON-durable fanout exchange" do
+        exchange = @channel.fanout("a_new_non_durable_fanout_exchange", :durable => false)
+        exchange.should_not be_durable
+        exchange.should be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted fanout exchange" do
+        exchange = @channel.fanout("a new auto-deleted fanout exchange", :auto_delete => true)
+
+        exchange.should be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted fanout exchange" do
+        exchange = @channel.fanout("a new non-auto-deleted fanout exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared without explicit :nowait parameter" do
+      it "is declared with :nowait by default" do
+        exchange = @channel.fanout("a new non-auto-deleted fanout exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is re-declared with parameters different from original declaration" do
+      it "raises an exception" do
+        @channel.fanout("previously.declared.durable.topic.exchange", :durable => true)
+
+        expect {
+          @channel.fanout("previously.declared.durable.topic.exchange", :durable => false)
+        }.to raise_error(MQ::IncompatibleOptionsError)
+
+        done
+      end # it
+    end # context
+  end # describe
+
+
+
+
+  describe "#topic" do
+    context "when exchange name is specified" do
+      let(:name) { "a.topic.exchange" }
+
+      it "declares a new topic exchange with that name" do
+        exchange = @channel.topic(name)
+        exchange.name.should == name
+
+        done
+      end
+    end # context
+
+    context "when exchange name is omitted" do
+      it "uses amq.topic" do
+        exchange = @channel.topic
+        exchange.name.should == "amq.topic"
+        exchange.name.should_not == "amq.topic2"
+
+        done
+      end
+    end # context
+
+    context "when passive option is used" do
+      context "and exchange with given name already exists" do
+        it "silently returns" do
+          name = "a_new_topic_exchange declared at #{Time.now.to_i}"
+
+          original_exchange = @channel.topic(name)
+          exchange          = @channel.topic(name, :passive => true)
+
+          exchange.should == original_exchange
+
+          done
+        end # it
+      end
+
+      context "and exchange with given name DOES NOT exist" do
+        it "raises an exception" do
+          pending "Not yet supported"
+
+          expect {
+            exchange = @channel.topic("topic exchange declared at #{Time.now.to_i}", :passive => true)
+          }.to raise_error
+
+          done
+        end # it
+      end # context
+    end # context
+
+
+    context "when exchange is declared as durable" do
+      it "returns a new durable topic exchange" do
+        exchange = @channel.topic("a_new_durable_topic_exchange", :durable => true)
+        exchange.should be_durable
+        exchange.should_not be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as non-durable" do
+      it "returns a new NON-durable topic exchange" do
+        exchange = @channel.topic("a_new_non_durable_topic_exchange", :durable => false)
+        exchange.should_not be_durable
+        exchange.should be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted topic exchange" do
+        exchange = @channel.topic("a new auto-deleted topic exchange", :auto_delete => true)
+
+        exchange.should be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted topic exchange" do
+        exchange = @channel.topic("a new non-auto-deleted topic exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared without explicit :nowait parameter" do
+      it "is declared with :nowait by default" do
+        exchange = @channel.topic("a new non-auto-deleted topic exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is re-declared with parameters different from original declaration" do
+      xit "raises an exception" do
+        @channel.topic("previously.declared.durable.topic.exchange", :durable => true)
+
+        expect {
+          @channel.topic("previously.declared.durable.topic.exchange", :durable => false)
+        }.to raise_error(MQ::IncompatibleOptionsError)
+
+        done
+      end # it
+    end # context
+  end # describe
+
+
+
+
+  describe "#headers" do
+    context "when exchange name is specified" do
+      let(:name) { "new.headers.exchange" }
+
+      it "declares a new headers exchange with that name" do
+        exchange = @channel.headers(name)
+
+        exchange.name.should == name
+
+        done
+      end
+    end # context
+
+    context "when exchange name is omitted" do
+      xit "uses amq.match" do
+        pending "Times out. MK."
+
+        exchange = @channel.headers
+        exchange.name.should == "amq.match"
+        exchange.name.should_not == "amq.headers"
+
+        done
+      end
+    end # context
+
+    context "when passive option is used" do
+      context "and exchange with given name already exists" do
+        it "silently returns" do
+          name = "a_new_headers_exchange declared at #{Time.now.to_i}"
+
+          original_exchange = @channel.headers(name)
+          exchange          = @channel.headers(name, :passive => true)
+
+          exchange.should == original_exchange
+
+          done
+        end # it
+      end
+
+      context "and exchange with given name DOES NOT exist" do
+        it "raises an exception" do
+          pending "Not yet supported"
+
+          expect {
+            exchange = @channel.headers("headers exchange declared at #{Time.now.to_i}", :passive => true)
+          }.to raise_error
+
+          done
+        end # it
+      end # context
+    end # context
+
+
+    context "when exchange is declared as durable" do
+      it "returns a new durable headers exchange" do
+        exchange = @channel.headers("a_new_durable_headers_exchange", :durable => true)
+        exchange.should be_durable
+        exchange.should_not be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as non-durable" do
+      it "returns a new NON-durable headers exchange" do
+        exchange = @channel.headers("a_new_non_durable_headers_exchange", :durable => false)
+        exchange.should_not be_durable
+        exchange.should be_transient
+
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted headers exchange" do
+        exchange = @channel.headers("a new auto-deleted headers exchange", :auto_delete => true)
+
+        exchange.should be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared as auto-deleted" do
+      it "returns a new auto-deleted headers exchange" do
+        exchange = @channel.headers("a new non-auto-deleted headers exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is declared without explicit :nowait parameter" do
+      it "is declared with :nowait by default" do
+        exchange = @channel.headers("a new non-auto-deleted headers exchange", :auto_delete => false)
+
+        exchange.should_not be_auto_deleted
+        done
+      end # it
+    end # context
+
+
+    context "when exchange is re-declared with parameters different from original declaration" do
+      xit "raises an exception" do
+        pending "Times out. MK."
+        @channel.headers("previously.declared.durable.topic.exchange", :durable => true)
+
+        expect {
+          @channel.headers("previously.declared.durable.topic.exchange", :durable => false)
+        }.to raise_error(MQ::IncompatibleOptionsError)
+
+        done
+      end # it
+    end # context
+  end # describe
+end # describe MQ