shoulda-matchers 1.1.0 → 1.2.0

data/lib/shoulda/matchers/active_record/association_matcher.rb

@@ -56,31 +56,32 @@ module Shoulda # :nodoc:
       class AssociationMatcher # :nodoc:
         def initialize(macro, name)
           @macro = macro
-          @name  = name
+          @name = name
+          @options = {}
         end
 
         def through(through)
-          @through = through
+          @options[:through] = through
           self
         end
 
         def dependent(dependent)
-          @dependent = dependent
+          @options[:dependent] = dependent
           self
         end
 
         def order(order)
-          @order = order
+          @options[:order] = order
           self
         end
 
         def conditions(conditions)
-          @conditions = conditions
+          @options[:conditions] = conditions
           self
         end
 
         def class_name(class_name)
-          @class_name = class_name
+          @options[:class_name] = class_name
           self
         end
 
@@ -107,10 +108,10 @@ module Shoulda # :nodoc:
 
         def description
           description = "#{macro_description} #{@name}"
-          description += " through #{@through}" if @through
-          description += " dependent => #{@dependent}" if @dependent
-          description += " class_name => #{@class_name}" if @class_name
-          description += " order => #{@order}" if @order
+          description += " through #{@options[:through]}"          if @options.key?(:through)
+          description += " dependent => #{@options[:dependent]}"   if @options.key?(:dependent)
+          description += " class_name => #{@options[:class_name]}" if @options.key?(:class_name)
+          description += " order => #{@options[:order]}"           if @options.key?(:order)
           description
         end
 
@@ -149,12 +150,12 @@ module Shoulda # :nodoc:
         end
 
         def through_association_valid?
-          @through.nil? || (through_association_exists? && through_association_correct?)
+          @options[:through].nil? || (through_association_exists? && through_association_correct?)
         end
 
         def through_association_exists?
           if through_reflection.nil?
-            @missing = "#{model_class.name} does not have any relationship to #{@through}"
+            @missing = "#{model_class.name} does not have any relationship to #{@options[:through]}"
             false
           else
             true
@@ -162,48 +163,60 @@ module Shoulda # :nodoc:
         end
 
         def through_association_correct?
-          if @through == reflection.options[:through]
+          if @options[:through] == reflection.options[:through]
             true
           else
-            @missing = "Expected #{model_class.name} to have #{@name} through #{@through}, " +
+            @missing = "Expected #{model_class.name} to have #{@name} through #{@options[:through]}, " +
               "but got it through #{reflection.options[:through]}"
             false
           end
         end
 
         def dependent_correct?
-          if @dependent.nil? || @dependent.to_s == reflection.options[:dependent].to_s
+          if @options[:dependent].nil? || @options[:dependent].to_s == reflection.options[:dependent].to_s
             true
           else
-            @missing = "#{@name} should have #{@dependent} dependency"
+            @missing = "#{@name} should have #{@options[:dependent]} dependency"
             false
           end
         end
 
         def class_name_correct?
-          if @class_name.nil? || @class_name.to_s == reflection.options[:class_name].to_s
-            true
+          if @options.key?(:class_name)
+            if @options[:class_name].to_s == reflection.options[:class_name].to_s
+              true
+            else
+              @missing = "#{@name} should have #{@options[:class_name]} as class_name"
+              false
+            end
           else
-            @missing = "#{@name} should have #{@class_name} as class_name"
-            false
+            true
           end
         end
 
         def order_correct?
-          if @order.nil? || @order.to_s == reflection.options[:order].to_s
-            true
+          if @options.key?(:order)
+            if @options[:order].to_s == reflection.options[:order].to_s
+              true
+            else
+              @missing = "#{@name} should be ordered by #{@options[:order]}"
+              false
+            end
           else
-            @missing = "#{@name} should be ordered by #{@order}"
-            false
+            true
           end
         end
 
         def conditions_correct?
