rspec-activerecord-expectations 1.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 202f92144b220ec281763d132152aa1bf3cced42d09273d3c050c8c41dab2018
-  data.tar.gz: f4e4e5f4fce4c3db060c3ea1fcb6752d876fd8b41cc0337dc81308c6acfceb08
+  metadata.gz: d320c1e0f80e96c3bbb2cb07df63b941aa9bb1aa3878f9ca46e6fa1fed483569
+  data.tar.gz: 69487efb7a89d208d28a0d26faa3c74fc3315645803a1ec4162a6bd9f3677008
 SHA512:
-  metadata.gz: fdbccf8e60640748b4eabc666355ac175455f0338a21a157d41eaee48f82361f45c4c921ec94ee2f3df5b9a274c72a1de868d4f7dfe5d3e2ff4480fbc08981ef
-  data.tar.gz: d330ce04fee3e846d0591cd4f0c34599e3501715e291f7ad7956a226e7ca7d91638892a09e566f567e13daaf2287d7da95869e4c99e849043a459e7afcc599e0
+  metadata.gz: 7db71325cbfa0abd65c7128cceb18ba8017af399bee5cdd4502d84a988c3865605f0c5d34f858af352c1520b401651723fbf1c2335d652ec45f9ef0308a675bb
+  data.tar.gz: 44082fc8ad08369ea9e578f6cb3a11ec3dd7f92445b63ef4d415e10e14c79e350ded3a39828821b613513c382fd71b72db9b0669e7c14bd2e900655e03cffa5d

data/.github/workflows/main.yml

@@ -11,22 +11,22 @@ 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: Test 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 correct gems / rails version
+      - name: Install Gems w/ Rails ${{ matrix.rails }}
         env:
           MATRIX_RAILS_VERSION: ${{ matrix.rails }}
         run: |
@@ -40,23 +40,51 @@ jobs:
   test_legacy:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
-        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: ${{ matrix.os }}
-    name: Test Legacy ruby ${{ matrix.ruby }} / rails ${{ matrix.rails }} / ${{ matrix.os }}
+    runs-on: ubuntu-latest
+    name: ruby ${{ 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
+
+  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 }}
+      - 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 correct gems / rails version
+      - name: Install Gems w/ Rails ${{ matrix.rails }}
         env:
           MATRIX_RAILS_VERSION: ${{ matrix.rails }}
         run: |
@@ -66,3 +94,4 @@ jobs:
 
       - name: Run tests
         run: bundle exec rspec
+ 

data/CHANGELOG.md

@@ -1,10 +1,33 @@
 # Changelog
 
-## [1.0.1] - 2020-12-30
+## [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] - 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] - 2021-12-30
+- Add query count matchers for e.g. `less_than_or_equal_to`, `greater_than`
+
+## [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|
@@ -91,11 +92,91 @@ That's it! Refactor your report to be more efficient and then leave the test in
 place to make sure that future developers don't accidentally cause a
 performance regression.
 
-## Supported Matchers
+## Preventing Repeated Load (N+1) Queries
+
+Reloading, whether by e.g. `Album.find` or `album.tracks` are both antipatterns
+within your code. They will load from the database for every iteration in a
+loop, unless you load records outside the loop, cache responses, or use an
+eager loading mechanism like `includes`. These sorts of queries are often
+referred to as N+1 queries.
+
+This sort of query can be prevented using the `repeatedly_load` expectation.
+
+```ruby
+expect {}.not_to repeatedly_load('SomeActiveRecordClass')
+```
+
+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!
+
+### 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
+
+Several comparison types are available, along with some aliases to allow for
+easier to read tests.
+
+```ruby
+expect {}.to execute.less_than(20).queries
 expect {}.to execute.fewer_than(20).queries
-expect {}.to execute.less_than(20).queries    # alias for fewer_than
+
+expect {}.to execute.less_than_or_equal_to(20).queries
+expect {}.to execute.at_most(20).queries
+
+expect {}.to execute.greater_than(20).queries
+expect {}.to execute.more_than(20).queries
+
+expect {}.to execute.greater_than_or_equal_to(20).queries
+expect {}.to execute.at_least(20).queries
+
+expect {}.to execute.exactly(20).queries
+
+expect {}.to execute.at_least(2).queries
+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`.
+
+```ruby
+expect {}.to execute.exactly(20).queries
+
+expect {}.to execute.exactly(20).insert_queries
+expect {}.to execute.exactly(20).load_queries
+expect {}.to execute.exactly(20).destroy_queries
+expect {}.to execute.exactly(20).exists_queries
+
+expect {}.to execute.exactly(20).schema_queries
+expect {}.to execute.exactly(20).transaction_queries
 ```
 
 ## Future Planned Functionality
