action_subscriber 5.1.5-java → 5.2.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca5face8fc684985f21cab2d0be98de2e2f6d8c56d08a403c62075291adbda8a
-  data.tar.gz: 3210c548ea05b9da02a358691434e22d875fcea6d11496959a849fee36223bfa
+  metadata.gz: 70428c30ef852da7b3e5678f2e9bbf43dbaaac46a0280a865e9aa314efb43fc3
+  data.tar.gz: 67d69b8f403eba527f180e9c0ea7d5eb49faabfe2adc91f8e42c192d4600e97c
 SHA512:
-  metadata.gz: 2089e546d6494cf331f658b26d4ff57f35151ddf231e586082dd951e6f635f29d816fe0b3b2d7302f7fd25a5141e56dcc8f1e56909f3973a3b8ba86b908cb64a
-  data.tar.gz: 7f72c8204ed5bc09a61c1f3b62f6f5fb03bc21b66a6ca388f758c8bea776b93b6e275d99f0c77271652a0f0a3d7a3cb1692c237156d577aa47b67df5d36cbf69
+  metadata.gz: 1eb8b21638811db8325eb6ccf27091aef00d9394324b2e46c41ce2ef2dfa3ac90be2a4b4e448afc8d910e0325e37e033b5fa071cb1545fdae28fb5e264dc2527
+  data.tar.gz: c3895c215507a1e61712ef071cf96ce4dfaca092df3172d044c3a97933970dd317260bac8c9aef791efb52f58cbdc027521fee07365a2254b8d08dd049ea6f53

data/.travis.yml

@@ -4,11 +4,10 @@ os:
 dist:
   trusty
 rvm:
- - 2.2.6
- - 2.3.3
- - jruby-9.0.5.0
- - jruby-9.1.7.0
+ - 2.3.8
+ - 2.5.7
  - jruby-9.1.12.0
+ - jruby-9.2.7.0
  - jruby-head
 services:
  - rabbitmq

data/README.md

@@ -135,6 +135,7 @@ Other configuration options include :
 * config.network_recovery_interval - reconnection interval for TCP connection failures (default 1)
 * config.password - RabbitMQ password (default "guest")
 * config.prefetch - number of messages to hold in the local queue in subscriber mode
+* config.resubscribe_on_consumer_cancellation - resubscribe when the consumer is cancelled (queue deleted or cluster fails, default true)
 * config.seconds_to_wait_for_graceful_shutdown - time to wait before force stopping server after shutdown signal
 * config.threadpool_size - set the number of threads available to action_subscriber
 * config.timeout - how many seconds to allow rabbit to respond before timing out

data/action_subscriber.gemspec

@@ -33,9 +33,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "active_publisher", "~> 0.1.5"
   spec.add_development_dependency "activerecord", ">= 3.2"
   spec.add_development_dependency "bundler", ">= 1.6"
-  spec.add_development_dependency "pry-coolline"
   spec.add_development_dependency "pry-nav"
   spec.add_development_dependency "rabbitmq_http_api_client", "~> 1.2.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
 end

data/lib/action_subscriber/bunny/subscriber.rb

@@ -2,6 +2,7 @@ module ActionSubscriber
   module Bunny
     module Subscriber
       include ::ActionSubscriber::Logging
+      include ::ActionSubscriber::Subscriber
 
       def bunny_consumers
         @bunny_consumers ||= []
@@ -26,35 +27,51 @@ module ActionSubscriber
 
       def start_subscribers!
         subscriptions.each do |subscription|
-          route = subscription[:route]
-          queue = subscription[:queue]
-          channel = queue.channel
-          threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
-          channel.prefetch(route.prefetch) if route.acknowledgements?
-          consumer = ::Bunny::Consumer.new(channel, queue, channel.generate_consumer_tag, !route.acknowledgements?)
-          consumer.on_delivery do |delivery_info, properties, encoded_payload|
-            ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
-            properties = {
-              :action => route.action,
-              :channel => queue.channel,
-              :content_type => properties.content_type,
-              :delivery_tag => delivery_info.delivery_tag,
-              :exchange => delivery_info.exchange,
-              :headers => properties.headers,
-              :message_id => properties.message_id,
-              :routing_key => delivery_info.routing_key,
-              :queue => queue.name,
-              :uses_acknowledgements => route.acknowledgements?,
-            }
-            env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            run_env(env, threadpool)
-          end
-          bunny_consumers << consumer
-          queue.subscribe_with(consumer)
+          start_subscriber_for_subscription(subscription)
         end
       end
 
