rspec-activerecord-expectations 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea0eb161965acaf677cec0de83466eece5379423903fc0a04b181cabe61a8121
-  data.tar.gz: 4df14e9211baf4ac6f3935a68b910191480f6f6af622f36c7d7e51a90374d222
+  metadata.gz: 92f14ca413e9e716ea9b3046abc13d3929893185cfef8cdeaf14b7bebc93755c
+  data.tar.gz: 93bfa962b7954844560961d66d080fa2c45a3188b8c9b92420d1852e36ce718b
 SHA512:
-  metadata.gz: 75bd827d5d0fc6566ba54f48cd432fab6cad301f2b5eb781383ea227ec74e2699733026fc22086899ac8bf725280e9cb1a5d7ca42545074cee1eb932142f9d93
-  data.tar.gz: ad9f387210fb8d30c06b5177a51b934a415d36805d94729d8117408200b241ee3f9408884bfbe63ab2bc93b28118f69a13dbe1aa05e3a2eb80bf04705a6b3de4
+  metadata.gz: bb81903bbb00357ab9613a59fb2684bfaad7671fbca955f9876d503f5b179f8ead6d36f248ea24909f30db3ddb6f4fc307c509a181d2fe85d33d1e04006856da
+  data.tar.gz: f813c1e8d6e320f6810cc33620fe702c379f47124b6add4bc1bdabde81c4e12c60a6aac5711caf8c23672f838d6185106ffb3695770a7c4002d04404c87929cb

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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

data/README.md

@@ -91,6 +91,30 @@ 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.
 
+## 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
@@ -123,12 +147,22 @@ 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
+**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
@@ -136,12 +170,10 @@ expect {}.to execute.exactly(20).insert_queries
 This gem still has lots of future functionality. See below.
 
 ```ruby
-expect {}.to execute.at_least(2).activerecord_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).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
@@ -152,13 +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)
 ```
 
-- differentiate AR queries from generic ones? arbitrary execution somehow?
-- warn about warmup
 - 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

@@ -2,11 +2,16 @@ module RSpec::ActiveRecord::Expectations
   class Collector
     def initialize
       @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)
@@ -17,11 +22,21 @@ module RSpec::ActiveRecord::Expectations
       @counts.include? type
     end
 
+    def calls_by_name(name)
+      @by_name.fetch(name, 0)
+    end
+
     def record_query(*_unused, data)
       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
@@ -67,6 +69,14 @@ module RSpec::ActiveRecord::Expectations
           @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
@@ -74,13 +84,17 @@ module RSpec::ActiveRecord::Expectations
 
       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
@@ -89,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
@@ -98,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
@@ -108,8 +122,8 @@ 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
@@ -117,8 +131,8 @@ module RSpec::ActiveRecord::Expectations
       def compare_exactly
         count = @collector.queries_of_type(@query_type)
 
-        @failure_message = "expected block to execute at #{@comparison} queries, but it executed #{count}"
-        @failure_message_when_negated = "expected block not to execute #{@comparison} queries, but it executed #{count}"
+        @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

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

@@ -1,7 +1,8 @@
 module RSpec::ActiveRecord::Expectations
   class QueryInspector
     def self.valid_query_types
-      [:queries, :schema_queries, :transaction_queries, :insert_queries]
+      [:queries, :schema_queries, :transaction_queries, :insert_queries,
+       :load_queries, :destroy_queries, :exists_queries]
     end
 
     def categorize(query)
@@ -11,6 +12,14 @@ module RSpec::ActiveRecord::Expectations
         [: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

data/lib/rspec/activerecord/expectations.rb

@@ -4,6 +4,10 @@ module RSpec
       def execute
         Matchers::QueryCountMatcher.new
       end
+
+      def repeatedly_load(klass)
+        Matchers::LoadMatcher.new(klass)
+      end
     end
   end
 end
@@ -11,4 +15,5 @@ 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.2.0'
+  spec.version       = '1.3.0'
   spec.authors       = ["Joseph Mastey"]
   spec.email         = ["hello@joemastey.com"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-activerecord-expectations
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Joseph Mastey
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-31 00:00:00.000000000 Z
+date: 2022-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -102,7 +102,8 @@ 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