giraffesoft-attribute_fu 0.2 → 0.2.1

data/test/test/unit/comment_test.rb

@@ -1,6 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class CommentTest < ActiveSupport::TestCase
-  should_belong_to :photo
-  should_require_attributes :author, :body
-end

data/test/test/unit/photo_test.rb

@@ -1,149 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class PhotoTest < ActiveSupport::TestCase
-  should_have_many :comments
-  
-  context "comment_attributes" do
-    context "with valid children" do
-      setup do
-        create_photo_and_children
-      
-        @photo.comment_attributes = { @gob.id.to_s => { :author => "Buster Bluth", :body => "I said it was _our_ nausia..." },
-                                      :new         => { "0" => { :author => "George-Michael", :body => "I was going to smoke the marijuana like a ciggarette." },
-                                                        "-1" => { :author => "Tobias Funke", :body => "I am an actor! An actor for crying out loud!" }}}
-      
-      end
-    
-      context "before save" do
-        should "not have deleted anything in the remove array" do
-          assert @photo.comments.any? { |comment| comment.author == "Bob Loblaw" }, "Comment in remove array was removed."
-        end
-      
-        should "not have saved any new objects" do
-          assert @photo.comments.any? { |comment| comment.new_record? }
-        end
-      end
-    
-      context "after save" do
-        setup do
-          @photo.save
-        end
-
-        context "with existing child" do
-          setup do
-            @gob.reload
-          end
-
-          should "update attributes" do
-            assert_equal "Buster Bluth", @gob.author, "Author attribute of child model was not updated."
-            assert_equal "I said it was _our_ nausia...", @gob.body, "Body attribute of child model was not updated."
-          end
-        end
-    
-        context "with new hash" do
-          should "create new comment" do
-            assert @photo.comments.any? { |comment| comment.author == "George-Michael" && comment.body =~ /was going to smoke/i }, "New comment was not created."
-          end
-          
-          should "order the negatives after the positives" do
-            assert_equal "Tobias Funke", @photo.comments.last.author, "Tobias is not the last comment: #{@photo.comments.inspect}"
-          end
-        end
-    
-        context "with missing associated" do
-          should "remove those children from the parent" do
-            assert !@photo.comments.any? { |comment| comment.author == "Bob Loblaw" }, "Comment not included was not removed."
-          end
-        end
-      end
-      
-      context "with comment_attributes = nil" do
-        setup do
-          @photo.save
-          @photo.comment_attributes = nil
-          @photo.save
-        end
-
-        should "remove all comments" do
-          assert @photo.comments.empty?, "one or more comments not removed: #{@photo.comments.inspect}"
-        end
-      end
-      
-      context "with discard_if => proc { }" do
-        setup do
-          create_photo_with_discard(proc { |comment| comment.author.blank? && comment.body.blank? })
-        end
-        
-        teardown do
-          Photo.class_eval do
-            managed_association_attributes[:comments].delete(:discard_if)
-          end
-        end
-
-        should "discard any child objects for which discard_if evaluates to true" do
-          assert !@photo.comments.any? { |comment| comment.author.blank? && comment.body.blank? }, @photo.comments.inspect
-        end
-        
-        should "not discard other objects" do
-          assert_equal 1, @photo.comments.length
-        end
-      end
-      
-      context "with discard_if => :symbol" do
-        setup do
-          create_photo_with_discard(:blank?)
-        end
-        
-        teardown do
-          Photo.class_eval do
-            managed_association_attributes[:comments].delete(:discard_if)
-          end
-        end
-        
-        should "discard any child objects for which discard_if evaluates to true" do
-          assert !@photo.comments.any? { |comment| comment.author.blank? && comment.body.blank? }, @photo.comments.inspect
-        end
-        
-        should "not discard other objects" do
-          assert_equal 1, @photo.comments.length
-        end
-      end
-    end
-    
-    context "updating with invalid children" do
-      setup do
-        @photo = Photo.create
-        @saved = @photo.update_attributes :comment_attributes => {:new => {"0" => {:author => "Tobias"}}}
-      end
-      
-      should "not save" do
-        assert !@saved
-      end
-      
-      should "have errors on child" do
-        assert @photo.comments.first.errors.on(:body)
-      end
-    end
-  end
-  
-  private
-    def create_photo_and_children
-      @photo = Photo.create
-      @gob = @photo.comments.create :author => "Gob Bluth",  :body => "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed..."
-      @bob = @photo.comments.create :author => "Bob Loblaw", :body => "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed..."
-    end
-    
-    def create_photo_with_discard(discard_if)
-      Photo.class_eval do
-        has_many :comments, :attributes => true, :discard_if => discard_if
-      end
-      
-      create_photo_and_children
-      
-      
-      @photo.comment_attributes = { @gob.id.to_s => { :author => "Buster Bluth", :body => "I said it was _our_ nausia..." },
-                                    @bob.id.to_s => { :author => '', :body => '' },
-                                    :new         => { "0" => { :author => "", :body => "" }}}
-      @photo.save
-    end
-end

