bureaucrat 0.0.3 → 0.10.0

data/test/fields_test.rb

@@ -1,577 +1,716 @@
-require File.dirname(__FILE__) + "/test_helper"
+require_relative 'test_helper'
 
-class TestFields < BureaucratTestCase
-  describe 'Field' do
-    describe 'with empty options' do
-      setup do
-        @field = Fields::Field.new
-      end
+module FieldTests
+  class Test_with_empty_options < BureaucratTestCase
+    def setup
+      @field = Fields::Field.new
+    end
 
-      should 'be required' do
-        blank_value = ''
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean(blank_value)
-        end
+    def test_be_required
+      blank_value = ''
+      assert_raises(ValidationError) do
+        @field.clean(blank_value)
       end
     end
+  end
 
-    describe 'with required as false' do
-      setup do
-        @field = Fields::Field.new(:required => false)
-      end
+  class Test_with_required_as_false < BureaucratTestCase
+    def setup
+      @field = Fields::Field.new(required: false)
+    end
 
-      should 'not be required' do
-        blank_value = ''
-        assert_nothing_raised do
-          @field.clean(blank_value)
-        end
+    def test_not_be_required
+      blank_value = ''
+      assert_nothing_raised do
+        @field.clean(blank_value)
       end
     end
+  end
 
-    describe 'on clean' do
-      setup do
-        @field = Fields::Field.new
-      end
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @field = Fields::Field.new
+    end
 
-      should 'return the original value if valid' do
-        value = 'test'
-        assert_equal(value, @field.clean(value))
-      end
+    def test_return_the_original_value_if_valid
+      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
+  class Test_when_copied < BureaucratTestCase
+    def setup
+      @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
+    def test_have_its_own_copy_of_initial_value
+      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
+    def test_have_its_own_copy_of_the_label
+      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
+    def test_have_its_own_copy_of_the_widget
+      assert_not_equal(@field.widget.object_id, @field_copy.widget.object_id)
     end
-  end
 
-  describe 'CharField' do
-    describe 'with empty options' do
-      setup do
-        @field = Fields::CharField.new
-      end
+    def test_have_its_own_copy_of_validators
+      assert_not_equal(@field.validators.object_id, @field_copy.validators.object_id)
+    end
 
-      should 'not validate max length' do
-        assert_nothing_raised do
-          @field.clean("string" * 1000)
-        end
-      end
+    def test_have_its_own_copy_of_the_error_messaes
+      assert_not_equal(@field.error_messages.object_id, @field_copy.error_messages.object_id)
+    end
+  end
+end
 
-      should 'not validate min length' do
-        assert_nothing_raised do
-          @field.clean("1")
-        end
-      end
+module CharFieldTests
+  class Test_with_empty_options < BureaucratTestCase
+    def setup
+      @field = Fields::CharField.new
     end
 
-    describe 'with max length of 10' do
-      setup do
-        @field = Fields::CharField.new(:max_length => 10)
+    def test_not_validate_max_length
+      assert_nothing_raised do
+        @field.clean("string" * 1000)
       end
+    end
 
-      should 'allow values with length <= 10' do
-        assert_nothing_raised do
-          @field.clean('a' * 10)
-        end
+    def test_not_validate_min_length
+      assert_nothing_raised do
+        @field.clean("1")
       end
+    end
+  end
 
-      should 'not allow values with length > 10' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('a' * 11)
-        end
-      end
+  class Test_with_max_length < BureaucratTestCase
+    def setup
+      @field = Fields::CharField.new(max_length: 10)
     end
 
-    describe 'with min length of 10' do
-      setup do
-        @field = Fields::CharField.new(:min_length => 10)
+    def test_allow_values_with_length_less_than_or_equal_to_max_length
+      assert_nothing_raised do
+        @field.clean('a' * 10)
+        @field.clean('a' * 5)
       end
+    end
 
-      should 'allow values with length >= 10' do
-        assert_nothing_raised do
-          @field.clean('a' * 10)
-        end
+    def test_not_allow_values_with_length_greater_than_max_length
+      assert_raises(ValidationError) do
+        @field.clean('a' * 11)
       end
+    end
+  end
 
-      should 'not allow values with length < 10' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('a' * 9)
-        end
-      end
+  class Test_with_min_length < BureaucratTestCase
+    def setup
+      @field = Fields::CharField.new(min_length: 10)
     end
 
