rspec-activerecord-expectations 1.0.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8090634964dbd7f2f5f8a386cfd0de07257d6f08cd6f9b14606982f983489815
-  data.tar.gz: 007eef50aa9f1eb61da08fba2a6e7eb6a4f4114c5e0b4fa68f2cb629d4ef86c6
+  metadata.gz: 92f14ca413e9e716ea9b3046abc13d3929893185cfef8cdeaf14b7bebc93755c
+  data.tar.gz: 93bfa962b7954844560961d66d080fa2c45a3188b8c9b92420d1852e36ce718b
 SHA512:
-  metadata.gz: 6c7072fc9e686e66c750e0e117515094d4b6cde5e764a8b07c750f3d8fa64cfd210f010c8816bbef6a6e0edd6c5af7983f6886e1c0fefe05de19b9a4bf2cf0af
-  data.tar.gz: 8196d1a03e6e7b1c73ab3b8524a759cadf554db7fee528a8a350df601661b0b21b7bb1cc3078ea852634aea64c5b6ba9c755ba9ce0232bcef46735e959dd57b1
+  metadata.gz: bb81903bbb00357ab9613a59fb2684bfaad7671fbca955f9876d503f5b179f8ead6d36f248ea24909f30db3ddb6f4fc307c509a181d2fe85d33d1e04006856da
+  data.tar.gz: f813c1e8d6e320f6810cc33620fe702c379f47124b6add4bc1bdabde81c4e12c60a6aac5711caf8c23672f838d6185106ffb3695770a7c4002d04404c87929cb

data/.github/workflows/main.yml

@@ -2,26 +2,66 @@ name: CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
 
 jobs:
-  test:
+  test_modern:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
-        ruby-version: [3.0, 2.7, 2.6, 2.5]
+        ruby_version: ['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 }}
 
     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 dependencies
-        run: bundle install
+
+      - 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_legacy:
+    strategy:
+      matrix:
+        ruby_version: ['2.6', '2.5', '2.4', '2.3']
+        rails: ['5.0', '5.1', '5.2']
+
+    runs-on: ubuntu-latest
+    name: legacy 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

data/.gitignore

@@ -10,4 +10,7 @@
 # rspec failure tracking
 .rspec_status
 
-# this is a gem, don't track the specific deps
+# this is a gem, don't track the specific deps or build artifact
+Gemfile.lock
+rails_*.gemfile.lock
+rspec-activerecord-expectations-*.gem

data/Appraisals

@@ -0,0 +1,23 @@
+appraise "rails-7.0" do
+  gem "rails", "~> 7.0.0"
+end
+
+appraise "rails-6.1" do
+  gem "rails", "~> 6.1.0"
+end
+
+appraise "rails-6.0" do
+  gem "rails", "~> 6.0.3", '>= 6.0.3.2'
+end
+
+appraise "rails-5.2" do
+  gem "rails", "~> 5.2.4", '>= 5.2.4.3'
+end
+
+appraise "rails-5.1" do
+  gem "rails", "~> 5.1.7"
+end
+
+appraise "rails-5.0" do
+  gem "rails", "~> 5.0.7", '>= 5.0.7.2'
+end

data/CHANGELOG.md

@@ -1,7 +1,26 @@
 # Changelog
 
+## [1.3.0] - 2020-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
+- 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
+- Add query count matchers for e.g. `less_than_or_equal_to`, `greater_than`
+
+## [1.0.1] - 2020-12-30
+- Pin all the dependencies to a proper working subset
+- Expand testing to many rails / ruby combinations
+
 ## [1.0.0] - 2020-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.
+- 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

@@ -91,11 +91,78 @@ 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!
+
+**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.
+
+## 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 +170,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 +184,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/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/rails_5.0.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "rails", "~> 5.0.7", ">= 5.0.7.2"
+
+gemspec path: "../"

data/gemfiles/rails_5.1.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "rails", "~> 5.1.7"
+
+gemspec path: "../"

data/gemfiles/rails_5.2.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "rails", "~> 5.2.4", ">= 5.2.4.3"
+
+gemspec path: "../"

data/gemfiles/rails_6.0.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "rails", "~> 6.0.3", ">= 6.0.3.2"
+
+gemspec path: "../"

data/gemfiles/rails_6.1.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "rails", "~> 6.1.0"
+
+gemspec path: "../"

data/gemfiles/rails_7.0.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "rails", "~> 7.0.0"
+
+gemspec path: "../"

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"
+        [: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.0'
+  spec.version       = '1.3.0'
   spec.authors       = ["Joseph Mastey"]
   spec.email         = ["hello@joemastey.com"]
 
@@ -22,8 +22,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", ">= 5.0", "< 7.0" # TODO run tests to loosen me
+  spec.add_dependency "activerecord", ">= 5.0.0", "< 7.1.0"
   spec.add_dependency "sqlite3", "~> 1.0"
 
   spec.add_development_dependency "pry", "~> 0.0"
+  spec.add_development_dependency "appraisal", "~> 2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-activerecord-expectations
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Joseph Mastey
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-30 00:00:00.000000000 Z
+date: 2022-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 5.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 5.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +58,20 @@ dependencies:
     - - "~>"
       - !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
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
 description: Adds new matchers to rspec to help you test whether your code is executing
   an unreasonable number of queries.
 email:
@@ -71,16 +85,26 @@ files:
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
+- Appraisals
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
+- gemfiles/.bundle/config
+- gemfiles/rails_5.0.gemfile
+- gemfiles/rails_5.1.gemfile
+- gemfiles/rails_5.2.gemfile
+- gemfiles/rails_6.0.gemfile
+- gemfiles/rails_6.1.gemfile
+- gemfiles/rails_7.0.gemfile
 - lib/rspec/activerecord-expectations.rb
 - 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:

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