message-driver 0.1.0 → 0.2.0.rc1

data/features/rabbitmq_specific_features/dead_letter_queueing.feature

@@ -0,0 +1,116 @@
+@bunny
+Feature: DLQ-ing messages with nacks and consumers
+
+  RabbitMQ supports sending messages to a DLQ if configured correctly.
+  See http://www.rabbitmq.com/dlx.html for details.
+
+  Background:
+    Given the following broker configuration
+    """ruby
+    MessageDriver::Broker.define do |b|
+      # declare a dead letter exchange
+      b.destination :rabbit_dlx, "rabbit.dead.letter.exchange", type: :exchange, declare: { type: :fanout }
+
+      # declare a dead letter queue and bind it to the exchange
+      b.destination :rabbit_dlq, "rabbit.dead.letter.queue", bindings: [
+        { source: "rabbit.dead.letter.exchange" }
+      ]
+
+      # declare a work queue that sends dead letters to our dead letter queue
+      b.destination :rabbit_work, "rabbit.work", arguments: { :"x-dead-letter-exchange" => "rabbit.dead.letter.exchange" }
+    end
+    """
+    And I have no messages on :rabbit_work
+    And I have no messages on :rabbit_dlq
+
+  Scenario: Nacking a message with requeue false
+    Given I send the following message to :rabbit_work
+      | body        |
+      | Nack Test 1 |
+
+    When I execute the following code
+    """ruby
+    message = MessageDriver::Client.pop_message(:rabbit_work, client_ack: true)
+    message.nack(requeue: false)
+    """
+
+    Then I expect to find no messages on :rabbit_work
+    And I expect to find the following 1 message on :rabbit_dlq
+      | body        |
+      | Nack Test 1 |
+
+
+  Scenario: Nacking a message on a manual_ack consumer
+    Given I have a message consumer
+    """ruby
+    MessageDriver::Broker.consumer(:manual_dql) do |message|
+      message.nack(requeue: false)
+    end
+    """
+    And I create a subscription
+    """ruby
+    MessageDriver::Client.subscribe(:rabbit_work, :manual_dql, ack: :manual)
+    """
+
+    When I send the following messages to :rabbit_work
+      | body          |
+      | Manual Nack 1 |
+      | Manual Nack 2 |
+    And I let the subscription process
+
+    Then I expect to find no messages on :rabbit_work
+    And I expect to find the following 2 messages on :rabbit_dlq
+      | body          |
+      | Manual Nack 1 |
+      | Manual Nack 2 |
+
+
+  Scenario: Raising a DontRequeueError in an auto_ack consumer
+    Given I have a message consumer
+    """ruby
+    MessageDriver::Broker.consumer(:manual_dql) do |message|
+      raise MessageDriver::DontRequeueError
+    end
+    """
+    And I create a subscription
+    """ruby
+    MessageDriver::Client.subscribe(:rabbit_work, :manual_dql, ack: :auto)
+    """
+
+    When I send the following messages to :rabbit_work
+      | body        |
+      | Auto Nack 1 |
+      | Auto Nack 2 |
+    And I let the subscription process
+
+    Then I expect to find no messages on :rabbit_work
+    And I expect to find the following 2 messages on :rabbit_dlq
+      | body        |
+      | Auto Nack 1 |
+      | Auto Nack 2 |
+
+
+  Scenario: Raising a DontRequeueError in a transactional consumer
+    Given I have a message consumer
+    """ruby
+    MessageDriver::Broker.consumer(:transactional_dql) do |message|
+      publish(:rabbit_work, "I get rolled back")
+      raise MessageDriver::DontRequeueError
+    end
+    """
+    And I create a subscription
+    """ruby
+    MessageDriver::Client.subscribe(:rabbit_work, :transactional_dql, ack: :transactional)
+    """
+
+    When I send the following messages to :rabbit_work
+      | body                 |
+      | Transactional Nack 1 |
+      | Transactional Nack 2 |
+    And I let the subscription process
+
+    Then I expect to find no messages on :rabbit_work
+    And I expect to find the following 2 messages on :rabbit_dlq
+      | body                 |
+      | Transactional Nack 1 |
+      | Transactional Nack 2 |

data/features/step_definitions/dynamic_destinations_steps.rb

@@ -1,9 +1,9 @@
-Given(/^I have a dynamic destination "(#{STRING_OR_SYM})" with the following messages on it:$/) do |destination, table|
-  dest = MessageDriver::Broker.dynamic_destination(destination, exclusive: true)
+Given(/^I have a dynamic destination "(#{STRING_OR_SYM})" with the following messages on it$/) do |destination, table|
+  dest = MessageDriver::Broker.dynamic_destination(destination)
   test_runner.publish_table_to_destination(dest, table)
 end
 