-          if @conditions.nil? || @conditions.to_s == reflection.options[:conditions].to_s
-            true
+          if @options.key?(:conditions)
+            if @options[:conditions].to_s == reflection.options[:conditions].to_s
+              true
+            else
+              @missing = "#{@name} should have the following conditions: #{@options[:conditions]}"
+              false
+            end
           else
-            @missing = "#{@name} should have the following conditions: #{@conditions}"
-            false
+            true
           end
         end
 
@@ -265,7 +278,7 @@ module Shoulda # :nodoc:
         end
 
         def through_reflection
-          @through_reflection ||= model_class.reflect_on_association(@through)
+          @through_reflection ||= model_class.reflect_on_association(@options[:through])
         end
 
         def expectation
@@ -274,10 +287,13 @@ module Shoulda # :nodoc:
 
         def macro_description
           case @macro.to_s
-          when 'belongs_to' then 'belong to'
-          when 'has_many'   then 'have many'
-          when 'has_one'    then 'have one'
-          when 'has_and_belongs_to_many' then
+          when 'belongs_to'
+            'belong to'
+          when 'has_many'
+            'have many'
+          when 'has_one'
+            'have one'
+          when 'has_and_belongs_to_many'
             'have and belong to many'
           end
         end

data/lib/shoulda/matchers/active_record/have_db_column_matcher.rb

@@ -22,20 +22,20 @@ module Shoulda # :nodoc:
       class HaveDbColumnMatcher # :nodoc:
         def initialize(column)
           @column = column
+          @options = {}
         end
 
         def of_type(column_type)
-          @column_type = column_type
+          @options[:column_type] = column_type
           self
         end
 
         def with_options(opts = {})
-          @precision = opts[:precision]
-          @limit     = opts[:limit]
-          @default   = opts[:default]
-          @null      = opts[:null]
-          @scale     = opts[:scale]
-          @primary   = opts[:primary]
+          %w(precision limit default null scale primary).each do |attribute|
+            if opts.key?(attribute.to_sym)
+              @options[attribute.to_sym] = opts[attribute.to_sym]
+            end
+          end
           self
         end
 
@@ -61,13 +61,13 @@ module Shoulda # :nodoc:
 
         def description
           desc = "have db column named #{@column}"
-          desc << " of type #{@column_type}"    unless @column_type.nil?
-          desc << " of precision #{@precision}" unless @precision.nil?
-          desc << " of limit #{@limit}"         unless @limit.nil?
-          desc << " of default #{@default}"     unless @default.nil?
-          desc << " of null #{@null}"           unless @null.nil?
-          desc << " of primary #{@primary}"     unless @primary.nil?
-          desc << " of scale #{@scale}"         unless @scale.nil?
+          desc << " of type #{@options[:column_type]}"    if @options.key?(:column_type)
+          desc << " of precision #{@options[:precision]}" if @options.key?(:precision)
+          desc << " of limit #{@options[:limit]}"         if @options.key?(:limit)
+          desc << " of default #{@options[:default]}"     if @options.key?(:default)
+          desc << " of null #{@options[:null]}"           if @options.key?(:null)
+          desc << " of primary #{@options[:primary]}"     if @options.key?(:primary)
+          desc << " of scale #{@options[:scale]}"         if @options.key?(:scale)
           desc
         end
 
@@ -83,82 +83,89 @@ module Shoulda # :nodoc:
         end
 
         def correct_column_type?
-          return true if @column_type.nil?
-          if matched_column.type.to_s == @column_type.to_s
+          return true unless @options.key?(:column_type)
+
+          if matched_column.type.to_s == @options[:column_type].to_s
             true
           else
             @missing = "#{model_class} has a db column named #{@column} " <<
-                       "of type #{matched_column.type}, not #{@column_type}."
+                       "of type #{matched_column.type}, not #{@options[:column_type]}."
             false
           end
         end
 
         def correct_precision?
-          return true if @precision.nil?
-          if matched_column.precision.to_s == @precision.to_s
+          return true unless @options.key?(:precision)
+
+          if matched_column.precision.to_s == @options[:precision].to_s
             true
           else
             @missing = "#{model_class} has a db column named #{@column} " <<
                        "of precision #{matched_column.precision}, " <<