-    describe 'on clean' do
-      setup do
-        @field = Fields::CharField.new
+    def test_allow_values_with_length_greater_or_equal_to_min_length
+      assert_nothing_raised do
+        @field.clean('a' * 10)
+        @field.clean('a' * 20)
       end
+    end
 
-      should 'return the original value if valid' do
-        valid_value = 'test'
-        assert_equal(valid_value, @field.clean(valid_value))
+    def test_not_allow_values_with_length_less_than_min_length
+      assert_raises(ValidationError) do
+        @field.clean('a' * 9)
       end
+    end
+  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
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @field = Fields::CharField.new
+    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
+    def test_return_the_original_value_if_valid
+      valid_value = 'test'
+      assert_equal(valid_value, @field.clean(valid_value))
     end
 
+    def test_return_a_blank_string_if_value_is_nil_and_required_is_false
+      @field.required = false
+      nil_value = nil
+      assert_equal('', @field.clean(nil_value))
+    end
+
+    def test_return_a_blank_string_if_value_is_empty_and_required_is_false
+      @field.required = false
+      empty_value = ''
+      assert_equal('', @field.clean(empty_value))
+    end
   end
 
-  describe 'IntegerField' do
-    describe 'with max value of 10' do
-      setup do
-        @field = Fields::IntegerField.new(:max_value => 10)
-      end
+end
 
-      should 'allow values <= 10' do
-        assert_nothing_raised do
-          @field.clean('10')
-        end
-      end
+module IntegerFieldTests
+  class Test_with_max_value < BureaucratTestCase
+    def setup
+      @field = Fields::IntegerField.new(max_value: 10)
+    end
 
-      should 'not allow values > 10' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('11')
-        end
+    def test_allow_values_less_or_equal_to_max_value
+      assert_nothing_raised do
+        @field.clean('10')
+        @field.clean('4')
       end
     end
 
-    describe 'with min value of 10' do
-      setup do
-        @field = Fields::IntegerField.new(:min_value => 10)
+    def test_not_allow_values_greater_than_max_value
+      assert_raises(ValidationError) do
+        @field.clean('11')
       end
+    end
+  end
 
-      should 'allow values >= 10' do
-        assert_nothing_raised do
-          @field.clean('10')
-        end
-      end
+  class Test_with_min_value < BureaucratTestCase
+    def setup
+      @field = Fields::IntegerField.new(min_value: 10)
+    end
 
-      should 'not allow values < 10' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('9')
-        end
+    def test_allow_values_greater_or_equal_to_min_value
+      assert_nothing_raised do
+        @field.clean('10')
+        @field.clean('20')
       end
-
     end
 
-    describe 'on clean' do
-      setup do
-        @field = Fields::IntegerField.new
+    def test_not_allow_values_less_than_min_value
+      assert_raises(ValidationError) do
+        @field.clean('9')
       end
+    end
 
-      should 'return an integer if valid' do
-        valid_value = '123'
-        assert_equal(123, @field.clean(valid_value))
-      end
+  end
 
-      should 'return nil if value is nil and required is false' do
-        @field.required = false
-        assert_nil(@field.clean(nil))
-      end
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @field = Fields::IntegerField.new
+    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
+    def test_return_an_integer_if_valid
+      valid_value = '123'
+      assert_equal(123, @field.clean(valid_value))
+    end
 
-      should 'not validate invalid formats' do
-        invalid_formats = ['a', 'hello', '23eeee', '.', 'hi323',
-                           'joe@example.com', '___3232___323',
-                           '123.0', '123..4']
+    def test_return_nil_if_value_is_nil_and_required_is_false
+      @field.required = false
+      assert_nil(@field.clean(nil))
+    end
 
-        invalid_formats.each do |invalid|
-          assert_raise(Fields::FieldValidationError) do
-            @field.clean(invalid)
-          end
-        end
-      end
+    def test_return_nil_if_value_is_empty_and_required_is_false
+      @field.required = false
+      empty_value = ''
+      assert_nil(@field.clean(empty_value))
+    end
 
-      should 'validate valid formats' do
-        valid_formats = ['3', '100', '-100', '0', '-0']
+    def test_not_validate_invalid_formats
+      invalid_formats = ['a', 'hello', '23eeee', '.', 'hi323',
+                         'joe@example.com', '___3232___323',
+                         '123.0', '123..4']
 