data/test/vendor/plugins/shoulda/init.rb

@@ -1,3 +0,0 @@
-require 'rubygems'
-require 'active_support'
-require 'shoulda'

data/test/vendor/plugins/shoulda/lib/shoulda.rb

@@ -1,20 +0,0 @@
-require 'yaml'
-require 'shoulda/private_helpers'
-require 'shoulda/general'
-require 'shoulda/context'
-require 'shoulda/active_record_helpers'
-
-
-module Test # :nodoc: all
-  module Unit 
-    class TestCase
-
-      include ThoughtBot::Shoulda::General
-
-      class << self
-        include ThoughtBot::Shoulda::Context
-        include ThoughtBot::Shoulda::ActiveRecord
-      end
-    end
-  end
-end

data/test/vendor/plugins/shoulda/lib/shoulda/active_record_helpers.rb

@@ -1,338 +0,0 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    # = Macro test helpers for your active record models
-    #
-    # These helpers will test most of the validations and associations for your ActiveRecord models.
-    #
-    #   class UserTest < Test::Unit::TestCase
-    #     should_require_attributes :name, :phone_number
-    #     should_not_allow_values_for :phone_number, "abcd", "1234"
-    #     should_allow_values_for :phone_number, "(123) 456-7890"
-    #     
-    #     should_protect_attributes :password
-    #     
-    #     should_have_one :profile
-    #     should_have_many :dogs
-    #     should_have_many :messes, :through => :dogs
-    #     should_belong_to :lover
-    #   end
-    #
-    # For all of these helpers, the last parameter may be a hash of options.
-    #
-    module ActiveRecord
-      # Ensures that the model cannot be saved if one of the attributes listed is not present.
-      # Requires an existing record.
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/blank/</tt>
-      #
-      # Example:
-      #   should_require_attributes :name, :phone_number
-      def should_require_attributes(*attributes)
-        message = get_options!(attributes, :message)
-        message ||= /blank/
-        klass = model_class
-        
-        attributes.each do |attribute|
-          should "require #{attribute} to be set" do
-            object = klass.new
-            assert !object.valid?, "#{klass.name} does not require #{attribute}."
-            assert object.errors.on(attribute), "#{klass.name} does not require #{attribute}."
-            assert_contains(object.errors.on(attribute), message)
-          end
-        end
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes listed is not unique.
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/taken/</tt>
-      #
-      # Example:
-      #   should_require_unique_attributes :keyword, :username
-      def should_require_unique_attributes(*attributes)
-        message, scope = get_options!(attributes, :message, :scoped_to)
-        message ||= /taken/
-        
-        klass = model_class
-        attributes.each do |attribute|
-          attribute = attribute.to_sym
-          should "require unique value for #{attribute}#{" scoped to #{scope}" if scope}" do
-            assert existing = klass.find(:first), "Can't find first #{klass}"
-            object = klass.new
-            
-            object.send(:"#{attribute}=", existing.send(attribute))
-            if scope
-              assert_respond_to object, :"#{scope}=", "#{klass.name} doesn't seem to have a #{scope} attribute."
-              object.send(:"#{scope}=", existing.send(scope))
-            end
-            
-            assert !object.valid?, "#{klass.name} does not require a unique value for #{attribute}."
-            assert object.errors.on(attribute), "#{klass.name} does not require a unique value for #{attribute}."
-            
-            assert_contains(object.errors.on(attribute), message)
-            
-            if scope
-              # Now test that the object is valid when changing the scoped attribute
-              # TODO:  actually find all values for scope and create a unique one.
-              object.send(:"#{scope}=", existing.send(scope).nil? ? 1 : existing.send(scope).next)
-              object.errors.clear
-              object.valid?
-              assert_does_not_contain(object.errors.on(attribute), message, 
-                                      "after :#{scope} set to #{object.send(scope.to_sym)}")
-            end
-          end
-        end
-      end
-
-      # Ensures that the attribute cannot be set on update
-      # Requires an existing record
-      #
-      #   should_protect_attributes :password, :admin_flag
-      def should_protect_attributes(*attributes)
-        get_options!(attributes)
-        klass = model_class
-        attributes.each do |attribute|
-          attribute = attribute.to_sym
-          should "not allow #{attribute} to be changed by update" do
-            assert object = klass.find(:first), "Can't find first #{klass}"
-            value = object[attribute]
-            # TODO:  1 may not be a valid value for the attribute (due to validations)
-            assert object.update_attributes({ attribute => 1 }),
-                   "Cannot update #{klass} with { :#{attribute} => 1 }, #{object.errors.full_messages.to_sentence}"
-            assert object.valid?, "#{klass} isn't valid after changing #{attribute}"
-            assert_equal value, object[attribute], "Was able to change #{klass}##{attribute}"
-          end
-        end
-      end
-  
-      # Ensures that the attribute cannot be set to the given values
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/invalid/</tt>
-      #
-      # Example:
-      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
-      def should_not_allow_values_for(attribute, *bad_values)
-        message = get_options!(bad_values, :message)
-        message ||= /invalid/
-        klass = model_class
-        bad_values.each do |v|
-          should "not allow #{attribute} to be set to \"#{v}\"" do
-            assert object = klass.find(:first), "Can't find first #{klass}"
-            object.send("#{attribute}=", v)
-            assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
-            assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
-            assert_contains(object.errors.on(attribute), message, "when set to \"#{v}\"")
-          end
-        end
-      end
-  
-      # Ensures that the attribute can be set to the given values.
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/invalid/</tt>
-      #
-      # Example:
-      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
-      def should_allow_values_for(attribute, *good_values)
-        message = get_options!(good_values, :message)
-        message ||= /invalid/
-        klass = model_class
-        good_values.each do |v|
-          should "allow #{attribute} to be set to \"#{v}\"" do
-            assert object = klass.find(:first), "Can't find first #{klass}"
-            object.send("#{attribute}=", v)
-            object.save
-            assert_does_not_contain(object.errors.on(attribute), message, "when set to \"#{v}\"")
-          end
-        end
-      end
-
-      # Ensures that the length of the attribute is in the given range
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/short/</tt>
-      # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/long/</tt>
-      #
-      # Example:
-      #   should_ensure_length_in_range :password, (6..20)
-      def should_ensure_length_in_range(attribute, range, opts = {})
-        short_message, long_message = get_options!([opts], :short_message, :long_message)
-        short_message ||= /short/
-        long_message  ||= /long/
-        
-        klass = model_class
-        min_length = range.first
-        max_length = range.last
-
-        if min_length > 0
-          min_value = "x" * (min_length - 1)
-          should "not allow #{attribute} to be less than #{min_length} chars long" do
-            assert object = klass.find(:first), "Can't find first #{klass}"
-            object.send("#{attribute}=", min_value)
-            assert !object.save, "Saved #{klass} with #{attribute} set to \"#{min_value}\""
-            assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{min_value}\""
-            assert_contains(object.errors.on(attribute), short_message, "when set to \"#{min_value}\"")
-          end
-        end
-    
-        max_value = "x" * (max_length + 1)
-        should "not allow #{attribute} to be more than #{max_length} chars long" do
-          assert object = klass.find(:first), "Can't find first #{klass}"
-          object.send("#{attribute}=", max_value)
-          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{max_value}\""
-          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{max_value}\""
-          assert_contains(object.errors.on(attribute), long_message, "when set to \"#{max_value}\"")
-        end
-      end    
-
-      # Ensure that the attribute is in the range specified
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/included/</tt>
-      # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/included/</tt>
-      #
-      # Example:
-      #   should_ensure_value_in_range :age, (0..100)
-      def should_ensure_value_in_range(attribute, range, opts = {})
-        low_message, high_message = get_options!([opts], :low_message, :high_message)
-        low_message  ||= /included/
-        high_message ||= /included/
-        
-        klass = model_class
-        min   = range.first
-        max   = range.last
-
-        should "not allow #{attribute} to be less than #{min}" do
-          v = min - 1
-          assert object = klass.find(:first), "Can't find first #{klass}"
-          object.send("#{attribute}=", v)
-          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
-          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
-          assert_contains(object.errors.on(attribute), low_message, "when set to \"#{v}\"")
-        end
-    
-        should "not allow #{attribute} to be more than #{max}" do
-          v = max + 1
-          assert object = klass.find(:first), "Can't find first #{klass}"
-          object.send("#{attribute}=", v)
-          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
-          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
-          assert_contains(object.errors.on(attribute), high_message, "when set to \"#{v}\"")
-        end
-      end    
-      
-      # Ensure that the attribute is numeric
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
-      #   Regexp or string.  Default = <tt>/number/</tt>
-      #
-      # Example:
-      #   should_only_allow_numeric_values_for :age
-      def should_only_allow_numeric_values_for(*attributes)
-        message = get_options!(attributes, :message)
-        message ||= /number/
-        klass = model_class
-        attributes.each do |attribute|
-          attribute = attribute.to_sym
-          should "only allow numeric values for #{attribute}" do
-            assert object = klass.find(:first), "Can't find first #{klass}"
-            object.send(:"#{attribute}=", "abcd")
-            assert !object.valid?, "Instance is still valid"
-            assert_contains(object.errors.on(attribute), message)
-          end
-        end
-      end
-
-      # Ensures that the has_many relationship exists.
-      # 
-      # Options:
-      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
-      #
-      # Example:
-      #   should_have_many :friends
-      #   should_have_many :enemies, :through => :friends
-      def should_have_many(*associations)
-        through = get_options!(associations, :through)
-        klass = model_class
-        associations.each do |association|
-          should "have many #{association}#{" through #{through}" if through}" do
-            reflection = klass.reflect_on_association(association)
-            assert reflection, "#{klass.name} does not have any relationship to #{association}"
-            assert_equal :has_many, reflection.macro
-            if through
-              through_reflection = klass.reflect_on_association(through)
-              assert through_reflection, "#{klass.name} does not have any relationship to #{through}"
-              assert_equal(through, reflection.options[:through])
-            end
-          end
-        end
-      end
-
-      # Ensures that the has_and_belongs_to_many relationship exists.  
-      #
-      #   should_have_and_belong_to_many :posts, :cars
-      def should_have_and_belong_to_many(*associations)
-        get_options!(associations)
-        klass = model_class
-        associations.each do |association|
-          should "should have and belong to many #{association}" do
-            assert klass.reflect_on_association(association), "#{klass.name} does not have any relationship to #{association}"
-            assert_equal :has_and_belongs_to_many, klass.reflect_on_association(association).macro
-          end
-        end
-      end
-  
-      # Ensure that the has_one relationship exists.
-      #
-      #   should_have_one :god # unless hindu
-      def should_have_one(*associations)
-        get_options!(associations)
-        klass = model_class
-        associations.each do |association|
-          should "have one #{association}" do
-            assert klass.reflect_on_association(association), "#{klass.name} does not have any relationship to #{association}"
-            assert_equal :has_one, klass.reflect_on_association(association).macro
-          end
-        end
-      end
-  
-      # Ensure that the belongs_to relationship exists.
-      #
-      #   should_belong_to :parent
-      def should_belong_to(*associations)
-        get_options!(associations)
-        klass = model_class
-        associations.each do |association|
-          should "belong_to #{association}" do
-            reflection = klass.reflect_on_association(association)
-            assert reflection, "#{klass.name} does not have any relationship to #{association}"
-            assert_equal :belongs_to, reflection.macro
-            fk = reflection.options[:foreign_key] || "#{association}_id"
-            assert klass.column_names.include?(fk), "#{klass.name} does not have a #{fk} foreign key."
-          end
-        end
-      end
-      
-      private
-      
-      include ThoughtBot::Shoulda::Private
-    end
-  end
-end