message-driver 0.4.0 → 0.5.0

data/features/amqp_specific_features/binding_amqp_destinations.feature

@@ -1,4 +1,5 @@
 @bunny
+@read_queues_directly
 Feature: Binding AMQP destinations to exchanges
   Background:
     Given the following broker configuration

data/features/amqp_specific_features/declaring_amqp_exchanges.feature

@@ -1,4 +1,5 @@
 @bunny
+@read_queues_directly
 Feature: Declaring AMQP exchanges
   If you want to create an exchange that doesn't exist on the broker, you can do so by adding
   the "declare" option to your destination.

data/features/amqp_specific_features/server_named_destinations.feature

@@ -1,4 +1,5 @@
 @bunny
+@read_queues_directly
 Feature: Server-Named Destinations
   AMQP brokers allow you to create queues that are named by the server. Here's
   how you do it with message_driver.

data/features/destination_metadata.feature

@@ -29,3 +29,29 @@ Feature: Destination Metadata
 
     Then I expect to have no errors
     And I expect to find 2 messages on :my_queue
+
+  Scenario: Check the consumer count when the queue has no consumers
+    When I execute the following code
+    """ruby
+    destination = MessageDriver::Client.find_destination(:my_queue)
+    expect(destination.consumer_count).to eq(0)
+    """
+
+    Then I expect to have no errors
+
+  Scenario: Check the consumer count when the queue has consumers
+    Given I create some subscriptions
+    """ruby
+    3.times do
+      MessageDriver::Client.subscribe_with(:my_queue) do |message|
+        puts message.inspect
+      end
+    end
+    """
+    When I execute the following code
+    """ruby
+    destination = MessageDriver::Client.find_destination(:my_queue)
+    expect(destination.consumer_count).to eq(3)
+    """
+
+    Then I expect to have no errors

data/features/logging.feature

@@ -1,5 +1,5 @@
 @all_adapters
-Feature: Stuff gets logged if you set a logger
+Feature: Logging
 
   You can configure the logger by setting it on `MessageDriver.logger`.
   If you don't provide a logger, then an info level logger will be created

data/features/middleware/middleware_basics.feature

@@ -0,0 +1,91 @@
+@bunny
+@in_memory
+Feature: Middleware Basics
+
+  Middlewares can be used to transform messages that are about to be published
+  or that are about to be consumed. This allows for handling of things like
+  serializing and deserializing the message body in a way that is transparent to
+  your application code.
+
+  Middlewares are applied in a stack to destinations, much like Rack middleware.
+  As a message that is about to be consumed, it starts by coming in the top of
+  the middleware stack and works it's way down before it is returned by
+  `pop_message` or passed to a consumer.
+
+  For messages that are being published, they start at the bottom of the stack
+  and work their way up until they are finally passed to the underlying driver
+  and sent to the message broker.
+
+  Background:
+    Given I am connected to the broker
+    And I have a destination :middleware_queue with no messages on it
+    And I have a middleware class
+    """ruby
+    class ExampleMiddleware < MessageDriver::Middleware::Base
+      def on_publish(body, headers, properties)
+        [body+':about_to_publish', headers, properties]
+      end
+
+      def on_consume(body, headers, properties)
+        ['about_to_be_consumed:'+body, headers, properties]
+      end
+    end
+    """
+
+  Scenario: The middleware stack of a destination is initially empty
+    When I execute the following code
+    """ruby
+    destination = MessageDriver::Client.find_destination(:middleware_queue)
+    expect(destination.middleware).to be_empty
+    """
+    Then I expect to have no errors
+
+
+  Scenario: Adding a piece of middleware to a destination
+    When I execute the following code
+    """ruby
+    destination = MessageDriver::Client.find_destination(:middleware_queue)
+    destination.middleware.append ExampleMiddleware
+    """
+
+    Then I expect the following check to pass
+    """ruby
+    destination = MessageDriver::Client.find_destination(:middleware_queue)
+    expect(destination.middleware).to include(an_instance_of(ExampleMiddleware))
+    """
+
+
+  Scenario: Middleware is applied to messages as they are published
+    When I append middleware "ExampleMiddleware" to :middleware_queue
+    And I send the following messages to :middleware_queue
+      | body           |
+      | Test Message 1 |
+      | Test Message 2 |
+
+    Then I expect to find the following 2 messages on :middleware_queue
+      | raw_body                        |
+      | Test Message 1:about_to_publish |
+      | Test Message 2:about_to_publish |
+
+
+  Scenario: Middleware is applied to messages as they are consumed
+    Given I have a destination :dest_queue with no messages on it
+
+    When I send the following messages to :middleware_queue
+      | body           |
+      | Test Message 1 |
+      | Test Message 2 |
+    And I append middleware "ExampleMiddleware" to :middleware_queue
+    And I create a subscription
+    """ruby
+    MessageDriver::Client.subscribe_with(:middleware_queue) do |message|
+      MessageDriver::Client.publish(:dest_queue, message.body)
+    end
+    """
+    And I let the subscription process
+
+    Then I expect to find no messages on :middleware_queue
+    And I expect to find the following 2 messages on :dest_queue
+      | raw_body                            |
+      | about_to_be_consumed:Test Message 1 |
+      | about_to_be_consumed:Test Message 2 |

