action_subscriber 5.1.4-java → 5.2.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5c9565dc4ed32426228f63f4a74e7478ce4dcb74
-  data.tar.gz: eb2893c3584ba9d237328939064299405b94819e
+SHA256:
+  metadata.gz: 69350b95fb8b203e390c3aac19dc9d53af00b2c517bd465b47c415633109b107
+  data.tar.gz: 5d93a16416a0cd14595ae0e0e029988154496575501862b4ecdd7469754004e6
 SHA512:
-  metadata.gz: 2b2c463f546b4fa3a979c0d6c55c4982f8abd7c4c253bcf9263fa62c96662ef5f8abe36483bd239bc4e7bee8314977261804ef5db9b93ac04f6c00d013960f4f
-  data.tar.gz: 3de474dfb99966ace57d9d9797860b627c8d4f85055c46b2f709c4b546843260c82d451fa824e9bb80b7d56243d073bc9fd2d4b8795baca00e0377a1edb1ef57
+  metadata.gz: 95909a21c18bdf27b56646b3431f200918618d30610dbab37d6afa6ca032e78695f603d9c8e3014f278346ce6493ee8e32f75526c3c51e71636d3d8595189b18
+  data.tar.gz: 680505cffe5b8b404b22e22246b104b58ef3e02cea0d0c501e56acb03d7daa3de03167067a9a26fa8147d89a8c12b89aab1b0cc98e3fd03f5bf6f0da21dd474b

data/.travis.yml

@@ -1,10 +1,13 @@
 language: ruby
+os:
+  linux
+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/lib/action_subscriber/bunny/subscriber.rb

