ratnikov-shoulda 2.0.6.3 → 2.9.0

data/README.rdoc

@@ -7,6 +7,7 @@ Helpers:: #context and #should give you rSpec like test blocks.
 Macros:: Generate hundreds of lines of Controller and ActiveRecord tests with these powerful macros.
          They get you started quickly, and can help you ensure that your application is conforming to best practices.
 Assertions:: Many common rails testing idioms have been distilled into a set of useful assertions.
+Matchers:: Rspec-compatible matchers providing the same tests as Shoulda macros.
 
 = Usage
 
@@ -54,8 +55,8 @@ Quick macro tests for your ActiveRecord associations and validations:
     should_have_many :tags, :through => :taggings
 
     should_require_unique_attributes :title
-    should_require_attributes :body, :message => /wtf/
-    should_require_attributes :title
+    should_validate_presence_of :body, :message => /wtf/
+    should_validate_presence_of :title
     should_only_allow_numeric_values_for :user_id
   end
 

data/Rakefile

@@ -8,7 +8,7 @@ require 'shoulda'
 load 'tasks/shoulda.rake'
 
 # Test::Unit::UI::VERBOSE
-test_files_pattern = 'test/{unit,functional,other}/**/*_test.rb'
+test_files_pattern = 'test/{unit,functional,other,matchers}/**/*_test.rb'
 Rake::TestTask.new do |t|
   t.libs << 'lib'
   t.pattern = test_files_pattern

data/lib/shoulda/active_record/assertions.rb

@@ -32,11 +32,12 @@ module Shoulda # :nodoc:
       #
       #   @product = Product.new(:tangible => false)
       #   assert_good_value(Product, :price, "0")
-      def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = //)
+      def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = nil)
         object = get_instance_of(object_or_klass)
-        object.send("#{attribute}=", value)
-        object.valid?
-        assert_does_not_contain(object.errors.on(attribute), error_message_to_avoid, "when set to #{value.inspect}")
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_avoid)
+        assert_accepts(matcher, object)
       end
 
       # Asserts that an Active Record model invalidates the passed
@@ -56,34 +57,12 @@ module Shoulda # :nodoc:
       #   @product = Product.new(:tangible => true)
       #   assert_bad_value(Product, :price, "0")
       def assert_bad_value(object_or_klass, attribute, value,
-                           error_message_to_expect = self.class.default_error_message(:invalid))
+                           error_message_to_expect = nil)
         object = get_instance_of(object_or_klass)
-        object.send("#{attribute}=", value)
-        assert !object.valid?, "#{object.class} allowed #{value.inspect} as a value for #{attribute}"
-        assert object.errors.on(attribute), "There are no errors on #{attribute} after being set to #{value.inspect}"
-        assert_contains(object.errors.on(attribute), error_message_to_expect, "when set to #{value.inspect}")
-      end
-
-      def pretty_error_messages(obj)
-        obj.errors.map do |a, m|
-          msg = "#{a} #{m}"
-          msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
-        end
-      end
-
-      private
-
-      def get_instance_of(object_or_klass)
-        if object_or_klass.is_a?(Class)
-          klass = object_or_klass
-          instance_variable_get("@#{instance_variable_name_for(klass)}") || klass.new
-        else
-          object_or_klass
-        end
-      end
-
-      def instance_variable_name_for(klass)
-        klass.to_s.split('::').last.underscore
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_expect)
+        assert_rejects(matcher, object)
       end
     end
   end

data/lib/shoulda/active_record/helpers.rb

@@ -0,0 +1,40 @@
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Helpers
+      def pretty_error_messages(obj) # :nodoc:
+        obj.errors.map do |a, m| 
+          msg = "#{a} #{m}" 
+          msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
+        end
+      end
+
+      def get_instance_of(object_or_klass)
+        if object_or_klass.is_a?(Class)
+          klass = object_or_klass
+          instance_variable_get("@#{instance_variable_name_for(klass)}") || klass.new
+        else
+          object_or_klass
+        end
+      end
+
+      def instance_variable_name_for(klass)
+        klass.to_s.split('::').last.underscore
+      end
+
+      # Helper method that determines the default error message used by Active
+      # Record.  Works for both existing Rails 2.1 and Rails 2.2 with the newly
+      # introduced I18n module used for localization.
+      #
+      #   default_error_message(:blank)
+      #   default_error_message(:too_short, :count => 5)
+      #   default_error_message(:too_long, :count => 60)
+      def default_error_message(key, values = {})
+        if Object.const_defined?(:I18n) # Rails >= 2.2
+          I18n.translate("activerecord.errors.messages.#{key}", values)
+        else # Rails <= 2.1.x
+          ::ActiveRecord::Errors.default_error_messages[key] % values[:count]
+        end
+      end
+    end
+  end
+end