bunny 0.8.0 → 0.9.0.pre1

data/lib/qrack/transport/frame.rb

@@ -1,102 +0,0 @@
-
-# encoding: utf-8
-
-
-#:stopdoc:
-# this file was autogenerated on 2012-02-28 11:22:27 -0500
-#
-# DO NOT EDIT! (edit ext/qparser.rb and config.yml instead, and run 'ruby qparser.rb')
-
-module Qrack
-  module Transport
-    class Frame
-
-      FOOTER = 206
-      ID = 0
-
-      @types = {
-                 1 => 'Method',
-                 2 => 'Header',
-                 3 => 'Body',
-                 8 => 'Heartbeat',
-               }
-
-      attr_accessor :channel, :payload
-
-      def initialize payload = nil, channel = 0
-        @channel, @payload = channel, payload
-      end
-
-      def id
-        self.class::ID
-      end
-
-      def to_binary
-        buf = Transport::Buffer.new
-        buf.write :octet, id
-        buf.write :short, channel
-        buf.write :longstr, payload
-        buf.write :octet, FOOTER
-        buf.rewind
-        buf
-      end
-
-      def to_s
-        to_binary.to_s
-      end
-
-      def == frame
-        [ :id, :channel, :payload ].inject(true) do |eql, field|
-          eql and __send__(field) == frame.__send__(field)
-        end
-      end
-
-      def self.parse(buf, opts)
-        buf = Transport::Buffer.new(buf) unless buf.is_a? Transport::Buffer
-
-        if opts[:timeout] or opts[:cancellator]
-          raise Qrack::FrameTimeout unless buf.read_ready?(opts[:timeout], opts[:cancellator])
-        end
-
-        buf.extract do
-          id, channel, payload, footer = buf.read(:octet, :short, :longstr, :octet)
-          Qrack::Transport.const_get(@types[id]).new(payload, channel) if footer == FOOTER
-        end
-      end
-
-    end
-
-    class Method < Frame
-
-      ID = 1
-
-      def initialize payload = nil, channel = 0
-        super
-        unless @payload.is_a? Protocol::Class::Method or @payload.nil?
-          @payload = Protocol.parse(@payload)
-        end
-      end
-    end
-
-    class Header < Frame
-
-      ID = 2
-
-      def initialize payload = nil, channel = 0
-        super
-        unless @payload.is_a? Protocol::Header or @payload.nil?
-          @payload = Protocol::Header.new(@payload)
-        end
-      end
-    end
-
-    class Body < Frame
-      ID = 3
-    end
-
-    class Heartbeat < Frame
-      ID = 8
-    end
-
-  end
-end

data/spec/spec_09/amqp_url_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
-# and that it is running on 'localhost'.
-
-# If this is not the case, please change the 'Bunny.new' call below to include
-# the relevant arguments e.g. @b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
-
-require "bunny"
-
-describe Bunny do
-  context "AMQP URL parsing" do
-    it "handles port properly" do
-      bunny = Bunny.new("amqp://dev.rabbitmq.com:1212")
-      bunny.port.should eql(1212)
-      bunny.stop
-    end
-  end
-end