data/features/middleware/middleware_ordering.feature

@@ -0,0 +1,60 @@
+@bunny
+@in_memory
+Feature: Middleware Ordering
+
+  Middleware are applied based on the order they appear in the stack. For
+  publish operations, middlewares are applied bottom of the stack to the top.
+  For consume operations, middleware are applied from the top of the stack to
+  the bottom.
+
+  Scenario: Apply two middlewares to a destination
+    Given I am connected to the broker
+    And I have a destination :middleware_queue with no messages on it
+    And I have a middleware class
+    """ruby
+    class MiddlewareOne < MessageDriver::Middleware::Base
+      def on_publish(body, headers, properties)
+        [body+':publish1', headers, properties]
+      end
+
+      def on_consume(body, headers, properties)
+        ['consume1:'+body, headers, properties]
+      end
+    end
+    """
+    And I have a middleware class
+    """ruby
+    class MiddlewareTwo < MessageDriver::Middleware::Base
+      def on_publish(body, headers, properties)
+        [body+':publish2', headers, properties]
+      end
+
+      def on_consume(body, headers, properties)
+        ['consume2:'+body, headers, properties]
+      end
+    end
+    """
+    And I append middleware "MiddlewareOne" to :middleware_queue
+    And I append middleware "MiddlewareTwo" to :middleware_queue
+
+    And I have a destination :dest_queue with no messages on it
+    And I create a subscription
+    """ruby
+    MessageDriver::Client.subscribe_with(:middleware_queue) do |message|
+      MessageDriver::Client.publish(:dest_queue, message.body)
+    end
+    """
+
+    When I send the following messages to :middleware_queue
+      | body           |
+      | Test Message 1 |
+      | Test Message 2 |
+      | Test Message 3 |
+    And I let the subscription process
+
+    Then I expect to find no messages on :middleware_queue
+    And I expect to find the following 3 messages on :dest_queue
+      | body                                               |
+      | consume1:consume2:Test Message 1:publish1:publish2 |
+      | consume1:consume2:Test Message 2:publish1:publish2 |
+      | consume1:consume2:Test Message 3:publish1:publish2 |

data/features/middleware/middleware_parameters.feature

@@ -0,0 +1,43 @@
+@bunny
+@in_memory
+Feature: Middleware Parameters
+
+  You can provide parameters to your middleware by passing them as additional
+  paremeters to the append and prepend calls.
+
+  Background:
+    Given I am connected to the broker
+    And I have a destination :middleware_queue with no messages on it
+    And I have a middleware class
+    """ruby
+    class ParameterizedMiddleware < MessageDriver::Middleware::Base
+
+      attr_reader :prefix, :seperator
+
+      def initialize(destination, prefix, seperator)
+        super(destination)
+        @prefix = prefix
+        @seperator = seperator
+      end
+
+      def on_publish(body, headers, properties)
+        ["#{prefix}#{seperator}#{body}", headers, properties]
+      end
+    end
+    """
+
+  Scenario: Adding a parameterized middleware to the stack
+    When I execute the following code
+    """ruby
+    destination = MessageDriver::Client.find_destination(:middleware_queue)
+    destination.middleware.append ParameterizedMiddleware, 'pub_pre', ':'
+    """
+    And I send the following messages to :middleware_queue
+      | body           |
+      | Test Message 1 |
+      | Test Message 2 |
+
+    Then I expect to find the following 2 messages on :middleware_queue
+      | raw_body               |
+      | pub_pre:Test Message 1 |
+      | pub_pre:Test Message 2 |

data/features/middleware/middleware_with_blocks.feature

