bureaucrat 0.0.1

data/test/fields_test.rb

@@ -0,0 +1,577 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestFields < BureaucratTestCase
+  describe 'Field' do
+    describe 'with empty options' do
+      setup do
+        @field = Fields::Field.new
+      end
+
+      should 'be required' do
+        blank_value = ''
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean(blank_value)
+        end
+      end
+    end
+
+    describe 'with required as false' do
+      setup do
+        @field = Fields::Field.new(:required => false)
+      end
+
+      should 'not be required' do
+        blank_value = ''
+        assert_nothing_raised do
+          @field.clean(blank_value)
+        end
+      end
+    end
+
+    describe 'on clean' do
+      setup do
+        @field = Fields::Field.new
+      end
+
+      should 'return the original value if valid' do
+        value = 'test'
+        assert_equal(value, @field.clean(value))
+      end
+    end
+
+    describe 'when copied' do
+      setup do
+        @field = Fields::Field.new(:initial => 'initial',
+                                   :label => 'label')
+        @field_copy = @field.dup
+      end
+
+      should 'have its own copy of initial value' do
+        assert_not_equal(@field.initial.object_id, @field_copy.initial.object_id)
+      end
+
+      should 'have its own copy of the label' do
+        assert_not_equal(@field.label.object_id, @field_copy.label.object_id)
+      end
+
+      should 'have its own copy of the error messaes' do
+        assert_not_equal(@field.error_messages.object_id, @field_copy.error_messages.object_id)
+      end
+    end
+  end
+
+  describe 'CharField' do
+    describe 'with empty options' do
+      setup do
+        @field = Fields::CharField.new
+      end
+
+      should 'not validate max length' do
+        assert_nothing_raised do
+          @field.clean("string" * 1000)
+        end
+      end
+
+      should 'not validate min length' do
+        assert_nothing_raised do
+          @field.clean("1")
+        end
+      end
+    end
+
+    describe 'with max length of 10' do
+      setup do
+        @field = Fields::CharField.new(:max_length => 10)
+      end
+
+      should 'allow values with length <= 10' do
+        assert_nothing_raised do
+          @field.clean('a' * 10)
+        end
+      end
+
+      should 'not allow values with length > 10' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('a' * 11)
+        end
+      end
+    end
+
+    describe 'with min length of 10' do
+      setup do
+        @field = Fields::CharField.new(:min_length => 10)
+      end
+
+      should 'allow values with length >= 10' do
+        assert_nothing_raised do
+          @field.clean('a' * 10)
+        end
+      end
+
+      should 'not allow values with length < 10' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('a' * 9)
+        end
+      end
+    end
+
+    describe 'on clean' do
+      setup do
+        @field = Fields::CharField.new
+      end
+
+      should 'return the original value if valid' do
+        valid_value = 'test'
+        assert_equal(valid_value, @field.clean(valid_value))
+      end
+
+      should 'return a blank string if value is nil and required is false' do
+        @field.required = false
+        nil_value = nil
+        assert_equal('', @field.clean(nil_value))
+      end
+
+      should 'return a blank string if value is empty and required is false' do
+        @field.required = false
+        empty_value = ''
+        assert_equal('', @field.clean(empty_value))
+      end
+    end
+
+  end
+
+  describe 'IntegerField' do
+    describe 'with max value of 10' do
+      setup do
+        @field = Fields::IntegerField.new(:max_value => 10)
+      end
+
+      should 'allow values <= 10' do
+        assert_nothing_raised do
+          @field.clean('10')
+        end
+      end
+
+      should 'not allow values > 10' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('11')
+        end
+      end
+    end
+
+    describe 'with min value of 10' do
+      setup do
+        @field = Fields::IntegerField.new(:min_value => 10)
+      end
+
+      should 'allow values >= 10' do
+        assert_nothing_raised do
+          @field.clean('10')
+        end
+      end
+
+      should 'not allow values < 10' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('9')
+        end
+      end
+
+    end
+
+    describe 'on clean' do
+      setup do
+        @field = Fields::IntegerField.new
+      end
+
+      should 'return an integer if valid' do
+        valid_value = '123'
+        assert_equal(123, @field.clean(valid_value))
+      end
+
+      should 'return nil if value is nil and required is false' do
+        @field.required = false
+        assert_nil(@field.clean(nil))
+      end
+
+      should 'return nil if value is empty and required is false' do
+        @field.required = false
+        empty_value = ''
+        assert_nil(@field.clean(empty_value))
+      end
+
+      should 'not validate invalid formats' do
+        invalid_formats = ['a', 'hello', '23eeee', '.', 'hi323',
+                           'joe@example.com', '___3232___323',
+                           '123.0', '123..4']
+
+        invalid_formats.each do |invalid|
+          assert_raise(Fields::FieldValidationError) do
+            @field.clean(invalid)
+          end
+        end
+      end
+
+      should 'validate valid formats' do
+        valid_formats = ['3', '100', '-100', '0', '-0']
+
+        assert_nothing_raised do
+          valid_formats.each do |valid|
+            @field.clean(valid)
+          end
+        end
+      end
+
+      should 'return an instance of Integer if valid' do
+        result = @field.clean('7')
+        assert_kind_of(Integer, result)
+      end
+    end
+
+  end
+
+  describe 'FloatField' do
+    describe 'with max value of 10.5' do
+      setup do
+        @field = Fields::FloatField.new(:max_value => 10.5)
+      end
+
+      should 'allow values <= 10.5' do
+        assert_nothing_raised do
+          @field.clean('10.5')
+        end
+      end
+
+      should 'not allow values > 10.5' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('10.55')
+        end
+      end
+    end
+
+    describe 'with min value of 10.5' do
+      setup do
+        @field = Fields::FloatField.new(:min_value => 10.5)
+      end
+
+      should 'allow values >= 10.5' do
+        assert_nothing_raised do
+          @field.clean('10.5')
+        end
+      end
+
+      should 'not allow values < 10.5' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('10.49')
+        end
+      end
+    end
+
+    describe 'on clean' do
+      setup do
+        @field = Fields::FloatField.new
+      end
+
+      should 'return nil if value is nil and required is false' do
+        @field.required = false
+        assert_nil(@field.clean(nil))
+      end
+
+      should 'return nil if value is empty and required is false' do
+        @field.required = false
+        empty_value = ''
+        assert_nil(@field.clean(empty_value))
+      end
+
+      should 'not validate invalid formats' do
+        invalid_formats = ['a', 'hello', '23eeee', '.', 'hi323',
+                           'joe@example.com', '___3232___323',
+                           '123..', '123..4']
+
+        invalid_formats.each do |invalid|
+          assert_raise(Fields::FieldValidationError) do
+            @field.clean(invalid)
+          end
+        end
+      end
+
+      should 'validate valid formats' do
+        valid_formats = ['3.14', "100", "1233.", ".3333", "0.434", "0.0"]
+
+        assert_nothing_raised do
+          valid_formats.each do |valid|
+            @field.clean(valid)
+          end
+        end
+      end
+
+      should 'return an instance of Float if valid' do
+        result = @field.clean('3.14')
+        assert_instance_of(Float, result)
+      end
+    end
+  end
+
+  describe 'BigDecimalField' do
+    describe 'with max value of 10.5' do
+      setup do
+        @field = Fields::BigDecimalField.new(:max_value => 10.5)
+      end
+
+      should 'allow values <= 10.5' do
+        assert_nothing_raised do
+          @field.clean('10.5')
+        end
+      end
+
+      should 'not allow values > 10.5' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('10.55')
+        end
+      end
+    end
+
+    describe 'with min value of 10.5' do
+      setup do
+        @field = Fields::BigDecimalField.new(:min_value => 10.5)
+      end
+
+      should 'allow values >= 10.5' do
+        assert_nothing_raised do
+          @field.clean('10.5')
+        end
+      end
+
+      should 'not allow values < 10.5' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('10.49')
+        end
+      end
+    end
+
+    describe 'on clean' do
+      setup do
+        @field = Fields::BigDecimalField.new
+      end
+
+      should 'return nil if value is nil and required is false' do
+        @field.required = false
+        assert_nil(@field.clean(nil))
+      end
+
+      should 'return nil if value is empty and required is false' do
+        @field.required = false
+        empty_value = ''
+        assert_nil(@field.clean(empty_value))
+      end
+
+      should 'not validate invalid formats' do
+        invalid_formats = ['a', 'hello', '23eeee', '.', 'hi323',
+                           'joe@example.com', '___3232___323',
+                           '123..', '123..4']
+
+        invalid_formats.each do |invalid|
+          assert_raise(Fields::FieldValidationError) do
+            @field.clean(invalid)
+          end
+        end
+      end
+
+      should 'validate valid formats' do
+        valid_formats = ['3.14', "100", "1233.", ".3333", "0.434", "0.0"]
+
+        assert_nothing_raised do
+          valid_formats.each do |valid|
+            @field.clean(valid)
+          end
+        end
+      end
+
+      should 'return an instance of BigDecimal if valid' do
+        result = @field.clean('3.14')
+        assert_instance_of(BigDecimal, result)
+      end
+    end
+  end
+
+  describe 'RegexField' do
+    setup do
+      @field = Fields::RegexField.new(/ba(na){2,}/)
+    end
+
+    describe 'on clean' do
+      should 'validate matching values' do
+        valid_values = ['banana', 'bananananana']
+        valid_values.each do |valid|
+          assert_nothing_raised do
+            @field.clean(valid)
+          end
+        end
+      end
+
+      should 'not validate non-matching values' do
+        invalid_values = ['bana', 'spoon']
+        assert_raise(Fields::FieldValidationError) do
+          invalid_values.each do |invalid|
+            @field.clean(invalid)
+          end
+        end
+      end
+
+      should 'return a blank string if value is empty and required is false' do
+        @field.required = false
+        empty_value = ''
+        assert_equal('', @field.clean(empty_value))
+      end
+    end
+  end
+
+  describe 'EmailField' do
+    setup do
+      @field = Fields::EmailField.new
+    end
+
+    describe 'on clean' do
+      should 'validate email-matching values' do
+        valid_values = ['email@domain.com', 'email+extra@domain.com',
+                        'email@domain.fm', 'email@domain.co.uk']
+        valid_values.each do |valid|
+          assert_nothing_raised do
+            @field.clean(valid)
+          end
+        end
+      end
+
+      should 'not validate non-email-matching values' do
+        invalid_values = ['banana', 'spoon', 'invalid#bla@domain.com',
+                          'invalid@@domain.com', 'invalid@domain',
+                          'invalid@.com']
+        assert_raise(Fields::FieldValidationError) do
+          invalid_values.each do |invalid|
+            @field.clean(invalid)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'BooleanField' do
+    setup do
+      @true_values = [1, true, 'true', '1']
+      @false_values = [nil, 0, false, 'false', '0']
+      @field = Fields::BooleanField.new
+    end
+
+    describe 'on clean' do
+      should 'return true for true values' do
+        @true_values.each do |true_value|
+          assert_equal(true, @field.clean(true_value))
+        end
+      end
+
+      should 'return false for false values' do
+        @field.required = false
+        @false_values.each do |false_value|
+          assert_equal(false, @field.clean(false_value))
+        end
+      end
+
+      should 'validate on true values when required' do
+        assert_nothing_raised do
+          @true_values.each do |true_value|
+            @field.clean(true_value)
+          end
+        end
+      end
+
+      should 'not validate on false values when required' do
+        @false_values.each do |false_value|
+          assert_raise(Fields::FieldValidationError) do
+            @field.clean(false_value)
+          end
+        end
+      end
+
+      should 'validate on false values when not required' do
+        @field.required = false
+        assert_nothing_raised do
+          @false_values.each do |false_value|
+            @field.clean(false_value)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'NullBooleanField' do
+    setup do
+      @true_values = [true, 'true', '1']
+      @false_values = [false, 'false', '0']
+      @null_values = [nil, '', 'banana']
+      @field = Fields::NullBooleanField.new
+    end
+
+    describe 'on clean' do
+      should 'return true for true values' do
+        @true_values.each do |true_value|
+          assert_equal(true, @field.clean(true_value))
+        end
+      end
+
+      should 'return false for false values' do
+        @false_values.each do |false_value|
+          assert_equal(false, @field.clean(false_value))
+        end
+      end
+
+      should 'return nil for null values' do
+        @null_values.each do |null_value|
+          assert_equal(nil, @field.clean(null_value))
+        end
+      end
+
+      should 'validate on all values' do
+        all_values = @true_values + @false_values + @null_values
+        assert_nothing_raised do
+          all_values.each do |value|
+            @field.clean(value)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'ChoiceField' do
+    setup do
+      @choices = [['tea', 'Tea'], ['milk', 'Milk']]
+      @field = Fields::ChoiceField.new(@choices)
+    end
+
+    describe 'on clean' do
+      should 'validate all values in choices list' do
+        assert_nothing_raised do
+          @choices.collect(&:first).each do |valid|
+            @field.clean(valid)
+          end
+        end
+      end
+
+      should 'not validate a value not in choices list' do
+        assert_raise(Fields::FieldValidationError) do
+          @field.clean('not_in_choices')
+        end
+      end
+
+      should 'return the original value if valid' do
+        value = 'tea'
+        result = @field.clean(value)
+        assert_equal(value, result)
+      end
+
+      should 'return an empty string if value is empty and not required' do
+        @field.required = false
+        result = @field.clean('')
+        assert_equal('', result)
+      end
+    end
+  end
+end