data/spec/spec_09/bunny_spec.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-
-# bunny_spec.rb
-
-# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
-# and that it is running on 'localhost'.
-
-# If this is not the case, please change the 'Bunny.new' call below to include
-# the relevant arguments e.g. @b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
-
-require "bunny"
-
-describe Bunny do
-
-  before(:each) do
-    @b = Bunny.new
-    @b.start
-  end
-
-  after(:each) do
-    begin
-      @b.stop
-    rescue Exception
-    ensure
-      @b = nil
-    end
-  end
-
-  it "should connect to an AMQP server" do
-    @b.status.should == :connected
-  end
-
-  it "should be able to create and open a new channel" do
-    c = @b.create_channel
-    c.number.should == 2
-    c.should be_an_instance_of(Bunny::Channel)
-    @b.channels.size.should == 3
-    c.open.should == :open_ok
-    @b.channel.number.should == 2
-  end
-
-  it "should be able to switch between channels" do
-    @b.channel.number.should == 1
-    @b.switch_channel(0)
-    @b.channel.number.should == 0
-  end
-
-  it "should raise an error if trying to switch to a non-existent channel" do
-    lambda { @b.switch_channel(5) }.should raise_error(RuntimeError)
-  end
-
-  it "should be able to create an exchange" do
-    exch = @b.exchange('test_exchange')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'test_exchange'
-    @b.exchanges.has_key?('test_exchange').should be(true)
-  end
-
-  it "should be able to create a queue" do
-    q = @b.queue('test1')
-    q.should be_an_instance_of(Bunny::Queue)
-    q.name.should == 'test1'
-    @b.queues.has_key?('test1').should be(true)
-  end
-
-  # Current RabbitMQ has not implemented some functionality
-  it "should raise an error if setting of QoS fails" do
-    lambda { @b.qos(:global => true) }.should raise_error(Bunny::ForcedConnectionCloseError)
-    @b.status.should == :not_connected
-  end
-
-  it "should be able to set QoS" do
-    @b.qos.should == :qos_ok
-  end
-
-end

data/spec/spec_09/connection_spec.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-# connection_spec.rb
-
-require "bunny"
-
-describe Bunny do
-
-  it "should raise an error if the wrong user name or password is used" do
-    b = Bunny.new(:user => 'wrong')
-    lambda { b.start}.should raise_error(Bunny::ProtocolError)
-  end
-
-  it "should merge custom settings from AMQP URL with default settings" do
-    b = Bunny.new("amqp://tagadab")
-    b.host.should eql("tagadab")
-  end
-
-  it "should be able to open a TCPSocket with a timeout" do
-    b = Bunny.new
-    connect_timeout = 5
-    lambda {
-      Bunny::Timer::timeout(connect_timeout, Qrack::ConnectionTimeout) do
-        TCPSocket.new(b.host, b.port)
-      end
-    }.should_not raise_error(Exception)
-  end
-
-  it "should know the default port of a SSL connection" do
-    b = Bunny.new(:ssl => true)
-    b.port.should eql(5671)
-  end
-
-end

data/spec/spec_09/exchange_spec.rb

