amqp 0.7.0.pre → 0.7.0

data/research/primes-threaded.rb

@@ -1,15 +1,17 @@
+# encoding: utf-8
+
 $:.unshift File.dirname(__FILE__) + '/../lib'
 require 'mq'
 
 MAX = 500
 
-def log *args
+def log(*args)
   p args
 end
 
 # MQ.logging = true
 
-EM.run{
+EM.run {
 
   # worker
 
@@ -21,21 +23,21 @@ EM.run{
     end
   end
 
-  MQ.queue('prime checker').subscribe{ |info, num|
-    EM.defer(proc{
+  MQ.queue('prime checker').subscribe { |info, num|
+    EM.defer(proc {
 
       log "prime checker #{Process.pid}-#{Thread.current.object_id}", :prime?, num
       if Integer(num).prime?
         MQ.queue(info.reply_to).publish(num, :reply_to => "#{Process.pid}-#{Thread.current.object_id}")
         EM.stop_event_loop if num == '499'
       end
-      
+
     })
   }
 
   # controller
 
-  MQ.queue('prime collector').subscribe{ |info, prime|
+  MQ.queue('prime collector').subscribe { |info, prime|
     log 'prime collector', :received, prime, :from, info.reply_to
     (@primes ||= []) << Integer(prime)
   }
@@ -46,4 +48,4 @@ EM.run{
     end
   end
 
-}
+}

data/spec/integration/automatic_binding_for_default_direct_exchange_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe "Queue that was bound to default direct exchange thanks to Automatic Mode (section 2.1.2.4 in AMQP 0.9.1 spec" do
+
+  #
+  # Environment
+  #
+
+  include AMQP::Spec
+
+  default_timeout 10
+
+  amqp_before do
+    @channel   = MQ.new
+
+    @queue1    = @channel.queue("queue1")
+    @queue2    = @channel.queue("queue2")
+
+    # Rely on default direct exchange binding, see section 2.1.2.4 Automatic Mode in AMQP 0.9.1 spec.
+    @exchange = MQ::Exchange.default
+  end
+
+
+
+  #
+  # Examples
+  #
+
+  it "receives messages with routing key equals it's name" do
+    number_of_received_messages = 0
+    expected_number_of_messages = 3
+    dispatched_data             = "to be received by queue1"
+
+    @queue1.subscribe do |payload|
+      number_of_received_messages += 1
+      payload.should == dispatched_data
+
+      if number_of_received_messages == expected_number_of_messages
+        $stdout.puts "Got all the messages I expected, wrapping up..."
+        done
+      else
+        n = expected_number_of_messages - number_of_received_messages
+        $stdout.puts "Still waiting for #{n} more message(s)"
+      end
+    end # subscribe
+
+    4.times do
+      @exchange.publish("some white noise", :routing_key => "killa key")
+    end
+
+    expected_number_of_messages.times do
+      @exchange.publish(dispatched_data,    :routing_key => @queue1.name)    
+    end
+
+    4.times do
+      @exchange.publish("some white noise", :routing_key => "killa key")
+    end
+  end # it
+end # describe

data/spec/mq_helper.rb

@@ -0,0 +1,70 @@
+# This helper supports writing specs for MQ (channel)
+
+require 'mq'
+
+# Mocking AMQP::Client::EM_CONNECTION_CLASS in order to
+# specify MQ instance behavior without the need to start EM loop.
+class MockConnection
+
+  def initialize
+    EM.stub(:reactor_running?).and_return(true)
+  end
+
+  def callback &block
+    callbacks << block
+    block.call(self) if block
+  end
+
+  def add_channel mq
+    channels[key = (channels.keys.max || 0) + 1] = mq
+    key
+  end
+
+  def send data, opts = {}
+    messages << {:data => data, :opts => opts}
+  end
+
+  def connected?
+    true
+  end
+
+  def channels
+    @channels||={}
+  end
+
+  def close
+  end
+
+  # Not part of AMQP::Client::EM_CONNECTION_CLASS interface, for mock introspection only
+  def callbacks
+    @callbacks||=[]
+  end
+
+  def messages
+    @messages||=[]
+  end
+end
+
+# Sets expectations about @header and @body passed to @consumer.
+def should_pass_updated_header_and_data_to consumer, opts={}
+  # - Why update @header.properties if @header becomes nil anyways?'
+  # - Because @consumer receives @header and may inspect its properties
+
+  subject_mock(:@method).should_receive(:arguments).
+      with(no_args).and_return(:myprop => 'mine')
+  consumer.should_receive(:receive) do |header, body|
+    header.klass.should == (opts[:klass] || AMQP::Protocol::Test)
+    header.size.should == (opts[:size] || 4)
+    header.weight.should == (opts[:weight] || 2)
+    header.properties.should == (opts[:properties] ||
+        {:delivery_mode => 1, :myprop => 'mine'})
+    body.should == (opts[:body] || 'data')
+  end
+end
+
+# Sets expectations that all listed instance variables for subject are nil
+def should_be_nil *ivars
+  ivars.each do |ivar|
+    subject.instance_variable_get(ivar).should be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -2,40 +2,95 @@
 
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 
+require 'bundler'
+Bundler.setup
+Bundler.require :default, :test
+
 require "mq"
-require "bacon"
-require "em-spec/bacon"
-
-# Notes about Bacon & EM-spec
-# - Subsequent describe blocks don't work.
-# - Bacon doesn't support any kind of pending specs.
-# - Bacon doesn't support before(:all) hook (see bellow).
-EM.spec_backend = EventMachine::Spec::Bacon
-
-# Usage with tracer:
-# 1) Start tracer on a PORT_NUMBER
-# 2) ruby spec/sync_async_spec.rb amqp://localhost:PORT_NUMBER
-if ARGV.first && ARGV.first.match(/^amqps?:/)
-  amqp_url = ARGV.first
-  puts "Using AMQP URL #{amqp_url}"
+
+amqp_config = File.dirname(__FILE__) + '/amqp.yml'
+
+if File.exists? amqp_config
+  class Hash
+    def symbolize_keys
+      self.inject({}) do |result, (key, value)|
+        new_key = key.is_a?(String) ? key.to_sym : key
+        new_value = value.is_a?(Hash) ? value.symbolize_keys : value
+        result[new_key] = new_value
+        result
+      end
+    end
+  end
+  AMQP_OPTS = YAML::load_file(amqp_config).symbolize_keys[:test]
 else
-  amqp_url = "amqp://localhost"
+  AMQP_OPTS = {:host => 'localhost', :port => 5672}
 end
 
-# Bacon doesn't seem to have some global before hook
-Bacon::Context.class_eval do
-  alias_method :__initialize__, :initialize
 
-  # Let's use Module#define_method, so we can
-  # access local variables defined in parent scopes.
-  define_method(:initialize) do |*args, &block|
-    __initialize__(*args, &block)
+if RUBY_VERSION == "1.8.7"
+  module ArrayExtensions
+    def sample
+      self.choice
+    end # sample
+  end
 
-    # There's no support for before(:all), so we just
-    # save whatever AMQP.connect returns (we suppose
-    # it isn't nil) and use value = value || connect().
-    self.before do
-      @connected ||= AMQP.connect(amqp_url)
-    end
+  class Array
+    include ArrayExtensions
   end
 end
+
+
+
+# Shorthand for mocking subject's instance variable
+def subject_mock(name, as_null = false)
+  mock = mock(name)
+  mock.as_null_object if as_null
+  subject.instance_variable_set(name.to_sym, mock)
+  mock
+end
+
+# Returns Header that should be correctly parsed
+def basic_header(opts = {})
+  AMQP::Frame::Header.new(
+      AMQP::Protocol::Header.new(
+          AMQP::Protocol::Basic, :priority => 1), opts[:channel] || 0)
+end
+
+# Returns AMQP Frame::Header frame that contains Protocol::Header header
+# with (pre-)defined accessors set.
+def test_header opts = {}
+  AMQP::Frame::Header.new(
+      AMQP::Protocol::Header.new(
+          opts[:klass] || AMQP::Protocol::Test,
+          opts[:size] || 4,
+          opts[:weight] || 2,
+          opts[:properties] || {:delivery_mode => 1}))
+end
+
+# Returns AMQP Frame::Method frame that contains Protocol::Basic::Deliver
+# with (pre-)defined accessors set.
+def test_method_deliver opts = {}
+  AMQP::Frame::Method.new(
+      AMQP::Protocol::Basic::Deliver.new(
+          :consumer_tag => opts[:consumer_tag] || 'test_consumer'))
+end
+
+require "stringio"
+
+def capture_stdout(&block)
+  $stdout = StringIO.new
+  block.call
+  $stdout.rewind
+  result = $stdout.read
+  $stdout = STDOUT
+  return result
+end
+
+def capture_stderr(&block)
+  $stderr = StringIO.new
+  block.call
+  $stderr.rewind
+  result = $stderr.read
+  $stderr = STDOUT
+  return result
+end

data/spec/unit/amqp/buffer_spec.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "amqp/buffer"
+
+
+if [].map.respond_to? :with_index
+  class Array #:nodoc:
+    def enum_with_index
+      each.with_index
+    end
+  end
+else
+  require 'enumerator'
+end
+
+
+describe AMQP::Buffer do
+
+  #
+  # Examples
+  #
+
+  it "has contents" do
+    subject.contents.should == ""
+  end
+
+  it "can be initialized with data" do
+    @buffer = described_class.new("abc")
+    @buffer.contents.should == "abc"
+  end
+
+  it "can append strings" do
+    subject << "abc"
+    subject << "def"
+
+    subject.contents.should == "abcdef"
+  end
+
+  it "can append other buffers" do
+    subject << described_class.new("abc")
+
+    subject.data.should == "abc"
+  end
+
+  it "has current position" do
+    subject.pos.should == 0
+
+    subject << described_class.new("abc")
+
+    subject.pos.should == 0
+  end
+
+
+  it "has length" do
+    subject.length.should == 0
+
+    subject << "abc"
+
+    subject.length.should == 3
+    # check for a crazy case when both RSpec and Bacon are loaded;
+    # then == matcher ALWAYS PASSES. Le sigh.
+    subject.length.should_not == 300
+  end
+
+
+  it "provides emptiness predicate" do
+    subject.should be_empty
+    subject << "xyz"
+
+    subject.should_not be_empty
+  end
+
+
+  it "supports writing of data" do
+    subject._write("abc")
+    subject.pos.should == 3
+    subject.rewind
+    subject.pos.should == 0
+  end
+
+
+  it "supports reading of data" do
+    subject._write("abc")
+    subject.rewind
+
+    subject._read(2).should == "ab"
+    subject.pos.should == 0
+    subject._read(1).should == "c"
+    subject.pos.should == 0
+  end
+
+
+  it "raises on overflow" do
+    expect {
+      subject._read(1)
+    }.should raise_error(described_class::Overflow)
+  end
+
+
+  it "refuses reading of unsupported types" do
+    expect {
+      subject.read(:junk)
+    }.to raise_error(described_class::InvalidType)
+  end
+
+
+  it "refuses writing of unsupported types" do
+    expect {
+      subject.write(:junk, 1)
+    }.to raise_error(described_class::InvalidType)
+  end
+
+
+  { :octet => 0b10101010,
+    :short => 100,
+    :long => 100_000_000,
+    :longlong => 666_555_444_333_222_111,
+    :shortstr => 'hello',
+    :longstr => 'bye'*500,
+    :timestamp => time = Time.at(Time.now.to_i),
+    :table => { :this => 'is', :a => 'hash', :with => {:nested => 123, :and => time, :also => 123.456} },
+    :bit => true
+  }.each do |type, value|
+    it "can read and write a #{type}" do
+      subject.write(type, value)
+      subject.rewind
+
+      subject.read(type).should == value
+      subject.should be_empty
+    end # it
+  end # each
+
+
+  it 'can read and write multiple bits' do
+    bits = [true, false, false, true, true, false, false, true, true, false]
+    subject.write(:bit, bits)
+    subject.write(:octet, 100)
+
+    subject.rewind
+
+    bits.map do
+      subject.read(:bit)
+    end.should == bits
+    subject.read(:octet).should == 100
+  end
+
+  it 'can read and write property tables' do
+    properties = ([
+                   [:octet, 1],
+                   [:shortstr, 'abc'],
+                   [:bit, true],
+                   [:bit, false],
+                   [:shortstr, nil],
+                   [:timestamp, nil],
+                   [:table, { :a => 'hash' }],
+                  ]*5).sort_by {rand}
+
+    subject.write(:properties, properties)
+    subject.rewind
+    subject.read(:properties, *properties.map { |type, _| type }).should == properties.map { |_, value| value }
+    subject.should be_empty
+  end
+
+  it 'does transactional reads with #extract' do
+    subject.write :octet, 8
+    orig = subject.to_s
+
+    subject.rewind
+    subject.extract do |b|
+      b.read :octet
+      b.read :short
+    end
+
+    subject.pos.should == 0
+    subject.data.should == orig
+  end
+end # describe