-        assert_nothing_raised do
-          valid_formats.each do |valid|
-            @field.clean(valid)
-          end
+      invalid_formats.each do |invalid|
+        assert_raises(ValidationError) do
+          @field.clean(invalid)
         end
       end
+    end
+
+    def test_validate_valid_formats
+      valid_formats = ['3', '100', '-100', '0', '-0']
 
-      should 'return an instance of Integer if valid' do
-        result = @field.clean('7')
-        assert_kind_of(Integer, result)
+      assert_nothing_raised do
+        valid_formats.each do |valid|
+          @field.clean(valid)
+        end
       end
     end
 
+    def test_return_an_instance_of_Integer_if_valid
+      result = @field.clean('7')
+      assert_kind_of(Integer, result)
+    end
   end
 
-  describe 'FloatField' do
-    describe 'with max value of 10.5' do
-      setup do
-        @field = Fields::FloatField.new(:max_value => 10.5)
-      end
+end
 
-      should 'allow values <= 10.5' do
-        assert_nothing_raised do
-          @field.clean('10.5')
-        end
-      end
+module FloatFieldTests
+  class Test_with_max_value < BureaucratTestCase
+    def setup
+      @field = Fields::FloatField.new(max_value: 10.5)
+    end
 
-      should 'not allow values > 10.5' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('10.55')
-        end
+    def test_allow_values_less_or_equal_to_max_value
+      assert_nothing_raised do
+        @field.clean('10.5')
+        @field.clean('5')
       end
     end
 
-    describe 'with min value of 10.5' do
-      setup do
-        @field = Fields::FloatField.new(:min_value => 10.5)
+    def test_not_allow_values_greater_than_max_value
+      assert_raises(ValidationError) do
+        @field.clean('10.55')
       end
+    end
+  end
 
-      should 'allow values >= 10.5' do
-        assert_nothing_raised do
-          @field.clean('10.5')
-        end
-      end
+  class Test_with_min_value < BureaucratTestCase
+    def setup
+      @field = Fields::FloatField.new(min_value: 10.5)
+    end
 
-      should 'not allow values < 10.5' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('10.49')
-        end
+    def test_allow_values_greater_or_equal_than_min_value
+      assert_nothing_raised do
+        @field.clean('10.5')
+        @field.clean('20.5')
       end
     end
 
-    describe 'on clean' do
-      setup do
-        @field = Fields::FloatField.new
+    def test_not_allow_values_less_than_min_value
+      assert_raises(ValidationError) do
+        @field.clean('10.49')
       end
+    end
+  end
 
-      should 'return nil if value is nil and required is false' do
-        @field.required = false
-        assert_nil(@field.clean(nil))
-      end
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @field = Fields::FloatField.new
+    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
+    def test_return_nil_if_value_is_nil_and_required_is_false
+      @field.required = false
+      assert_nil(@field.clean(nil))
+    end
+
+    def test_return_nil_if_value_is_empty_and_required_is_false
+      @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']
+    def test_not_validate_invalid_formats
+      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
+      invalid_formats.each do |invalid|
+        assert_raises(ValidationError) do
+          @field.clean(invalid)
         end
       end
+    end
 
-      should 'validate valid formats' do
-        valid_formats = ['3.14', "100", "1233.", ".3333", "0.434", "0.0"]
+    def test_validate_valid_formats
+      valid_formats = ['3.14', "100", "1233.", ".3333", "0.434", "0.0"]
 
-        assert_nothing_raised do
-          valid_formats.each do |valid|
-            @field.clean(valid)
-          end
+      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
+    def test_return_an_instance_of_Float_if_valid
+      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
+module BigDecimalFieldTests
+  class Test_with_max_value < BureaucratTestCase
+    def setup
+      @field = Fields::BigDecimalField.new(max_value: 10.5)
+    end
 
-      should 'allow values <= 10.5' do
-        assert_nothing_raised do
-          @field.clean('10.5')
-        end
+    def test_allow_values_less_or_equal_to_max_value
+      assert_nothing_raised do
+        @field.clean('10.5')
+        @field.clean('5')
       end
+    end
 
-      should 'not allow values > 10.5' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('10.55')
-        end
+    def test_not_allow_values_greater_than_max_value
+      assert_raises(ValidationError) 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
+  class Test_with_min_value < BureaucratTestCase
+    def setup
+      @field = Fields::BigDecimalField.new(min_value: 10.5)
+    end
 