@@ -1,173 +0,0 @@
-# encoding: utf-8
-
-# exchange_spec.rb
-
-# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
-# and that it is running on 'localhost'.
-
-# If this is not the case, please change the 'Bunny.new' call below to include
-# the relevant arguments e.g. @b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
-
-require "bunny"
-
-describe 'Exchange' do
-
-  before(:each) do
-    @b = Bunny.new
-    @b.start
-  end
-
-  after(:each) do
-    begin
-      @b.stop
-    rescue Exception
-    ensure
-      @b = nil
-    end
-  end
-
-  it "should raise an error if instantiated as non-existent type" do
-    lambda { @b.exchange('bogus_ex', :type => :bogus) }.should raise_error(Bunny::ForcedConnectionCloseError)
-    @b.status.should == :not_connected
-  end
-
-  it "should allow a default direct exchange to be instantiated by specifying :type" do
-    exch = @b.exchange('amq.direct', :type => :direct)
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'amq.direct'
-    exch.type.should == :direct
-    @b.exchanges.has_key?('amq.direct').should be(true)
-  end
-
-  it "should allow a default direct exchange to be instantiated without specifying :type" do
-    exch = @b.exchange('amq.direct')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'amq.direct'
-    exch.type.should == :direct
-    @b.exchanges.has_key?('amq.direct').should be(true)
-  end
-
-  it "should allow a default fanout exchange to be instantiated without specifying :type" do
-    exch = @b.exchange('amq.fanout')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'amq.fanout'
-    exch.type.should == :fanout
-    @b.exchanges.has_key?('amq.fanout').should be(true)
-  end
-
-  it "should allow a default topic exchange to be instantiated without specifying :type" do
-    exch = @b.exchange('amq.topic')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'amq.topic'
-    exch.type.should == :topic
-    @b.exchanges.has_key?('amq.topic').should be(true)
-  end
-
-  it "should allow a default headers (amq.match) exchange to be instantiated without specifying :type" do
-    exch = @b.exchange('amq.match')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'amq.match'
-    exch.type.should == :headers
-    @b.exchanges.has_key?('amq.match').should be(true)
-  end
-
-  it "should allow a default headers (amq.headers) exchange to be instantiated without specifying :type" do
-    exch = @b.exchange('amq.headers')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'amq.headers'
-    exch.type.should == :headers
-    @b.exchanges.has_key?('amq.headers').should be(true)
-  end
-
-  it "should create an exchange as direct by default" do
-    exch = @b.exchange('direct_defaultex')
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'direct_defaultex'
-    exch.type.should == :direct
-    @b.exchanges.has_key?('direct_defaultex').should be(true)
-  end
-
-  it "should be able to be instantiated as a direct exchange" do
-    exch = @b.exchange('direct_exchange', :type => :direct)
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'direct_exchange'
-    exch.type.should == :direct
-    @b.exchanges.has_key?('direct_exchange').should be(true)
-  end
-
-  it "should be able to be instantiated as a topic exchange" do
-    exch = @b.exchange('topic_exchange', :type => :topic)
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'topic_exchange'
-    exch.type.should == :topic
-    @b.exchanges.has_key?('topic_exchange').should be(true)
-  end
-
-  it "should be able to be instantiated as a fanout exchange" do
-    exch = @b.exchange('fanout_exchange', :type => :fanout)
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'fanout_exchange'
-    exch.type.should == :fanout
-    @b.exchanges.has_key?('fanout_exchange').should be(true)
-  end
-
-  it "should be able to be instantiated as a headers exchange" do
-    exch = @b.exchange('headers_exchange', :type => :headers)
-    exch.should be_an_instance_of(Bunny::Exchange)
-    exch.name.should == 'headers_exchange'
-    exch.type.should == :headers
-    @b.exchanges.has_key?('headers_exchange').should be(true)
-  end
-
-  it "should ignore the :nowait option when instantiated" do
-    exch = @b.exchange('direct2_exchange', :nowait => true)
-  end
-
-  it "should be able to publish a message" do
-    exch = @b.exchange('direct_exchange')
-    exch.publish('This is a published message')
-  end
-
-  it "should not modify the passed options hash when publishing a message" do
-    exch = @b.exchange('direct_exchange')
-    opts = {:key => 'a', :persistent => true}
-    exch.publish('', opts)
-    opts.should == {:key => 'a', :persistent => true}
-  end
-
-  it "should be able to return an undeliverable message" do
-    exch = @b.exchange('return_exch')
-    exch.publish('This message should be undeliverable', :immediate => true)
-    ret_msg = @b.returned_message
-    ret_msg.should be_an_instance_of(Hash)
-    ret_msg[:payload].should == 'This message should be undeliverable'
-  end
-
-  it "should be able to return a message that exceeds maximum frame size" do
-    exch = @b.exchange('return_exch')
-    lg_msg = 'z' * 142000
-    exch.publish(lg_msg, :immediate => true)
-    ret_msg = @b.returned_message
-    ret_msg.should be_an_instance_of(Hash)
-    ret_msg[:payload].should == lg_msg
-  end
-
-  it "should report an error if delete fails" do
-    exch = @b.exchange('direct_exchange')
-    lambda { exch.delete(:exchange => 'bogus_ex') }.should raise_error(Bunny::ForcedChannelCloseError)
-    @b.channel.active.should == false
-  end
-
-  it "should be able to be deleted" do
-    exch = @b.exchange('direct_exchange')
-    res = exch.delete
-    res.should == :delete_ok
-    @b.exchanges.has_key?('direct_exchange').should be(false)
-  end
-
-  it "should ignore the :nowait option when deleted" do
-    exch = @b.exchange('direct2_exchange')
-    exch.delete(:nowait => true)
-  end
-
-end

