bunny 0.8.0 → 0.9.0.pre1

data/spec/higher_level_api/integration/queue_delete_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Bunny::Queue, "#delete" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close
+  end
+
+
+
+  context "with a name of an existing queue" do
+    it "deletes that queue" do
+      ch = connection.create_channel
+      q  = ch.queue("")
+
+      q.delete
+      expect {
+        q.delete
+      }.to raise_error(Bunny::NotFound)
+    end
+  end
+
+
+  context "with a name of an existing queue" do
+    it "raises an exception" do
+      ch = connection.create_channel
+
+      expect {
+        ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
+      }.to raise_error(Bunny::NotFound)
+    end
+  end
+end

data/spec/higher_level_api/integration/queue_purge_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Bunny::Queue do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close
+  end
+
+
+  it "can be purged" do
+    ch = connection.create_channel
+
+    q  = ch.queue("", :exclusive => true)
+    x  = ch.default_exchange
+
+    x.publish("xyzzy", :routing_key => q.name)
+    sleep(0.5)
+
+    q.message_count.should == 1
+    q.purge
+    q.message_count.should == 0
+
+    ch.close
+  end
+end

data/spec/higher_level_api/integration/queue_unbind_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Bunny::Queue, "bound to an exchange" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close
+  end
+
+
+  it "can be unbound from an exchange it was bound to"
+end
+
+
+
+describe Bunny::Queue, "NOT bound to an exchange" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close
+  end
+
+
+  it "cannot be unbound (raises a channel error)"
+end

data/spec/higher_level_api/integration/tx_commit_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#tx_commit" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  it "is supported" do
+    ch = connection.create_channel
+    ch.tx_select
+    ch.tx_commit
+
+    ch.close
+  end
+end

data/spec/higher_level_api/integration/tx_rollback_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#tx_rollback" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  it "is supported" do
+    ch = connection.create_channel
+    ch.tx_select
+    ch.tx_rollback
+
+    ch.close
+  end
+end

data/spec/lower_level_api/integration/basic_cancel_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#basic_cancel" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  it "returns basic.cancel-ok" do
+    ch = connection.create_channel
+    q  = ch.queue("", :exclusive => true)
+
+    consume_ok = ch.basic_consume(q, "")
+    cancel_ok  = ch.basic_cancel(consume_ok.consumer_tag)
+
+    cancel_ok.should be_instance_of(AMQ::Protocol::Basic::CancelOk)
+    cancel_ok.consumer_tag.should == consume_ok.consumer_tag
+
+    ch.close
+  end
+
+  context "when the given consumer tag is valid" do
+    let(:queue_name) { "bunny.basic.cancel.queue#{rand}" }
+
+    it "cancels the consumer" do
+      delivered_data = []
+
+      t = Thread.new do
+        ch         = connection.create_channel
+        q          = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        consume_ok = ch.basic_consume(q, "", true, false) do |metadata, payload|
+          delivered_data << payload
+        end
+
+        consume_ok.consumer_tag.should_not be_nil
+        cancel_ok = ch.basic_cancel(consume_ok.consumer_tag)
+        cancel_ok.consumer_tag.should == consume_ok.consumer_tag
+
+        ch.close
+      end
+      t.abort_on_exception = true
+      sleep 0.5
+
+      sleep 0.7
+      delivered_data.should be_empty
+    end
+  end
+
+  context "when the given consumer tag is invalid (was never registered)" do
+    it "causes a channel error"
+  end
+end

data/spec/lower_level_api/integration/basic_consume_spec.rb