-      should 'allow values >= 10.5' do
-        assert_nothing_raised do
-          @field.clean('10.5')
-        end
+    def test_allow_values_greater_or_equal_to_min_value
+      assert_nothing_raised do
+        @field.clean('10.5')
+        @field.clean('20.5')
       end
+    end
 
-      should 'not allow values < 10.5' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('10.49')
-        end
+    def test_not_allow_values_less_than_min_value
+      assert_raises(ValidationError) do
+        @field.clean('10.49')
       end
     end
+  end
 
-    describe 'on clean' do
-      setup do
-        @field = Fields::BigDecimalField.new
-      end
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @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
+    def test_return_nil_if_value_is_nil_and_required_is_false
+      @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
+    def test_return_nil_if_value_is_empty_and_required_is_false
+      @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']
+    def test_not_validate_invalid_formats
+      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
+      invalid_formats.each do |invalid|
+        assert_raises(ValidationError) do
+          @field.clean(invalid)
         end
       end
+    end
 
-      should 'validate valid formats' do
-        valid_formats = ['3.14', "100", "1233.", ".3333", "0.434", "0.0"]
+    def test_validate_valid_formats
+      valid_formats = ['3.14', "100", "1233.", ".3333", "0.434", "0.0"]
 
-        assert_nothing_raised do
-          valid_formats.each do |valid|
-            @field.clean(valid)
-          end
+      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
+    def test_return_an_instance_of_BigDecimal_if_valid
+      result = @field.clean('3.14')
+      assert_instance_of(BigDecimal, result)
     end
   end
+end
 
-  describe 'RegexField' do
-    setup do
+module RegexFieldTests
+  class Test_on_clean < BureaucratTestCase
+    def setup
       @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
+    def test_validate_matching_values
+      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
+    def test_not_validate_non_matching_values
+      invalid_values = ['bana', 'spoon']
+      assert_raises(ValidationError) 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
+    def test_return_a_blank_string_if_value_is_empty_and_required_is_false
+      @field.required = false
+      empty_value = ''
+      assert_equal('', @field.clean(empty_value))
     end
   end
+end
 
-  describe 'EmailField' do
-    setup do
+module EmailFieldTests
+  class Test_on_clean < BureaucratTestCase
+    def setup
       @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
+    def test_validate_email_matching_values
+      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
+    def test_not_validate_non_email_matching_values
+      invalid_values = ['banana', 'spoon', 'invalid@dom#ain.com',
+                        'invalid@@domain.com', 'invalid@domain',
+                        'invalid@.com']
+      invalid_values.each do |invalid|
+        assert_raises(ValidationError) do
+          @field.clean(invalid)
         end
       end
     end
   end
+end
 
-  describe 'BooleanField' do
-    setup do
+module BooleanFieldTests
+  class Test_on_clean < BureaucratTestCase
+    def setup
       @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
+    def test_return_true_for_true_values
+      @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
+    def test_return_false_for_false_values
+      @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
+    def test_validate_on_true_values_when_required
+      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
+    def test_not_validate_on_false_values_when_required
+      @false_values.each do |false_value|
+        assert_raises(ValidationError) 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
+    def test_validate_on_false_values_when_not_required
+      @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
+module NullBooleanFieldTests
+  class Test_on_clean < BureaucratTestCase
+    def setup
       @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
+    def test_return_true_for_true_values
+      @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
+    def test_return_false_for_false_values
+      @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
+    def test_return_nil_for_null_values
+      @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
+    def test_validate_on_all_values
+      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
+module ChoiceFieldTests
+  class Test_when_copied < BureaucratTestCase
+    def setup
       @choices = [['tea', 'Tea'], ['milk', 'Milk']]
       @field = Fields::ChoiceField.new(@choices)
+      @field_copy = @field.dup
     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
