rspec-activerecord-expectations 1.3.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92f14ca413e9e716ea9b3046abc13d3929893185cfef8cdeaf14b7bebc93755c
-  data.tar.gz: 93bfa962b7954844560961d66d080fa2c45a3188b8c9b92420d1852e36ce718b
+  metadata.gz: 0f84a252fb5e5923d4bc6c03ed4d99ede76579017d8391dbf6f48a665236e54e
+  data.tar.gz: ce944950ee62940f67f79204966f5954fc28eac8f52dee79e18475933d9f3910
 SHA512:
-  metadata.gz: bb81903bbb00357ab9613a59fb2684bfaad7671fbca955f9876d503f5b179f8ead6d36f248ea24909f30db3ddb6f4fc307c509a181d2fe85d33d1e04006856da
-  data.tar.gz: f813c1e8d6e320f6810cc33620fe702c379f47124b6add4bc1bdabde81c4e12c60a6aac5711caf8c23672f838d6185106ffb3695770a7c4002d04404c87929cb
+  metadata.gz: 4828d15b2420ae821199db596b96cc5d4630e3994b6c12bb2d6b95c32067388bb30161b318b0c03c49771d5b95e3010757e564c70a1f6840ab6934c14479f58d
+  data.tar.gz: d8220ae71a3e1dc6be694f976185262e019d55c6eedc1ec255492fbb5cd7a2988ac45e3519c14f1936cf8d0fd09062710f71b2d788322771e4ccde864be436a9

data/.github/workflows/main.yml

@@ -11,19 +11,19 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
-        ruby_version: ['3.0', '2.7']
+        ruby-version: ['3.1', '3.0', '2.7']
         rails: ['5.0', '5.1', '5.2', '6.0', '6.1', '7.0']
 
     runs-on: ${{ matrix.os }}
-    name: ruby ${{ matrix.ruby_version }}, rails ${{ matrix.rails }}, ${{ matrix.os }}
+    name: ruby ${{ matrix.ruby-version }}, rails ${{ matrix.rails }}, ${{ matrix.os }}
 
     steps:
       - uses: actions/checkout@v2
 
-      - name: Set up Ruby ${{ matrix.ruby_version }}
+      - name: Set up Ruby ${{ matrix.ruby-version }}
         uses: ruby/setup-ruby@v1
         with:
-          ruby_version: ${{ matrix.ruby_version }}
+          ruby-version: ${{ matrix.ruby-version }}
           bundler-cache: true
 
       - name: Install Gems w/ Rails ${{ matrix.rails }}
@@ -40,19 +40,19 @@ jobs:
   test_legacy:
     strategy:
       matrix:
-        ruby_version: ['2.6', '2.5', '2.4', '2.3']
+        ruby-version: ['2.6', '2.5']
         rails: ['5.0', '5.1', '5.2']
 
     runs-on: ubuntu-latest
-    name: legacy ruby ${{ matrix.ruby_version }}, rails ${{ matrix.rails }}
+    name: ruby ${{ matrix.ruby-version }}, rails ${{ matrix.rails }}
 
     steps:
       - uses: actions/checkout@v2
 
-      - name: Set up Ruby ${{ matrix.ruby_version }}
+      - name: Set up Ruby ${{ matrix.ruby-version }}
         uses: ruby/setup-ruby@v1
         with:
-          ruby_version: ${{ matrix.ruby_version }}
+          ruby-version: ${{ matrix.ruby-version }}
           bundler-cache: true
 
       - name: Install Gems w/ Rails ${{ matrix.rails }}
@@ -65,3 +65,33 @@ jobs:
 
       - name: Run tests
         run: bundle exec rspec
