remarkable_activerecord 3.0.0

data/lib/remarkable_activerecord/matchers/association_matcher.rb

@@ -0,0 +1,235 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class AssociationMatcher < Remarkable::ActiveRecord::Base
+        arguments :macro, :collection => :associations, :as => :association
+
+        optionals :through, :class_name, :foreign_key, :dependent, :join_table, :as
+        optionals :uniq, :readonly, :validate, :autosave, :polymorphic, :counter_cache, :default => true
+
+        # Stores optionals declared above in a CONSTANT to generate assertions
+        ASSOCIATION_OPTIONS = self.matcher_optionals
+
+        collection_assertions :association_exists?, :macro_matches?, :through_exists?,
+                              :join_table_exists?, :foreign_key_exists?, :polymorphic_exists?,
+                              :counter_cache_exists?
+
+        protected
+
+          def association_exists?
+            reflection
+          end
+
+          def macro_matches?
+            reflection.macro == @macro
+          end
+
+          def through_exists?
+            return true unless @options.key?(:through)
+            subject_class.reflect_on_association(@options[:through])
+          end
+
+          def join_table_exists?
+            return true unless has_join_table?
+            ::ActiveRecord::Base.connection.tables.include?(reflection_join_table)
+          end
+
+          def foreign_key_exists?
+            table_has_column?(foreign_key_table, reflection_foreign_key)
+          end
+
+          def polymorphic_exists?
+            return true unless @options[:polymorphic]
+            table_has_column?(subject_class.table_name, reflection_foreign_key.sub(/_id$/, '_type'))
+          end
+
+          def counter_cache_exists?
+            return true unless @options[:counter_cache]
+            table_has_column?(reflection.klass.table_name, reflection.counter_cache_column.to_s)
+          end
+
+          ASSOCIATION_OPTIONS.each do |option|
+            collection_assertion :"#{option}_matches?"
+
+            class_eval <<-METHOD, __FILE__, __LINE__
+              def #{option}_matches?
+                return true unless @options.key?(#{option.inspect})
+                actual_value = respond_to?(:reflection_#{option}, true) ? reflection_#{option} : reflection.options[#{option.inspect}].to_s
+
+                return true if @options[#{option.inspect}].to_s == actual_value
+              end
+            METHOD
+          end
+
+        private
+
+          def reflection
+            @reflection ||= subject_class.reflect_on_association(@association.to_sym)
+          end
+
+          # Rescue nil to avoid raising errors in invalid through associations
+          def reflection_class_name
+            reflection.class_name.to_s rescue nil
+          end
+
+          def reflection_foreign_key
+            reflection.primary_key_name.to_s
+          end
+
+          def reflection_join_table
+            (reflection.options[:join_table] || reflection.options[:through]).to_s
+          end
+
+          def has_join_table?
+            reflection.options.key?(:through) || reflection.macro == :has_and_belongs_to_many
+          end
+
+          def table_has_column?(table_name, column)
+            ::ActiveRecord::Base.connection.columns(table_name, 'Remarkable column retrieval').any?{|c| c.name == column }
+          end
+
+          # In cases a join table exists (has_and_belongs_to_many and through
+          # associations), we check the foreign key in the join table.
+          #
+          # On belongs to, the foreign_key is in the subject class table and in
+          # other cases it's on the reflection class table.
+          #
+          def foreign_key_table
+            if has_join_table?
+              reflection_join_table
+            elsif reflection.macro == :belongs_to
+              subject_class.table_name
+            else
+              reflection.klass.table_name
+            end
+          end
+
+          def interpolation_options
+            options = { :macro => Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s) }
+
+            if @subject && reflection
+              options.merge!(
+                :actual_macro         => Remarkable.t(reflection.macro, :scope => matcher_i18n_scope, :default => reflection.macro.to_s),
+                :subject_table        => subject_class.table_name.inspect,
+                :reflection_table     => reflection.klass.table_name.inspect,
+                :foreign_key_table    => foreign_key_table.inspect,
+                :polymorphic_column   => reflection_foreign_key.sub(/_id$/, '_type').inspect,
+                :counter_cache_column => reflection.counter_cache_column.to_s.inspect
+              ) rescue nil # rescue to allow specs to run properly
+
+              ASSOCIATION_OPTIONS.each do |option|
+                value_to_compare = respond_to?(:"reflection_#{option}", true) ? send(:"reflection_#{option}") : reflection.options[option].to_s
+                options[:"actual_#{option}"] = value_to_compare.inspect
+              end
+
+            end
+
+            options
+          end
+      end
+
+      # Ensure that the belongs_to relationship exists. Will also test that the
+      # subject table has the association_id column.
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt> - the expected associted class name.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the subject table.
+      # * <tt>:dependent</tt> - the expected dependent value for the association.
+      # * <tt>:readonly</tt> - checks wether readonly is true or false.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      # * <tt>:counter_cache</tt> - the expected dependent value for the association.
+      #   It also checks if the column actually exists in the table.
+      # * <tt>:polymorphic</tt> - if the association should be polymorphic or not.
+      #   When true it also checks for the association_type column in the subject table.
+      #
+      # == Examples
+      #
+      #   should_belong_to :parent, :polymorphic => true
+      #   it { should belong_to(:parent) }
+      #
+      def belong_to(*associations)
+        AssociationMatcher.new(:belongs_to, *associations).spec(self)
+      end
+
+      # Ensures that the has_and_belongs_to_many relationship exists, if the join
+      # table is in place and if the foreign_key column exists.
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt>  - the expected associted class name.
+      # * <tt>:join_table</tt>  - the expected join table name.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the association table.
+      # * <tt>:uniq</tt>     - checks wether uniq is true or false.
+      # * <tt>:readonly</tt> - checks wether readonly is true or false.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # == 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).spec(self)
+      end
+
+      # Ensures that the has_many relationship exists. Will also test that the
+      # associated table has the required columns. It works by default with 
+      # polymorphic association (:as does not have to be supplied).
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt>  - the expected associted class name.
+      # * <tt>:through</tt>     - the expected join model which to perform the query.
+      #   It also checks if the through table exists.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
+      #   When used with :through, it will check for the foreign key in the join table.
+      # * <tt>:dependent</tt>   - the expected dependent value for the association.
+      # * <tt>:uniq</tt>     - checks wether uniq is true or false.
+      # * <tt>:readonly</tt> - checks wether readonly is true or false.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # == 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).spec(self)
+      end
+
+      # Ensures that the has_many relationship exists. Will also test that the
+      # associated table has the required columns. It works by default with 
+      # polymorphic association (:as does not have to be supplied).
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt>  - the expected associted class name.
+      # * <tt>:through</tt>     - the expected join model which to perform the query.
+      #   It also checks if the through table exists.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
+      #   When used with :through, it will check for the foreign key in the join table.
+      # * <tt>:dependent</tt>   - the expected dependent value for the association.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # == Examples
+      #
+      #  should_have_one :universe
+      #  it{ should have_one(:universe) }
+      #
+      def have_one(*associations)
+        AssociationMatcher.new(:has_one, *associations).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_column_matcher.rb

@@ -0,0 +1,68 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveColumnMatcher < Remarkable::ActiveRecord::Base
+        arguments :collection => :columns, :as => :column
+
+        optional :type, :default, :precision, :limit, :scale, :sql_type
+        optional :primary, :null, :default => true
+
+        collection_assertions :column_exists?, :options_match?
+
+        before_assert do
+          @options.each{|k,v| @options[k] = v.to_s}
+        end
+
+        protected
+
+          def column_exists?
+            !column_type.nil?
+          end
+
+          def options_match?
+            actual = get_column_options(column_type, @options.keys)
+            return actual == @options, :actual => actual.inspect
+          end
+
+          def column_type
+            subject_class.columns.detect {|c| c.name == @column.to_s }
+          end
+
+          def get_column_options(column, keys)
+            keys.inject({}) do |hash, key|
+              hash[key] = column.instance_variable_get("@#{key}").to_s
+              hash
+            end
+          end
+
+          def interpolation_options
+            { :options => @options.inspect }
+          end
+
+      end
+
+      # Ensures that a column of the database actually exists.
+      #
+      # == Options
+      # 
+      # * All options available in migrations are available:
+      #
+      #   :type, :default, :precision, :limit, :scale, :sql_type, :primary, :null
+      #
+      # == Examples
+      #
+      #   should_have_column :name, :type => :string, :default => ''
+      #
+      #   it { should have_column(:name, :type => :string) }
+      #   it { should have_column(:name).type(:string) }
+      # 
+      def have_column(*args)
+        HaveColumnMatcher.new(*args).spec(self)
+      end
+      alias :have_columns    :have_column
+      alias :have_db_column  :have_column
+      alias :have_db_columns :have_column
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_index_matcher.rb

@@ -0,0 +1,57 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveIndexMatcher < Remarkable::ActiveRecord::Base
+        arguments :collection => :columns, :as => :column
+
+        optional :unique, :default => true
+
+        collection_assertions :index_exists?, :is_unique?
+
+        protected
+
+          def index_exists?
+            !matched_index.nil?
+          end
+
+          def is_unique?
+            return true unless @options.key?(:unique)
+            return @options[:unique] == matched_index.unique, :actual => matched_index.unique
+          end
+
+          def matched_index
+            columns = [@column].flatten.map(&:to_s)
+            indexes.detect { |ind| ind.columns == columns }
+          end
+
+          def indexes
+            @indexes ||= ::ActiveRecord::Base.connection.indexes(subject_class.table_name)
+          end
+
+          def interpolation_options
+            @subject ? { :table_name => subject_class.table_name } : {}
+          end
+
+      end
+
+      # Ensures the database column has specified index.
+      #
+      # == Options
+      #
+      # * <tt>unique</tt> - when supplied, tests if the index is unique or not
+      #
+      # == Examples
+      #
+      #   it { should have_index(:ssn).unique(true) }
+      #   it { should have_index([:name, :email]).unique(true) }
+      #
+      def have_index(*args)
+        HaveIndexMatcher.new(*args).spec(self)
+      end
+      alias :have_indices    :have_index
+      alias :have_db_index   :have_index
+      alias :have_db_indices :have_index
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_readonly_attributes_matcher.rb

@@ -0,0 +1,30 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveReadonlyAttributesMatcher < Remarkable::ActiveRecord::Base
+        arguments :collection => :attributes, :as => :attribute
+        collection_assertions :is_readonly?
+
+        private
+
+          def is_readonly?
+            readonly = subject_class.readonly_attributes || []
+            return readonly.include?(@attribute.to_s), :actual => readonly.to_a.inspect
+          end
+      end
+
+      # Ensures that the attribute cannot be changed once the record has been
+      # created.
+      #
+      # == Examples
+      #
+      #   it { should have_readonly_attributes(:password, :admin_flag) }
+      #
+      def have_readonly_attributes(*attributes)
+        HaveReadonlyAttributesMatcher.new(*attributes).spec(self)
+      end
+      alias :have_readonly_attribute :have_readonly_attributes
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_scope_matcher.rb

@@ -0,0 +1,80 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveScopeMatcher < Remarkable::ActiveRecord::Base
+        arguments :scope_name
+        assertions :is_scope?, :options_match?
+
+        optionals :with, :select, :conditions, :order, :limit, :offset
+
+        protected
+
+          def is_scope?
+            @scope_object = if @options[:with]
+              subject_class.send(@scope_name, *@options[:with])
+            else
+              subject_class.send(@scope_name)
+            end
+
+            @scope_object.class == ::ActiveRecord::NamedScope::Scope
+          end
+
+          def options_match?
+            @options.empty? || @scope_object.proxy_options == @options.except(:with)
+          end
+
+          def interpolation_options
+            { :options => @options.except(:with).inspect,
+              :actual  => (@scope_object ? @scope_object.proxy_options.inspect : '{}')
+            }
+          end
+
+      end
+
+      # Ensures that the model has a method named scope that returns a NamedScope
+      # object with the supplied proxy options.
+      #
+      # == Options
+      #
+      # * <tt>with</tt> - Options to be sent to the named scope
+      #
+      # And all other options that the named scope would pass on to find.
+      #
+      # == Examples
+      # 
+      #   it { should have_scope(:visible, :conditions => {:visible => true}) }
+      #   it { should have_scope(:visible).conditions(:visible => true) }
+      #
+      # Passes for
+      #
+      #   named_scope :visible, :conditions => {:visible => true}
+      #
+      # Or for
+      #
+      #   def self.visible
+      #     scoped(:conditions => {:visible => true})
+      #   end
+      #
+      # You can test lambdas or methods that return ActiveRecord#scoped calls:
+      #
+      #   it { should have_scope(:recent, :with => 5) }
+      #   it { should have_scope(:recent, :with => 1) }
+      #
+      # Passes for
+      #
+      #   named_scope :recent, lambda {|c| {:limit => c}}
+      #
+      # Or for
+      #
+      #   def self.recent(c)
+      #     scoped(:limit => c)
+      #   end
+      #
+      def have_scope(*args)
+        HaveScopeMatcher.new(*args).spec(self)
+      end
+      alias :have_named_scope :have_scope
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_acceptance_of_matcher.rb

@@ -0,0 +1,51 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateAcceptanceOfMatcher < Remarkable::ActiveRecord::Base
+
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :accept, :message
+        optional :allow_nil, :default => true
+
+        collection_assertions :requires_acceptance?, :accept_is_valid?, :allow_nil?
+
+        default_options :message => :accepted
+
+        protected
+
+          def requires_acceptance?
+            bad?(false)
+          end
+
+          def accept_is_valid?
+            return true unless @options.key?(:accept)
+            good?(@options[:accept])
+          end
+
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
+      #
+      # == Options
+      #
+      # * <tt>:accept</tt> - the expected value to be accepted.
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.accepted')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_acceptance_of :eula, :terms
+      #   should_validate_acceptance_of :eula, :terms, :accept => true
+      #
+      #   it { should validate_acceptance_of(:eula, :terms) }
+      #   it { should validate_acceptance_of(:eula, :terms, :accept => true) }
+      #
+      def validate_acceptance_of(*attributes)
+        ValidateAcceptanceOfMatcher.new(*attributes).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_associated_matcher.rb

@@ -0,0 +1,99 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateAssociatedMatcher < Remarkable::ActiveRecord::Base
+        arguments :collection => :associations, :as => :association, :block => :block
+        optional  :message, :builder
+
+        collection_assertions :find_association?, :is_valid?
+        default_options :message => :invalid
+
+        protected
+
+          def find_association?
+            reflection = @subject.class.reflect_on_association(@association)
+
+            raise ScriptError, "Could not find association #{@association} on #{subject_class}." unless reflection
+
+            associated_object = if builder = @options[:builder] || @block
+              builder.call(@subject)
+            elsif [:belongs_to, :has_one].include?(reflection.macro)
+              @subject.send(:"build_#{@association}") rescue nil
+            else
+              @subject.send(@association).build rescue nil
+            end
+
+            raise ScriptError, "The association object #{@association} could not be built. You can give me " <<
+                               ":builder as option or a block which returns an association." unless associated_object
+
+            raise ScriptError, "The associated object #{@association} is not invalid. You can give me " <<
+                               ":builder as option or a block which returns an invalid association." if associated_object.save
+
+            return true
+          end
+
+          def is_valid?
+            return false if @subject.valid?
+
+            error_message_to_expect = error_message_from_model(@subject, :base, @options[:message])
+
+            # In Rails 2.1.2, the error on association returns a symbol (:invalid)
+            # instead of the message, so we check this case here.
+            @subject.errors.on(@association) == @options[:message] ||
+            assert_contains(@subject.errors.on(@association), error_message_to_expect)
+          end
+      end
+
+      # Ensures that the model is invalid if one of the associations given is
+      # invalid. It tries to build the association automatically. In has_one
+      # and belongs_to cases, it will build it like this:
+      #
+      #   @model.build_association
+      #   @project.build_manager
+      #
+      # In has_many and has_and_belongs_to_many to cases it will build it like
+      # this:
+      #
+      #   @model.association.build
+      #   @project.tasks.build
+      #
+      # The object returned MUST be invalid and it's likely the case, since the
+      # associated object is empty when calling build. However, if the associated
+      # object has to be manipulated to be invalid, you will have to give :builder
+      # as option or a block to manipulate it:
+      #
+      #   should_validate_associated(:tasks) do |project|
+      #     project.tasks.build(:captcha => 'i_am_a_bot')
+      #   end
+      #
+      # In the case above, the associated object task is only invalid when the
+      # captcha attribute is set. So we give a block to the matcher that tell
+      # exactly how to build an invalid object.
+      #
+      # The example above can also be written as:
+      #
+      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #
+      # == Options
+      #
+      # * <tt>:builder</tt> - a proc to build the association
+      #
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_associated :tasks
+      #   should_validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #
+      #   it { should validate_associated(:tasks) }
+      #   it { should validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') } }
+      #   it { should validate_associated(:tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }) }
+      #
+      def validate_associated(*args, &block)
+        ValidateAssociatedMatcher.new(*args, &block).spec(self)
+      end
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_confirmation_of_matcher.rb

@@ -0,0 +1,45 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateConfirmationOfMatcher < Remarkable::ActiveRecord::Base
+
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :message
+        collection_assertions :responds_to_confirmation?, :confirms?
+
+        default_options :message => :confirmation
+
+        protected
+
+          def responds_to_confirmation?
+            @subject.respond_to?(:"#{@attribute}_confirmation=")
+          end
+
+          def confirms?
+            @subject.send(:"#{@attribute}_confirmation=", 'something')
+            bad?('different')
+          end
+
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes is not confirmed.
+      #
+      # == Options
+      #
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.confirmation')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_confirmation_of :email, :password
+      #
+      #   it { should validate_confirmation_of(:email, :password) }
+      #
+      def validate_confirmation_of(*attributes)
+        ValidateConfirmationOfMatcher.new(*attributes).spec(self)
+      end
+
+    end
+  end
+end