-Then(/^I expect to find (#{NUMBER}) messages? on the dynamic destination "(#{STRING_OR_SYM})" with:$/) do |count, destination, table|
+Then(/^I expect to find (#{NUMBER}) messages? on the dynamic destination "(#{STRING_OR_SYM})" with$/) do |count, destination, table|
   expect(test_runner).to have_no_errors
   dest = MessageDriver::Broker.dynamic_destination(destination, passive: true)
   messages = test_runner.fetch_messages(dest)

data/features/step_definitions/error_handling_steps.rb

@@ -1,9 +1,11 @@
 When "the broker goes down" do
-  result = block_broker_port
+  block_broker_port
+  sleep 2
 end
 
 When "the broker comes up" do
-  result = unblock_broker_port
+  unblock_broker_port
+  sleep 20
 end
 
 After do

data/features/step_definitions/logging_steps.rb

@@ -0,0 +1,28 @@
+require 'logger'
+
+LOG_FILE_NAME = "cucumber_log_file.log"
+
+Given(/^I am logging to a log file(?: at the (#{STRING_OR_SYM}) level)?$/) do |level|
+  step "an empty file named \"#{LOG_FILE_NAME}\""
+  in_current_dir do
+    @logger = Logger.new(LOG_FILE_NAME)
+  end
+  step "I set the log level to #{level || "info"}"
+  scenario_config[:logger] = @logger
+end
+
+Given(/^I set the log level to (#{STRING_OR_SYM})$/) do |level|
+  level = level ? level.to_s.upcase : "INFO"
+  @logger.level = Logger::SEV_LABEL.find_index(level)
+end
+
+Then "the log file should contain:" do |string|
+  step "the file \"#{LOG_FILE_NAME}\" should contain:", string
+end
+
+After do
+  if @logger
+    @logger.close
+    @logger = nil
+  end
+end

data/features/step_definitions/message_consumers_steps.rb

@@ -0,0 +1,29 @@
+Given "I have a message consumer" do |src|
+  test_runner.run_config_code(src)
+  expect(test_runner).to have_no_errors
+end
+
+Given(/^I subscribe to (#{STRING_OR_SYM}) with (#{STRING_OR_SYM})$/) do |destination, consumer|
+  MessageDriver::Client.subscribe(destination, consumer)
+end
+
+Given "I create a subscription" do |src|
+  test_runner.run_test_code("@subscription = #{src}")
+  expect(test_runner).to have_no_errors
+end
+
+When "I cancel the subscription" do
+  test_runner.run_test_code("@subscription.unsubscribe")
+  step "I allow for processing"
+end
+
+When "I let the subscription process" do
+  step "I allow for processing"
+  step "I cancel the subscription"
+  expect(test_runner).to have_no_errors
+end
+
+When "I restart the subscription" do
+  test_runner.run_test_code("@subscription.start")
+  step "I allow for processing"
+end

data/features/step_definitions/steps.rb

@@ -1,27 +1,68 @@
 Given "I am connected to the broker" do
-  MessageDriver.configure(BrokerConfig.config)
+  MessageDriver.configure(broker_config)
 end
 
-Given "the following broker configuration:" do |src|
+Given "the following broker configuration" do |src|
   step "I am connected to the broker"
-  test_runner.config_broker(src)
+  test_runner.run_config_code(src)
 end
 
-When "I execute the following code:" do |src|
+Given(/^I have a destination (#{STRING_OR_SYM})$/) do |destination|
+  MessageDriver::Broker.define do |b|
+    b.destination(destination, destination.to_s)
+  end
+end
+
+Given(/^I have a destination (#{STRING_OR_SYM}) with no messages on it$/) do |destination|
+  dest = destination.kind_of?(Symbol) ? destination.inspect : destination.to_s
+  step "I have a destination #{dest}"
+  test_runner.purge_destination(destination)
+end
+
+Given(/^I have the following messages? on (#{STRING_OR_SYM})$/) do |destination, table|
+  test_runner.purge_destination(destination)
+  dest = destination.kind_of?(Symbol) ? destination.inspect : destination.to_s
+  step "I send the following messages to #{dest}", table
+end
+
+Given(/^I have no messages on (#{STRING_OR_SYM})$/) do |destination|
+  test_runner.purge_destination(destination)
+end
+
+When(/^I send the following messages? to (#{STRING_OR_SYM})$/) do |destination, table|
+  table.hashes.each do |msg|
+    MessageDriver::Client.publish(destination, msg[:body])
+  end
+end
+
+When "I execute the following code" do |src|
   test_runner.run_test_code(src)
 end
 
+When "I reset the context" do
+  MessageDriver::Client.current_adapter_context.invalidate
+end
+
+When "I allow for processing" do
+  test_runner.pause_if_needed
+end
+
 Then(/^I expect to find (#{NUMBER}) messages? on (#{STRING_OR_SYM})$/) do |count, destination|
   expect(test_runner).to have_no_errors
   messages = test_runner.fetch_messages(destination)
-  expect(messages).to have(count).items
+  expect(messages).to have(count).items, "expected #{count} messages, but got these instead: #{messages.map(&:body)}"
 end
 
-Then(/^I expect to find (#{NUMBER}) messages? on (#{STRING_OR_SYM}) with:$/) do |count, destination, table|
+Then(/^I expect to find the following (#{NUMBER}) messages? on (#{STRING_OR_SYM})$/) do |count, destination, table|
   expect(test_runner).to have_no_errors
   messages = test_runner.fetch_messages(destination)
-  expect(messages).to have(count).items
   expect(messages).to match_message_table(table)
+  expect(messages).to have(count).items
+end
+
+Then(/^I expect to find the following message on (#{STRING_OR_SYM})$/) do |destination, table|
+  dest = destination.kind_of?(Symbol) ? destination.inspect : destination.to_s
+  step "I expect to find the following 1 message on #{dest}", table
 end
 
 Then(/^I expect it to raise "(.*?)"$/) do |error_msg|
@@ -31,11 +72,21 @@ Then(/^I expect it to raise "(.*?)"$/) do |error_msg|
 end
 
 Then(/^I expect it to raise a (.*?) error$/) do |error_type|
-  expect(test_runner.raised_error).to_not be_nil
-  expect(test_runner.raised_error.class.to_s).to match error_type
+  err = test_runner.raised_error
+  expect(err).to_not be_nil
+  expect(err.class.to_s).to match error_type
   test_runner.raised_error = nil
 end
 
 Then "I expect to have no errors" do
   expect(test_runner).to have_no_errors
 end
+
+Then "I expect the following check to pass" do |src|
+  step "I execute the following code", src
+  step "I expect to have no errors"
+end
+
+Before do |current_scenario|
+  test_runner.current_feature_file = current_scenario.feature.file
+end

data/features/support/broker_config_helper.rb

@@ -0,0 +1,19 @@
+module BrokerConfigHelper
+  def broker_config
+    BrokerConfig.config.merge(@config)
+  end
+
+  def reset_broker_config
+    @config = {}
+  end
+
+  def scenario_config
+    @config
+  end
+end
+
+Before do
+  reset_broker_config
+end
+
+World(BrokerConfigHelper)

data/features/support/env.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'test_lib', 'broker_config')
 
+require 'aruba/cucumber'
 require 'message_driver'
 
 After do

data/features/support/firewall_helper.rb

@@ -1,27 +1,24 @@
 module FirewallHelper
 
+  def self.port
+    BrokerConfig.current_adapter_port
+  end
+
   COMMANDS = {
     darwin: {
       setup: [
-        "sudo ipfw add 02070 deny tcp from any to any 5672"
+        "lunchy stop rabbit"
       ],
       teardown: [
-        "sudo ipfw delete 02070"
+        "lunchy start rabbit"
       ]
     },
     linux: {
       setup: [
-        "sudo iptables -N block-rabbit",
-        "sudo iptables -A block-rabbit -p tcp --dport 5672 -j DROP",
-        "sudo iptables -A block-rabbit -p tcp --sport 5672 -j DROP",
-        "sudo iptables -I INPUT -j block-rabbit",
-        "sudo iptables -I OUTPUT -j block-rabbit"
+        "sudo service rabbitmq-server stop"
       ],
       teardown: [
-        "sudo iptables -D INPUT -j block-rabbit",
-        "sudo iptables -D OUTPUT -j block-rabbit",
-        "sudo iptables -F block-rabbit",
-        "sudo iptables -X block-rabbit"
+        "sudo service rabbitmq-server start"
       ]
     }
   }

data/features/support/message_table_matcher.rb

@@ -1,11 +1,27 @@
-RSpec::Matchers.define :match_message_table do |expected|
-  match do |messages|
-    actual = messages.collect do |msg|
-      expected.headers.inject({}) do |memo, obj|
+RSpec::Matchers.define :match_message_table do |expected_tbl|
+  define_method :expected_hash do
+    @expected_hash ||= expected_tbl.hashes
+  end
+
+  define_method :messages_to_hash do |messages|
+    messages.collect do |msg|
+      expected_tbl.headers.inject({ }) do |memo, obj|
         memo[obj] = msg.send(obj)
         memo
       end
     end
-    actual == expected.hashes
+  end
+
+  match do |messages|
+    @actual = messages_to_hash(messages)
+    @actual == expected_hash
+  end
+
+  failure_message_for_should do |_|
+    "expected #{expected_hash} and got #{@actual}"
+  end
+
+  description do
+    "contain messages #{expected_hash}"
   end
 end

data/features/support/test_runner.rb

@@ -1,36 +1,50 @@
-require 'message_driver'
-
 class TestRunner
-  include MessageDriver::MessagePublisher
+  include MessageDriver::Client
   include RSpec::Matchers
 
   attr_accessor :raised_error
+  attr_accessor :current_feature_file
 
-  def config_broker(src)
-    instance_eval(src)
+  def run_config_code(src)
+    instance_eval(src, current_feature_file)
   end
 
   def run_test_code(src)
     begin
-      instance_eval(src)
-    rescue Exception => e
+      instance_eval(src, current_feature_file)
+    rescue => e
       @raised_error = e
     end
   end
 
-  def fetch_messages(destination)
+  def fetch_messages(destination_name)
+    destination = fetch_destination(destination_name)
+    pause_if_needed
+    result = []
+    begin
+      msg = destination.pop_message
+      result << msg unless msg.nil?
+    end until msg.nil?
+    result
+  end
+
+  def purge_destination(destination_name)
+    destination = fetch_destination(destination_name)
+    if destination.respond_to? :purge
+      destination.purge
+    else
+      fetch_messages(destination)
+    end
+  end
+
+  def fetch_destination(destination)
     case destination
     when String, Symbol
-      fetch_messages(MessageDriver::Broker.find_destination(destination))
+      MessageDriver::Broker.find_destination(destination)
     when MessageDriver::Destination::Base
-      result = []
-      begin
-        msg = destination.pop_message
-        result << msg unless msg.nil?
-      end until msg.nil?
-      result
+      destination
     else
-      raise "didn't understand destination #{destination}"
+      raise "didn't understand destination #{destination.inspect}"
     end
   end
 
@@ -39,6 +53,15 @@ class TestRunner
       destination.publish(msg[:body], msg[:headers]||{}, msg[:properties]||{})
     end
   end
+
+  def pause_if_needed(seconds=0.1)
+    seconds *= 10 if ENV['CI'] == 'true'
+    case BrokerConfig.current_adapter
+    when :in_memory
+    else
+      sleep seconds
+    end
+  end
 end
 
 module KnowsMyTestRunner

data/lib/message_driver/adapters/base.rb

@@ -1,10 +1,41 @@
 module MessageDriver
   module Adapters
     class Base
+      include Logging
+
+      attr_accessor :contexts
+
       def initialize(configuration)
         raise "Must be implemented in subclass"
       end
 
+      def new_context
+        @contexts ||= []
+        ctx = build_context
+        contexts << ctx
+        ctx
+      end
+
+      def build_context
+        raise "Must be implemented in subclass"
+      end
+
+      def stop
+        contexts.each { |ctx| ctx.invalidate } if contexts
+      end
+    end
+
+    class ContextBase
+      include Logging
+
+      attr_reader :adapter
+      attr_accessor :valid
+
+      def initialize(adapter)
+        @adapter = adapter
+        @valid = true
+      end
+
       def publish(destination, body, headers={}, properties={})
         raise "Must be implemented in subclass"
       end
@@ -13,16 +44,32 @@ module MessageDriver
         raise "Must be implemented in subclass"
       end
 
-      def stop
-        raise "Must be implemented in subclass"
+      def subscribe(destination, options={}, &consumer)
+        raise "#subscribe is not supported by #{adapter.class}"
       end
 
       def create_destination(name, dest_options={}, message_props={})
         raise "Must be implemented in subclass"
       end
 
-      def with_transaction(options={}, &block)
-        yield
+      def valid?
+        @valid
+      end
+
+      def invalidate
+        @valid = false
+      end
+
+      def supports_transactions?
+        false
+      end
+
+      def supports_client_acks?
+        false
+      end
+
+      def supports_subscriptions?
+        false
       end
     end
   end