+
+  test_alt_rubies:
+    strategy:
+      matrix:
+        ruby-version: ['jruby', 'truffleruby']
+        rails: ['6.0', '6.1'] # jruby / jdbc-sqlite3 end up tightly bound to rails 6.x
+
+    runs-on: ubuntu-latest
+    name: ${{ matrix.ruby-version }}, rails ${{ matrix.rails }}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Install Gems w/ Rails ${{ matrix.rails }}
+        env:
+          MATRIX_RAILS_VERSION: ${{ matrix.rails }}
+        run: |
+          export BUNDLE_GEMFILE="${GITHUB_WORKSPACE}/gemfiles/rails_${MATRIX_RAILS_VERSION}.gemfile"
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+
+      - name: Run tests
+        run: bundle exec rspec
+ 

data/CHANGELOG.md

@@ -1,25 +1,48 @@
 # Changelog
 
-## [1.3.0] - 2020-12-31
+## [2.3.0] - 2022-01-29
+- Add quantifiers to transaction matchers
+- Add much more complicated English output for readable matchers
+- Update README for the same
+
+## [2.2.0] - 2022-01-14
+- Adds transaction matcher to verify that code was executed within a
+  transaction at minimum
+- Transaction matcher also allows for commits and rollbacks
+- Update README for accompanying functionality
+
+## [2.1.1] - 2022-01-12
+- Gemspec is really generated using the version of ruby that's locally in use.
+  Update that build artifact to use non-java dependencies.
+
+## [2.1.0] - 2022-01-12
+- Change CI matrix for more version compatibility
+- Update gemspec to move some deps into development only
+- README changes
+
+## [2.0.0] - 2022-01-07
+- Require much more recent ruby, to use syntax that's been around since 2017
+
+## [1.3.0] - 2021-12-31
 - Add `repeatedly_load` matcher
 - Add query type matchers for `load_queries`, `schema_queries`, `transaction_queries`, `destroy_queries`
 - Allow singular version of all query types (e.g. `transaction_queries` vs `transaction_query`)
 - Fix failure message for `execute.exactly` matcher
 
-## [1.2.0] - 2020-12-31
+## [1.2.0] - 2021-12-31
 - Add `query` as a synonym for `queries`
 - Ignore schema and transaction queries in query count
 - Add beginning of recording specific query types
 - Add query count matcher for `exactly`
 
-## [1.1.0] - 2020-12-30
+## [1.1.0] - 2021-12-30
 - Add query count matchers for e.g. `less_than_or_equal_to`, `greater_than`
 
-## [1.0.1] - 2020-12-30
+## [1.0.1] - 2021-12-30
 - Pin all the dependencies to a proper working subset
 - Expand testing to many rails / ruby combinations
 
-## [1.0.0] - 2020-12-30
+## [1.0.0] - 2021-12-30
 - Basic gem w/ all the fixins and README and such
 - Add `less_than` comparison, and `queries` type
 - Basic tests in place, and not bad tbh

data/README.md

@@ -30,7 +30,8 @@ group 'test' do
 end
 ```
 
-Then, include the functionality within your spec helper (or in a support file).
+Then, include the functionality within your `rails_helper.rb` (or in a support
+file).
 
 ```ruby
 RSpec.configure do |config|
@@ -109,18 +110,34 @@ This matcher will track ActiveRecord's built in load methods to prevent those
 N+1 situations. Using eager loading (e.g. `Track.all.includes(:album)`) will
 allow these expectations to pass as expected!
 
-**Note:** At the moment, this expectation will fail if you use a mechanism
-that loads records in batches, such as with `find_in_batches`. This will cause
-records to be "repeatedly loaded", but this is actually expected behavior in
-this case. If your tests load a relatively small number of records (which is
-probable), your tests won't fail. But it is possible.
+### Testing Batch Queries
+
+If your code loads records in batches, it may be more difficult to create
+expectations for repeated loading. After all, each batch will execute its own
+queries, which may look like repeated loading.
+
+If your test has a small enough number of records that only one batch is
+loaded, your tests may work just fine. But otherwise, you may want to allow
+your code to specify a batch size in order to guarantee only a single batch
+is loaded.
+
+```ruby
+tracks = Track.all
+
+expect {
+  TrackSerializer.perform(tracks, batch_size: tracks.count)
+}.not_to repeatedly_load('Track')
+```
 
 ## Counting Queries
 
