amqp 0.7.0 → 0.7.1

data/spec/unit/amqp/misc_spec.rb

@@ -1,123 +0,0 @@
-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/mq/misc_spec.rb

@@ -1,228 +0,0 @@
-require 'spec_helper'
-require 'mq_helper'
-
-describe 'MQ', 'class object' do
-#  after{AMQP.cleanup_state} # Tips off Thread.current[:mq] call
-  subject { MQ }
-
-  its(:logging) { should be_false }
-
-
-  describe '.logging=' do
-    it 'is independent from AMQP.logging' do
-      #
-      AMQP.logging = true
-      MQ.logging.should be_false
-      MQ.logging = false
-      AMQP.logging.should == true
-
-      #
-      AMQP.logging = false
-      MQ.logging = true
-      AMQP.logging.should be_false
-      MQ.logging = false
-    end
-  end # .logging=
-
-
-  describe '.default' do
-    it 'creates MQ object and stashes it in a Thread-local Hash' do
-      MQ.should_receive(:new).with(no_args).and_return('MQ mock')
-      Thread.current.should_receive(:[]).with(:mq)
-      Thread.current.should_receive(:[]=).with(:mq, 'MQ mock')
-      MQ.default.should == 'MQ mock'
-    end
-  end # .default
-
-
-
-  describe '.id' do
-    it 'returns Thread-local uuid for mq' do
-      uuid_pattern = /.*-[0-9]*-[0-9]*/
-      Thread.current.should_receive(:[]).with(:mq_id)
-      Thread.current.should_receive(:[]=).with(:mq_id, uuid_pattern)
-      MQ.id.should =~ uuid_pattern
-    end
-  end # .id
-
-
-
-  describe '.error' do
-    after(:all) { MQ.instance_variable_set(:@error_callback, nil) } # clear error callback
-
-    it 'is noop unless @error_callback was previously set' do
-      MQ.instance_variable_get(:@error_callback).should be_nil
-      MQ.error("Msg").should be_nil
-    end
-
-    context 'when @error_callback is set' do
-      before { MQ.error { |message| message.should == "Msg"; @callback_fired = true } }
-
-      it 'is setting @error_callback to given block' do
-        MQ.instance_variable_get(:@error_callback).should_not be_nil
-        @callback_fired.should be_false
-      end
-
-      it 'does not fire @error_callback immediately' do
-        @callback_fired.should be_false
-      end
-
-      it 'fires @error_callback on subsequent .error calls' do
-        MQ.error("Msg")
-        @callback_fired.should be_true
-      end
-    end
-  end # .error
-
-
-
-  describe '.method_missing' do
-    it 'routes all unrecognized methods to MQ.default' do
-      MQ.should_receive(:new).with(no_args).and_return(mock('channel'))
-      MQ.default.should_receive(:foo).with("Msg")
-      MQ.foo("Msg")
-    end
-  end # .method_missing
-end # describe 'MQ as a class'
-
-
-
-
-describe 'Channel object' do
-  context 'when initialized with a mock connection' do
-    before { @client = MockConnection.new }
-    after { AMQP.cleanup_state }
-    subject { MQ.new(@client).tap { |mq| mq.succeed } } # Indicates that channel is connected
-
-    it 'should have a channel' do
-      subject.channel.should be_kind_of Fixnum
-      subject.channel.should == 1 # Essentially, this channel (mq) number
-    end
-
-    it 'has publicly accessible collections' do
-      subject.exchanges.should be_empty
-      subject.queues.should be_empty
-      subject.consumers.should be_empty
-      subject.rpcs.should be_empty
-    end
-
-    describe '#send' do
-      it 'sends given data through its connection' do
-        args = [ 'data1', 'data2', 'data3']
-        subject.send *args
-        @client.messages[-3..-1].map { |message| message[:data] }.should == args
-      end #send
-
-      it 'sets data`s ticket property if @ticket is set for MQ object' do
-        ticket = subject_mock(:@ticket)
-        data = mock('data')
-        data.should_receive(:ticket=).with(ticket)
-        subject.send data
-      end
-    end
-
-
-
-    describe '#reset' do
-      it 'resets and reinitializes the channel, clears and resets its queues/exchanges' do
-        subject.queue('test').should_receive(:reset)
-        subject.fanout('fanout').should_receive(:reset)
-        subject.should_receive(:initialize).with(@client)
-
-        subject.reset
-        subject.queues.should be_empty
-        subject.exchanges.should be_empty
-        subject.consumers.should be_empty
-      end
-    end #reset
-
-
-
-    describe '#prefetch', 'setting :prefetch_count for broker' do
-      it 'sends Protocol::Basic::Qos' do
-        subject.prefetch 13
-        @client.messages.last[:data].should be_an AMQP::Protocol::Basic::Qos
-        @client.messages.last[:data].instance_variable_get(:@prefetch_count).should == 13
-      end
-
-      it 'returns MQ object itself, allowing for method chains' do
-        subject.prefetch(1).should == subject
-      end
-    end #prefetch
-
-
-
-    describe '#recover', "asks broker to redeliver unack'ed messages on this channel" do
-      it "sends Basic::Recover through @connection" do
-        subject.recover
-        @client.messages.last[:data].should be_an AMQP::Protocol::Basic::Recover
-      end
-
-      it 'defaults to :requeue=nil, redeliver messages to the original recipient' do
-        subject.recover
-        @client.messages.last[:data].instance_variable_get(:@requeue).should == nil
-      end #prefetch
-
-      it 'prompts broker to requeue messages (to other subs) if :requeue set to true' do
-        subject.recover true
-        @client.messages.last[:data].instance_variable_get(:@requeue).should == true
-      end
-
-      it 'returns MQ object itself, allowing for method chains' do
-        subject.recover.should == subject
-      end
-    end #recover
-
-
-
-    describe '#close', 'closes channel' do
-      it 'can be simplified, getting rid of @closing ivar?'
-      # TODO: Just set a callback sending Protocol::Channel::Close...'
-
-      it 'sends Channel::Close through @connection' do
-        subject.close
-        @client.messages.last[:data].should be_an AMQP::Protocol::Channel::Close
-      end
-
-      it 'does not actually delete the channel or close connection' do
-        @client.channels.should_not_receive(:delete)
-        @client.should_not_receive(:close)
-        subject.close
-      end
-
-      it 'actual channel closing happens ONLY when Channel::CloseOk is received' do
-        @client.channels.should_receive(:delete) do |key|
-          key.should == 1
-          @client.channels.clear
-        end
-        @client.should_receive(:close)
-        subject.process_frame AMQP::Frame::Method.new(AMQP::Protocol::Channel::CloseOk.new)
-      end
-    end #close
-
-
-
-
-    describe '#get_queue', 'supports #pop (Basic::Get) operation on queues' do
-      it 'yields a FIFO queue to a given block' do
-        subject.get_queue do |fifo|
-          @block_called = true
-          fifo.should == []
-        end
-        @block_called.should be_true
-      end
-
-      it 'FIFO queue contains consumers that called Queue#pop' do
-        queue1 = subject.queue('test1')
-        queue2 = subject.queue('test2')
-        queue1.pop
-        queue2.pop
-        subject.get_queue do |fifo|
-          fifo.should have(2).consumers
-          fifo.first.should == queue1
-          fifo.last.should == queue2
-        end
-      end
-    end #get_queue
-  end #  context 'when initialized with a mock connection'
-end # describe MQ object, also vaguely known as "channel"