@@ -103,17 +184,11 @@ expect {}.to execute.less_than(20).queries    # alias for fewer_than
 This gem still has lots of future functionality. See below.
 
 ```ruby
-expect {}.to execute.more_than(20).activerecord_queries
-expect {}.to execute.fewer_than(20).insert_queries
-expect {}.to execute.exactly(5).queries
-expect {}.to execute.at_least(5).handrolled_queries
-
-expect {}.to execute.less_than(20).delete_queries
-expect {}.to execute.less_than(20).load_queries
-expect {}.to execute.less_than(20).schema_queries
-expect {}.to execute.less_than(20).exists_queries
-expect {}.to execute.less_than(20).queries
-expect {}.to execute.less_than(20).queries_of_type("Audited::Audit Load")
+expect {}.to execute.at_least(2).queries_of_type("Audited::Audit Load")
+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
@@ -123,18 +198,10 @@ expect {}.to create.exactly(5).of_type(User)
 expect {}.to insert.exactly(5).subscription_changes
 expect {}.to update.exactly(2).of_any_type
 expect {}.to delete.exactly(2).of_any_type
-
-expect {}.not_to repeatedly_load(Audited::Audit)
-
-at_least, more_than, at_most, less_than, lteq?
-exactly(1) => once?
 ```
 
-- ignore transactionals (begin / rollback)
-- `name: Foo Load`
-- differentiate AR queries from generic ones? arbitrary execution somehow?
-- warn about warmup
-- make sure we don't smite any built in methods (or from other libs)
+- warn if we smite any built in methods (or methods from other libs)
+- support Rails 6 bulk insert (still one query)
 
 ## Development
 

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

@@ -1,23 +1,42 @@
 module RSpec::ActiveRecord::Expectations
   class Collector
     def initialize
-      @counts = {
-        queries: 0
-      }
+      @inspector  = QueryInspector.new
+      @by_name    = {}
+      @counts     = QueryInspector.valid_query_types.each_with_object({}) do |query_type, hash|
+        hash[query_type] = 0
+      end
 
-      ActiveSupport::Notifications.subscribe("sql.active_record", method(:record_query))
+      @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", method(:record_query))
+    end
+
+    def finalize
+      ActiveSupport::Notifications.unsubscribe(@subscription)
     end
 
     def queries_of_type(type)
-      @counts.fetch(type)
+      @counts[type] || (raise ArgumentError, "Sorry, #{type} is not a valid kind of query")
     end
 
     def valid_type?(type)
       @counts.include? type
     end
 
+    def calls_by_name(name)
+      @by_name.fetch(name, 0)
+    end
+
     def record_query(*_unused, data)
-      @counts[:queries] += 1
+      categories = @inspector.categorize(data)
+
+      categories.each do |category|
+        @counts[category] += 1
+      rescue NoMethodError
+        raise "tried to add to to #{category} but it doesn't exist"
+      end
+
+      @by_name[data[:name]] ||= 0
+      @by_name[data[:name]] += 1
     end
   end
 end

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

@@ -0,0 +1,29 @@
+module RSpec::ActiveRecord::Expectations
+  module Matchers
+    class LoadMatcher
+      def initialize(klass)
+        @collector = Collector.new
+        @klass = klass.to_s
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(block)
+        block.call
+
+        @count = @collector.calls_by_name("#{@klass} Load")
+        @count > 1
+      end
+
+      def failure_message
+        "expected block to repeatedly load #{@klass}, but it was loaded #{@count} times"
+      end
+
+      def failure_message_when_negated
+        "expected block not to repeatedly load #{@klass}, but it was loaded #{@count} times"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module RSpec::ActiveRecord::Expectations
+  module Matchers
+    class QueryCountMatcher
+      attr_reader :failure_message, :failure_message_when_negated
+
+      def initialize
+        @collector = Collector.new
+
+        @match_method = nil
+        @comparison   = nil
+        @query_type   = nil
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(block)
+        raise NoComparisonError unless @match_method
+        raise NoQueryTypeError unless @collector.valid_type?(@query_type)
+
+        block.call
+        result = @match_method.call
+        @collector.finalize
+
+        result
+      end
+
+      # COMPARISON TYPES
+
+      def less_than(n)
+        @comparison   = n
+        @match_method = method(:compare_less_than)
+        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)
+        self
+      end
+      alias_method :at_most, :less_than_or_equal_to
+
+      def greater_than(n)
+        @comparison   = n
+        @match_method = method(:compare_greater_than)
+        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)
+        self
+      end
+      alias_method :at_least, :greater_than_or_equal_to
+
+      def exactly(n)
+        @comparison   = n
+        @match_method = method(:compare_exactly)
+        self
+      end
+
+      # TARGET QUERY TYPES
+
+      RSpec::ActiveRecord::Expectations::QueryInspector.valid_query_types.each do |type|
+        define_method type do
+          @query_type = type
+          self
+        end
+
+        singularized_type = type.to_s.gsub('queries', 'query')
+        if singularized_type != type.to_s
+          define_method singularized_type do
+            @query_type = type
+            self
+          end
+        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}"
+
+        count == @comparison
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module RSpec::ActiveRecord::Expectations
+  class QueryInspector
+    def self.valid_query_types
+      [:queries, :schema_queries, :transaction_queries, :insert_queries,
+       :load_queries, :destroy_queries, :exists_queries]
+    end
+
+    def categorize(query)
+      if query[:name] == "SCHEMA"
+        [:schema_queries]
+      elsif query[:name] == "TRANSACTION" || query[:sql] =~ /^begin/i || query[:sql] =~ /^commit/i
+        [:transaction_queries]
+      elsif query[:name] =~ /Create$/
+        [:queries, :insert_queries]
+      elsif query[:name] =~ /Load$/
+        [:queries, :load_queries]
+      elsif query[:name] =~ /Destroy$/
+        [:queries, :destroy_queries]
+      elsif query[:name] =~ /Delete All$/
+        [:queries, :destroy_queries]
+      elsif query[:name] =~ /Exists\??$/
+        [:queries, :exists_queries]
+      else
+        [:queries]
+      end
+    end
+  end
+end