-### Types of Comparisons
+Some services won't necessarily have N+1 issues with records loading, but might
+still have problems with executing too many queries. In this case, the
+`repeatedly_load` matcher might be insufficient.
 
-Several comparison types are available, along with some aliases to allow for
-easier to read tests.
+In this case, consider creating an expectation on the total number of queries
+executed by your code. Several comparison types are available, along with some
+aliases to allow for easier to read tests.
 
 ```ruby
 expect {}.to execute.less_than(20).queries
@@ -143,15 +160,10 @@ expect {}.to execute.at_least(1).query # singular form also accepted
 
 ### Specific Query Types
 
-You can of course make assertions for the total number of queries executed, but
-sometimes it's more valuable to assert particular _types_ of queries, such as
-inserts or find statements. Matchers are supported for this as well!
-
-**Note:** Transaction (for example, `ROLLBACK`) queries are not counted in any of these
-categories, nor are queries that load the DB schema.
-
-**Note:** Destroy and delete queries are both condensed into the matcher for
-`destroy_queries`.
+You can make assertions for the total number of queries executed, but sometimes
+it's more valuable to assert that a particular _type_ of query was executed.
+For example, a particular number of queries to destroy records. There are
+matchers available for that purpose as well!
 
 ```ruby
 expect {}.to execute.exactly(20).queries