-      private
+    private
+
+      def start_subscriber_for_subscription(subscription)
+        route = subscription[:route]
+        queue = subscription[:queue]
+        channel = queue.channel
+        threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
+        channel.prefetch(route.prefetch) if route.acknowledgements?
+        consumer = ::Bunny::Consumer.new(channel, queue, channel.generate_consumer_tag, !route.acknowledgements?)
+
+        if ::ActionSubscriber.configuration.resubscribe_on_consumer_cancellation
+          # Add cancellation callback to rebuild subscriber on cancel.
+          consumer.on_cancellation do
+            ::ActionSubscriber.logger.warn "Cancellation received for queue consumer: #{queue.name}, rebuilding subscription..."
+            bunny_consumers.delete(consumer)
+            channel.close
+            safely_restart_subscriber(subscription)
+          end
+        end
+
+        consumer.on_delivery do |delivery_info, properties, encoded_payload|
+          ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+          properties = {
+            :action => route.action,
+            :channel => queue.channel,
+            :content_type => properties.content_type,
+            :delivery_tag => delivery_info.delivery_tag,
+            :exchange => delivery_info.exchange,
+            :headers => properties.headers,
+            :message_id => properties.message_id,
+            :routing_key => delivery_info.routing_key,
+            :queue => queue.name,
+            :uses_acknowledgements => route.acknowledgements?,
+          }
+          env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
+          run_env(env, threadpool)
+        end
+
+        bunny_consumers << consumer
+        queue.subscribe_with(consumer)
+      end
 
       def setup_queue(route)
         channel = ::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.create_channel(nil, 1) }

data/lib/action_subscriber/configuration.rb

@@ -16,6 +16,7 @@ module ActionSubscriber
                   :password,
                   :port,
                   :prefetch,
+                  :resubscribe_on_consumer_cancellation,
                   :seconds_to_wait_for_graceful_shutdown,
                   :threadpool_size,
                   :timeout,
@@ -42,6 +43,7 @@ module ActionSubscriber
       :password => "guest",
       :port => 5672,
       :prefetch => 2,
+      :resubscribe_on_consumer_cancellation => true,
       :seconds_to_wait_for_graceful_shutdown => 30,
       :threadpool_size => 8,
       :timeout => 1,
@@ -75,8 +77,8 @@ module ActionSubscriber
           end
 
           ::ActionSubscriber::Configuration::DEFAULTS.each_pair do |key, value|
-            setting = cli_options[key] || yaml_config[key.to_s]
-            ::ActionSubscriber.config.__send__("#{key}=", setting) if setting
+            exists, setting = fetch_config_value(key, cli_options, yaml_config)
+            ::ActionSubscriber.config.__send__("#{key}=", setting) if exists
           end
 
           true
@@ -84,6 +86,15 @@ module ActionSubscriber
       end
     end
 
+    def self.fetch_config_value(key, cli_options, yaml_config)
+      return [true, cli_options[key]] if cli_options.key?(key)
+      return [true, cli_options[key.to_s]] if cli_options.key?(key.to_s)
+      return [true, yaml_config[key]] if yaml_config.key?(key)
+      return [true, yaml_config[key.to_s]] if yaml_config.key?(key.to_s)
+      [false, nil]
+    end
+    private_class_method :fetch_config_value
+
     ##
     # Instance Methods
     #

data/lib/action_subscriber/march_hare/subscriber.rb

@@ -2,9 +2,11 @@ module ActionSubscriber
   module MarchHare
     module Subscriber
       include ::ActionSubscriber::Logging
+      include ::ActionSubscriber::Subscriber
 
       def cancel_consumers!
-        march_hare_consumers.each(&:cancel)
+        # Cancel any non-cancelled consumers.
+        march_hare_consumers.reject(&:cancelled?).each(&:cancel)
         ::ActionSubscriber::ThreadPools.threadpools.each do |name, threadpool|
           threadpool.shutdown
         end
@@ -26,33 +28,49 @@ module ActionSubscriber
 
       def start_subscribers!
         subscriptions.each do |subscription|
