carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/active_record/macros/associations/association_matcher.rb

@@ -0,0 +1,242 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+
+      class AssociationMatcher < Remarkable::Matcher::Base
+        def initialize(macro, *associations)
+          @options = associations.extract_options!
+          @macro = macro
+          @associations = associations
+        end
+
+        def through(through)
+          @options[:through] = through
+          self
+        end
+
+        def dependent(dependent)
+          @options[:dependent] = dependent
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+          
+          assert_matcher_for(@associations) do |association|
+            association_correct?(association)
+          end
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          description = "#{macro_description} #{@associations.to_sentence}"
+          description += " through #{@options[:through]}" if @options[:through]
+          description += " dependent => #{@options[:dependent]}" if @options[:dependent]
+          description
+        end
+
+        protected
+
+        def association_correct?(association)
+          @name = association
+          
+          association_exists? && 
+          macro_correct? && 
+          foreign_key_exists? && 
+          through_association_valid? && 
+          dependent_correct? &&
+          join_table_exists?
+        end
+
+        def association_exists?
+          if reflection.nil?
+            @missing = "no association called #{@name}"
+            false
+          else
+            true
+          end
+        end
+
+        def macro_correct?
+          if reflection.macro == @macro
+            true
+          else
+            @missing = "actual association type was #{reflection.macro}"
+            false
+          end
+        end
+
+        def foreign_key_exists?
+          !(belongs_foreign_key_missing? || has_foreign_key_missing?)
+        end
+
+        def belongs_foreign_key_missing?
+          @macro == :belongs_to && !class_has_foreign_key?(subject_class)
+        end
+
+        def has_foreign_key_missing?
+          [:has_many, :has_one].include?(@macro) &&
+          !through? &&
+          !class_has_foreign_key?(associated_class)
+        end
+
+        def through_association_valid?
+          @options[:through].nil? || (through_association_exists? && through_association_correct?)
+        end
+
+        def through_association_exists?
+          if through_reflection.nil?
+            @missing = "#{subject_name} does not have any relationship to #{@options[:through]}"
+            false
+          else
+            true
+          end
+        end
+
+        def through_association_correct?
+          if @options[:through] == reflection.options[:through]
+            @missing = "Expected #{subject_name} to have #{@name} through #{@options[:through]}, " <<
+            " but got it through #{reflection.options[:through]}"
+            true
+          else
+            false
+          end
+        end
+
+        def dependent_correct?
+          if @options[:dependent].nil? || @options[:dependent].to_s == reflection.options[:dependent].to_s
+            true
+          else
+            @missing = "#{@name} should have #{@options[:dependent]} dependency"
+            false
+          end
+        end
+
+        def join_table_exists?
+          if @macro != :has_and_belongs_to_many || 
+            ::ActiveRecord::Base.connection.tables.include?(join_table.to_s)
+            true
+          else
+            @missing = "join table #{join_table} doesn't exist"
+            false
+          end
+        end
+
+        def class_has_foreign_key?(klass)
+          if klass.column_names.include?(foreign_key.to_s)
+            true
+          else
+            @missing = "#{klass} does not have a #{foreign_key} foreign key."
+            false
+          end
+        end
+
+        def join_table
+          reflection.options[:join_table]
+        end
+
+        def associated_class
+          reflection.klass
+        end
+
+        def foreign_key
+          reflection.primary_key_name
+        end
+
+        def through?
+          reflection.options[:through]
+        end
+
+        def reflection
+          subject_class.reflect_on_association(@name)
+        end
+
+        def through_reflection
+          subject_class.reflect_on_association(@options[:through])
+        end
+
+        def expectation
+          "#{subject_name} to have a #{@macro} association called #{@name}"
+        end
+
+        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
+            'have and belong to many'
+          end
+        end
+      end
+
+
+      # Ensure that the belongs_to relationship exists.
+      #
+      # Examples:
+      #
+      #   should_belong_to :parent
+      #   it { should belong_to(:parent) }
+      #
+      def belong_to(*associations)
+        AssociationMatcher.new(:belongs_to, *associations)
+      end
+
+      # Ensures that the has_many relationship exists. Will also test that the associated table has the required columns. Works with polymorphic associations.
+      #
+      # Options:
+      #
+      # * <tt>:through</tt> - association name for has_many :through
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Examples:
+      #
+      #   should_have_many :friends
+      #   should_have_many :enemies, :through => :friends
+      #   should_have_many :enemies, :dependent => :destroy
+      #
+      #   it{ should have_many(:friends) }
+      #   it{ should have_many(:enemies, :through => :friends) }
+      #   it{ should have_many(:enemies, :dependent => :destroy) }
+      #
+      #
+      def have_many(*associations)
+        AssociationMatcher.new(:has_many, *associations)
+      end
+
+      # Ensure that the has_one relationship exists. Will also test that the associated table has the required columns. Works with polymorphic associations.
+      #
+      # Options:
+      #
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Examples:
+      #
+      #  should_have_one :god
+      #  it{ should have_one(:god) }
+      #
+      def have_one(*associations)
+        AssociationMatcher.new(:has_one, *associations)
+      end
+
+      # Ensures that the has_and_belongs_to_many relationship exists, and that the join table is in place.
+      #
+      # Examples:
+      #
+      #  should_have_and_belong_to_many :posts, :cars
+      #  it{ should have_and_belong_to_many :posts, :cars }
+      #
+      def have_and_belong_to_many(*associations)
+        AssociationMatcher.new(:has_and_belongs_to_many, *associations)
+      end
+
+    end
+  end
+end