data/lib/rspec/activerecord/expectations.rb

@@ -4,10 +4,16 @@ module RSpec
       def execute
         Matchers::QueryCountMatcher.new
       end
+
+      def repeatedly_load(klass)
+        Matchers::LoadMatcher.new(klass)
+      end
     end
   end
 end
 
 require_relative 'expectations/errors'
+require_relative 'expectations/query_inspector'
 require_relative 'expectations/collector'
-require_relative 'expectations/matchers/query_count'
+require_relative 'expectations/matchers/query_count_matcher'
+require_relative 'expectations/matchers/load_matcher'

data/rspec-activerecord-expectations.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "rspec-activerecord-expectations"
-  spec.version       = '1.0.1'
+  spec.version       = '2.1.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,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rspec-activerecord-expectations
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Joseph Mastey
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-30 00:00:00.000000000 Z
+date: 2022-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -20,8 +19,9 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 7.1.0
-  type: :runtime
+  name: activerecord
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -31,42 +31,42 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 7.1.0
 - !ruby/object:Gem::Dependency
-  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
+        version: '60'
+  name: activerecord-jdbcsqlite3-adapter
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '60'
 - !ruby/object:Gem::Dependency
-  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
-  type: :development
+  name: pry
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
 - !ruby/object:Gem::Dependency
-  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
-  type: :development
+  name: appraisal
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -102,7 +102,9 @@ files:
 - lib/rspec/activerecord/expectations.rb
 - lib/rspec/activerecord/expectations/collector.rb
 - lib/rspec/activerecord/expectations/errors.rb
-- lib/rspec/activerecord/expectations/matchers/query_count.rb
+- lib/rspec/activerecord/expectations/matchers/load_matcher.rb
+- lib/rspec/activerecord/expectations/matchers/query_count_matcher.rb
+- lib/rspec/activerecord/expectations/query_inspector.rb
 - rspec-activerecord-expectations.gemspec
 homepage: https://github.com/jmmastey/rspec-activerecord-expectations
 licenses:
@@ -119,14 +121,14 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: A gem to test how many activerecord queries your code executes.

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

@@ -1,57 +0,0 @@
-module RSpec::ActiveRecord::Expectations
-  module Matchers
-    class QueryCountMatcher
-      attr_reader :failure_message, :failure_message_when_negated
-
-      def initialize
-        @collector = Collector.new
-
-        @match_method = nil
-        @comparison   = nil
-        @query_type   = nil
-      end
-
-      def supports_block_expectations?
-        true
-      end
-
-      def matches?(block)
-        raise NoComparisonError unless @match_method
-        raise NoQueryTypeError unless @collector.valid_type?(@query_type)
-
-        result    = block.call
-
-        !!@match_method.call
-      end
-
-      # COMPARISON TYPES
-
-      def fewer_than(n)
-        @comparison   = n
-        @match_method = method(:match_fewer_than)
-        self
-      end
-      alias_method :less_than, :fewer_than
-
-      # TARGET QUERY TYPES
-
-      def queries
-        @query_type = :queries
-        self
-      end
-
-      private
-
-      # MATCHERS
-
-      def match_fewer_than
-        count = @collector.queries_of_type(@query_type)
-
-        @failure_message = "expected block to execute fewer than #{@comparison} queries, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute fewer than #{@comparison} queries, but it executed #{count}"
-
-        count < @comparison
-      end
-    end
-  end
-end