bunny 2.19.0 → 2.20.0

data/spec/stress/connection_open_close_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-unless defined?(JRUBY_VERSION) && !ENV["FORCE_JRUBY_RUN"]
-  describe Bunny::Session do
-    # creating thousands of connections means creating
-    # twice as many threads and this won't fly with the JVM
-    # in CI containers. MK.
-    n = if defined?(JRUBY_VERSION)
-          250
-        else
-          2500
-        end
-
-    n.times do |i|
-      it "can be closed (automatic recovery disabled, take #{i})" do
-        c  = Bunny.new(automatically_recover: false)
-        c.start
-        ch = c.create_channel
-
-        expect(c).to be_connected
-        c.stop
-        expect(c).to be_closed
-      end
-    end
-
-    n.times do |i|
-      it "can be closed (automatic recovery enabled, take #{i})" do
-        c  = Bunny.new(automatically_recover: true)
-        c.start
-        ch = c.create_channel
-
-        expect(c).to be_connected
-        c.stop
-        expect(c).to be_closed
-      end
-    end
-
-    context "in the single threaded mode" do
-      n.times do |i|
-        it "can be closed (single threaded mode, take #{i})" do
-          c  = Bunny.new(automatically_recover: false, threaded: false)
-          c.start
-          ch = c.create_channel
-
-          expect(c).to be_connected
-          c.stop
-          expect(c).to be_closed
-        end
-      end
-    end
-  end
-end

data/spec/stress/merry_go_round_spec.rb

@@ -1,105 +0,0 @@
-require "spec_helper"
-
-describe "A batch of messages proxied by multiple intermediate consumers" do
-  let(:c1) do
-    c = Bunny.new(username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      heartbeat_timeout: 6)
-    c.start
-    c
-  end
-
-  let(:c2) do
-    c = Bunny.new(username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      heartbeat_timeout: 6)
-    c.start
-    c
-  end
-
-  let(:c3) do
-    c = Bunny.new(username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      heartbeat_timeout: 6)
-    c.start
-    c
-  end
-
-  let(:c4) do
-    c = Bunny.new(username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      heartbeat_timeout: 6)
-    c.start
-    c
-  end
-
-  let(:c5) do
-    c = Bunny.new(username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      heartbeat_timeout: 6)
-    c.start
-    c
-  end
-
-  after :each do
-    [c1, c2, c3, c4, c5].each do |c|
-      c.close if c.open?
-    end
-  end
-
-  [1000, 5_000, 10_000, 20_000, 30_000, 50_000].each do |n|
-    # message flow is as follows:
-    #
-    # x => q4 => q3 => q2 => q1 => xs (results)
-    it "successfully reaches its final destination (batch size: #{n})" do
-      xs  = []
-
-      ch1 = c1.create_channel
-      q1  = ch1.queue("", exclusive: true)
-      q1.subscribe(manual_ack: true) do |delivery_info, _, payload|
-        xs << payload
-        ch1.ack(delivery_info.delivery_tag)
-      end
-
-      ch2 = c2.create_channel
-      q2  = ch2.queue("", exclusive: true)
-      q2.subscribe do |_, _, payload|
-        q1.publish(payload)
-      end
-
-      ch3 = c3.create_channel(nil, 2)
-      q3  = ch3.queue("", exclusive: true)
-      q3.subscribe(manual_ack: true) do |delivery_info, _, payload|
-        q2.publish(payload)
-        ch3.ack(delivery_info.delivery_tag)
-      end
-
-      ch4 = c4.create_channel(nil, 4)
-      q4  = ch4.queue("", exclusive: true)
-      q4.subscribe do |_, _, payload|
-        q3.publish(payload)
-      end
-
-      ch5 = c5.create_channel(nil, 8)
-      x   = ch5.default_exchange
-
-      n.times do |i|
-        x.publish("msg #{i}", routing_key: q4.name)
-      end
-
-      Bunny::TestKit.poll_until(90) do
-        xs.size >= n
-      end
-
-      expect(xs.size).to eq n
-      expect(xs.last).to eq "msg #{n - 1}"
-
-      [q1, q2, q3, q4].each { |q| q.delete }
-    end
-  end
-end

data/spec/toxiproxy_helper.rb