@@ -0,0 +1,85 @@
+@bunny
+@in_memory
+Feature: Middleware with Blocks
+
+  You can also create middleware by passing a hash with blocks as the input to
+  append or prepend
+
+  Background:
+    Given I am connected to the broker
+    And I have a destination :middleware_queue with no messages on it
+
+  Scenario: providing an on_publish block
+    When I execute the following code
+    """ruby
+      destination = MessageDriver::Client.find_destination(:middleware_queue)
+      destination.middleware.append on_publish: ->(body, headers, properties) { [body+' published with a block!', headers, properties] }
+    """
+
+    And I send the following messages to :middleware_queue
+      | body           |
+      | Test Message 1 |
+      | Test Message 2 |
+
+    Then I expect to find the following 2 messages on :middleware_queue
+      | raw_body               |
+      | Test Message 1 published with a block! |
+      | Test Message 2 published with a block! |
+
+
+  Scenario: providing an on_consume block
+    Given I have a destination :dest_queue with no messages on it
+
+    When I execute the following code
+    """ruby
+      destination = MessageDriver::Client.find_destination(:middleware_queue)
+      destination.middleware.append on_consume: ->(body, headers, properties) { [body+' consumed with a block!', headers, properties] }
+    """
+
+    And I send the following messages to :middleware_queue
+      | body           |
+      | Test Message 1 |
+      | Test Message 2 |
+
+    And I create a subscription
+    """ruby
+    MessageDriver::Client.subscribe_with(:middleware_queue) do |message|
+      MessageDriver::Client.publish(:dest_queue, message.body)
+    end
+    """
+    And I let the subscription process
+
+    Then I expect to find no messages on :middleware_queue
+    And I expect to find the following 2 messages on :dest_queue
+      | raw_body                              |
+      | Test Message 1 consumed with a block! |
+      | Test Message 2 consumed with a block! |
+
+  Scenario: providing an on_consume block and an on_publish block
+    Given I have a destination :dest_queue with no messages on it
+
+    When I execute the following code
+    """ruby
+      destination = MessageDriver::Client.find_destination(:middleware_queue)
+      destination.middleware.append(on_consume: ->(body, headers, properties) { [body + ' consumed', headers, properties] },
+                                    on_publish: ->(body, headers, properties) { ['published ' + body, headers, properties] })
+    """
+
+    And I send the following messages to :middleware_queue
+      | body           |
+      | Test Message 1 |
+      | Test Message 2 |
+
+    And I create a subscription
+    """ruby
+    MessageDriver::Client.subscribe_with(:middleware_queue) do |message|
+      MessageDriver::Client.publish(:dest_queue, message.body)
+    end
+    """
+    And I let the subscription process
+
+    Then I expect to find no messages on :middleware_queue
+    And I expect to find the following 2 messages on :dest_queue
+      | raw_body                              |
+      | published Test Message 1 consumed |
+      | published Test Message 2 consumed |

data/features/step_definitions/dynamic_destinations_steps.rb

@@ -7,6 +7,6 @@ Then(/^I expect to find (#{NUMBER}) messages? on the dynamic destination "(#{STR
   expect(test_runner).to have_no_errors
   dest = MessageDriver::Client[test_runner.broker_name].dynamic_destination(destination, passive: true)
   messages = test_runner.fetch_messages(dest)
-  expect(messages).to have(count).items
+  expect(messages.size).to eq(count)
   expect(messages).to match_message_table(table)
 end

data/features/step_definitions/message_consumers_steps.rb

@@ -12,6 +12,11 @@ Given 'I create a subscription' do |src|
   expect(test_runner).to have_no_errors
 end
 
+Given 'I create some subscriptions' do |src|
+  test_runner.run_test_code(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'

data/features/step_definitions/middleware_steps.rb

@@ -0,0 +1,10 @@
+Given('I have a middleware class') do |src|
+  write_file('feature_middleware.rb', src)
+  in_current_dir { load './feature_middleware.rb' }
+end
+
+When(/^I append middleware "(.*?)" to (#{STRING_OR_SYM})$/) do |class_name, dest_name|
+  klass = Object.const_get(class_name)
+  destination = test_runner.fetch_destination(dest_name)
+  destination.middleware.append klass
+end

data/features/step_definitions/steps.rb

@@ -59,14 +59,14 @@ 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, "expected #{count} messages, but got these instead: #{messages.map(&:body)}"
+  expect(messages.size).to eq(count), "expected #{count} messages, but got these instead: #{messages.map(&:body)}"
 end
 
 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 match_message_table(table)
-  expect(messages).to have(count).items
+  expect(messages.size).to eq(count)
 end
 
 Then(/^I expect to find the following message on (#{STRING_OR_SYM})$/) do |destination, table|
@@ -99,3 +99,11 @@ end
 Before do |current_scenario|
   test_runner.current_feature_file = current_scenario.feature.file
 end
+
+Before '@read_queues_directly' do
+  test_runner.provider.read_queues_directly = true
+end
+
+After '@read_queues_directly' do
+  test_runner.provider.read_queues_directly = false
+end

data/features/support/env.rb

@@ -1,11 +1,12 @@
-require 'coveralls'
-Coveralls.wear!
-
+ENV['COMMAND_NAME'] = 'features'
+require File.join(File.dirname(__FILE__), '..', '..', 'test_lib', 'coverage')
 require File.join(File.dirname(__FILE__), '..', '..', 'test_lib', 'broker_config')
 
 require 'aruba/cucumber'
 require 'message_driver'
 
+BrokerConfig.setup_provider
+
 After do
   MessageDriver::Broker.reset
 end

data/features/support/firewall_helper.rb

@@ -35,7 +35,7 @@ module FirewallHelper
   def run_commands(step)
     COMMANDS[os][step].each do |cmd|
       result = system(cmd)
-      raise "command `#{cmd}` failed!" unless result
+      fail "command `#{cmd}` failed!" unless result
     end
   end
 

data/features/support/message_table_matcher.rb

@@ -13,10 +13,11 @@ RSpec::Matchers.define :match_message_table do |expected_tbl|
 
   match do |messages|
     @actual = messages_to_hash(messages)
-    @actual == expected_hash
+    expect(@actual).to match_array(expected_hash)
+    true
   end
 
-  failure_message_for_should do |_|
+  failure_message do |_|
     "expected #{expected_hash} and got #{@actual}"
   end