data/lib/remarkable/active_record/macros/callbacks/callback_matcher.rb

@@ -0,0 +1,46 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+
+      ::ActiveRecord::Callbacks::CALLBACKS.each do |callback|
+        define_method("have_#{callback}_callback") do |method|
+          CallbackMatcher.new(callback, method)
+        end
+      end
+
+      class CallbackMatcher < Remarkable::Matcher::Base
+        def initialize(callback, method)
+          @callback = callback
+          @method   = method
+        end
+
+        def matches?(subject)
+          @subject = subject
+          assert_matcher { has_callback? }
+        end
+
+        def description
+          "have a #{@callback} callback named #{@method}"
+        end
+
+        private
+
+        def has_callback?
+          return true if callbacks_for(@callback).include?(@method)
+
+          @missing = "#{subject_name} does not have a #{@callback} callback named #{@method}"
+          return false
+        end
+
+        def callbacks_for(callback)
+          subject_class.send("#{callback}_callback_chain").collect(&:method)
+        end
+
+        def expectation
+          "#{subject_name} have a #{@callback} callback named #{@method}"
+        end
+
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/database/column_matcher.rb

@@ -0,0 +1,122 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+
+      class ColumnMatcher < Remarkable::Matcher::Base
+        def initialize(*columns)
+          @options = columns.extract_options!
+          @columns  = columns
+        end
+
+        def type(type)
+          @options[:type] = type
+          self
+        end
+
+        def primary(value = true)
+          @options[:primary] = value
+          self
+        end
+
+        def default(default)
+          @options[:default] = default
+          self
+        end
+
+        def precision(precision)
+          @options[:precision] = precision
+          self
+        end
+
+        def limit(limit)
+          @options[:limit] = limit
+          self
+        end
+
+        def null(value = true)
+          @options[:null] = value
+          self
+        end
+
+        def scale(scale)
+          @options[:scale] = scale
+          self
+        end
+
+        def sql_type(sql_type)
+          @options[:sql_type] = sql_type
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+          
+          assert_matcher_for(@columns) do |column|
+            @column = column
+            has_column? && all_options_correct?
+          end
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          description = if @columns.size == 1
+            "have column named :#{@columns[0]}"
+          else
+            "have columns #{@columns.to_sentence}"
+          end
+          description << " with options " + @options.inspect unless @options.empty?
+          description
+        end
+
+        protected
+
+        def column_type
+          subject_class.columns.detect {|c| c.name == @column.to_s }
+        end
+
+        def has_column?
+          return true if column_type
+          @missing = "#{subject_name} does not have column #{@column}"
+          false
+        end
+
+        def all_options_correct?
+          @options.each do |option, value|
+            return false unless option_correct?(option, value)
+          end
+        end
+
+        def option_correct?(option, expected_value)
+          found_value = column_type.instance_variable_get("@#{option.to_s}").to_s
+
+          if found_value == expected_value.to_s
+            true
+          else
+            @missing = ":#{@column} column on table for #{subject_class} does not match option :#{option}, found '#{found_value}' but expected '#{expected_value}'"
+            false
+          end
+        end
+
+        def expectation
+          "#{subject_name} to have a column named #{@column}"
+        end
+      end
+
+      def have_db_column(column, options = {})
+        ColumnMatcher.new(column, options)
+      end
+      
+      def have_db_columns(*columns)
+        ColumnMatcher.new(*columns)
+      end
+      
+    end
+  end
+end

data/lib/remarkable/active_record/macros/database/index_matcher.rb