@@ -1,28 +0,0 @@
-module RabbitMQ
-  module Toxiproxy
-    RABBITMQ_UPSTREAM_HOST = if !ENV["LOCAL_RABBITMQ"].nil?
-                               # a local Toxiproxy/RabbitMQ combination
-                               "localhost"
-                             else
-                               # docker-compose
-                               "rabbitmq"
-                             end
-
-    def setup_toxiproxy
-      ::Toxiproxy.populate([{
-        name: "rabbitmq",
-        listen: "0.0.0.0:11111",
-            upstream: "#{RABBITMQ_UPSTREAM_HOST}:5672"
-      }])
-      rabbitmq_toxiproxy.enable
-    end
-
-    def cleanup_toxiproxy
-      ::Toxiproxy.populate()
-    end
-
-    def rabbitmq_toxiproxy
-      ::Toxiproxy[/rabbitmq/]
-    end
-  end
-end

data/spec/unit/bunny_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe Bunny do
-  it "has library version" do
-    expect(Bunny::VERSION).not_to be_nil
-    expect(Bunny.version).not_to be_nil
-  end
-
-
-  it "has AMQP protocol version" do
-    expect(Bunny::PROTOCOL_VERSION).to eq "0.9.1"
-    expect(AMQ::Protocol::PROTOCOL_VERSION).to eq "0.9.1"
-    expect(Bunny.protocol_version).to eq "0.9.1"
-  end
-end

data/spec/unit/concurrent/atomic_fixnum_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-require "bunny/concurrent/atomic_fixnum"
-
-describe Bunny::Concurrent::AtomicFixnum do
-  it "allows retrieving the current value" do
-    af = described_class.new(0)
-
-    expect(af.get).to eq 0
-    expect(af).to eq 0
-  end
-
-  it "can be updated" do
-    af = described_class.new(0)
-
-    expect(af.get).to eq 0
-    Thread.new do
-      af.set(10)
-    end
-    sleep 0.6
-    expect(af.get).to eq 10
-  end
-
-  it "can be incremented" do
-    af = described_class.new(0)
-
-    expect(af.get).to eq 0
-    10.times do
-      Thread.new do
-        af.increment
-      end
-    end
-    sleep 0.6
-    expect(af.get).to eq 10
-  end
-end

data/spec/unit/concurrent/condition_spec.rb

@@ -1,82 +0,0 @@
-require "spec_helper"
-require "bunny/concurrent/condition"
-
-describe Bunny::Concurrent::Condition do
-
-  describe "#wait" do
-    50.times do |i|
-      it "blocks current thread until notified (take #{i})" do
-        condition = described_class.new
-        xs        = []
-
-        t = Thread.new do
-          xs << :notified
-
-          sleep 0.2
-          condition.notify
-        end
-        t.abort_on_exception = true
-
-        condition.wait
-        expect(xs).to eq [:notified]
-      end
-    end
-  end
-
-  describe "#notify" do
-    50.times do |i|
-      it "notifies a single thread waiting on the latch (take #{i})" do
-        mutex     = Mutex.new
-        condition = described_class.new
-        xs        = []
-
-        t1 = Thread.new do
-          condition.wait
-          mutex.synchronize { xs << :notified1 }
-        end
-        t1.abort_on_exception = true
-
-        t2 = Thread.new do
-          condition.wait
-          mutex.synchronize { xs << :notified2 }
-        end
-        t2.abort_on_exception = true
-
-        sleep 0.2
-        condition.notify
-        sleep 0.5
-        expect(xs).to satisfy { |ys| ys.size == 1 && (ys.include?(:notified1) || ys.include?(:notified2)) }
-      end
-    end
-  end
-
-  describe "#notify_all" do
-    let(:n) { 30 }
-
-    50.times do |i|
-      it "notifies all the threads waiting on the latch (take #{i})" do
-        mutex     = Mutex.new
-        condition = described_class.new
-        @xs       = []
-
-        n.times do |i|
-          t = Thread.new do
-            condition.wait
-            mutex.synchronize { @xs << "notified#{i + 1}".to_sym }
-          end
-          t.abort_on_exception = true
-        end
-
-        sleep 0.5
-        condition.notify_all
-        sleep 0.5
-
-        n.times do |i|
-          item = "notified#{i + 1}".to_sym
-
-          expect(@xs).to include item
-        end
-      end
-    end
-  end
-end

data/spec/unit/concurrent/linked_continuation_queue_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-if defined?(JRUBY_VERSION)
-  require "bunny/concurrent/linked_continuation_queue"
-
-  describe Bunny::Concurrent::LinkedContinuationQueue do
-    describe "#poll with a timeout that is never reached" do
-      it "blocks until the value is available, then returns it" do
-        # force subject evaluation
-        cq = subject
-        t = Thread.new do
-          cq.push(10)
-        end
-        t.abort_on_exception = true
-
-        v = subject.poll(500)
-        expect(v).to eq 10
-      end
-    end
-
-    describe "#poll with a timeout that is reached" do
-      it "raises an exception" do
-        # force subject evaluation
-        cq = subject
-        t = Thread.new do
-          sleep 1.5
-          cq.push(10)
-        end
-        t.abort_on_exception = true
-
-        expect { subject.poll(500) }.to raise_error(::Timeout::Error)
-      end
-    end
-  end
-end