data/spec/unit/mq/queue_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-require 'mq_helper'
-
-describe MQ::Queue, :broker => true do
-
-  #
-  # Environment
-  #
-
-  include AMQP::Spec
-
-  default_options AMQP_OPTS
-  default_timeout 3
-
-  amqp_before do
-    @channel = MQ.new
-    @queue   = MQ::Queue.new(@channel, 'test_queue', :option => 'useless')
-  end
-
-  amqp_after { @queue.purge; AMQP.cleanup_state }
-
-
-  #
-  # Examples
-  #
-
-  context 'declared with name of "test_queue"' do
-    amqp_after {@queue.unsubscribe; @queue.delete}
-    # TODO: Fix amqp_after: it is NOT run in case of raised exceptions, it seems
-
-    it 'supports asynchronous subscription to broker-predefined amq.direct exchange' do
-      data = "data sent via amq.direct exchange"
-
-      @queue.subscribe do |header, message|
-        header.should be_an MQ::Header
-        message.should == data
-        done
-      end
-      @queue.publish(data)
-    end # it
-
-    it 'supports synchronous message fetching via #pop (Basic.Get)' do
-      @queue.publish('send some data down the pipe')
-
-      @queue.pop do |header, message|
-        header.should be_an MQ::Header
-        message.should == 'send some data down the pipe'
-        done
-      end
-    end # it
-
-    xit 'asynchronously receives own status from the broker' do
-      pending "TODO: this example currently fails; do investigate why. MK."
-      total_number_of_messages = 123
-
-      total_number_of_messages.times do |n|
-        @queue.publish('message # #{n}')
-      end
-
-      @on_status_fired = false
-      @queue.status do |messages, consumers|
-        @on_status_fired = true
-        messages.should == total_number_of_messages
-        consumers.should == 0
-      end # it
-
-      @on_status_fired.should be_true
-      done(1)
-    end # it
-  end # context
-end # MQ::Queue, 'with real connection