@@ -165,6 +177,74 @@ expect {}.to execute.exactly(20).schema_queries
 expect {}.to execute.exactly(20).transaction_queries
 ```
 
+**Note:** Transaction (for example, `ROLLBACK`) queries are not counted in any of these
+categories, nor are queries that load the DB schema.
+
+**Note:** Destroy and delete queries are both condensed into the matcher for
+the errorthe error  `destroy_queries`.
+
+## Transaction Management
+
+Sometimes, it makes sense to monitor whether database transactions were
+successful or not. This is very similar to using `expect{}.to change(SomeModel,
+:count)` in a spec, but nonetheless it can be useful to assert transactions
+themselves. Some assertions are available for this purpose.
+
+```ruby
+expect {}.to execute_a_transaction
+expect {}.to rollback_a_transaction
+expect {}.to roll_back_a_transaction
+expect {}.to commit_a_transaction
+```
+
+A complication to this scheme is that Rails tries not to make unnecessary database
+calls, which means that attempting to save a model that has failing validations
+won't actually attempt to save to the database.
+
+```ruby
+expect {
+  MyClass.create!(required_field: nil)
+}.to rollback_a_transaction
+```
+
+This assertion will fail, as `create!` will never make it as far as the
+database.  That said, if you manually create a transaction, _and you select
+data within that transaction_, you may assert a rollback.
+
+```ruby
+expect {
+  MyClass.first # triggers the transaction
+  MyClass.create!(required_field: nil)
+}.to rollback_a_transaction
+```
+
+It you need to make transaction-related assertions of this sort, your best bet
+may be to assert that a commit statement was _not_ issued.
+
+```ruby
+expect do
+  MyClass.create!(required_field: nil)
+rescue
+  # NOOP
+end.not_to rollback_a_transaction
+```
+
+Note that ActiveRecord will not only roll back the transaction, but also
+re-raise errors. As such, it's necessary in this example to rescue that error,
+otherwise the test would fail simply because the code caused a `raise`.
+
+### Counting Transactions
+
+Similar to counting queries, you can quantify the number of transactions you
+expect to succeed / fail. This is probably of limited value in all but some
+very specific cases.
+
+```ruby
+expect {}.to commit_a_transaction.once
+expect {}.to rollback_a_transaction.exactly(5).times
+expect {}.to commit_a_transaction.at_least(5).times
+```
+
 ## Future Planned Functionality
 
 This gem still has lots of future functionality. See below.
@@ -176,10 +256,6 @@ expect {}.to execute.at_least(2).load_queries("Audited::Audit")
 expect {}.to execute.at_least(2).activerecord_queries
 expect {}.to execute.at_least(2).hand_rolled_queries
 
-expect {}.not_to rollback_transaction.exactly(5).times
-expect {}.not_to commit_transaction.once
-expect {}.to run_a_transaction
-
 expect {}.to create.exactly(5).of_type(User)
 expect {}.to insert.exactly(5).subscription_changes
 expect {}.to update.exactly(2).of_any_type

data/lib/rspec/activerecord/expectations/matchers/query_count_matcher.rb

@@ -1,16 +1,25 @@
 module RSpec::ActiveRecord::Expectations
   module Matchers
     class QueryCountMatcher
-      attr_reader :failure_message, :failure_message_when_negated
+      attr_reader :collector, :quantifier, :comparison, :query_type
 
       def initialize
         @collector = Collector.new
+        @message_builder = MessageBuilder.new(self)
 
         @match_method = nil
-        @comparison   = nil
+        @quantifier   = nil
         @query_type   = nil
       end
 
+      def failure_message
+        @message_builder.failure_message
+      end
+
+      def failure_message_when_negated
+        @message_builder.failure_message_when_negated
+      end
+
       def supports_block_expectations?
         true
       end
@@ -26,39 +35,44 @@ module RSpec::ActiveRecord::Expectations
         result
       end
 
-      # COMPARISON TYPES
+      # QUANTIFIERS
 
       def less_than(n)
-        @comparison   = n
-        @match_method = method(:compare_less_than)
+        @quantifier   = n
+        @comparison   = :less_than
+        @match_method = -> { actual_count < @quantifier }
         self
       end
       alias_method :fewer_than, :less_than
 
       def less_than_or_equal_to(n)
-        @comparison   = n
-        @match_method = method(:compare_less_than_or_equal_to)
+        @quantifier   = n
+        @comparison   = :less_than_or_equal_to
+        @match_method = -> { actual_count <= @quantifier }
         self
       end
       alias_method :at_most, :less_than_or_equal_to
 
       def greater_than(n)
-        @comparison   = n
-        @match_method = method(:compare_greater_than)
+        @quantifier   = n
+        @comparison   = :greater_than
+        @match_method = -> { actual_count > @quantifier }
         self
       end
       alias_method :more_than, :greater_than
 
       def greater_than_or_equal_to(n)
-        @comparison   = n
-        @match_method = method(:compare_greater_than_or_equal_to)
+        @quantifier   = n
+        @comparison   = :greater_than_or_equal_to
+        @match_method = -> { actual_count >= @quantifier }
         self
       end
       alias_method :at_least, :greater_than_or_equal_to
 
       def exactly(n)
-        @comparison   = n
-        @match_method = method(:compare_exactly)
+        @quantifier   = n
+        @comparison   = :exactly
+        @match_method = -> { actual_count == @quantifier }
         self
       end
 
@@ -79,62 +93,10 @@ module RSpec::ActiveRecord::Expectations
         end
       end
 
-      # TODO singularize everything
-      alias_method :query, :queries
-
-      private
-
-      def humanized_query_type
-        @query_type.to_s.gsub("_", " ")
-      end
-
-      # MATCHERS
-
-      def compare_less_than
-        count = @collector.queries_of_type(@query_type)
-
-        @failure_message = "expected block to execute fewer than #{@comparison} #{humanized_query_type}, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute fewer than #{@comparison} #{humanized_query_type}, but it executed #{count}"
-
-        count < @comparison
-      end
-
-      def compare_less_than_or_equal_to
-        count = @collector.queries_of_type(@query_type)
-
-        # boy this negated operator is confusing. don't use that plz.
-        @failure_message = "expected block to execute at most #{@comparison} #{humanized_query_type}, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute any less than #{@comparison} #{humanized_query_type}, but it executed #{count}"
-
-        count <= @comparison
-      end
-
-      def compare_greater_than
-        count = @collector.queries_of_type(@query_type)
-
-        @failure_message = "expected block to execute greater than #{@comparison} #{humanized_query_type}, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute greater than #{@comparison} #{humanized_query_type}, but it executed #{count}"
-
-        count > @comparison
-      end
-
-      def compare_greater_than_or_equal_to
-        count = @collector.queries_of_type(@query_type)
-
-        # see above, negating this matcher is so confusing.
-        @failure_message = "expected block to execute at least #{@comparison} #{humanized_query_type}, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute any more than #{@comparison} #{humanized_query_type}, but it executed #{count}"
-
-        count >= @comparison
-      end
-
-      def compare_exactly
-        count = @collector.queries_of_type(@query_type)
-
-        @failure_message = "expected block to execute exactly #{@comparison} #{humanized_query_type}, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute exactly #{@comparison} #{humanized_query_type}, but it executed #{count}"
+      # helper for message builder
 
-        count == @comparison
+      def actual_count
+        @collector.queries_of_type(@query_type)
       end
     end
   end

data/lib/rspec/activerecord/expectations/matchers/transaction_matcher.rb

@@ -0,0 +1,99 @@
+module RSpec::ActiveRecord::Expectations
+  module Matchers
+    class TransactionMatcher
+      attr_reader :collector, :quantifier, :comparison, :query_type
+
+      def initialize(transaction_type)
+        @collector    = Collector.new
+        @query_type  = transaction_type
+        @message_builder = MessageBuilder.new(self)
+
+        self.at_least(1)
+      end
+
+      def failure_message
+        @message_builder.failure_message
+      end
+
+      def failure_message_when_negated
+        @message_builder.failure_message_when_negated
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(block)
+        raise NoComparisonError unless @match_method
+
+        block.call
+        result = @match_method.call
+        @collector.finalize
+
+        result
+      end
+
+      # QUANTIFIERS
+
+      def less_than(n)
+        @quantifier   = n
+        @comparison = :less_than
+        @match_method = -> { actual_count < @quantifier }
+        self
+      end
+      alias_method :fewer_than, :less_than
+
+      def less_than_or_equal_to(n)
+        @quantifier   = n
+        @comparison = :less_than_or_equal_to
+        @match_method = -> { actual_count <= @quantifier }
+        self
+      end
+      alias_method :at_most, :less_than_or_equal_to
+
+      def greater_than(n)
+        @quantifier   = n
+        @comparison = :greater_than
+        @match_method = -> { actual_count > @quantifier }
+        self
+      end
+      alias_method :more_than, :greater_than
+
+      def greater_than_or_equal_to(n)
+        @quantifier   = n
+        @comparison = :greater_than_or_equal_to
+        @match_method = -> { actual_count >= @quantifier }
+        self
+      end
+      alias_method :at_least, :greater_than_or_equal_to
+
+      def exactly(n)
+        @quantifier   = n
+        @comparison = :exactly
+        @match_method = -> { actual_count == @quantifier }
+        self
+      end
+
+      def once
+        exactly(1).time
+      end
+
+      def twice
+        exactly(2).times
+      end
+
+      def thrice # hehe
+        exactly(3).times
+      end
+
+      def times
+        self # NOOP
+      end
+      alias_method :time, :times
+
+      def actual_count
+        @collector.queries_of_type(@query_type)
+      end
+    end
+  end
+end

data/lib/rspec/activerecord/expectations/message_builder.rb

@@ -0,0 +1,160 @@
+module RSpec::ActiveRecord::Expectations
+  class MessageBuilder
+    attr_reader :matcher, :phrase_builder
+
+    def initialize(matcher)
+      @matcher = matcher
+      @phrase_builder = case matcher
+        when Matchers::QueryCountMatcher then QueryPhrases.new(matcher)
+        when Matchers::TransactionMatcher then TransactionPhrases.new(matcher)
+        else raise ArgumentError
+      end
+    end
+
+    def failure_message
+      "expected block to #{phrase_builder.prefix}, but it #{phrase_builder.suffix}"
+    end
+
+    def failure_message_when_negated
+      "expected block not to #{phrase_builder.prefix}, but it #{phrase_builder.negative_suffix}"
+    end
+
+    private
+
+    # TODO: expect {}.not_to execute.less_than_or_equal_to(3).insert_queries
+    # expected block not to execute at most 3 insert queries, but it executed 0
+
+
+    class QueryPhrases
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
+      end
+
+      def prefix
+        "execute #{comparison_phrase} #{query_type_name}"
+      end
+
+      def suffix
+        if matcher.actual_count == 0
+          "didn't execute any"
+        elsif matcher.actual_count == 1
+          "executed one"
+        else
+          "executed #{matcher.actual_count}"
+        end
+      end
+
+      # using positive suffix from above can cause double negatives
+      def negative_suffix
+        if matcher.comparison == :exactly
+          "did so"
+        elsif matcher.actual_count == 1
+          "executed one"
+        else
+          "executed #{matcher.actual_count}"
+        end
+      end
+
+      private
+
+      def query_type_name
+        if matcher.quantifier == 1
+          matcher.query_type.to_s.gsub("_", " ").gsub("queries", "query")
+        else
+          matcher.query_type.to_s.gsub("_", " ")
+        end
+      end
+
+      def comparison_phrase
+        quant = if matcher.quantifier == 1 && matcher.comparison == :exactly
+          "a"
+        elsif matcher.quantifier == 1
+          "one"
+        else
+          matcher.quantifier
+        end
+
+        case matcher.comparison
+          when :exactly                   then quant
+          when :greater_than              then "more than #{quant}"
+          when :greater_than_or_equal_to  then "at least #{quant}"
+          when :less_than                 then "less than #{quant}"
+          when :less_than_or_equal_to     then "at most #{quant}"
+          else raise ArgumentError, "unsupported comparison matcher #{matcher.comparison}"
+        end
+      end
+    end
+
+    class TransactionPhrases
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
+      end
+
+      def prefix
+        nouns = matcher.quantifier == 1 ? "transaction" : "transactions"
+        verb  = case matcher.query_type
+          when :transaction_queries then "execute"
+          when :rollback_queries then "roll back"
+          when :commit_queries then "commit"
+        end
+
+        "#{verb} #{comparison} #{nouns}"
+      end
+
+      def suffix
+        singular_verb  = case matcher.query_type
+          when :transaction_queries then "execute"
+          when :rollback_queries then "roll back"
+          when :commit_queries then "commit"
+        end
+
+        plural_verb  = case matcher.query_type
+          when :transaction_queries then "executed"
+          when :rollback_queries then "rolled back"
+          when :commit_queries then "committed"
+        end
+
+        if matcher.actual_count == 0
+          "didn't #{singular_verb} any"
+        elsif matcher.actual_count == 1
+          "#{plural_verb} one"
+        else
+          "#{plural_verb} #{matcher.actual_count}"
+        end
+      end
+
+      def negative_suffix
+        if matcher.comparison == :exactly
+          "did so"
+        else
+          suffix
+        end
+      end
+
+      private
+
+      def comparison
+        quant = if matcher.quantifier == 1 && matcher.comparison == :exactly
+          "a"
+        elsif matcher.quantifier == 1
+          "one"
+        else
+          matcher.quantifier
+        end
+
+        case matcher.comparison
+          when :exactly                   then quant
+          when :greater_than              then "more than #{quant}"
+          when :greater_than_or_equal_to  then "at least #{quant}"
+          when :less_than                 then "less than #{quant}"
+          when :less_than_or_equal_to     then "at most #{quant}"
+          else raise ArgumentError, "unsupported comparison matcher #{matcher.comparison}"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/activerecord/expectations/query_inspector.rb

@@ -1,13 +1,18 @@
 module RSpec::ActiveRecord::Expectations
   class QueryInspector
     def self.valid_query_types
-      [:queries, :schema_queries, :transaction_queries, :insert_queries,
-       :load_queries, :destroy_queries, :exists_queries]
+      [:queries, :schema_queries, :insert_queries, :load_queries,
+       :destroy_queries, :exists_queries,
+       :transaction_queries, :commit_queries, :rollback_queries]
     end
 
     def categorize(query)
       if query[:name] == "SCHEMA"
         [:schema_queries]
+      elsif query[:sql] =~ /^commit/i
+        [:commit_queries]
+      elsif query[:sql] =~ /^rollback/i
+        [:rollback_queries]
       elsif query[:name] == "TRANSACTION"
         [:transaction_queries]
       elsif query[:name] =~ /Create$/
@@ -18,7 +23,7 @@ module RSpec::ActiveRecord::Expectations
         [:queries, :destroy_queries]
       elsif query[:name] =~ /Delete All$/
         [:queries, :destroy_queries]
-      elsif query[:name] =~ /Exists\?$/
+      elsif query[:name] =~ /Exists\??$/
         [:queries, :exists_queries]
       else
         [:queries]

data/lib/rspec/activerecord/expectations.rb

@@ -8,6 +8,22 @@ module RSpec
       def repeatedly_load(klass)
         Matchers::LoadMatcher.new(klass)
       end
+
+      def execute_a_transaction
+        Matchers::TransactionMatcher.new(:transaction_queries)
+      end
+
+      def rollback_a_transaction
+        Matchers::TransactionMatcher.new(:rollback_queries)
+      end
+
+      def roll_back_a_transaction
+        Matchers::TransactionMatcher.new(:rollback_queries)
+      end
+
+      def commit_a_transaction
+        Matchers::TransactionMatcher.new(:commit_queries)
+      end
     end
   end
 end
@@ -15,5 +31,7 @@ end
 require_relative 'expectations/errors'
 require_relative 'expectations/query_inspector'
 require_relative 'expectations/collector'
+require_relative 'expectations/message_builder'
 require_relative 'expectations/matchers/query_count_matcher'
 require_relative 'expectations/matchers/load_matcher'
+require_relative 'expectations/matchers/transaction_matcher'

data/rspec-activerecord-expectations.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "rspec-activerecord-expectations"
-  spec.version       = '1.3.0'
+  spec.version       = '2.3.0'
   spec.authors       = ["Joseph Mastey"]
   spec.email         = ["hello@joemastey.com"]
 
@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Adds new matchers to rspec to help you test whether your code is executing an unreasonable number of queries.}
   spec.homepage      = "https://github.com/jmmastey/rspec-activerecord-expectations"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
@@ -23,7 +23,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activerecord", ">= 5.0.0", "< 7.1.0"
-  spec.add_dependency "sqlite3", "~> 1.0"
+
+  if RUBY_PLATFORM == 'java'
+    spec.add_development_dependency "activerecord-jdbcsqlite3-adapter", '>= 60'
+  else
+    spec.add_development_dependency "sqlite3", "~> 1.0"
+  end
 
   spec.add_development_dependency "pry", "~> 0.0"
   spec.add_development_dependency "appraisal", "~> 2"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-activerecord-expectations
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Joseph Mastey
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-04 00:00:00.000000000 Z
+date: 2022-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -37,7 +37,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -104,6 +104,8 @@ files:
 - lib/rspec/activerecord/expectations/errors.rb
 - lib/rspec/activerecord/expectations/matchers/load_matcher.rb
 - lib/rspec/activerecord/expectations/matchers/query_count_matcher.rb
+- lib/rspec/activerecord/expectations/matchers/transaction_matcher.rb
+- lib/rspec/activerecord/expectations/message_builder.rb
 - lib/rspec/activerecord/expectations/query_inspector.rb
 - rspec-activerecord-expectations.gemspec
 homepage: https://github.com/jmmastey/rspec-activerecord-expectations
@@ -121,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="