-          route = subscription[:route]
-          queue = subscription[:queue]
-          queue.channel.prefetch = route.prefetch if route.acknowledgements?
-          threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
-          consumer = queue.subscribe(route.queue_subscription_options) do |metadata, encoded_payload|
-            ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
-            properties = {
-              :action => route.action,
-              :channel => queue.channel,
-              :content_type => metadata.content_type,
-              :delivery_tag => metadata.delivery_tag,
-              :exchange => metadata.exchange,
-              :headers => _normalized_headers(metadata),
-              :message_id => metadata.message_id,
-              :routing_key => metadata.routing_key,
-              :queue => queue.name,
-              :uses_acknowledgements => route.acknowledgements?,
-            }
-            env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            run_env(env, threadpool)
+          start_subscriber_for_subscription(subscription)
+        end
+      end
+
+    private
+
+      def start_subscriber_for_subscription(subscription)
+        route = subscription[:route]
+        queue = subscription[:queue]
+        queue.channel.prefetch = route.prefetch if route.acknowledgements?
+        threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
+        opts = route.queue_subscription_options
+
+        if ::ActionSubscriber.configuration.resubscribe_on_consumer_cancellation
+          # Add cancellation callback to rebuild subscriber on cancel.
+          opts[:on_cancellation] = lambda do |the_consumer|
+            ::ActionSubscriber.logger.warn "Cancellation received for queue consumer: #{queue.name}, rebuilding subscription..."
+            march_hare_consumers.delete(the_consumer)
+            queue.channel.close
+            safely_restart_subscriber(subscription)
           end
+        end
 
-          march_hare_consumers << consumer
+        consumer = queue.subscribe(opts) do |metadata, encoded_payload|
+          ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+          properties = {
+            :action => route.action,
+            :channel => queue.channel,
+            :content_type => metadata.content_type,
+            :delivery_tag => metadata.delivery_tag,
+            :exchange => metadata.exchange,
+            :headers => _normalized_headers(metadata),
+            :message_id => metadata.message_id,
+            :routing_key => metadata.routing_key,
+            :queue => queue.name,
+            :uses_acknowledgements => route.acknowledgements?,
+          }
+          env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
+          run_env(env, threadpool)
         end
-      end
 
-      private
+        march_hare_consumers << consumer
+      end
 
       def setup_queue(route)
         channel = ::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.create_channel }

data/lib/action_subscriber/rabbit_connection.rb

@@ -30,9 +30,22 @@ module ActionSubscriber
           ::MarchHare::ThreadPools.fixed_of_size(options[:threadpool_size])
         end
         connection = ::MarchHare.connect(options)
+        connection.on_blocked do |reason|
+          on_blocked(reason)
+        end
+        connection.on_unblocked do
+          on_unblocked
+        end
+        connection
       else
         connection = ::Bunny.new(options)
         connection.start
+        connection.on_blocked do |blocked_message|
+          on_blocked(blocked_message.reason)
+        end
+        connection.on_unblocked do
+          on_unblocked
+        end
         connection
       end
     end
@@ -59,5 +72,15 @@ module ActionSubscriber
       }
     end
     private_class_method :connection_options
+
+    def self.on_blocked(reason)
+      ::ActiveSupport::Notifications.instrument("connection_blocked.action_subscriber", :reason => reason)
+    end
+    private_class_method :on_blocked
+
+    def self.on_unblocked
+      ::ActiveSupport::Notifications.instrument("connection_unblocked.action_subscriber")
+    end
+    private_class_method :on_unblocked
   end
 end

data/lib/action_subscriber/subscriber.rb

@@ -0,0 +1,18 @@
+module ActionSubscriber
+  module Subscriber
+    # resubscribes to queue, continuously retrying to subscribe in the event of a potentially recoverable error while
+    # also calling the error handler to surface that a subscription failure happened
+    def safely_restart_subscriber(subscription)
+      subscription[:queue] = setup_queue(subscription[:route])
+      start_subscriber_for_subscription(subscription)
+    rescue StandardError => e
+      ::ActionSubscriber.configuration.error_handler.call(e)
+      raise e unless e.message =~ /queue .* process is stopped by supervisor/
+
+      nap_time = rand(2.0..5.0)
+      ::ActionSubscriber.logger.error("Failed to resubscribe to #{subscription[:queue].name}, retrying again in #{nap_time} seconds...")
+      sleep(nap_time)
+      retry
+    end
+  end
+end

data/lib/action_subscriber/version.rb

@@ -1,3 +1,3 @@
 module ActionSubscriber
-  VERSION = "5.1.5"
+  VERSION = "5.2.3"
 end

data/lib/action_subscriber.rb

@@ -21,6 +21,7 @@ require "action_subscriber/message_retry"
 require "action_subscriber/middleware"
 require "action_subscriber/rabbit_connection"
 require "action_subscriber/subscribable"