data/spec/unit/concurrent/synchronized_sorted_set_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-require "bunny/concurrent/synchronized_sorted_set"
-
-unless ENV["CI"]
-  describe Bunny::Concurrent::SynchronizedSortedSet do
-    50.times do |i|
-      it "provides the same API as SortedSet for key operations (take #{i})" do
-        s = described_class.new
-        expect(s.length).to eq 0
-
-        s << 1
-        expect(s.length).to eq 1
-        s << 1
-        expect(s.length).to eq 1
-        s << 2
-        expect(s.length).to eq 2
-        s << 3
-        expect(s.length).to eq 3
-        s << 4
-        expect(s.length).to eq 4
-        s << 4
-        s << 4
-        s << 4
-        expect(s.length).to eq 4
-        s << 5
-        expect(s.length).to eq 5
-        s << 5
-        s << 5
-        s << 5
-        expect(s.length).to eq 5
-        s << 6
-        expect(s.length).to eq 6
-        s << 7
-        expect(s.length).to eq 7
-        s << 8
-        expect(s.length).to eq 8
-        s.delete 8
-        expect(s.length).to eq 7
-        s.delete_if { |i| i == 1 }
-        expect(s.length).to eq 6
-      end
-      it "synchronizes common operations needed by Bunny (take #{i})" do
-        s = described_class.new
-        expect(s.length).to eq 0
-
-        10.times do
-          Thread.new do
-            s << 1
-            s << 1
-            s << 2
-            s << 3
-            s << 4
-            s << 4
-            s << 4
-            s << 4
-            s << 5
-            s << 5
-            s << 5
-            s << 5
-            s << 6
-            s << 7
-            s << 8
-            s.delete 8
-            s.delete_if { |i| i == 1 }
-          end
-        end
-        sleep 0.5
-
-        expect(s.length).to eq 6
-      end
-    end
-  end
-end

data/spec/unit/exchange_recovery_spec.rb

@@ -1,39 +0,0 @@
-require 'bunny/channel'
-require 'bunny/exchange'
-
-module Bunny
-  describe Exchange do
-    context "recovery" do
-      it "recovers exchange bindings, unless already unbound" do
-        ch = instance_double(Bunny::Channel,
-                             exchange_declare: nil,
-                             register_exchange: nil)
-        src1 = Exchange.new(ch, "direct", "src1")
-        src2 = Exchange.new(ch, "direct", "src2")
-        src3 = Exchange.new(ch, "direct", "src3")
-        dst = Exchange.new(ch, "direct", "dst")
-
-        original_binds_count = 5
-        expected_rebinds_count = 3
-        expected_total_binds = original_binds_count + expected_rebinds_count
-        allow(ch).to receive(:exchange_bind).exactly(expected_total_binds).times
-
-        dst.bind(src1, routing_key: "abc")
-        dst.bind(src2, routing_key: "def")
-        dst.bind(src2, routing_key: "ghi")
-        dst.bind(src3, routing_key: "jkl")
-        dst.bind(src3, routing_key: "jkl", arguments: {"key" => "value"})
-
-        allow(ch).to receive(:exchange_unbind).twice
-        dst.unbind(src2, routing_key: "def")
-        dst.unbind(src3, routing_key: "jkl", arguments: {"key" => "value"})
-
-        expect(ch).to receive(:exchange_bind).with(src1, dst, routing_key: "abc")
-        expect(ch).to receive(:exchange_bind).with(src2, dst, routing_key: "ghi")
-        expect(ch).to receive(:exchange_bind).with(src3, dst, routing_key: "jkl")
-
-        dst.recover_from_network_failure
-      end
-    end
-  end
-end

data/spec/unit/version_delivery_tag_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-require "bunny/concurrent/atomic_fixnum"
-require "bunny/versioned_delivery_tag"
-
-describe Bunny::VersionedDeliveryTag, "#stale?" do
-  subject { described_class.new(2, 1) }
-
-  context "when delivery tag version < provided version" do
-    it "returns true" do
-      expect(subject.stale?(2)).to eq true
-    end
-  end
-
-  context "when delivery tag version = provided version" do
-    it "returns false" do
-      expect(subject.stale?(1)).to eq false
-    end
-  end
-
-  context "when delivery tag version > provided version" do
-    it "returns true" do
-      # this scenario is unrealistic but we still can
-      # unit test it. MK.
-      expect(subject.stale?(0)).to eq false
-    end
-  end
-end