@@ -0,0 +1,100 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#basic_consume" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  it "returns basic.consume-ok when it is received" do
+    ch = connection.create_channel
+    q  = ch.queue("", :exclusive => true)
+
+    consume_ok = ch.basic_consume(q)
+    consume_ok.should be_instance_of(AMQ::Protocol::Basic::ConsumeOk)
+    consume_ok.consumer_tag.should_not be_nil
+
+    ch.close
+  end
+
+  it "carries server-generated consumer tag with basic.consume-ok" do
+    ch = connection.create_channel
+    q  = ch.queue("", :exclusive => true)
+
+    consume_ok = ch.basic_consume(q, "")
+    consume_ok.consumer_tag.should =~ /amq\.ctag.*/
+
+    ch.close
+  end
+
+  context "with automatic acknowledgement mode" do
+    let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+    it "causes messages to be automatically removed from the queue after delivery" do
+      delivered_keys = []
+      delivered_data = []
+
+      t = Thread.new do
+        ch = connection.create_channel
+        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        ch.basic_consume(q, "", true, false) do |metadata, payload|
+          delivered_keys << metadata.routing_key
+          delivered_data << payload
+        end
+      end
+      t.abort_on_exception = true
+      sleep 0.5
+
+      ch = connection.create_channel
+      x  = ch.default_exchange
+      x.publish("hello", :routing_key => queue_name)
+
+      sleep 0.7
+      delivered_keys.should include(queue_name)
+      delivered_data.should include("hello")
+
+      ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+
+      ch.close
+    end
+  end
+
+  context "with manual acknowledgement mode" do
+    let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+    it "waits for an explicit acknowledgement" do
+      delivered_keys = []
+      delivered_data = []
+
+      t = Thread.new do
+        ch = connection.create_channel
+        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        ch.basic_consume(q, "", false, false) do |metadata, payload|
+          delivered_keys << metadata.routing_key
+          delivered_data << payload
+
+          ch.close
+        end
+      end
+      t.abort_on_exception = true
+      sleep 0.5
+
+      ch = connection.create_channel
+      x  = ch.default_exchange
+      x.publish("hello", :routing_key => queue_name)
+
+      sleep 0.7
+      delivered_keys.should include(queue_name)
+      delivered_data.should include("hello")
+
+      ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+
+      ch.close      
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8; mode: ruby -*-
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+Bundler.setup(:default, :test)
+
+
+require "effin_utf8"
+require "bunny"
+
+
+require "amq/protocol/version"
+puts "Using Ruby #{RUBY_VERSION}, amq-protocol #{AMQ::Protocol::VERSION}"
+
+
+
+#
+# Ruby version-specific
+#
+
+case RUBY_VERSION
+when "1.8.7" then
+  class Array
+    alias sample choice
+  end
+when "1.8.6" then
+  raise "Ruby 1.8.6 is not supported. Sorry, pal. Time to move on beyond One True Ruby. Yes, time flies by."
+end
+
+
+
+module RabbitMQ
+  module Control
+    def rabbitmq_pid
+      $1.to_i if `rabbitmqctl status` =~ /\{pid,(\d+)\}/
+    end
+
+    def start_rabbitmq(delay = 1.0)
+      # this is Homebrew-specific :(
+      `rabbitmq-server > /dev/null 2>&1 &`; sleep(delay)
+    end
+
+    def stop_rabbitmq(pid = rabbitmq_pid, delay = 1.0)
+      `rabbitmqctl stop`; sleep(delay)
+    end
+
+    def kill_rabbitmq(pid = rabbitmq_pid, delay = 1.0)
+      # tango is down, tango is down!
+      Process.kill("KILL", pid); sleep(delay)
+    end
+  end
+end
+
+
+module PlatformDetection
+  def mri?
+    !defined?(RUBY_ENGINE) || (defined?(RUBY_ENGINE) && ("ruby" == RUBY_ENGINE))
+  end
+
+  def rubinius?
+    defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'rbx')
+  end
+end

data/spec/unit/bunny_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Bunny do
+  it "has library version" do
+    Bunny::VERSION.should_not be_nil
+    Bunny.version.should_not be_nil
+  end
+
+
+  it "has AMQP protocol version" do
+    Bunny::PROTOCOL_VERSION.should == "0.9.1"
+    AMQ::Protocol::PROTOCOL_VERSION.should == "0.9.1"
+    Bunny.protocol_version.should == "0.9.1"
+  end
+end

data/spec/unit/concurrent/condition_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "bunny/concurrent/condition"
+
+describe Bunny::Concurrent::Condition do
+  describe "#wait" do
+    it "blocks current thread until notified" do
+      condition = described_class.new
+      xs        = []
+
+      t = Thread.new do
+        xs << :notified
+
+        sleep 0.25
+        condition.notify
+      end
+
+      condition.wait
+      xs.should == [:notified]
+    end
+  end
+
+  describe "#notify" do
+    it "notifies a single thread waiting on the latch" do
+      condition = described_class.new
+      xs        = []
+
+      t1 = Thread.new do
+        condition.wait
+        xs << :notified1
+      end
+
+      t2 = Thread.new do
+        condition.wait
+        xs << :notified2
+      end
+
+      sleep 0.25
+      condition.notify
+      sleep 0.5
+      xs.should satisfy { |ys| ys.size == 1 && (ys.include?(:notified1) || ys.include?(:notified2)) }
+    end
+  end
+
+  describe "#notify_all" do
+    it "notifies all the threads waiting on the latch" do
+      condition = described_class.new
+      @xs        = []
+
+      t1 = Thread.new do
+        condition.wait
+        @xs << :notified1
+      end
+
+      t2 = Thread.new do
+        condition.wait
+        @xs << :notified2
+      end
+
+      sleep 0.5
+      condition.notify_all
+      sleep 0.5
+      @xs.should include(:notified1)
+      @xs.should include(:notified2)
+    end
+  end
+end