+require "action_subscriber/subscriber"
 require "action_subscriber/thread_pools"
 require "action_subscriber/bunny/subscriber"
 require "action_subscriber/march_hare/subscriber"

data/spec/integration/automatic_reconnect_spec.rb

@@ -7,36 +7,36 @@ class GusSubscriber < ActionSubscriber::Base
 end
 
 describe "Automatically reconnect on connection failure", :integration => true, :slow => true do
- let(:draw_routes) do
-   ::ActionSubscriber.draw_routes do
-     default_routes_for GusSubscriber
-   end
- end
- let(:http_client) { RabbitMQ::HTTP::Client.new("http://127.0.0.1:15672") }
- let(:subscriber) { GusSubscriber }
+  let(:draw_routes) do
+    ::ActionSubscriber.draw_routes do
+      default_routes_for GusSubscriber
+    end
+  end
+  let(:http_client) { RabbitMQ::HTTP::Client.new("http://127.0.0.1:15672") }
+  let(:subscriber) { GusSubscriber }
 
- it "reconnects when a connection drops" do
-   ::ActionSubscriber::start_subscribers!
-   ::ActivePublisher.publish("gus.spoke", "First", "events")
-   verify_expectation_within(5.0) do
-     expect($messages).to eq(Set.new(["First"]))
-   end
+  it "reconnects when a connection drops" do
+    ::ActionSubscriber::start_subscribers!
+    ::ActivePublisher.publish("gus.spoke", "First", "events")
+    verify_expectation_within(5.0) do
+      expect($messages).to eq(Set.new(["First"]))
+    end
 
-   close_all_connections!
-   sleep 5.0
-   verify_expectation_within(5.0) do
-     expect(::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.open?}).to eq(true)
-   end
+    close_all_connections!
+    sleep 5.0
+    verify_expectation_within(5.0) do
+      expect(::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.open?}).to eq(true)
+    end
 
-   ::ActivePublisher.publish("gus.spoke", "Second", "events")
-   verify_expectation_within(5.0) do
-     expect($messages).to eq(Set.new(["First", "Second"]))
-   end
- end
+    ::ActivePublisher.publish("gus.spoke", "Second", "events")
+    verify_expectation_within(5.0) do
+      expect($messages).to eq(Set.new(["First", "Second"]))
+    end
+  end
 
- def close_all_connections!
-   http_client.list_connections.each do |conn_info|
-     http_client.close_connection(conn_info.name)
-   end
- end
+  def close_all_connections!
+    http_client.list_connections.each do |conn_info|
+      http_client.close_connection(conn_info.name)
+    end
+  end
 end

