@@ -32,13 +32,8 @@ module ThoughtBot # :nodoc: 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_bad_value(object, attribute, nil, message) - end + should_not_allow_values_for attribute, nil, :message => message, :should => "require #{attribute} to be set" end end @@ -144,16 +139,19 @@ module ThoughtBot # :nodoc: # Options: # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>. # Regexp or string. Default = <tt>/invalid/</tt> + # * <tt>:should</tt> - an override of the default should test name. + # Usually only used by other macros. # # 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, name = get_options!(bad_values, :message, :should) message ||= /invalid/ klass = model_class bad_values.each do |v| - should "not allow #{attribute} to be set to #{v.inspect}" do + name ||= "not allow #{attribute} to be set to #{v.inspect}" + should name do object = klass.new assert_bad_value(object, attribute, v, message) end @@ -163,16 +161,24 @@ module ThoughtBot # :nodoc: # Ensures that the attribute can be set to the given values. # Requires an existing record # + # Options: + # * <tt>:message</tt> - value the test shouldn't find in <tt>errors.on(:attribute)</tt>. + # Regexp or string. Default = <tt>//</tt> + # * <tt>:should</tt> - an override of the default should test name. + # Usually only used by other macros. + # # Example: # should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0" # def should_allow_values_for(attribute, *good_values) - get_options!(good_values) + message, name = get_options!(good_values, :message, :should) + message ||= // klass = model_class good_values.each do |v| - should "allow #{attribute} to be set to #{v.inspect}" do + name ||= "allow #{attribute} to be set to #{v.inspect}" + should name do object = klass.new - assert_good_value(object, attribute, v) + assert_good_value(object, attribute, v, message) end end end @@ -194,39 +200,26 @@ module ThoughtBot # :nodoc: short_message ||= /short/ long_message ||= /long/ - klass = model_class min_length = range.first max_length = range.last same_length = (min_length == max_length) if min_length > 0 - should "not allow #{attribute} to be less than #{min_length} chars long" do - min_value = "x" * (min_length - 1) - object = klass.new - assert_bad_value(object, attribute, min_value, short_message) - end + min_value = "x" * (min_length - 1) + should_not_allow_values_for attribute, min_value, :message => short_message, :should => "not allow #{attribute} to be less than #{min_length} chars long" end if min_length > 0 - should "allow #{attribute} to be exactly #{min_length} chars long" do - min_value = "x" * min_length - object = klass.new - assert_good_value(object, attribute, min_value, short_message) - end + min_value = "x" * min_length + should_allow_values_for attribute, min_value, :message => short_message, :should => "allow #{attribute} to be exactly #{min_length} chars long" end - should "not allow #{attribute} to be more than #{max_length} chars long" do - max_value = "x" * (max_length + 1) - object = klass.new - assert_bad_value(object, attribute, max_value, long_message) - end + max_value = "x" * (max_length + 1) + should_not_allow_values_for attribute, max_value, :message => long_message, :should => "not allow #{attribute} to be more than #{max_length} chars long" unless same_length - should "allow #{attribute} to be exactly #{max_length} chars long" do - max_value = "x" * max_length - object = klass.new - assert_good_value(object, attribute, max_value, long_message) - end + max_value = "x" * max_length + should_allow_values_for attribute, max_value, :message => long_message, :should => "allow #{attribute} to be exactly #{max_length} chars long" end end @@ -244,20 +237,13 @@ module ThoughtBot # :nodoc: short_message = get_options!([opts], :short_message) short_message ||= /short/ - klass = model_class - if min_length > 0 min_value = "x" * (min_length - 1) - should "not allow #{attribute} to be less than #{min_length} chars long" do - object = klass.new - assert_bad_value(object, attribute, min_value, short_message) - end - end - should "allow #{attribute} to be at least #{min_length} chars long" do - valid_value = "x" * (min_length) - object = klass.new - assert_good_value(object, attribute, valid_value, short_message) + should_not_allow_values_for attribute, min_value, :message => short_message, :should => "not allow #{attribute} to be less than #{min_length} chars long" end + + valid_value = "x" * (min_length) + should_allow_values_for attribute, valid_value, :message => short_message, :should => "allow #{attribute} to be at least #{min_length} chars long" end # Ensures that the length of the attribute is exactly a certain length @@ -274,25 +260,14 @@ module ThoughtBot # :nodoc: message = get_options!([opts], :message) message ||= /wrong length/ - klass = model_class - - should "not allow #{attribute} to be less than #{length} chars long" do - min_value = "x" * (length - 1) - object = klass.new - assert_bad_value(object, attribute, min_value, message) - end + min_value = "x" * (length - 1) + should_not_allow_values_for attribute, min_value, :message => message, :should => "not allow #{attribute} to be less than #{length} chars long" - should "not allow #{attribute} to be greater than #{length} chars long" do - max_value = "x" * (length + 1) - object = klass.new - assert_bad_value(object, attribute, max_value, message) - end + max_value = "x" * (length + 1) + should_not_allow_values_for attribute, max_value, :message => message, :should => "not allow #{attribute} to be greater than #{length} chars long" - should "allow #{attribute} to be #{length} chars long" do - valid_value = "x" * (length) - object = klass.new - assert_good_value(object, attribute, valid_value, message) - end + valid_value = "x" * (length) + should_allow_values_for attribute, valid_value, :message => message, :should => "allow #{attribute} to be #{length} chars long" end # Ensure that the attribute is in the range specified @@ -312,33 +287,13 @@ module ThoughtBot # :nodoc: 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 - object = klass.new - assert_bad_value(object, attribute, v, low_message) - end - - should "allow #{attribute} to be #{min}" do - v = min - object = klass.new - assert_good_value(object, attribute, v, low_message) - end - - should "not allow #{attribute} to be more than #{max}" do - v = max + 1 - object = klass.new - assert_bad_value(object, attribute, v, high_message) - end - - should "allow #{attribute} to be #{max}" do - v = max - object = klass.new - assert_good_value(object, attribute, v, high_message) - end + should_not_allow_values_for attribute, (min - 1), :message => low_message, :should => "not allow #{attribute} to be less than #{min}" + should_allow_values_for attribute, min, :message => low_message, :should => "allow #{attribute} to be #{min}" + should_not_allow_values_for attribute, (max + 1), :message => high_message, :should => "not allow #{attribute} to be more than #{max}" + should_allow_values_for attribute, max, :message => high_message, :should => "allow #{attribute} to be #{max}" end # Ensure that the attribute is numeric @@ -354,13 +309,8 @@ module ThoughtBot # :nodoc: 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 - object = klass.new - assert_bad_value(object, attribute, "abcd", message) - end + should_not_allow_values_for attribute, "abcd", :message => message, :should => "only allow numeric values for #{attribute}" end end @@ -593,13 +543,9 @@ module ThoughtBot # :nodoc: def should_require_acceptance_of(*attributes) message = get_options!(attributes, :message) message ||= /must be accepted/ - klass = model_class attributes.each do |attribute| - should "require #{attribute} to be accepted" do - object = klass.new - assert_bad_value(object, attribute, false, message) - end + should_not_allow_values_for attribute, false, :message => message, :should => "require #{attribute} to be accepted" end end lib/shoulda/active_record_helpers.rb 4c5768d1630bbfc522c6019eede33fb1b2e6c57f Ryan McGeary ryanongit@mcgeary.org http://github.com/rmm5t/shoulda/commit/063426f75110a9081eccda5607e18274c666b162 063426f75110a9081eccda5607e18274c666b162 2008-07-28T21:32:25-07:00 2008-07-28T21:32:25-07:00 Further DRY'd Active Record several macros to re-use should_allow_values_for and should_not_allow_values_for ec542cd53b8ba2d1ae840563e2100f7fee30a5e6 Ryan McGeary ryanongit@mcgeary.org