-                       "not #{@precision}."
+                       "not #{@options[:precision]}."
             false
           end
         end
 
         def correct_limit?
-          return true if @limit.nil?
-          if matched_column.limit.to_s == @limit.to_s
+          return true unless @options.key?(:limit)
+
+          if matched_column.limit.to_s == @options[:limit].to_s
             true
           else
             @missing = "#{model_class} has a db column named #{@column} " <<
                        "of limit #{matched_column.limit}, " <<
-                       "not #{@limit}."
+                       "not #{@options[:limit]}."
             false
           end
         end
 
         def correct_default?
-          return true if @default.nil?
-          if matched_column.default.to_s == @default.to_s
+          return true unless @options.key?(:default)
+
+          if matched_column.default.to_s == @options[:default].to_s
             true
           else
             @missing = "#{model_class} has a db column named #{@column} " <<
                        "of default #{matched_column.default}, " <<
-                       "not #{@default}."
+                       "not #{@options[:default]}."
             false
           end
         end
 
         def correct_null?
-          return true if @null.nil?
-          if matched_column.null.to_s == @null.to_s
+          return true unless @options.key?(:null)
+
+          if matched_column.null.to_s == @options[:null].to_s
             true
           else
             @missing = "#{model_class} has a db column named #{@column} " <<
                        "of null #{matched_column.null}, " <<
-                       "not #{@null}."
+                       "not #{@options[:null]}."
             false
           end
         end
 
         def correct_scale?
-          return true if @scale.nil?
-          if matched_column.scale.to_s == @scale.to_s
+          return true unless @options.key?(:scale)
+
+          if matched_column.scale.to_s == @options[:scale].to_s
             true
           else
             @missing = "#{model_class} has a db column named #{@column} " <<
-                       "of scale #{matched_column.scale}, not #{@scale}."
+                       "of scale #{matched_column.scale}, not #{@options[:scale]}."
             false
           end
         end
 
         def correct_primary?
-          return true if @primary.nil?
-          if matched_column.primary == @primary
+          return true unless @options.key?(:primary)
+
+          if matched_column.primary == @options[:primary]
             true
           else
             @missing = "#{model_class} has a db column named #{@column} "
-            if @primary
+            if @options[:primary]
               @missing << "that is not primary, but should be"
             else
               @missing << "that is primary, but should not be"

data/lib/shoulda/matchers/active_record/have_db_index_matcher.rb

@@ -9,8 +9,7 @@ module Shoulda # :nodoc:
       # * <tt>unique</tt> - whether or not the index has a unique
       #   constraint. Use <tt>true</tt> to explicitly test for a unique
       #   constraint.  Use <tt>false</tt> to explicitly test for a non-unique
-      #   constraint. Use <tt>nil</tt> if you don't care whether the index is
-      #   unique or not.  Default = <tt>nil</tt>
+      #   constraint.
       #
       # Examples:
       #
@@ -25,10 +24,11 @@ module Shoulda # :nodoc:
       class HaveDbIndexMatcher # :nodoc:
         def initialize(columns)
           @columns = normalize_columns_to_array(columns)
+          @options = {}
         end
 
         def unique(unique)
-          @unique = unique
+          @options[:unique] = unique
           self
         end
 
@@ -46,7 +46,11 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "have a #{index_type} index on columns #{@columns.join(' and ')}"
+          if @options.key?(:unique)
+            "have a #{index_type} index on columns #{@columns.join(' and ')}"
+          else
+            "have an index on columns #{@columns.join(' and ')}"
+          end
         end
 
         protected
@@ -56,12 +60,13 @@ module Shoulda # :nodoc:
         end
 
         def correct_unique?
-          return true if @unique.nil?
-          if !!matched_index.unique == @unique
+          return true unless @options.key?(:unique)
+
+          if matched_index.unique == @options[:unique]
             true
           else
             @missing = "#{table_name} has an index named #{matched_index.name} " <<
-                       "of unique #{!!matched_index.unique}, not #{@unique}."
+                       "of unique #{matched_index.unique}, not #{@options[:unique]}."
             false
           end
         end