data/spec/spec_09/queue_spec.rb

@@ -1,240 +0,0 @@
-# encoding: utf-8
-
-# queue_spec.rb
-
-# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
-# and that it is running on 'localhost'.
-
-# If this is not the case, please change the 'Bunny.new' call below to include
-# the relevant arguments e.g. @b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
-
-require "bunny"
-
-describe 'Queue' do
-
-  before(:each) do
-    @b = Bunny.new
-    @b.start
-
-    @default_exchange = @b.exchange("")
-  end
-
-  after(:each) do
-    begin
-      @b.stop
-    rescue Exception
-    ensure
-      @b = nil
-    end
-  end
-
-  def message_count(queue, sleep_time = 0.1)
-    sleep sleep_time
-    queue.message_count
-  end
-
-  it "should ignore the :nowait option when instantiated" do
-    q = @b.queue('test0', :nowait => true)
-  end
-
-  it "should ignore the :nowait option when binding to an exchange" do
-    exch = @b.exchange('direct_exch')
-    q = @b.queue('test0')
-    q.bind(exch, :nowait => true).should == :bind_ok
-  end
-
-  it "should raise an error when trying to bind to a non-existent exchange" do
-    q = @b.queue('test1')
-    lambda {q.bind('bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
-    @b.channel.active.should == false
-  end
-
-  it "should be able to bind to an existing exchange" do
-    exch = @b.exchange('direct_exch')
-    q = @b.queue('test1')
-    q.bind(exch).should == :bind_ok
-  end
-
-  it "should ignore the :nowait option when unbinding from an existing exchange" do
-    exch = @b.exchange('direct_exch')
-    q = @b.queue('test0')
-    q.unbind(exch, :nowait => true).should == :unbind_ok
-  end
-
-  it "should raise an error if unbinding from a non-existent exchange" do
-    q = @b.queue('test1')
-    lambda {q.unbind('bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
-    @b.channel.active.should == false
-  end
-
-  it "should be able to unbind from an exchange" do
-    exch = @b.exchange('direct_exch')
-    q = @b.queue('test1')
-    q.unbind(exch).should == :unbind_ok
-  end
-
-  it "should be able to pop a message complete with header and delivery details" do
-    q = @b.queue('test1')
-    @default_exchange.publish('This is a test message', :key => 'test1')
-    msg = q.pop()
-    msg.should be_an_instance_of(Hash)
-    msg[:header].should be_an_instance_of(Bunny::Protocol::Header)
-    msg[:payload].should == 'This is a test message'
-    msg[:delivery_details].should be_an_instance_of(Hash)
-    message_count(q).should == 0
-  end
-
-  it "should be able to send reply_to, correlation_id and user_id headers " do
-    q = @b.queue('test1')
-    @default_exchange.publish('This is a test message', :key => 'test1', 
-                              :reply_to => 'test_reply_to',
-                              :correlation_id => '987654',
-                              :user_id => 'guest')
-    msg = q.pop()
-    msg[:header].properties[:reply_to].should == 'test_reply_to'
-    msg[:header].properties[:correlation_id].should == '987654'
-    msg[:header].properties[:user_id].should == 'guest'
-  end
-
-  it "should be able to pop a message and just get the payload" do
-    q = @b.queue('test1')
-    @default_exchange.publish('This is another test message', :key => 'test1')
-    msg = q.pop[:payload]
-    msg.should == 'This is another test message'
-    message_count(q).should == 0
-  end
-
-  it "should be able to pop a message where body length exceeds max frame size" do
-    q = @b.queue('test1')
-    lg_msg = 'z' * 142000
-    @default_exchange.publish(lg_msg, :key => 'test1')
-    msg = q.pop[:payload]
-    msg.should == lg_msg
-  end
-
-  it "should be able call a block when popping a message" do
-    q = @b.queue('test1')
-    @default_exchange.publish('This is another test message', :key => 'test1')
-    q.pop { |msg| msg[:payload].should == 'This is another test message' }
-    q.pop { |msg| msg[:payload].should == :queue_empty }
-  end
-
-  it "should raise an error if purge fails" do
-    q = @b.queue('test1')
-    5.times { @default_exchange.publish('This is another test message', :key => 'test1') }
-    message_count(q).should == 5
-    lambda {q.purge(:queue => 'bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
-  end
-
-  it "should be able to be purged to remove all of its messages" do
-    q = @b.queue('test1')
-    message_count(q).should == 5
-    q.purge.should == :purge_ok
-    message_count(q).should == 0
-  end
-
-  it "should return an empty message when popping an empty queue" do
-    q = @b.queue('test1')
-    @default_exchange.publish('This is another test message', :key => 'test1')
-    q.pop
-    msg = q.pop[:payload]
-    msg.should == :queue_empty
-  end
-
-  it "should stop subscription without processing messages if max specified is 0" do
-    q = @b.queue('test1')
-    5.times { @default_exchange.publish('Yet another test message', :key => 'test1') }
-    message_count(q).should == 5
-    q.subscribe(:message_max => 0)
-    message_count(q).should == 5
-    q.purge.should == :purge_ok
-  end
-
-  it "should stop subscription after processing number of messages specified > 0" do
-    q = @b.queue('test1')
-    5.times { @default_exchange.publish('Yet another test message', :key => 'test1') }
-    message_count(q).should == 5
-    q.subscribe(:message_max => 5)
-  end
-
-  it "should stop subscription after processing message_max messages < total in queue" do
-    q = @b.queue('test1')
-    @b.qos()
-    10.times { @default_exchange.publish('Yet another test message', :key => 'test1') }
-    message_count(q).should == 10
-    q.subscribe(:message_max => 5, :ack => true)
-    message_count(q).should == 5
-    q.purge.should == :purge_ok
-  end
-
-  it "should raise an error when delete fails" do
-    q = @b.queue('test1')
-    lambda {q.delete(:queue => 'bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
-    @b.channel.active.should == false
-  end
-
-  it "should pass correct block parameters through on subscribe" do
-    q = @b.queue('test1')
-    @default_exchange.publish("messages pop'n", :key => 'test1')
-
-    q.subscribe do |msg|
-      msg[:header].should be_an_instance_of Qrack::Protocol::Header
-      msg[:payload].should == "messages pop'n"
-      msg[:delivery_details].should_not be_nil
-
-      q.unsubscribe
-      break
-    end
-  end
-  
-  specify "subscribe method should support cancellation through a cancellator IO object" do
-    q = @b.queue('test1')
-    a, b = IO.pipe
-    b.close
-    block_called = false
-    q.subscribe(:cancellator => a) do |msg|
-      block_called = true
-    end
-    block_called.should be_false
-  end
-
-  it "should finish processing subscription messages if break is called in block" do
-    q = @b.queue('test1')
-    @default_exchange.publish('messages in my quezen', :key => 'test1')
-
-    q.subscribe do |msg|
-      msg[:payload].should == 'messages in my quezen'
-      q.unsubscribe
-      break
-    end
-
-    5.times {|i| @default_exchange.publish("#{i}", :key => 'test1') }
-    q.subscribe do |msg|
-      if msg[:payload] == '4'
-        q.unsubscribe
-        break
-      end
-    end
-  end
-
-  it "should be able to be deleted" do
-    q = @b.queue('test1')
-    res = q.delete
-    res.should == :delete_ok
-    @b.queues.has_key?('test1').should be(false)
-  end
-
-  it "should ignore the :nowait option when deleted" do
-    q = @b.queue('test0')
-    q.delete(:nowait => true)
-  end
-
-  it "should support server named queues" do
-    q = @b.queue
-    q.name.should_not == nil
-
-    @b.queue(q.name).should == q
-    q.delete
-  end
-
-end