data/spec/integration/consumer_cancellation_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+require "rabbitmq/http/client"
+
+class YoloSubscriber < ActionSubscriber::Base
+  def created
+    $messages << payload
+  end
+end
+
+describe "Automatically handles consumer cancellation", :integration => true, :slow => true do
+  let(:draw_routes) do
+    ::ActionSubscriber.draw_routes do
+      default_routes_for ::YoloSubscriber
+    end
+  end
+  let(:http_client) { ::RabbitMQ::HTTP::Client.new("http://127.0.0.1:15672") }
+  let(:subscriber) { ::YoloSubscriber }
+
+  it "resubscribes on cancellation" do
+    ::ActionSubscriber::start_subscribers!
+    ::ActivePublisher.publish("yolo.created", "First", "events")
+    verify_expectation_within(5.0) do
+      expect($messages).to eq(::Set.new(["First"]))
+    end
+
+    consumers = rabbit_consumers.dup
+
+    # Signal a cancellation event to all subscribers.
+    delete_all_queues!
+
+    # Give consumers a chance to restart.
+    sleep 2.0
+
+    expect(rabbit_consumers).to_not eq(consumers)
+
+    ::ActivePublisher.publish("yolo.created", "Second", "events")
+    verify_expectation_within(5.0) do
+      expect($messages).to eq(Set.new(["First", "Second"]))
+    end
+  end
+
+  context "when resubscribe on consumer cancellation is disabled" do
+    before do
+      allow(::ActionSubscriber.configuration).to receive(:resubscribe_on_consumer_cancellation).and_return(false)
+    end
+
+    it "does not resubscribe on cancellation" do
+      ::ActionSubscriber::start_subscribers!
+      ::ActivePublisher.publish("yolo.created", "First", "events")
+      verify_expectation_within(5.0) do
+        expect($messages).to eq(::Set.new(["First"]))
+      end
+
+      consumers = rabbit_consumers.dup
+
+      # Signal a cancellation event to all subscribers.
+      delete_all_queues!
+
+      # Give consumers a chance to restart.
+      sleep 2.0
+
+      # Verify the consumers did not change.
+      expect(rabbit_consumers).to eq(consumers)
+
+      ::ActivePublisher.publish("yolo.created", "Second", "events")
+
+      # Force sleep 2 seconds to ensure a resubscribe did not happen and messages were not processed.
+      sleep 2.0
+      expect($messages).to eq(Set.new(["First"]))
+    end
+  end
+
+  describe "resubscription logic" do
+    let(:subscription) { subject.send(:subscriptions).first }
+    subject { ::ActionSubscriber.send(:route_set) }
+
+    it "sets up consumers" do
+      if ::RUBY_PLATFORM == "java"
+        expect { subject.safely_restart_subscriber(subscription) }.to change { subject.march_hare_consumers.count }.from(0).to(1)
+      else
+        expect { subject.safely_restart_subscriber(subscription) }.to change { subject.bunny_consumers.count }.from(0).to(1)
+      end
+    end
+
+    context "when error is raised during resubscription process" do
+      context "and error is one that can be retried" do
+        let(:error) { ::RuntimeError.new("queue 're.created' in vhost '/' process is stopped by supervisor") }
+
+        it "retries resubscription process" do
+          expect(subject).to receive(:setup_queue).and_raise(error).ordered
+          expect(subject).to receive(:setup_queue).and_raise(error).ordered
+          expect(subject).to receive(:setup_queue).and_call_original.ordered
+          expect(::ActionSubscriber.config.error_handler).to receive(:call).with(error).twice
+          expect(::ActionSubscriber.logger).to receive(:error).twice
+          expect(subject).to receive(:sleep).twice # mostly to skip the delay
+          subject.safely_restart_subscriber(subscription)
+        end
+      end
+
+      context "and error is one that can't be retried" do
+        let(:error) { ::RuntimeError.new("kaBOOM") }
+
+        it "calls error handler and raises" do
+          expect(subject).to receive(:setup_queue).and_raise(error).ordered
+          expect(::ActionSubscriber.config.error_handler).to receive(:call).with(error).once
+          expect(subject).to_not receive(:sleep)
+          expect { subject.safely_restart_subscriber(subscription) }.to raise_error(error)
+        end
+      end
+    end
+  end
+
+  def rabbit_consumers
+    route_set = ::ActionSubscriber.send(:route_set)
+    route_set.try(:bunny_consumers) || route_set.try(:march_hare_consumers)
+  end
+
+  def delete_all_queues!
+    http_client.list_queues.each do |queue|
+      http_client.delete_queue(queue.vhost, queue.name)
+    end
+  end
+end

data/spec/lib/action_subscriber/configuration_spec.rb

@@ -24,6 +24,13 @@ describe ::ActionSubscriber::Configuration do
         ::ActionSubscriber::Configuration.configure_from_yaml_and_cli({}, true)
       end
     end
+
+    it "can override a true value with a false value" do
+      expect(::ActionSubscriber.configuration.verify_peer).to eq(true)
+      expect(::ActionSubscriber.configuration).to receive(:verify_peer=).with(false).and_call_original
+      ::ActionSubscriber::Configuration.configure_from_yaml_and_cli({"verify_peer" => false}, true)
+      expect(::ActionSubscriber.configuration.verify_peer).to eq(false)
+    end
   end
 
   describe "add_decoder" do

