rspec-activerecord-expectations 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3205b050d5f2164b5bc72de9fe29a0f6d988cd869ecd6703a09b83b2550bb02e
-  data.tar.gz: d43d363888f5c8f85dc551fae7d1381a945ac304c597192544ffd1506d1f7495
+  metadata.gz: 0f84a252fb5e5923d4bc6c03ed4d99ede76579017d8391dbf6f48a665236e54e
+  data.tar.gz: ce944950ee62940f67f79204966f5954fc28eac8f52dee79e18475933d9f3910
 SHA512:
-  metadata.gz: a98cfac5ba127c3e5f7bd2b42ef48fa56e6750e75d0ab841988b076a2a39c0ca13e5d67e534020fd81af3b7885cba3d192c23a2fbb0b4ccd0d8e725e3cafb147
-  data.tar.gz: 65347df27d406531b1ea594bfe9a3d9b6405c75ad5f8be5c3f52f668e3d976e0e73c5e1560caeb308cb203b73547ab18c0ffd758aff0e913a9f010665a0a6595
+  metadata.gz: 4828d15b2420ae821199db596b96cc5d4630e3994b6c12bb2d6b95c32067388bb30161b318b0c03c49771d5b95e3010757e564c70a1f6840ab6934c14479f58d
+  data.tar.gz: d8220ae71a3e1dc6be694f976185262e019d55c6eedc1ec255492fbb5cd7a2988ac45e3519c14f1936cf8d0fd09062710f71b2d788322771e4ccde864be436a9

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [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

data/README.md

@@ -230,8 +230,20 @@ 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 in order for the test to fail.
+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
 
@@ -248,9 +260,6 @@ 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 {}.to commit_a_transaction.once
-expect {}.to rollback_a_transaction.exactly(5).times
 ```
 
 - warn if we smite any built in methods (or methods from other libs)

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

@@ -1,9 +1,22 @@
 module RSpec::ActiveRecord::Expectations
   module Matchers
     class TransactionMatcher
+      attr_reader :collector, :quantifier, :comparison, :query_type
+
       def initialize(transaction_type)
         @collector    = Collector.new
-        @transaction  = transaction_type
+        @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?
@@ -11,59 +24,75 @@ module RSpec::ActiveRecord::Expectations
       end
 
       def matches?(block)
+        raise NoComparisonError unless @match_method
+
         block.call
+        result = @match_method.call
+        @collector.finalize
 
-        @count = @collector.queries_of_type(@transaction)
-        @count > 0
+        result
       end
 
-      def failure_message
-        type_msg = case @transaction
-                   when :transaction_queries
-                     "execute a transaction"
-                   when :rollback_queries
-                     "roll back a transaction"
-                   when :commit_queries
-                     "commit a transaction"
-                   end
-
-        "expected block to #{type_msg}, but it didn't do so"
+      # QUANTIFIERS
+
+      def less_than(n)
+        @quantifier   = n
+        @comparison = :less_than
+        @match_method = -> { actual_count < @quantifier }
+        self
       end
+      alias_method :fewer_than, :less_than
 
-      def failure_message_when_negated
-        if @count == 1
-          negated_message_singular
-        else
-          negated_message_plural
-        end
+      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
 
-      private
+      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 negated_message_singular
-        pre_msg, post_msg  = case @transaction
-                             when :transaction_queries
-                               ["execute a transaction", "executed one"]
-                             when :rollback_queries
-                               ["roll back a transaction", "rolled one back"]
-                             when :commit_queries
-                               ["commit a transaction", "committed one"]
-                             end
+      def once
+        exactly(1).time
+      end
+
+      def twice
+        exactly(2).times
+      end
+
+      def thrice # hehe
+        exactly(3).times
+      end
 
-        "expected block not to #{pre_msg}, but it #{post_msg}"
+      def times
+        self # NOOP
       end
+      alias_method :time, :times
 
-      def negated_message_plural
-        pre_msg, post_msg = case @transaction
-                   when :transaction_queries
-                     ["execute a transaction", "executed #{@count} transactions"]
-                   when :rollback_queries
-                     ["roll back a transaction", "rolled back #{@count} transactions"]
-                   when :commit_queries
-                     ["commit a transaction", "committed #{@count} transactions"]
-                   end
-
-        "expected block not to #{pre_msg}, but it #{post_msg}"
+      def actual_count
+        @collector.queries_of_type(@query_type)
       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.rb

@@ -31,6 +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       = '2.2.0'
+  spec.version       = '2.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: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Joseph Mastey
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-15 00:00:00.000000000 Z
+date: 2022-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -105,6 +105,7 @@ files:
 - 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