sidekiq-transaction_guard 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f1c8f731c16ff8a3da91b3073be50dd1544a1b17a82521b60637baaa4643421
-  data.tar.gz: 711cd9daff96b69e24d54a8e21803bcf85bf64e60ab813ba168d943e7092f236
+  metadata.gz: 118711493ed2b0a682e2245f00fe8f204aa3e3212d51187c8482d2c526898087
+  data.tar.gz: 23efcba40a7c8f96e95045e489387ab6199ef0fc951d4b9f10b4894bf89c166c
 SHA512:
-  metadata.gz: ff23694280b688a5d0cdf7274408aa3640385dd4269814fb54421848c339f101b7dc865c7013dde0ff83ce6a9031810082155f3bfed727eaf9643a5b7cffdaa0
-  data.tar.gz: 36ad8e565e052c16e309fffa3f6e2b6fa715c8c694546b74b63d4aeee7f04224b68ebd193421a1f1f550fc8d02c8332507f0acf9583e1f074247d24eea60b3c4
+  metadata.gz: 7c3b67986b8662c2ce6ba291a2ca927e2727fe6a942a4a77fac5291d2f52374d01d8007e1902e6c69c9b93487f2ac0bde71f4455a4b76d80c0b061e0cc140efe
+  data.tar.gz: 62dc769e7881266b57219f6c686adcd2db301c16ec66035913e874428ed2293686c073806e4c8dc6d8ec885420ea4be02056dae3f225c5e3ffc68b2d5f13bbba

data/AGENTS.md

@@ -0,0 +1,13 @@
+## Coding style
+
+Always include the # frozen_string_literal: true magic comment at the top of each ruby file.
+
+Use `class << self` syntax for defining class methods. instead of `def self.method_name`.
+
+All public methods should have YARD documentation. Include an empty comment line between the method description and the first YARD tag.
+
+This project uses the standardrb style guide. Run `bundle exec standardrb --fix` to automatically fix style issues.
+
+## Testing
+
+Run the test suite with `bundle exec rspec`.

data/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.1.0
+
+### Added
+
+- `Sidekiq::TransactionGuard.testing` now automatically sets the allowed transaction level when the block begins. This provides better support transactional fixtures in test environments.
+- Added `Sidekiq::TransactionGuard.disable` method to allow temporarily disabling the transaction guard within a block. This is useful in test environments when you want to setup data for your tests without worrying about transaction levels.
+- Added `count` parameter to `set_allowed_transaction_level` to allow setting the allowed transaction level explicitly. This is useful for test setups where the transaction level cannot be determined automatically, such as when using ActiveRecord transactional fixtures.
+- Added Railtie for automatic integration with Rails applications.
+- Added helpers for easier testing setup with RSpec.
+- Added `Sidekiq::TransactionGuard::Middleware.init` method to simplify middleware initialization.
+- Added minitest helper module for easier integration with Minitest test suites.
+
+### Removed
+
+- Removed support for ActiveRecord versions prior to 6.0.
+- Removed support for Sidekiq versions prior to 6.0.
+
 ## 1.0.3
 
 ### Changed

data/README.md

