amqp 0.8.0.rc14 → 0.8.0.rc15

data/docs/Troubleshooting.textile

@@ -68,6 +68,32 @@ version 2.0 or later.
 TBD
 
 
+h2. Handling channel-level exceptions
+
+A broad range of problems result in AMQP channel exceptions: an indication by the broker that there was an issue application needs to be aware of.
+Channel-level exceptions are typically not fatal and can be recovered from. Some examples are:
+
+ * Exchange is re-declared with attributes different from the original declaration. For example, a non-durable exchange is being re-declared as durable.
+ * Queue is re-declared with attributes different from the original declaration. For example, an autodeletable queue is being re-declared as non-autodeletable.
+ * Queue is bound to an exchange that does not exist.
+
+and so on. When troubleshooting AMQP applications, it is recommended that you detect and handle channel-level exceptions on all channels your
+application may use. For that, use {AMQP::Channel#on_error} method as demonstrated below:
+
+<pre>
+<code>
+events_channel.on_error do |ch, channel_close|
+  puts "Channel-level exception on the events channel: #{channel_close.reply_text}"
+end
+
+commands_channel.on_error do |ch, channel_close|
+  puts "Channel-level exception on the commands channel: #{channel_close.reply_text}"
+end
+</code>
+</pre>
+
+Defining channel-level exception handlers will reveal many issues that it might take more time to detect using other troubleshooting techniques.
+
 
 h2. Testing network connection with AMQP broker using Telnet
 
@@ -117,6 +143,11 @@ suggests that *erlang-os-mon* package is not installed.
 
 
 
+h2. Authors
+
+This guide was written by "Michael Klishin":http://twitter.com/michaelklishin and edited by "Chris Duncan":https://twitter.com/celldee.
+
+
 
 h2. Tell us what you think!
 

data/docs/VendorSpecificExtensions.textile

@@ -4,14 +4,19 @@ h1. Vendor-specific AMQP extensions support in amqp gem
 
 h2. RabbitMQ extensions
 
-h3. Supported extensions
+h2. Supported extensions
 
-AMQP gem supports two "RabbitMQ extensions to AMQP 0.9.1":
+AMQP gem supports many RabbitMQ extensions to AMQP 0.9.1:
 
 * "Publisher confirmations":http://www.rabbitmq.com/extensions.html#confirms (confirm.* class)
 * "Negative acknowledgements":http://www.rabbitmq.com/extensions.html#negative-acknowledgements (basic.nack)
+* "Alternate Exchanges":http://www.rabbitmq.com/extensions.html#alternate-exchange
+* "Per-queue Message Time-to-Live":http://www.rabbitmq.com/extensions.html#queue-ttl
+* "Queue Leases":http://www.rabbitmq.com/extensions.html#queue-leases
+* "Sender-selected Distribution":http://www.rabbitmq.com/extensions.html#sender-selected-distribution
+* "Validated user_id":http://www.rabbitmq.com/extensions.html#validated-user-id
 
-h3. Enabling RabbitMQ extensions
+h2. Enabling RabbitMQ extensions
 
 If you are using RabbitMQ as AMQP broker and want to use these extensions, simply replace
 
@@ -24,14 +29,140 @@ require "amqp"
 require "amqp/extensions/rabbitmq"
 </pre>
 
-h3. Example of using publisher confirmations
+
+h2. Per-queue Message Time-to-Live
+
+Per-queue Message Time-to-Live (TTL) is a RabbitMQ extension to AMQP 0.9.1 that lets developers control for how long
+a message published to a queue can live before it is discarded. A message that has been in the queue for longer than the
+configured TTL is said to be dead. Dead messages will not be delivered to consumers and cannot be fetched using
+*basic.get* operation ({AMQP::Queue#pop}).
+
+Message TTL is specified using *x-message-ttl* argument on declaration. With amqp gem, you pass it to {AMQP::Queue#initialize} or
+{AMQP::Channel#queue}:
+
+<pre>
+<code>
+# 1000 milliseconds
+channel.queue("", :arguments => { "x-message-ttl" => 1000 })
+</code>
+</pre>
+
+When a published messages is routed to multiple queues, each of the queues gets a _copy of the message_. If then the message dies in
+one of the queues, it has no effect on copies of the message in other queues.
+
+h3. Example
+
+The example below sets message TTL for a new server-named queue to be 1000 milliseconds. It then publishes several messages that
+are routed to the queue and tries to fetch messages using *basic.get* AMQP method ({AMQP::Queue#pop} after 0.7 and 1.5 seconds:
+
+<script src="https://gist.github.com/1113127.js"> </script>
+
+
+h3. Learn More
+
+See also rabbitmq.com section on "Per-queue Message TTL":http://www.rabbitmq.com/extensions.html#queue-ttl
+
+
+
+h2. Publisher Confirms (Publisher Acknowledgements)
+
+In some situations not a single message can be lost. The only reliable way of doing so is using confirmations.
+"Publisher Confirms AMQP extension":http://www.rabbitmq.com/blog/2011/02/10/introducing-publisher-confirms/ was designed to solve the reliable publishing problem.
+
+Publisher confirms are similar to message acknowledgements documented in the {file:docs/Queues.textile Working With Queues} guide but involve publisher and AMQP broker
+instead of consumer and AMQP broker.
+
+
+h3. Public API
+
+To use publisher confirmations, first put channel into confirmation mode using {AMQP::Channel#confirm_select}:
+
+<pre>
+<code>
+channel.confirm_select
+</code>
+</pre>
+
+From this moment on, every message published on this channel will cause channel's _publisher index_ (message counter) to be incremented. It is possible to access
+using {AMQP::Channel#publisher_index} method. To check whether channel is in the confirmation mode, use {AMQP::Channel#uses_publisher_confirmations?} predicate.
+
+To handle AMQP broker acknowledgements, define a handler using {AMQP::Channel#on_ack}, for example:
+
+<pre>
+<code>
+channel.on_ack do |basic_ack|
+ puts "Received basic_ack: multiple = #{basic_ack.multiple}, delivery_tag = #{basic_ack.delivery_tag}"
+end
+</code>
+</pre>
+
+Delivery tag will indicate number of confirmed messages. If *multiple* attribute is true, the confirmation is for all messages up to the number
+delivery tag indicates. In other words, AMQP broker may confirm just one message or a batch of them.
+
+
+h3. Example
 
 <script src="https://gist.github.com/923599.js?file=rabbitmq_publisher_confirmations_with_amqp_gem_0.8.0.rb"></script>
 
 
-h3. Documentation
+h3. Learn More
+
+See also rabbitmq.com section on "Confirms aka Publisher Acknowledgements":http://www.rabbitmq.com/extensions.html#confirms
+
+
+
+
+h2. basic.nack
+
+The AMQP specification defines the basic.reject method that allows clients to reject individual, delivered messages, instructing the broker
+to either discard them or requeue them. Unfortunately, basic.reject provides no support for negatively acknowledging messages in bulk.
+
+To solve this, RabbitMQ supports the basic.nack method that provides all the functionality of basic.reject whilst also
+allowing for bulk processing of messages.
+
+h3. Public API
+
+When RabbitMQ extensions are loaded, {AMQP::Channel#reject} method is overriden via mixin to take one additional argument: multi (defaults to false).
+When it is given and is true, amqp gem will use basic.nack AMQP method instead of basic.reject, to reject multiple messages at once.
+Otherwise, basic.reject is used as usual.
+
+
+h3. Learn More
+
+See also rabbitmq.com section on "Confirms aka Publisher Acknowledgements":http://www.rabbitmq.com/extensions.html#negative-acknowledgements
+
+
+
+h2. Alternate Exchanges
+
+Alternate Exchanges is a RabbitMQ extension to AMQP 0.9.1 that lets developers define "fallback" exchanges where unroutable messages will be sent.
+
+
+h3. Public API
+
+To specify exchange A as alternate exchange to exchange B, specify 'alternate-exchange' argument on declaration of B:
+
+<pre>
+<code>
+exchange1 = channel.fanout("ops.fallback",     :auto_delete => true)
+exchange2 = channel.fanout("events.collector", :auto_delete => true, :arguments => { "alternate-exchange" => "ops.fallback" })
+</code>
+</pre>
+
+
+h3. Example
+
+<script src="https://gist.github.com/1159091.js?file=using_alternate_exchanges.rb"></script>
+
+
+h3. Learn More
+
+See also rabbitmq.com section on "Alternate Exchanges":http://www.rabbitmq.com/extensions.html#alternate-exchange
+
+
+h2. Authors
 
-RabbitMQ extensions documentation is part of "amq-client gem documentation":http://rubydoc.info/github/ruby-amqp/amq-client/master/frames
+This guide was written by "Michael Klishin":http://twitter.com/michaelklishin and edited by "Chris Duncan":https://twitter.com/celldee.
 
 
 

data/examples/extensions/rabbitmq/per_queue_message_ttl.rb

@@ -10,44 +10,43 @@ require "amqp/extensions/rabbitmq"
 
 AMQP.start do |connection|
   puts "Connected!"
-  AMQP::Channel.new(connection) do |channel, open_ok|
-    puts "Channel #{channel.id} is now open"
-
-    channel.on_error do |ch, channel_close|
-      puts "Oops! a channel-level exception: #{channel_close.reply_text}"
-    end
+  channel = AMQP::Channel.new(connection)
+  channel.on_error do |ch, channel_close|
+    puts "Oops! a channel-level exception: #{channel_close.reply_text}"
+  end
 
-    x = channel.fanout("amq.fanout")
-    channel.queue("", :auto_delete => true, :arguments => { "x-message-ttl" => 1000 }) do |q|
-      puts "Declared a new server-named qeueue: #{q.name}"
-      q.bind(x)
+  x = channel.fanout("amq.fanout")
+  channel.queue("", :auto_delete => true, :arguments => { "x-message-ttl" => 1000 }) do |q|
+    puts "Declared a new server-named queue: #{q.name}"
+    q.bind(x)
 
 
-      EventMachine.add_timer(0.3) do
-        10.times do |i|
-          puts "Publishing message ##{i}"
-          x.publish("Message ##{i}")
-        end
+    EventMachine.add_timer(0.3) do
+      10.times do |i|
+        puts "Publishing message ##{i}"
+        x.publish("Message ##{i}")
       end
+    end
 
-      EventMachine.add_timer(0.7) do
-        q.pop do |headers, payload|
-          raise "x-message-ttl didn't seem to work (timeout is up)" if payload.nil?
-        end
+    EventMachine.add_timer(0.7) do
+      q.pop do |headers, payload|
+        puts "Got a message: #{payload}"
       end
+    end
 
-      EventMachine.add_timer(1.5) do
-        q.pop do |headers, payload|
-          raise "x-message-ttl didn't seem to work (timeout isn't up)" if payload
+    EventMachine.add_timer(1.5) do
+      q.pop do |headers, payload|
+        if payload.nil?
+          puts "No messages in the queue"
+        else
+          raise "x-message-ttl didn't seem to work (timeout isn't up)"
         end
       end
     end
   end
 
   show_stopper = Proc.new {
-    AMQP.stop do
-      EM.stop
-    end
+    AMQP.stop { EventMachine.stop }
   }
 
 

data/examples/extensions/rabbitmq/publisher_confirmations_with_transient_messages.rb

@@ -8,46 +8,37 @@ $:.unshift(File.expand_path("../../../../lib", __FILE__))
 require 'amqp'
 require "amqp/extensions/rabbitmq"
 
-AMQP.start do |connection|
-  puts "Connected!"
+EventMachine.run do
+  connection = AMQP.connect(:host => '127.0.0.1')
+  puts "Connecting to AMQP broker. Running #{AMQP::VERSION} version of the gem..."
+
   AMQP::Channel.new(connection) do |channel|
     puts "Channel #{channel.id} is now open"
 
     channel.confirm_select
-    channel.on_error do |ch, channel_close|
-      puts "Oops! a channel-level exception: #{channel_close.reply_text}"
-    end
-
-
-    channel.on_ack do |basic_ack|
-      puts "Received basic_ack: multiple = #{basic_ack.multiple}, delivery_tag = #{basic_ack.delivery_tag}"
-    end
+    channel.on_error { |ch, channel_close| puts "Oops! a channel-level exception: #{channel_close.reply_text}" }
+    channel.on_ack   { |basic_ack| puts "Received basic_ack: multiple = #{basic_ack.multiple}, delivery_tag = #{basic_ack.delivery_tag}" }
 
     x = channel.fanout("amq.fanout")
     channel.queue("", :auto_delete => true) do |q|
-      puts "Declared a new server-named qeueue: #{q.name}"
-
-      q.bind(x, :no_ack => true).subscribe(:ack => true) do |header, payload|
+      q.bind(x).subscribe(:ack => true) do |header, payload|
         puts "Received #{payload}"
       end
     end
 
     EventMachine.add_timer(0.5) do
       10.times do |i|
-        puts "Publishing message ##{i}"
-        x.publish("Message ##{i}")
+        puts "Publishing message ##{i + 1}"
+        x.publish("Message ##{i + 1}")
       end
     end
   end
 
   show_stopper = Proc.new {
-    AMQP.stop do
-      EM.stop
-    end
+    connection.close { EventMachine.stop }
   }
 
-
-  EM.add_timer(3, show_stopper)
+  EM.add_timer(6, show_stopper)
   Signal.trap('INT',  show_stopper)
   Signal.trap('TERM', show_stopper)
 end

data/examples/extensions/rabbitmq/using_alternate_exchanges.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../../lib", __FILE__))
+
+require 'amqp'
+
+EventMachine.run do
+  connection = AMQP.connect(:host => '127.0.0.1')
+  puts "Connecting to AMQP broker. Running #{AMQP::VERSION} version of the gem..."
+
+  channel   = AMQP::Channel.new(connection)
+  queue     = channel.queue("amqpgem.examples.hello_world", :auto_delete => true)
+  exchange1 = channel.fanout("my.fanout1", :auto_delete => true)
+  exchange2 = channel.fanout("my.fanout2", :auto_delete => true, :arguments => { "alternate-exchange" => "my.fanout1" })
+
+  queue.bind(exchange1).subscribe do |payload|
+    puts "Received a message: #{payload}. Disconnecting..."
+
+    connection.close { EventMachine.stop }
+  end
+
+  exchange1.publish "This message will be routed because of the binding",   :mandatory => true
+  exchange2.publish "This message will be re-routed to alternate-exchange", :mandatory => true
+end

data/examples/hello_world.rb

@@ -14,7 +14,7 @@ EventMachine.run do
 
   channel  = AMQP::Channel.new(connection)
   queue    = channel.queue("amqpgem.examples.hello_world", :auto_delete => true)
-  exchange = channel.direct("")
+  exchange = channel.default_exchange
 
   queue.subscribe do |payload|
     puts "Received a message: #{payload}. Disconnecting..."

data/lib/amqp.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+require "amq/protocol"
 require "amq/client"
 require "amq/client/adapters/event_machine"
 

data/lib/amqp/compatibility/ruby187_patchlevel_check.rb

@@ -14,6 +14,8 @@ this issue.
 
 To reiterate: 1.8.7-p174 and 1.8.7-p334 are supported. The fix has been committed to MRI in December 2009. It's
 a good idea to upgrade, although downgrading to p174 is an option, too.
+
+To learn more (including the 0.8.x migration guide) at http://bit.ly/amqp-gem-docs and https://github.com/ruby-amqp.
     MESSAGE
   end
 end

data/lib/amqp/integration/rails.rb

@@ -0,0 +1,17 @@
+require "yaml"
+
+module AMQP
+  module Integration
+    class Rails
+
+      def self.start(options = {}, &block)
+        yaml     = YAML.load_file(File.join(::Rails.root, "config", "amqp.yml"))
+        settings = yaml.fetch(::Rails.env, Hash.new).symbolize_keys
+
+        EventMachine.next_tick do
+          AMQP.start(settings.merge(options), &block)
+        end
+      end
+    end # Rails
+  end # Integration
+end # AMQP

data/lib/amqp/version.rb

@@ -6,5 +6,5 @@ module AMQP
   #
   # @see AMQ::Protocol::VERSION
   # @return [String] AMQP gem version
-  VERSION = '0.8.0.rc14'
+  VERSION = '0.8.0.rc15'
 end

data/spec/integration/authentication_spec.rb

@@ -67,7 +67,7 @@ describe "Authentication attempt" do
       end # context
 
       context "and provided credentials ARE INCORRECT" do
-        default_timeout 6
+        default_timeout 10
 
         after(:all) { done }
 
@@ -83,7 +83,7 @@ describe "Authentication attempt" do
 
 
       context "and provided vhost DOES NOT EXIST" do
-        default_timeout 6
+        default_timeout 10
 
         after(:all) { done }
 

data/spec/integration/fanout_exchange_routing_spec.rb

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-describe "Workload distribution" do
+describe AMQP::Exchange, "of type fanout" do
 
   #
   # Environment
@@ -32,215 +32,59 @@ describe "Workload distribution" do
   # Examples
   #
 
-  context "that uses fanout exchange" do
-    amqp_before :each do
-      @exchange = @channel.fanout("amqpgem.integration.multicast.fanout", :auto_delete => true)
-    end
-
-    context "with three bound queues" do
-      amqp_before :each do
-        @queue1   = @channel.queue("amqpgem.integration.multicast.queue1",  :auto_delete => true)
-        @queue2   = @channel.queue("amqpgem.integration.multicast.queue2",  :auto_delete => true)
-        @queue3   = @channel.queue("amqpgem.integration.multicast.queue3",  :auto_delete => true)
-
-        @queues   = [@queue1, @queue2, @queue3]
-
-        @sent_values = Array.new
-
-        @queue1.bind(@exchange).subscribe do |payload|
-          @received_messages[@queue1.name].push(payload.to_i)
-        end # subscribe
-
-        @queue2.bind(@exchange).subscribe do |payload|
-          @received_messages[@queue2.name].push(payload.to_i)
-        end # subscribe
-
-        @queue3.bind(@exchange).subscribe do |payload|
-          @received_messages[@queue3.name].push(payload.to_i)
-        end # subscribe
-      end
-
-      amqp_before :each do
-        @received_messages = {
-          @queue1.name => [],
-          @queue2.name => [],
-          @queue3.name => []
-        }
-
-        @expected_number_of_messages = {
-          @queue1.name => 100,
-          @queue2.name => 100,
-          @queue3.name => 100
-        }
-      end
-
-      amqp_after :each do
-        @sent_values.clear
-      end
-
-
-      context "and messages are published as non-mandatory" do
-        it "routes all messages to all bound queues" do
-          100.times do
-            dispatched_data             = rand(5_000_000)
-            @sent_values.push(dispatched_data)
-
-            @exchange.publish(dispatched_data, :mandatory => false)
-          end
-
-          # for Rubinius, it is surprisingly slow on this workload
-          done(3.5) {
-            [@queue1, @queue2, @queue3].each do |q|
-              @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
-
-              # this one is ordering assertion
-              @received_messages[q.name].should == @sent_values
-            end
-          }
-        end # it
-      end # context
-
-
-
-      context "and messages are published as mandatory" do
-        it "routes all messages to all bound queues" do
-          100.times do
-            dispatched_data             = rand(5_000_000)
-            @sent_values.push(dispatched_data)
-
-            @exchange.publish(dispatched_data, :mandatory => true)
-          end
 
-          # 6 seconds are for Rubinius, it is surprisingly slow on this workload
-          done(3.5) {
-            [@queue1, @queue2, @queue3].each do |q|
-              @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
-
-              # this one is ordering assertion
-              @received_messages[q.name].should == @sent_values
-            end
-          }
-        end # it
-      end # context
-
-
-
-      context "and messages are published as non-persistent" do
-        it "routes all messages to all bound queues" do
-          100.times do
-            dispatched_data             = rand(5_000_000)
-            @sent_values.push(dispatched_data)
-
-            @exchange.publish(dispatched_data, :persistent => false)
-          end
-
-          # 6 seconds are for Rubinius, it is surprisingly slow on this workload
-          done(3.5) {
-            [@queue1, @queue2, @queue3].each do |q|
-              @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
-
-              # this one is ordering assertion
-              @received_messages[q.name].should == @sent_values
-            end
-          }
-        end # it
-      end # context
-
-
-
-      context "and messages are published as persistent" do
-        it "routes all messages to all bound queues" do
-          100.times do
-            dispatched_data             = rand(5_000_000)
-            @sent_values.push(dispatched_data)
-
-            @exchange.publish(dispatched_data, :persistent => true)
-          end
-
-          # 6 seconds are for Rubinius, it is surprisingly slow on this workload
-          done(3.5) {
-            [@queue1, @queue2, @queue3].each do |q|
-              @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
-
-              # this one is ordering assertion
-              @received_messages[q.name].should == @sent_values
-            end
-          }
-        end # it
-      end # context
-
-
-      context "and messages are published as non-immediate" do
-        it "routes all messages to all bound queues" do
-          100.times do
-            dispatched_data             = rand(5_000_000)
-            @sent_values.push(dispatched_data)
-
-            @exchange.publish(dispatched_data, :immediate => false)
-          end
-
-          # 6 seconds are for Rubinius, it is surprisingly slow on this workload
-          done(3.5) {
-            [@queue1, @queue2, @queue3].each do |q|
-              @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
-
-              # this one is ordering assertion
-              @received_messages[q.name].should == @sent_values
-            end
-          }
-        end # it
-      end # context
+  context "with three bound queues" do
+    it "routes all messages to all bound queues" do
+      @exchange = @channel.fanout("amqpgem.integration.multicast.fanout", :auto_delete => true)
+      @queue1   = @channel.queue("amqpgem.integration.multicast.queue1",  :auto_delete => true)
+      @queue2   = @channel.queue("amqpgem.integration.multicast.queue2",  :auto_delete => true)
+      @queue3   = @channel.queue("amqpgem.integration.multicast.queue3",  :auto_delete => true)
 
+      @queues   = [@queue1, @queue2, @queue3]
 
+      @received_messages = {
+        @queue1.name => [],
+        @queue2.name => [],
+        @queue3.name => []
+      }
 
-      context "and messages are published as immediate" do
-        it "may get a Basic.Return back"
-      end # context
+      @expected_number_of_messages = {
+        @queue1.name => 10,
+        @queue2.name => 10,
+        @queue3.name => 10
+      }
 
 
+      @sent_values = Array.new
 
-      context "and messages are published WITHOUT routing key" do
-        it "routes all messages to all bound queues" do
-          100.times do
-            dispatched_data             = rand(5_000_000)
-            @sent_values.push(dispatched_data)
+      @queue1.bind(@exchange).subscribe do |payload|
+        @received_messages[@queue1.name].push(payload.to_i)
+      end # subscribe
 
-            @exchange.publish(dispatched_data)
-          end
+      @queue2.bind(@exchange).subscribe do |payload|
+        @received_messages[@queue2.name].push(payload.to_i)
+      end # subscribe
 
-          # 6 seconds are for Rubinius, it is surprisingly slow on this workload
-          done(3.5) {
-            [@queue1, @queue2, @queue3].each do |q|
-              @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
+      @queue3.bind(@exchange).subscribe do |payload|
+        @received_messages[@queue3.name].push(payload.to_i)
+      end # subscribe
 
-              # this one is ordering assertion
-              @received_messages[q.name].should == @sent_values
-            end
-          }
-        end # it
-      end # context
+      10.times do
+        dispatched_data             = rand(5_000_000)
+        @sent_values.push(dispatched_data)
 
+        @exchange.publish(dispatched_data, :mandatory => false)
+      end
 
-      context "and messages are published WITH routing key that matches name of one of the queues" do
-        it "routes all messages to all bound queues" do
-          100.times do
-            dispatched_data             = rand(5_000_000)
-            @sent_values.push(dispatched_data)
-
-            @exchange.publish(dispatched_data, :routing_key => @queues.sample.name)
-          end
+      # for Rubinius, it is surprisingly slow on this workload
+      done(2.5) {
+        [@queue1, @queue2, @queue3].each do |q|
+          @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
 
-          # 6 seconds are for Rubinius, it is surprisingly slow on this workload
-          done(3.5) {
-            [@queue1, @queue2, @queue3].each do |q|
-              @received_messages[q.name].size.should == @expected_number_of_messages[q.name]
-
-              # this one is ordering assertion
-              @received_messages[q.name].should == @sent_values
-            end
-          }
-        end # it
-      end # context
-    end # context
-  end # context
+          # this one is ordering assertion
+          @received_messages[q.name].should == @sent_values
+        end
+      }
+    end # it
+  end
 end # describe