+    def test_have_its_own_copy_of_choices
+      assert_not_equal(@field.choices.object_id, @field_copy.choices.object_id)
+    end
+  end
+
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @choices = [['tea', 'Tea'], ['milk', 'Milk']]
+      @choices_hash = [[{ value: "able" }, "able"], [{ value: "baker" }, "Baker"]]
+      @field = Fields::ChoiceField.new(@choices)
+      @field_hash = Fields::ChoiceField.new(@choices_hash)
+    end
+
+    def test_validate_all_values_in_choices_list
+      assert_nothing_raised do
+        @choices.collect(&:first).each do |valid|
+          @field.clean(valid)
+        end
+      end
+    end
+
+    def test_validate_all_values_in_a_hash_choices_list
+      assert_nothing_raised do
+        @choices_hash.collect(&:first).each do |valid|
+          @field_hash.clean(valid[:value])
+        end
+      end
+    end
+
+    def test_not_validate_a_value_not_in_choices_list
+      assert_raises(ValidationError) do
+        @field.clean('not_in_choices')
+      end
+    end
+
+    def test_not_validate_a_value_not_in_a_hash_choices_list
+      assert_raises(ValidationError) do
+        @field_hash.clean('not_in_choices')
+      end
+    end
+
+    def test_return_the_original_value_if_valid
+      value = 'tea'
+      result = @field.clean(value)
+      assert_equal(value, result)
+    end
+
+    def test_return_the_original_value_if_valid_from_a_hash_choices_list
+      value = 'baker'
+      result = @field_hash.clean(value)
+      assert_equal(value, result)
+    end
+
+    def test_return_an_empty_string_if_value_is_empty_and_not_required
+      @field.required = false
+      result = @field.clean('')
+      assert_equal('', result)
+    end
+
+    def test_return_an_empty_string_if_value_is_empty_and_not_required_from_a_hash_choices_list
+      @field_hash.required = false
+      result = @field_hash.clean('')
+      assert_equal('', result)
+    end
+  end
+end
+
+module TypedChoiceFieldTests
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @choices = [[1, 'One'], [2, 'Two'], ['3', 'Three']]
+      to_int = lambda{|val| Integer(val)}
+      @field = Fields::TypedChoiceField.new(@choices,
+                                            coerce: to_int)
+    end
+
+    def test_validate_all_values_in_choices_list
+      assert_nothing_raised do
+        @choices.collect(&:first).each do |valid|
+          @field.clean(valid)
         end
       end
+    end
+
+    def test_not_validate_a_value_not_in_choices_list
+      assert_raises(ValidationError) do
+        @field.clean('four')
+      end
+    end
+
+    def test_return_the_original_value_if_valid
+      value = 1
+      result = @field.clean(value)
+      assert_equal(value, result)
+    end
 
-      should 'not validate a value not in choices list' do
-        assert_raise(Fields::FieldValidationError) do
-          @field.clean('not_in_choices')
+    def test_return_a_coerced_version_of_the_original_value_if_valid_but_of_different_type
+      value = 2
+      result = @field.clean(value.to_s)
+      assert_equal(value, result)
+    end
+
+    def test_return_an_empty_string_if_value_is_empty_and_not_required
+      @field.required = false
+      result = @field.clean('')
+      assert_equal('', result)
+    end
+  end
+end
+
+module MultipleChoiceFieldTests
+  class Test_on_clean < BureaucratTestCase
+    def setup
+      @choices = [['tea', 'Tea'], ['milk', 'Milk'], ['coffee', 'Coffee']]
+      @field = Fields::MultipleChoiceField.new(@choices)
+    end
+
+    def test_validate_all_single_values_in_choices_list
+      assert_nothing_raised do
+        @choices.collect(&:first).each do |valid|
+          @field.clean([valid])
         end
       end
+    end
 
-      should 'return the original value if valid' do
-        value = 'tea'
-        result = @field.clean(value)
-        assert_equal(value, result)
+    def test_validate_multiple_values
+      values = ['tea', 'coffee']
+      assert_nothing_raised do
+        @field.clean(values)
       end
+    end
 
-      should 'return an empty string if value is empty and not required' do
-        @field.required = false
-        result = @field.clean('')
-        assert_equal('', result)
+    def test_not_validate_a_value_not_in_choices_list
+      assert_raises(ValidationError) do
+        @field.clean(['tea', 'not_in_choices'])
       end
     end
+
+    def test_return_the_original_value_if_valid
+      value = 'tea'
+      result = @field.clean([value])
+      assert_equal([value], result)
+    end
+
+    def test_return_an_empty_list_if_value_is_empty_and_not_required
+      @field.required = false
+      result = @field.clean([])
+      assert_equal([], result)
+    end
   end
 end