rspec-activerecord-expectations 1.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ed8bce8c2576663b3d187efc7ae064c239c9ab8f3e6dacae592563ea4c484fb
-  data.tar.gz: 9e67c875fd8dcab13a8e0ed56b34f842519f1af4f0037f5c8955970cc82f2850
+  metadata.gz: a6e24b218adcab0f1e6fb117d66463a2cdf60996fe5c16f60d48f8efd37c3259
+  data.tar.gz: 4f0acb5f4c489f4b2ded11b7d27a1bec613d231b04d836f651a26daf1bdb5bb1
 SHA512:
-  metadata.gz: 0ea389afd2110fbaca8c2215507874e1fed2ad1e1f5dae167baaf532d56f91bcfa3f7458a88a71e6ce2de341160ba0fe3f3a25c786641204ebda1f3fe2db707c
-  data.tar.gz: 9ace14690c79ee0ca1e5c9a3841a9769d58b315685e811b253d393c2a5858294153cf1b0e88471b584112391b351173163cd4d6326920654e35d3aac83c6cf77
+  metadata.gz: d077a6aa43e9f243a4be0d5b4db338a2aa3272e49974b8cc9b987499571de846e6f5cbc4c9d1f4d3d58d50b1d91ce3d361f2719ee3073ae8eeeee589a62d3e8c
+  data.tar.gz: 4473b4f016d10ca617e4ef5b3b1550c44903a170e9fde1291a88097a264028a0e21383fa37324f063c9529412c52e70e6fb24fab9e7a6df2382568f6a763fbc5

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,13 +1,37 @@
 # Changelog
 
-## [1.1.0] - 2020-12-30
-- Add matchers for less_than_or_equal_to, greater_than
+## [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.
 
-## [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,9 +92,52 @@ 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
 
-Listed along with their aliases.
+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
+
+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.
+
+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
@@ -107,22 +151,47 @@ 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 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
+
+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
+```
+
+**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`.
+
 ## Future Planned Functionality
 
 This gem still has lots of future functionality. See below.
 
 ```ruby
-expect {}.to execute.exactly(5).queries
+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).insert_queries
-expect {}.to execute.at_least(2).delete_queries
-expect {}.to execute.at_least(2).load_queries
-expect {}.to execute.at_least(2).schema_queries
-expect {}.to execute.at_least(2).exists_queries
-expect {}.to execute.at_least(2).queries_of_type("Audited::Audit Load")
 expect {}.to execute.at_least(2).hand_rolled_queries
 
 expect {}.not_to rollback_transaction.exactly(5).times
@@ -133,17 +202,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)
-
-expect {}.to execute.at_least(1).query
 ```
 
-- 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.rb → query_count_matcher.rb}

@@ -19,9 +19,11 @@ module RSpec::ActiveRecord::Expectations
         raise NoComparisonError unless @match_method
         raise NoQueryTypeError unless @collector.valid_type?(@query_type)
 
-        result    = block.call
+        block.call
+        result = @match_method.call
+        @collector.finalize
 
-        !!@match_method.call
+        result
       end
 
       # COMPARISON TYPES
@@ -54,22 +56,45 @@ module RSpec::ActiveRecord::Expectations
       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
 
-      def queries
-        @query_type = :queries
-        self
+      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} queries, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute fewer than #{@comparison} queries, but it executed #{count}"
+        @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
@@ -78,8 +103,8 @@ module RSpec::ActiveRecord::Expectations
         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} queries, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute any less than #{@comparison} queries, but it executed #{count}"
+        @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
@@ -87,8 +112,8 @@ module RSpec::ActiveRecord::Expectations
       def compare_greater_than
         count = @collector.queries_of_type(@query_type)
 
-        @failure_message = "expected block to execute greater than #{@comparison} queries, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute greater than #{@comparison} queries, but it executed #{count}"
+        @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
@@ -97,11 +122,20 @@ module RSpec::ActiveRecord::Expectations
         count = @collector.queries_of_type(@query_type)
 
         # see above, negating this matcher is so confusing.
-        @failure_message = "expected block to execute at least #{@comparison} queries, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute any more than #{@comparison} queries, but it executed #{count}"
+        @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.1.0'
+  spec.version       = '2.1.1'
   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.1.0
+  version: 2.1.1
 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
@@ -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:
@@ -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,7 +121,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:
   - - ">="