@@ -1,7 +1,6 @@
 # Sidekiq Transaction Guard
 
 [![Continuous Integration](https://github.com/bdurand/sidekiq-transaction_guard/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/sidekiq-transaction_guard/actions/workflows/continuous_integration.yml)
-[![Regression Test](https://github.com/bdurand/sidekiq-transaction_guard/actions/workflows/regression_test.yml/badge.svg)](https://github.com/bdurand/sidekiq-transaction_guard/actions/workflows/regression_test.yml)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 [![Gem Version](https://badge.fury.io/rb/sidekiq-transaction_guard.svg)](https://badge.fury.io/rb/sidekiq-transaction_guard)
 
@@ -31,11 +30,11 @@ class PostCreatedWorker
 end
 ```
 
-In this case, the `PostCreatedWorker` job will be created for a new `Post` record in Sidekiq before the data is actually written to the database. If Sidekiq picks up that worker and tries to execute it before the transaction is committed, `Post.find_by(id: post_id)` won't find anything and the worker will exit without performing it's task. Even if the worker doesn't need to read from the database, there is still a chance for an error to rollback the transaction leaving a possibility of workers running that should not have been scheduled.
+In this case, the `PostCreatedWorker` job will be created for a new `Post` record in Sidekiq before the data is actually written to the database. If Sidekiq picks up that worker and tries to execute it before the transaction is committed, `Post.find_by(id: post_id)` won't find anything and the worker will exit without performing its task. Even if the worker doesn't need to read from the database, there is still a chance for an error to rollback the transaction leaving a possibility of workers running that should not have been scheduled.
 
 To solve this, workers like this should be invoked in ActiveRecord from an `after_commit` callback. These callbacks are guaranteed to only execute after the data has been written to the database. However, as your application grows and gets more complicated, it can be difficult to ensure that workers are not being scheduled in the middle of transactions.
 
-Switching from callbacks to service objects won't help you either, because service objects can be wrapped in transactions as well. The will just give you a new problem to solve.
+Switching from callbacks to service objects won't help you either, because service objects can be wrapped in transactions as well. They will just give you a new problem to solve.
 
 ```ruby
 class CreatePost
@@ -44,35 +43,39 @@ class CreatePost
   end
 
   def call
-    post = Post.create!(attributes)
+    post = Post.create!(@attributes)
     PostCreatedWorker.perform_async(post.id)
   end
 end
 
 # Still calling `perform_async` inside a transaction.
 Post.transaction do
-  CreatePost.new(post_1_attributes)
-  CreatePost.new(post_2_attributes)
+  CreatePost.new(post_1_attributes).call
+  CreatePost.new(post_2_attributes).call
 end
 ```
 
 ## The Solution
 
-You can use this gem to add Sidekiq client middleware that will either warn you or raise an error when workers are scheduled inside of a database transaction. You can do this by simply adding this to your application's initialization code:
+You can use this gem to add Sidekiq client middleware that will either warn you or raise an error when workers are scheduled inside of a database transaction.
+
+### Rails Applications
+
+If you're using Rails, the middleware is automatically added via a Railtie. The default mode will be `:error` in development and test environments, and `:warn` in production. You don't need any additional configuration, though you can customize the mode as described below.
+
+### Non-Rails Applications
+
+For non-Rails applications, you need to manually add the middleware in your application's initialization code:
 
 ```ruby
 require 'sidekiq/transaction_guard'
 
-Sidekiq.configure_client do |config|
-  config.client_middleware do |chain|
-    chain.add(Sidekiq::TransactionGuard::Middleware)
-  end
-end
+Sidekiq::TransactionGuard::Middleware.init
 ```
 
 ### Mode
 
-By default, the behavior is to log that a worker is being scheduled inside of a transaction to the `Sidekiq.logger`. If you are running a test suite, you may want to expose the problematic calls by either raising errors or logging the calls to standard error. The mode can be one of `[:warn, :stderr, :error, :disabled]`.
+You can set the mode at any time. The mode can be one of `[:warn, :stderr, :error, :disabled]`.
 
 ```ruby
 # Raise errors
@@ -88,7 +91,13 @@ Sidekiq::TransactionGuard.mode = :warn
 Sidekiq::TransactionGuard.mode = :disabled
 ```
 
-You can also set the mode on individual worker classes with `sidekiq_options transaction_guard: mode`.
+You can set the mode when initializing the middleware:
+
+```ruby
+Sidekiq::TransactionGuard::Middleware.init(mode: :error)
+```
+
+You can also set the mode on individual worker classes with `sidekiq_options transaction_guard: mode`. The worker-specific mode will override the global mode.
 
 ```ruby
 class SomeWorker
@@ -98,23 +107,26 @@ class SomeWorker
 end
 ```
 
-
-You can use the `:disabled` mode to allow individual worker classes to be scheduled inside of transactions where the worker logic doesn't care about the state of the database. For instance, if you use a Sidekiq worker to report errors, you would want to all it inside of transactions. If you don't control the worker you want to change the mode on, you simply call this in an initializer:
+You can use the `:disabled` mode to allow individual worker classes to be scheduled inside of transactions where the worker logic doesn't care about the state of the database. For instance, if you use a Sidekiq worker to report errors, you would want to allow it inside of transactions. If you don't control the worker you want to change the mode on, you can simply call this in an initializer:
 
 ```ruby
 SomeWorker.sidekiq_options.merge(transaction_guard: :disabled)
 ```
 
-You could
+#### Default Modes
+
+**Rails applications**: The default mode is `:error` in development and test environments, and `:warn` in production or other environments.
+
+**Non-Rails applications**: The default mode is `:stderr` if `ENV["RAILS_ENV"]` or `ENV["RACK_ENV"]` is set to `"test"`, otherwise `:warn`.
 
 ### Notification Handlers
 
-You can also set a block to be called if a worker is scheduled inside of a transaction. This can be useful if you use an error logging service to notify you of problematic calls in production so you can fix them.
+You can also set a block to be called if a worker is scheduled inside of a transaction. This can be useful if you use an error logging service to notify you of problematic calls in production so you can fix them. Note that notification handlers are only called when the mode is `:warn` or `:stderr` (not when mode is `:error` or `:disabled`).
 
 ```ruby
 # Define a global notify handler
 Sidekiq::TransactionGuard.notify do |job|
-  # Do what ever you need to. The job argument will be a Sidekiq job hash.
+  # Do whatever you need to. The job argument will be a Sidekiq job hash.
 end
 
 # Define on a per worker level
@@ -138,7 +150,7 @@ Out of the box, this gem only deals with one database and monitors the connectio
 
 ```ruby
 class MyClass < ActiveRecord::Base
-  # This estabilishes a new connection pool.
+  # This establishes a new connection pool.
   establish_connection(configurations["otherdb"])
 end
 
@@ -147,9 +159,35 @@ Sidekiq::TransactionGuard.add_connection_class(MyClass)
 
 The class is used to get to the connection pool used for the class. You only need to add one class per connection pool, so you don't need to add any subclasses of `MyClass`.
 
-## Transaction Fixtures In Tests
+## Transactional Fixtures In Tests
+
+If you're using transaction fixtures in your tests, there will always be a database transaction open.
+
+### Rails Transactional Fixtures
+
+When using Rails transactional fixtures, you'll need to wrap each test in a `Sidekiq::TransactionGuard.testing` block and set the number of transaction levels to ignore.
+
+### RSpec Support
 
-If you're using transaction fixtures in your tests, there will always be a database transaction open. If you're using [DatabaseCleaner](https://github.com/DatabaseCleaner/database_cleaner) in your tests, you just need to include this snippet in your test suite initializer:
+If you're using RSpec, you can use the built-in RSpec helper to automatically set up the hooks to deal with transactional fixtures. Add this line to your `spec_helper.rb` or `rails_helper.rb` file:
+
+```ruby
+require 'sidekiq/transaction_guard/rspec'
+```
+
+This will also add support for adding a metadata tag to your specs to control the transaction guard mode on a per-spec basis. For example:
+
+```ruby
+RSpec.describe "Some feature", sidekiq_transaction_guard: :disabled do
+  it "does something that schedules workers inside transactions" do
+    # ...
+  end
+end
+```
+
+### DatabaseCleaner Support
+
+If you're using [DatabaseCleaner](https://github.com/DatabaseCleaner/database_cleaner) in your tests, you just need to include this snippet in your test suite initializer:
 
 ```ruby
 require 'sidekiq/transaction_guard/database_cleaner'
@@ -157,4 +195,75 @@ require 'sidekiq/transaction_guard/database_cleaner'
 
 This will add the appropriate code so that the surrounding transaction in the test suite is ignored (i.e. workers will only warn/error if there is more than one open transaction).
 
-If you're using something else for your transactional fixtures or have some other weird setup, look in the `lib/sidekiq_transaction_guard/database_cleaner.rb` file for an example of what you need to do.
+### Minitest Support
+
+If you're using Minitest with `ActiveSupport::TestCase` (Rails default), you can use the built-in Minitest helper to automatically set up the hooks for transactional fixtures. Add this line to your `test_helper.rb` file:
+
+```ruby
+require 'sidekiq/transaction_guard/minitest'
+```
+
+This will automatically wrap each test in the appropriate `testing` block and handle transactional fixtures.
+
+If you're using plain Minitest (without `ActiveSupport::TestCase`), you can manually include the helper module:
+
+```ruby
+class MyTests < Minitest::Test
+  include Sidekiq::TransactionGuard::MinitestHelper
+
+  def test_something
+    # Test code here
+  end
+end
+```
+
+Alternatively, you can manually use the `testing` method with minitest-hooks:
+
+```ruby
+class MyTests < Minitest::Test
+  # Using minitest-hooks gem
+  def around(&block)
+    Sidekiq::TransactionGuard.testing(base_transaction_level: 1) do
+      block.call
+    end
+  end
+end
+```
+
+### Disabling When Setting Up Test Data
+
+If you have test setup code that is triggering the transaction guard with false positives, you can temporarily disable the transaction guard within a block:
+
+```ruby
+Sidekiq::TransactionGuard.disable do
+  # Code that schedules workers inside transactions, such as test setup code.
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "sidekiq-transaction_guard"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install sidekiq-transaction_guard
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-1.0.3
+1.1.0

data/lib/sidekiq/transaction_guard/database_cleaner.rb

@@ -9,15 +9,18 @@ module Sidekiq
       # Override the start method to set the base number of allowed transactions to
       # the current level. Anything above this number will then be considered to be
       # in a transaction.
+      #
+      # @return [Object] the return value from the superclass's start method
       def start
         retval = super
         Sidekiq::TransactionGuard.set_allowed_transaction_level(connection_class)
         retval
       end
 
-      # Wrap the `Sidekiq::TransactionGuard.testing` which sets up the data structures
+      # Wrap the `Sidekiq::TransactionGuard.testing` method which sets up the data structures
       # needed for custom counting of the transaction level within a test block.
       #
+      # @yield the cleaning block to execute
       # @return [Object] the return value of the block
       def cleaning(&block)
         Sidekiq::TransactionGuard.testing { super(&block) }

data/lib/sidekiq/transaction_guard/middleware.rb

@@ -10,9 +10,7 @@ module Sidekiq
     # the default behavior set in `Sidekiq::TransactionGuard.mode` and
     # `Sidekiq::TransactionGuard.notify` respectively.
     class Middleware
-      if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new("7.0")
-        include Sidekiq::ClientMiddleware
-      end
+      include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
 
       def call(worker_class, job, queue, redis_pool)
         # Check if we need to log this. Also, convert worker_class to its actual class
@@ -66,20 +64,23 @@ module Sidekiq
 
       def log_transaction(worker_class, job)
         mode = worker_mode(job)
-        if mode != :disabled
-          message = "#{worker_class.name} was called from inside a database transaction"
-          if mode == :error
-            raise Sidekiq::TransactionGuard::InsideTransactionError.new(message)
-          else
-            logger = Sidekiq.logger unless mode == :stderr
-            if logger
-              logger.warn(message)
-            else
-              $stderr.write("WARNING #{message}\n")
-            end
-            notify!(worker_class, job)
-          end
+        return if mode == :disabled
+
+        message = "#{worker_class.name} was called from inside a database transaction. " \
+          "Resolve by moving the job outside the transaction, using an after_commit callback, " \
+          "or setting `sidekiq_options transaction_guard: :disabled` if the job is safe to run before the transaction commits."
+        if mode == :error
+          raise Sidekiq::TransactionGuard::InsideTransactionError.new(message)
         end
+
+        logger = Sidekiq.logger unless mode == :stderr
+        if logger
+          logger.warn(message)
+        else
+          $stderr.write("WARNING #{message}\n")
+        end
+
+        notify!(worker_class, job)
       end
     end
   end

data/lib/sidekiq/transaction_guard/minitest.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "minitest"
+
+module Sidekiq
+  module TransactionGuard
+    # Minitest helper module for testing with Sidekiq::TransactionGuard.
+    #
+    # Include this module in your test class to automatically wrap tests in the
+    # Sidekiq::TransactionGuard.testing block and handle transactional fixtures.
+    #
+    # @example
+    #   class MyTest < Minitest::Test
+    #     include Sidekiq::TransactionGuard::MinitestHelper
+    #
+    #     def test_something
+    #       # Test code here
+    #     end
+    #   end
+    module MinitestHelper
+      def self.included(base)
+        base.class_eval do
+          # Save the original mode before the test suite runs
+          @@sidekiq_transaction_guard_mode = Sidekiq::TransactionGuard.mode
+          Sidekiq::TransactionGuard.mode = :disabled
+
+          def setup
+            @sidekiq_transaction_guard_saved_mode = Sidekiq::TransactionGuard.mode
+            Sidekiq::TransactionGuard.mode = :error
+            Sidekiq::TransactionGuard.testing do
+              @sidekiq_transaction_guard_testing_block = true
+              super
+            end
+          end
+
+          def teardown
+            super
+            Sidekiq::TransactionGuard.mode = @sidekiq_transaction_guard_saved_mode
+          end
+        end
+      end
+    end
+  end
+end
+
+# If using ActiveSupport::TestCase, automatically include the helper
+if defined?(ActiveSupport::TestCase)
+  ActiveSupport::TestCase.class_eval do
+    def setup
+      @sidekiq_transaction_guard_saved_mode = Sidekiq::TransactionGuard.mode
+      Sidekiq::TransactionGuard.mode = :error
+
+      Sidekiq::TransactionGuard.testing do
+        super
+      end
+    end
+
+    def teardown
+      super
+      Sidekiq::TransactionGuard.mode = @sidekiq_transaction_guard_saved_mode
+    end
+  end
+end

data/lib/sidekiq/transaction_guard/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Sidekiq::TransactionGuard
+  class Railtie < ::Rails::Railtie
+    initializer "sidekiq.transaction_guard" do
+      mode = (Rails.env.development? || Rails.env.test?) ? :error : :warn
+      Sidekiq::TransactionGuard.init(mode: mode)
+    end
+  end
+end

data/lib/sidekiq/transaction_guard/rspec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  global_sidekiq_transaction_guard_mode = nil
+
+  # Disable by default to avoid raising errors in test setup and teardown.
+  config.before(:suite) do
+    global_sidekiq_transaction_guard_mode = Sidekiq::TransactionGuard.mode
+    Sidekiq::TransactionGuard.mode = :disabled
+  end
+
+  config.after(:suite) do
+    Sidekiq::TransactionGuard.mode = global_sidekiq_transaction_guard_mode
+  end
+
+  config.around do |example|
+    mode = example.metadata[:sidekiq_transaction_guard]
+    mode = :disabled if mode == false
+    mode = global_sidekiq_transaction_guard_mode if mode == :default
+    mode = :error unless mode.is_a?(Symbol)
+
+    save_val = Sidekiq::TransactionGuard.mode
+    begin
+      Sidekiq::TransactionGuard.mode = mode
+      Sidekiq::TransactionGuard.testing do
+        example.run
+      end
+    ensure
+      Sidekiq::TransactionGuard.mode = save_val
+    end
+  end
+
+  # Re-snapshot the allowed transaction level after all setup (including
+  # transactional fixtures) has run so that setup transactions are ignored.
+  config.before(:each) do
+    Sidekiq::TransactionGuard.set_allowed_transaction_level(:all)
+  end
+end

data/lib/sidekiq/transaction_guard.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_record"
 require "sidekiq"
 require "set"
 
@@ -18,16 +19,31 @@ module Sidekiq
     class << self
       VALID_MODES = [:warn, :stderr, :error, :disabled].freeze
 
+      # Helper method to add the client middleware to Sidekiq.
+      #
+      # @return [void]
+      def init(mode: nil)
+        self.mode = mode if mode
+
+        Sidekiq.configure_client do |config|
+          config.client_middleware do |chain|
+            unless chain.exists?(Sidekiq::TransactionGuard::Middleware)
+              chain.add Sidekiq::TransactionGuard::Middleware
+            end
+          end
+        end
+      end
+
       # Set the global mode to one of `[:warn, :stderr, :error, :disabled]`. The
       # default mode is `:warn`. This controls the behavior of workers enqueued
       # inside of transactions.
       # * :warn - Log to Sidekiq.logger
       # * :stderr - Log to STDERR
-      # * :error - Throw a `Sidekiq::TransactionGuard::InsideTransactionError`
+      # * :error - Raise a `Sidekiq::TransactionGuard::InsideTransactionError`
       # * :disabled - Allow workers inside of transactions
       #
-      # @param mode [Symbol]
-      # @return [void]
+      # @param symbol [Symbol] one of `:warn`, `:stderr`, `:error`, or `:disabled`
+      # @return [Symbol] the mode that was set
       def mode=(symbol)
         if VALID_MODES.include?(symbol)
           @mode = symbol
@@ -45,6 +61,7 @@ module Sidekiq
       # job hash for all jobs enqueued inside transactions if the mode is `:warn`
       # or `:stderr`.
       #
+      # @yield [Hash] the Sidekiq job hash
       # @return [void]
       def notify(&block)
         @notify = block
@@ -52,30 +69,33 @@ module Sidekiq
 
       # Return the block set as the notify handler with a call to `notify`.
       #
-      # @return [Proc]
+      # @return [Proc, nil] the notify block, or nil if none has been set
       def notify_block
         @notify
       end
 
-      # Add a class that maintains it's own connection pool to the connections
+      # Add a class that maintains its own connection pool to the connections
       # being monitored for open transactions. You don't need to add `ActiveRecord::Base`
       # or subclasses. Only the base class that establishes a new connection pool
       # with a call to `establish_connection` needs to be added.
       #
-      # @param connection_class [Class]
+      # @param connection_class [Class] an ActiveRecord model class with its own connection pool
       # @return [void]
       def add_connection_class(connection_class)
         @lock.synchronize { @connection_classes << connection_class }
       end
 
+      # Return the classes that have been added via `add_connection_class`.
+      #
+      # @return [Array<Class>]
+      def connection_classes
+        ([ActiveRecord::Base] + @lock.synchronize { @connection_classes.to_a }).uniq
+      end
+
       # Return true if any connection is currently inside of a transaction.
       #
       # @return [Boolean]
       def in_transaction?
-        connection_classes = [ActiveRecord::Base]
-        unless @connection_classes.empty?
-          connection_classes.concat(@lock.synchronize { @connection_classes.to_a })
-        end
         connection_classes.any? do |connection_class|
           connection_pool = connection_class.connection_pool
           connection = connection_class.connection if connection_pool.active_connection?
@@ -87,15 +107,34 @@ module Sidekiq
         end
       end
 
+      # Disable the transaction guard within the provided block. This is useful in test environments when you want to
+      # setup data for your tests without worrying about transaction levels.
+      #
+      # @yield the block to execute with the transaction guard disabled
+      # @return [Object] the return value of the block
+      def disable
+        save_mode = mode
+        begin
+          self.mode = :disabled
+          yield
+        ensure
+          self.mode = save_mode
+        end
+      end
+
       # This method call needs to be wrapped around tests that use transactional fixtures.
       # It sets up data structures used to track the number of open transactions.
+      # The current transaction level is automatically captured as the baseline so that
+      # any transactions opened by test setup (e.g. transactional fixtures) are ignored.
       #
+      # @yield the test block to execute
       # @return [Object] the return value of the block
-      def testing(&block)
+      def testing
         var = :sidekiq_rails_transaction_guard
         save_val = Thread.current[var]
         begin
           Thread.current[var] = (save_val ? save_val.dup : {})
+          set_allowed_transaction_level(:all)
           yield
         ensure
           Thread.current[var] = save_val
@@ -104,17 +143,27 @@ module Sidekiq
 
       # This method needs to be called to set the allowed transaction level for a connection
       # class (see `add_connection_class` for more info). The current transaction level
-      # for that class' connection will be set as the zero point. This method can only
+      # for that class's connection will be set as the zero point. This method can only
       # be called inside a block wrapped with the `testing` method.
       #
-      # @param connection_class [Class]
+      # @param connection_classes [Class, Array<Class>, Symbol] the connection class(es) to set the allowed
+      #   transaction level for. If `:all` is provided, set the allowed transaction level
+      #   for all connection classes set via `add_connection_class`.
+      # @param base_transaction_level [Integer] if provided, increment the allowed transaction level
+      #   by this amount. This is used when using transactional fixtures to ignore the transaction
+      #   opened within the test setup.
       # @return [void]
-      def set_allowed_transaction_level(connection_class)
+      def set_allowed_transaction_level(connection_classes, base_transaction_level = 0)
         connection_counts = Thread.current[:sidekiq_rails_transaction_guard]
         unless connection_counts
           raise("set_allowed_transaction_level is only allowed inside a testing block")
         end
-        connection_counts[connection_class.name] = connection_class.connection.open_transactions if connection_counts
+
+        connection_classes = self.connection_classes if connection_classes == :all
+        Array(connection_classes).each do |connection_class|
+          class_count = connection_class.connection.open_transactions + base_transaction_level
+          connection_counts[connection_class.name] = class_count
+        end
       end
 
       private
@@ -127,6 +176,10 @@ module Sidekiq
   end
 end
 
+if defined?(Rails::Railtie)
+  require_relative "transaction_guard/railtie"
+end
+
 # Configure the default transaction guard mode for known testing environments.
 if ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
   Sidekiq::TransactionGuard.mode = :stderr

data/sidekiq-transaction_guard.gemspec

@@ -7,9 +7,16 @@ Gem::Specification.new do |spec|
   spec.email = ["bbdurand@gmail.com", "me@winstondurand.com"]
 
   spec.summary = "Protect from accidentally invoking Sidekiq jobs when there are open database transactions"
+
   spec.homepage = "https://github.com/bdurand/sidekiq-transaction_guard"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w[
@@ -28,10 +35,10 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.2.2"
+  spec.required_ruby_version = ">= 2.7"
 
-  spec.add_dependency "activerecord", ">= 4.0"
-  spec.add_dependency "sidekiq", ">= 3.0"
+  spec.add_dependency "activerecord", ">= 6.0"
+  spec.add_dependency "sidekiq", ">= 6.0"
 
   spec.add_development_dependency "bundler"
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-transaction_guard
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Brian Durand
 - Winston Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - bbdurand@gmail.com
 - me@winstondurand.com
@@ -61,6 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- AGENTS.md
 - CHANGELOG.md
 - MIT_LICENSE.txt
 - README.md
@@ -69,13 +68,18 @@ files:
 - lib/sidekiq/transaction_guard.rb
 - lib/sidekiq/transaction_guard/database_cleaner.rb
 - lib/sidekiq/transaction_guard/middleware.rb
+- lib/sidekiq/transaction_guard/minitest.rb
+- lib/sidekiq/transaction_guard/railtie.rb
+- lib/sidekiq/transaction_guard/rspec.rb
 - lib/sidekiq/transaction_guard/version.rb
 - sidekiq-transaction_guard.gemspec
 homepage: https://github.com/bdurand/sidekiq-transaction_guard
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  homepage_uri: https://github.com/bdurand/sidekiq-transaction_guard
+  source_code_uri: https://github.com/bdurand/sidekiq-transaction_guard
+  changelog_uri: https://github.com/bdurand/sidekiq-transaction_guard/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -83,15 +87,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Protect from accidentally invoking Sidekiq jobs when there are open database
   transactions