data/test/forms_test.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestForm < BureaucratTestCase
+  describe 'inherited form with a CharField' do
+    class OneForm < Forms::Form
+      include Bureaucrat::Fields
+
+      field :name, CharField.new
+    end
+
+    should 'return an instance of Media when calling #media' do
+      form = OneForm.new
+      assert_kind_of(Widgets::Media, form.media)
+    end
+
+    should 'have a BoundField in [:name]' do
+      form = OneForm.new
+      assert_kind_of(Forms::BoundField, form[:name])
+    end
+
+    should 'be bound when data is provided' do
+      form = OneForm.new(:name => 'name')
+      assert_equal(true, form.bound?)
+    end
+
+    describe 'when calling #valid?' do
+      should 'return false when data isn\'t valid' do
+        form = OneForm.new(:name => nil)
+        assert_equal(false, form.valid?)
+      end
+
+      should 'return true when data is valid' do
+        form = OneForm.new(:name => 'valid')
+        assert_equal(true, form.valid?)
+      end
+    end
+
+    describe 'when calling #errors' do
+      should 'have errors when invalid' do
+        form = OneForm.new(:name => nil)
+        assert_operator(form.errors.size, :>, 0)
+      end
+
+      should 'not have errors when valid' do
+        form = OneForm.new(:name => 'valid')
+        assert_equal(form.errors.size, 0)
+      end
+    end
+
+    describe 'when calling #changed_data' do
+      should 'return an empty list if no field was changed' do
+        form = OneForm.new
+        assert_equal([], form.changed_data)
+      end
+
+      should 'return a list of changed fields when modified' do
+        form = OneForm.new(:name => 'changed')
+        assert_equal([:name], form.changed_data)
+      end
+    end
+  end
+
+  describe 'form with custom clean proc on field' do
+    class CustomCleanForm < Forms::Form
+      include Bureaucrat::Fields
+
+      field :name, CharField.new
+
+      def clean_name
+        value = cleaned_data[:name]
+        raise FieldValidationError.new("Invalid name") unless value == 'valid_name'
+        value.upcase
+      end
+    end
+
+    should 'not be valid if clean method fails' do
+      form = CustomCleanForm.new(:name => 'other')
+      assert_equal(false, form.valid?)
+    end
+
+    should 'be valid if clean method passes' do
+      form = CustomCleanForm.new(:name => 'valid_name')
+      assert_equal(true, form.valid?)
+    end
+
+    should 'set the value to the one returned by the custom clean method' do
+      form = CustomCleanForm.new(:name => 'valid_name')
+      form.valid?
+      assert_equal('VALID_NAME', form.cleaned_data[:name])
+    end
+
+  end
+
+  describe 'inherited form with two charfields when rendered' do
+    class TwoForm < Forms::Form
+      include Bureaucrat::Fields
+
+      field :name, CharField.new(:label => 'Name')
+      field :color, CharField.new
+    end
+
+    def setup
+      @form = TwoForm.new(:name => 'name')
+      @unbound_form = TwoForm.new
+    end
+
+    should 'should correctly render as table' do
+      expected = normalize_html("<tr><th><label for='id_name'>Name:</label></th><td><input name='name' id='id_name' type='text' value='name'/></td></tr>\n<tr><th><label for='id_color'>Color:</label></th><td><ul class='errorlist'><li>This field is required</li></ul><input name='color' id='id_color' type='text'/></td></tr>")
+      rendered = normalize_html(@form.as_table)
+      assert_equal(expected, rendered)
+    end
+
+    should 'should correctly render as ul' do
+      expected = normalize_html("<li><label for='id_name'>Name:</label> <input name='name' id='id_name' type='text' value='name'/></li>\n<li><ul class='errorlist'><li>This field is required</li></ul><label for='id_color'>Color:</label> <input name='color' id='id_color' type='text'/></li>")
+      rendered = normalize_html(@form.as_ul)
+      assert_equal(expected, rendered)
+    end
+
+    should 'should correctly render as p' do
+      expected = normalize_html("<p><label for='id_name'>Name:</label> <input name='name' id='id_name' type='text' value='name'/></p>\nThis field is required\n<p><label for='id_color'>Color:</label> <input name='color' id='id_color' type='text'/></p>")
+      rendered = normalize_html(@form.as_p)
+      assert_equal(expected, rendered)
+    end
+
+    should 'correctly render as p when not bound' do
+      expected = normalize_html("<p><label for='id_name'>Name:</label> <input name='name' id='id_name' type='text'/></p>\n<p><label for='id_color'>Color:</label> <input name='color' id='id_color' type='text'/></p>")
+      rendered = normalize_html(@unbound_form.as_p)
+      assert_equal(expected, rendered)
+    end
+  end
+end