@@ -87,13 +92,10 @@ module Shoulda # :nodoc:
         end
 
         def index_type
-          case @unique
-          when nil
-            ''
-          when false
-            'non-unique'
-          else
+          if @options[:unique]
             'unique'
+          else
+            'non-unique'
           end
         end
 

data/lib/shoulda/matchers/active_record/query_the_database_matcher.rb

@@ -20,65 +20,66 @@ module Shoulda # :nodoc:
 
       class QueryTheDatabaseMatcher # :nodoc:
         def initialize(times)
+          @queries = []
+          @options = {}
+
           if times.respond_to?(:count)
-            @expected_query_count = times.count
+            @options[:expected_query_count] = times.count
           else
-            @expected_query_count = times
+            @options[:expected_query_count] = times
           end
         end
 
         def when_calling(method_name)
-          @method_name = method_name
+          @options[:method_name] = method_name
           self
         end
 
         def with(*method_arguments)
-          @method_arguments = method_arguments
+          @options[:method_arguments] = method_arguments
           self
         end
 
         def or_less
-          @expected_count_is_maximum = true
+          @options[:expected_count_is_maximum] = true
           self
         end
 
         def matches?(subject)
-          @queries = []
-
           subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |name, started, finished, id, payload|
             @queries << payload unless filter_query(payload)
           end
 
-          if @method_arguments
-            subject.send(@method_name, *@method_arguments)
+          if @options[:method_arguments]
+            subject.send(@options[:method_name], *@options[:method_arguments])
           else
-            subject.send(@method_name)
+            subject.send(@options[:method_name])
           end
 
           ActiveSupport::Notifications.unsubscribe(subscriber)
 
-          if @expected_count_is_maximum
-            @queries.length <= @expected_query_count
-          elsif @expected_query_count.present?
-            @queries.length == @expected_query_count
+          if @options[:expected_count_is_maximum]
+            @queries.length <= @options[:expected_query_count]
+          elsif @options[:expected_query_count].present?
+            @queries.length == @options[:expected_query_count]
           else
             @queries.length > 0
           end
         end
 
         def failure_message
-          if @expected_query_count
-            "Expected ##{@method_name} to cause #{@expected_query_count} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
+          if @options.key?(:expected_query_count)
+            "Expected ##{@options[:method_name]} to cause #{@options[:expected_query_count]} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
           else
-            "Expected ##{@method_name} to query the database but it actually caused #{@queries.length} queries:" + friendly_queries
+            "Expected ##{@options[:method_name]} to query the database but it actually caused #{@queries.length} queries:" + friendly_queries
           end
         end
 
         def negative_failure_message
-          if @expected_query_count
-            "Expected ##{@method_name} to not cause #{@expected_query_count} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
+          if @options[:expected_query_count]
+            "Expected ##{@options[:method_name]} to not cause #{@options[:expected_query_count]} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
           else
-            "Expected ##{@method_name} to not query the database but it actually caused #{@queries.length} queries:" + friendly_queries
+            "Expected ##{@options[:method_name]} to not query the database but it actually caused #{@queries.length} queries:" + friendly_queries
           end
         end
 
@@ -91,14 +92,14 @@ module Shoulda # :nodoc:
         end
 
         def filter_query(query)
-          query[:name] == 'SCHEMA' || looks_like_schema(query[:sql])
+          query[:name] == 'SCHEMA' || looks_like_schema?(query[:sql])
         end
 
         def schema_terms
-          ['FROM sqlite_master', 'PRAGMA', 'SHOW TABLES', 'SHOW KEYS FROM', 'SHOW FIELDS FROM']
+          ['FROM sqlite_master', 'PRAGMA', 'SHOW TABLES', 'SHOW KEYS FROM', 'SHOW FIELDS FROM', 'begin transaction', 'commit transaction']
         end
 
-        def looks_like_schema(sql)
+        def looks_like_schema?(sql)
           schema_terms.any? { |term| sql.include?(term) }
         end
       end