@@ -26,35 +26,52 @@ 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 "Cancelation received for queue consumer: #{queue.name}, rebuilding subscription..."
+            bunny_consumers.delete(consumer)
+            channel.close
+            queue = subscription[:queue] = setup_queue(route)
+            start_subscriber_for_subscription(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/dsl.rb

@@ -1,5 +1,38 @@
 module ActionSubscriber
   module DSL
+    class Filter
+      attr_accessor :callback_method
+      attr_accessor :included_actions
+      attr_accessor :excluded_actions
+
+      def initialize(callback_method, options)
+        @callback_method = callback_method
+        @included_actions = @excluded_actions = []
+        parse_options(options)
+      end
+
+      def matches(action)
+        unless included_actions.empty?
+          return included_actions.include?(action)
+        end
+
+        unless excluded_actions.empty?
+          return false if excluded_actions.include?(action)
+        end
+
+        true
+      end
+
+    private
+
+      def parse_options(options)
+        return unless options
+
+        @included_actions  = options.fetch(:if, [])
+        @excluded_actions = options.fetch(:unless, [])
+      end
+    end
+
     def at_least_once!
       @_acknowledge_messages = true
       @_at_least_once = true
@@ -22,11 +55,16 @@ module ActionSubscriber
       !!@_acknowledge_messages
     end
 
-    def around_filter(filter_method)
-      around_filters << filter_method unless around_filters.include?(filter_method)
+    def around_filter(callback_method, options = nil)
+      filter = Filter.new(callback_method, options)
+      conditionally_add_filter!(filter)
       around_filters
     end
 
+    def conditionally_add_filter!(filter)
+      around_filters << filter unless around_filters.any? { |f| f.callback_method == filter.callback_method }
+    end
+
     def around_filters
       @_around_filters ||= []
     end
@@ -95,7 +133,11 @@ module ActionSubscriber
       final_block = Proc.new { subscriber_instance.public_send(action) }
 
       first_proc = around_filters.reverse.reduce(final_block) do |block, filter|
-        Proc.new { subscriber_instance.send(filter, &block) }
+        if filter.matches(action)
+          Proc.new { subscriber_instance.send(filter.callback_method, &block) }
+        else
+          block
+        end
       end
       first_proc.call
     end

data/lib/action_subscriber/march_hare/subscriber.rb

@@ -4,7 +4,8 @@ module ActionSubscriber
       include ::ActionSubscriber::Logging
 
       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 +27,50 @@ 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 "Cancelation received for queue consumer: #{queue.name}, rebuilding subscription..."
+            march_hare_consumers.delete(the_consumer)
+            queue.channel.close
+            queue = subscription[:queue] = setup_queue(route)
+            start_subscriber_for_subscription(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/version.rb

@@ -1,3 +1,3 @@
 module ActionSubscriber
-  VERSION = "5.1.4"
+  VERSION = "5.2.2"
 end

data/spec/integration/around_filters_spec.rb

@@ -33,7 +33,7 @@ describe "subscriber filters", :integration => true do
   let(:subscriber) { InstaSubscriber }
 
   it "does not allow an around filter to be pushed on twice" do
-    expect(InstaSubscriber.around_filters).to eq([:whisper, :yell])
+    expect(InstaSubscriber.around_filters.map(&:callback_method)).to eq([:whisper, :yell])
   end
 
   it "runs multiple around filters" do
@@ -46,3 +46,89 @@ describe "subscriber filters", :integration => true do
     end
   end
 end
+
+class OptionsSubscriber < ActionSubscriber::Base
+  around_filter :whisper, :if => [:primero, :segundo]
+  around_filter :yell, :if => [:primero]
+  around_filter :gossip, :unless => [:private_action]
+  around_filter :everybody
+
+  def primero
+    $messages << payload
+  end
+
+  def private_action
+    $messages << payload
+  end
+
+  def segundo
+    $messages << payload
+  end
+
+  private
+
+  def everybody
+    $messages << :everybody_before
+    yield
+    $messages << :everybody_after
+  end
+
+  def gossip
+    $messages << :gossip_before
+    yield
+    $messages << :gossip_after
+  end
+
+  def whisper
+    $messages << :whisper_before
+    yield
+    $messages << :whisper_after
+  end
+
+  def yell
+    $messages << :yell_before
+    yield
+    $messages << :yell_after
+  end
+end
+
+describe "subscriber filters with conditions", :integration => true do
+  let(:draw_routes) do
+    ::ActionSubscriber.draw_routes do
+      default_routes_for OptionsSubscriber
+    end
+  end
+  let(:subscriber) { OptionsSubscriber }
+
+  context "honors conditions" do
+    it "runs yell" do
+      $messages = []
+      ::ActionSubscriber.start_subscribers!
+      ::ActivePublisher.publish("options.primero", "Howdy!", "events")
+
+      verify_expectation_within(1.0) do
+        expect($messages).to eq [:whisper_before, :yell_before, :gossip_before, :everybody_before, "Howdy!", :everybody_after, :gossip_after, :yell_after, :whisper_after]
+      end
+    end
+
+    it "doesn't yell" do
+      $messages = []
+      ::ActionSubscriber.start_subscribers!
+      ::ActivePublisher.publish("options.segundo", "Howdy!", "events")
+
+      verify_expectation_within(1.0) do
+        expect($messages).to eq [:whisper_before, :gossip_before, :everybody_before, "Howdy!", :everybody_after, :gossip_after, :whisper_after]
+      end
+    end
+
+    it "doesn't gossip" do
+      $messages = []
+      ::ActionSubscriber.start_subscribers!
+      ::ActivePublisher.publish("options.private_action", "Howdy!", "events")
+
+      verify_expectation_within(1.0) do
+        expect($messages).to eq [:everybody_before, "Howdy!", :everybody_after]
+      end
+    end
+  end
+end

data/spec/integration/consumer_cancellation_spec.rb

@@ -0,0 +1,83 @@
+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
+
+ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: action_subscriber
 version: !ruby/object:Gem::Version
-  version: 5.1.4
+  version: 5.2.2
 platform: java
 authors:
 - Brian Stien
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-07 00:00:00.000000000 Z
+date: 2020-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -258,6 +258,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 +273,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
@@ -297,7 +299,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.14.1
+rubygems_version: 2.7.9
 signing_key:
 specification_version: 4
 summary: ActionSubscriber is a DSL that allows a rails app to consume messages from
@@ -308,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
@@ -322,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