@@ -0,0 +1,103 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+
+      # Ensures the database column has specified index.
+      #
+      # Options:
+      # * <tt>unique</tt> - 
+      #
+      # Example:
+      #   it { should have_index(:ssn).unique(true) }
+      #
+      def have_indices(*columns)
+        IndexMatcher.new(*columns)
+      end
+      alias_method :have_index, :have_indices
+
+      class IndexMatcher < Remarkable::Matcher::Base
+        INDEX_TYPES = { true => "unique", false => "non-unique" }
+        
+        def initialize(*columns)
+          load_options(columns)
+          @columns = columns
+        end
+
+        def unique(value = true)
+          @options[:unique] = value
+          self
+        end
+
+        def table_name=(table_name)
+          @table_name = table_name
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @expected_uniqueness = @options[:unique] ? 'unique' : 'non-unique'
+          
+          assert_matcher_for(@columns) do |column|
+            @column = column
+            index_exists? && correct_unique?
+          end
+        end
+
+        def failure_message
+          "Expected to #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect to #{expectation}"
+        end
+
+        def description
+          "have #{index_type} index on #{table_name} for #{@columns.inspect}"
+        end
+
+        protected
+
+        def index_exists?
+          return true if matched_index
+
+          @missing = "#{table_name} does not have an index for #{@column}"
+          return false
+        end
+
+        def correct_unique?
+          return true unless [true, false].include?(@options[:unique])
+          return true if @options[:unique] == matched_index.unique
+
+          @missing = "Expected #{index_type} index but was #{INDEX_TYPES[!@options[:unique]]}."
+          return false
+        end
+
+        def matched_index
+          columns = [@column].flatten.map(&:to_s)
+          indexes.detect { |ind| ind.columns == columns }
+        end
+
+        def index_type
+          INDEX_TYPES[@options[:unique]] || "an"
+        end
+
+        def table_name
+          @table_name ||= subject_class.table_name
+        end
+
+        def indexes
+          @indexes ||= ::ActiveRecord::Base.connection.indexes(table_name)
+        end
+
+        def expectation
+          "have #{index_type} index on #{table_name} for #{@column.inspect}"
+        end
+        
+        def load_options(options)
+          @options = {
+            :unique => nil
+          }.merge(options.extract_options!)
+        end
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/allow_mass_assignment_of_matcher.rb

@@ -0,0 +1,52 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class AllowMassAssignmentOfMatcher < Remarkable::Matcher::Base
+        def initialize(*attributes)
+          attributes.extract_options!
+          @attributes = attributes
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher_for(@attributes) do |attribute|
+            @attribute = attribute
+            allowed_to_mass_update?
+          end
+        end
+
+        def description
+          "allow mass assignment of #{@attributes.to_sentence}"
+        end
+
+        private
+
+        def allowed_to_mass_update?
+          attribute  = @attribute.to_sym
+          protected  = subject_class.protected_attributes || []
+          accessible = subject_class.accessible_attributes || []
+
+          return true unless protected.include?(attribute.to_s)
+          return true unless accessible.empty? || accessible.include?(attribute.to_s)
+
+          @missing = accessible.empty? ? "#{subject_class} is protecting #{protected.to_a.to_sentence}" :
+                                         "#{subject_class} has not made #{attribute} accessible"
+          return false
+        end
+
+        def expectation
+          "to allow mass assignment of #{@attribute}"
+        end
+      end
+
+      # Ensures that the attribute can be set on mass update.
+      #
+      #   it { should allow_mass_assignment_of(:email, :name) }
+      #
+      def allow_mass_assignment_of(*attributes)
+        AllowMassAssignmentOfMatcher.new(*attributes)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/ensure_value_in_list_matcher.rb

@@ -0,0 +1,83 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class EnsureValueInListMatcher < Remarkable::Matcher::Base
+        include Remarkable::ActiveRecord::Helpers
+
+        def initialize(attribute, behavior, *good_values)
+          @behavior = behavior
+          load_options(good_values.extract_options!)
+
+          @attribute = attribute
+          @good_values = good_values
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher_for(@good_values) do |good_value|
+            @good_value = good_value
+            value_valid?
+          end &&
+          assert_matcher do
+            @good_value = 'nil'
+            allow_nil?
+          end &&
+          assert_matcher do
+            @good_value = 'blank'
+            allow_blank?
+          end
+        end
+
+        def description
+          values = @good_values.dup
+          values << 'nil'   if @options[:allow_nil]
+          values << 'blank' if @options[:allow_blank]
+
+          if @behavior == :invalid
+            "allow #{@attribute} to be set to #{values.to_sentence}"
+          else
+            "ensure #{@behavior} of #{values.to_sentence} in #{@attribute}"
+          end
+        end
+
+        def failure_message
+          "Expected to #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect to #{expectation}"
+        end
+
+        private
+
+        def load_options(options = {})
+          @options = {
+            :message => @behavior
+          }.merge(options)
+        end
+
+        def value_valid?
+          if @behavior == :exclusion
+            return true if bad?(@good_value)
+            @missing = "#{@attribute} can be set to #{@good_value.inspect}"
+          else
+            return true if good?(@good_value)
+            @missing = "#{@attribute} cannot be set to #{@good_value.inspect}"
+          end
+
+          false
+        end
+
+        def expectation
+          if @behavior == :invalid
+            "allow #{@attribute} to be set to #{@good_value.inspect}"
+          else
+            "validate #{@behavior} of #{@good_value.inspect} in #{@attribute}"
+          end
+        end
+      end
+
+    end
+  end
+end