data/spec/lib/action_subscriber/rabbit_connection_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe ::ActionSubscriber::RabbitConnection do
+  let(:reason) { "low on disk" }
+
+  before { ActionSubscriber.draw_routes {} }
+
+  context "on_block" do
+    if ::RUBY_PLATFORM == "java"
+      def trigger_mocked_blocking_event(connection, reason)
+        amqp_message = ::Java::ComRabbitmqClient::AMQP::Connection::Blocked::Builder.new.
+          reason(reason).build
+        amq_command = ::Java::ComRabbitmqClientImpl::AMQCommand.new(amqp_message)
+
+        connection.send(:processControlCommand, amq_command)
+      end
+    else
+      def trigger_mocked_blocking_event(connection, reason)
+        connection.send(:handle_frame, 0, ::AMQ::Protocol::Connection::Blocked.new(reason))
+      end
+    end
+
+    it "can deliver an on_blocked message" do
+      expect(::ActiveSupport::Notifications).to receive(:instrument).
+        with("connection_blocked.action_subscriber", :reason => reason)
+
+      described_class.with_connection do |connection|
+        # NOTE: Trigger the receiving of a blocked message from the broker.
+        # It's a bit of a hack but it is a more realistic test without changing
+        # memory alarms.
+        trigger_mocked_blocking_event(connection, reason)
+      end
+    end
+  end
+
+  context "on_unblocked" do
+    if ::RUBY_PLATFORM == "java"
+      def trigger_mocked_unblocked_event(connection, reason)
+        amqp_message = ::Java::ComRabbitmqClient::AMQP::Connection::Unblocked::Builder.new.
+          build
+        amq_command = ::Java::ComRabbitmqClientImpl::AMQCommand.new(amqp_message)
+
+        connection.send(:processControlCommand, amq_command)
+      end
+    else
+      def trigger_mocked_unblocked_event(connection, reason)
+        connection.send(:handle_frame, 0, ::AMQ::Protocol::Connection::Unblocked.new)
+      end
+    end
+
+    it "can deliver an on_unblocked message" do
+      expect(::ActiveSupport::Notifications).to receive(:instrument).
+        with("connection_unblocked.action_subscriber")
+
+      described_class.with_connection do |connection|
+        # NOTE: Trigger the receiving of an unblocked message from the broker.
+        # It's a bit of a hack but it is a more realistic test without changing
+        # memory alarms.
+        trigger_mocked_unblocked_event(connection, reason)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,14 @@
 require 'rubygems'
 require 'bundler'
 
+unless ENV["NO_COV"]
+  require "simplecov"
+  ::SimpleCov.start do
+    enable_coverage :branch
+    add_filter "spec"
+  end
+end
+
 ENV['APP_NAME'] = 'Alice'
 
 Bundler.require(:default, :development, :test)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: action_subscriber
 version: !ruby/object:Gem::Version
-  version: 5.1.5
+  version: 5.2.3
 platform: java
 authors:
 - Brian Stien
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-10 00:00:00.000000000 Z
+date: 2021-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -126,20 +126,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  name: pry-coolline
-  prerelease: false
-  type: :development
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -196,6 +182,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: simplecov
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ActionSubscriber is a DSL that allows a rails app to consume messages
   from a RabbitMQ broker.
 email:
@@ -249,6 +249,7 @@ files:
 - lib/action_subscriber/router.rb
 - lib/action_subscriber/rspec.rb
 - lib/action_subscriber/subscribable.rb
+- lib/action_subscriber/subscriber.rb
 - lib/action_subscriber/thread_pools.rb
 - lib/action_subscriber/uri.rb
 - lib/action_subscriber/version.rb
@@ -258,6 +259,7 @@ files:
 - spec/integration/at_most_once_spec.rb
 - spec/integration/automatic_reconnect_spec.rb
 - spec/integration/basic_subscriber_spec.rb
+- spec/integration/consumer_cancellation_spec.rb
 - spec/integration/custom_actions_spec.rb
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
@@ -272,6 +274,7 @@ files:
 - spec/lib/action_subscriber/middleware/error_handler_spec.rb
 - spec/lib/action_subscriber/middleware/router_spec.rb
 - spec/lib/action_subscriber/middleware/runner_spec.rb
+- spec/lib/action_subscriber/rabbit_connection_spec.rb
 - spec/lib/action_subscriber/router_spec.rb
 - spec/lib/action_subscriber/subscribable_spec.rb
 - spec/spec_helper.rb
@@ -296,7 +299,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.28
 signing_key:
 specification_version: 4
 summary: ActionSubscriber is a DSL that allows a rails app to consume messages from
@@ -307,6 +310,7 @@ test_files:
 - spec/integration/at_most_once_spec.rb
 - spec/integration/automatic_reconnect_spec.rb
 - spec/integration/basic_subscriber_spec.rb
+- spec/integration/consumer_cancellation_spec.rb
 - spec/integration/custom_actions_spec.rb
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
@@ -321,6 +325,7 @@ test_files:
 - spec/lib/action_subscriber/middleware/error_handler_spec.rb
 - spec/lib/action_subscriber/middleware/router_spec.rb
 - spec/lib/action_subscriber/middleware/runner_spec.rb
+- spec/lib/action_subscriber/rabbit_connection_spec.rb
 - spec/lib/action_subscriber/router_spec.rb
 - spec/lib/action_subscriber/subscribable_spec.rb
 - spec/spec_helper.rb