bureaucrat 0.0.3 → 0.10.0

data/test/forms_test.rb

@@ -1,66 +1,61 @@
-require File.dirname(__FILE__) + "/test_helper"
+require_relative 'test_helper'
 
-class TestForm < BureaucratTestCase
-  describe 'inherited form with a CharField' do
+module FormTests
+  class Test_inherited_form_with_a_CharField < BureaucratTestCase
     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
+    def test_have_a_BoundField
       form = OneForm.new
       assert_kind_of(Forms::BoundField, form[:name])
     end
 
-    should 'be bound when data is provided' do
-      form = OneForm.new(:name => 'name')
+    def test_be_bound_when_data_is_provided
+      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)
+    class Test_when_calling_valid < BureaucratTestCase
+      def test_return_false_when_data_isnt_valid
+        form = OneForm.new(name: nil)
         assert_equal(false, form.valid?)
       end
 
-      should 'return true when data is valid' do
-        form = OneForm.new(:name => 'valid')
+      def test_return_true_when_data_is_valid
+        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)
+    class Test_when_calling_errors < BureaucratTestCase
+      def test_have_errors_when_invalid
+        form = OneForm.new(name: nil)
         assert_operator(form.errors.size, :>, 0)
       end
 
-      should 'not have errors when valid' do
-        form = OneForm.new(:name => 'valid')
+      def test_not_have_errors_when_valid
+        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
+    class Test_when_calling_changed_data < BureaucratTestCase
+      def test_return_an_empty_list_if_no_field_was_changed
         form = OneForm.new
         assert_equal([], form.changed_data)
       end
 
-      should 'return a list of changed fields when modified' do
-        form = OneForm.new(:name => 'changed')
+      def test_return_a_list_of_changed_fields_when_modified
+        form = OneForm.new(name: 'changed')
         assert_equal([:name], form.changed_data)
       end
     end
   end
 
-  describe 'form with custom clean proc on field' do
+  class Test_form_with_custom_clean_proc_on_field < BureaucratTestCase
     class CustomCleanForm < Forms::Form
       include Bureaucrat::Fields
 
@@ -68,64 +63,89 @@ class TestForm < BureaucratTestCase
 
       def clean_name
         value = cleaned_data[:name]
-        raise FieldValidationError.new("Invalid name") unless value == 'valid_name'
+        unless value == 'valid_name'
+          raise Bureaucrat::ValidationError.new("Invalid name")
+        end
         value.upcase
       end
     end
 
-    should 'not be valid if clean method fails' do
-      form = CustomCleanForm.new(:name => 'other')
+    def test_not_be_valid_if_clean_method_fails
+      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')
+    def test_be_valid_if_clean_method_passes
+      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')
+    def test_set_the_value_to_the_one_returned_by_the_custom_clean_method
+      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
+  class Test_populating_objects < BureaucratTestCase
+    class PopulatorForm < Forms::Form
       include Bureaucrat::Fields
 
-      field :name, CharField.new(:label => 'Name')
-      field :color, CharField.new
+      field :name, CharField.new(required: false)
+      field :color, CharField.new(required: false)
+      field :number, IntegerField.new(required: false)
     end
 
-    def setup
-      @form = TwoForm.new(:name => 'name')
-      @unbound_form = TwoForm.new
-    end
+    def test_correctly_populate_an_object_with_all_fields
+      obj = Struct.new(:name, :color, :number).new
+      name_value = 'The Name'
+      color_value = 'Black'
+      number_value = 10
 
-    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
+      form = PopulatorForm.new(name: name_value,
+                               color: color_value,
+                               number: number_value.to_s)
+
+      assert form.valid?
 
-    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)
+      form.populate_object(obj)
+
+      assert_equal(name_value, obj.name)
+      assert_equal(color_value, obj.color)
+      assert_equal(number_value, obj.number)
     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)
+    def test_correctly_populate_an_object_without_all_fields
+      obj = Struct.new(:name, :number).new
+      name_value = 'The Name'
+      color_value = 'Black'
+      number_value = 10
+
+      form = PopulatorForm.new(name: name_value,
+                               color: color_value,
+                               number: number_value.to_s)
+
+      assert form.valid?
+
+      form.populate_object(obj)
+
+      assert_equal(name_value, obj.name)
+      assert_equal(number_value, obj.number)
     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)
+    def test_correctly_populate_an_object_with_all_fields_with_some_missing_values
+      obj = Struct.new(:name, :color, :number).new('a', 'b', 2)
+
+      form = PopulatorForm.new({})
+
+      assert form.valid?
+
+      form.populate_object(obj)
+
+      assert_equal('', obj.name)
+      assert_equal('', obj.color)
+      assert_equal(nil, obj.number)
     end
   end
 end

data/test/formsets_test.rb

@@ -1,17 +1,28 @@
-require File.dirname(__FILE__) + "/test_helper"
+require_relative 'test_helper'
 
-class SimpleForm < Bureaucrat::Forms::Form
-  include Bureaucrat::Fields
+module FormsetTests
+  class SimpleForm < Bureaucrat::Forms::Form
+    include Bureaucrat::Fields
 
-  field :name, CharField.new
-end
+    field :name, CharField.new
+  end
+
+  SimpleFormFormSet =
+    Bureaucrat::Formsets.make_formset_class(SimpleForm, extra: 2)
+
+  class CustomFormSet < Bureaucrat::Formsets::BaseFormSet
+    def clean
+      raise Bureaucrat::ValidationError.new('This is wrong!')
+    end
+  end
 
-SimpleFormFormSet = Bureaucrat::Formsets.make_formset_class(SimpleForm,
-                                                            :extra => 2)
+  SimpleFormCustomFormSet =
+    Bureaucrat::Formsets.make_formset_class(SimpleForm,
+                                            extra: 2,
+                                            formset: CustomFormSet)
 
-class TestFormset < BureaucratTestCase
-  describe 'formset with empty data' do
-    setup do
+  class Test_formset_with_empty_data < BureaucratTestCase
+    def setup
       management_form_data = {
         :'form-TOTAL_FORMS' => '2',
         :'form-INITIAL_FORMS' => '2'
@@ -23,29 +34,44 @@ class TestFormset < BureaucratTestCase
       @invalid_bound_set = SimpleFormFormSet.new(management_form_data.merge(invalid_data))
     end
 
-    should 'correctly render when calling as_table' do
-      expected = normalize_html("<input name='form-TOTAL_FORMS' id='id_form-TOTAL_FORMS' type='hidden' value='2'/><input name='form-INITIAL_FORMS' id='id_form-INITIAL_FORMS' type='hidden' value='0'/>\n<tr><th><label for='id_form-0-name'>Name:</label></th><td><input name='form-0-name' id='id_form-0-name' type='text'/></td></tr> <tr><th><label for='id_form-1-name'>Name:</label></th><td><input name='form-1-name' id='id_form-1-name' type='text'/></td></tr>")
-      rendered = normalize_html(@set.as_table)
-      assert_equal(expected, rendered)
-    end
-
-    should '#valid? returns true if all forms are valid' do
+    def test_#valid?_returns_true_if_all_forms_are_valid
       assert(@valid_bound_set.valid?)
     end
 
-    should '#valid? returns false if there is an invalid form' do
+    def test_#valid?_returns_false_if_there_is_an_invalid_form
       assert(!@invalid_bound_set.valid?)
     end
 
-    should 'correctly return the list of errors' do
-      assert_equal([{}, {:name => ["This field is required"]}],
+    def test_correctly_return_the_list_of_errors
+      assert_equal([{}, {name: ["This field is required"]}],
                    @invalid_bound_set.errors)
     end
 
-    should 'correctly return the list of cleaned data' do
-      expected = [{:name => 'Lynch'}, {:name => 'Tio'}]
+    def test_correctly_return_the_list_of_cleaned_data
+      expected = [{'name' => 'Lynch'}, {'name' => 'Tio'}]
       result = @valid_bound_set.cleaned_data
       assert_equal(expected, result)
     end
   end
+
+  class Test_Formset_with_clean_method_raising_a_ValidationError_exception < BureaucratTestCase
+    def setup
+      management_form_data = {
+        :'form-TOTAL_FORMS' => '2',
+        :'form-INITIAL_FORMS' => '2'
+      }
+      valid_data = {:'form-0-name' => 'Lynch', :'form-1-name' => 'Tio'}
+      @bound_set =
+        SimpleFormCustomFormSet.new(management_form_data.merge(valid_data))
+    end
+
+    def test_not_be_valid
+      assert_equal(false, @bound_set.valid?)
+    end
+
+    def test_add_clean_errors_to_nonfield_errors
+      @bound_set.valid?
+      assert_equal(["This is wrong!"],  @bound_set.non_form_errors)
+    end
+  end
 end

data/test/test_helper.rb

@@ -1,22 +1,30 @@
 require 'bigdecimal'
-require 'rubygems'
-require "contest"
+require 'minitest/autorun'
 
-require File.join(File.dirname(__FILE__), '..', 'lib', 'bureaucrat')
-require File.join(File.dirname(__FILE__), '..', 'lib', 'bureaucrat', 'formsets')
+require_relative '../lib/bureaucrat'
+require_relative '../lib/bureaucrat/formsets'
 
 # Used to compare rendered htmls
 require 'rexml/document'
 
-class BureaucratTestCase < Test::Unit::TestCase
+class BureaucratTestCase < MiniTest::Unit::TestCase
   include Bureaucrat
-end
 
-def normalize_html(html)
-  begin
-    node = REXML::Document.new("<DUMMYROOT>#{html}</DUMMYROOT>")
-    node.to_s.gsub!(/<\/?DUMMYROOT>/, '')
-  rescue Exception => e
-    html
+  def assert_nothing_raised(&block)
+    block.call
+    assert true
+  end
+
+  def assert_not_equal(value, other)
+    assert value != other, "should be different from #{value}"
+  end
+
+  def normalize_html(html)
+    begin
+      node = REXML::Document.new("<DUMMYROOT>#{html.strip}</DUMMYROOT>")
+      node.to_s.gsub!(/<\/?DUMMYROOT>/, '')
+    rescue Exception => e
+      html
+    end
   end
 end

data/test/widgets_test.rb

@@ -1,101 +1,9 @@
-require File.dirname(__FILE__) + "/test_helper"
+require_relative 'test_helper'
 
-class TestWidgets < BureaucratTestCase
-  describe 'Media' do
-    describe 'empty' do
-      setup do
-        @media = Widgets::Media.new
-      end
-
-      should 'render an empty string' do
-        rendered = @media.render
-        assert_equal('', rendered)
-      end
-    end
-
-    describe 'with only javascript' do
-      setup do
-        @media = Widgets::Media.new(:js => ['test.js', 'test2.js'])
-      end
-
-      should 'render correctly and in same order' do
-        rendered = @media.render
-        expected = "<script type=\"text/javascript\" src=\"http://localhost/test.js\"></script>\n<script type=\"text/javascript\" src=\"http://localhost/test2.js\"></script>"
-        assert_equal(expected, rendered)
-      end
-    end
-
-    describe 'with only css' do
-      setup do
-        @media = Widgets::Media.new(:css => {:screen => ['test.css',
-                                                         'test2.css']})
-      end
-
-      should 'render correctly' do
-        rendered = @media.render
-        expected = "<link href=\"http://localhost/test.css\" type=\"text/css\" media=\"screen\" rel=\"stylesheet\" />\n<link href=\"http://localhost/test2.css\" type=\"text/css\" media=\"screen\" rel=\"stylesheet\" />"
-        assert_equal(expected, rendered)
-      end
-    end
-
-    describe 'with both js and css' do
-      setup do
-        @media = Widgets::Media.new(:js => ['test.js', 'test2.js'],
-                                    :css => {:screen => ['test.css',
-                                                         'test2.css']})
-      end
-
-      should 'render correctly' do
-        rendered = @media.render
-        expected = "<link href=\"http://localhost/test.css\" type=\"text/css\" media=\"screen\" rel=\"stylesheet\" />\n<link href=\"http://localhost/test2.css\" type=\"text/css\" media=\"screen\" rel=\"stylesheet\" />\n<script type=\"text/javascript\" src=\"http://localhost/test.js\"></script>\n<script type=\"text/javascript\" src=\"http://localhost/test2.js\"></script>"
-        assert_equal(expected, rendered)
-      end
-    end
-
-    describe 'the result of summing two instances of Media' do
-      setup do
-        @media1 = Widgets::Media.new(:js => ['test1.js', 'test2.js'],
-                                     :css => {:screen => ['test1.css',
-                                                          'test2.css']})
-        @media2 = Widgets::Media.new(:js => ['test3.js', 'test4.js'],
-                                     :css => {:screen => ['test3.css',
-                                                          'test4.css']})
-        @combined = @media1 + @media2
-      end
-
-      should 'be an instance of Media' do
-        assert_kind_of(Widgets::Media, @combined)
-      end
-
-      should 'contain a combined list of js' do
-        expected = @media1.to_hash[:js] + @media2.to_hash[:js]
-        result = @combined.to_hash[:js]
-        assert_equal(expected, result)
-      end
-
-      should 'contain a combined list of css' do
-        expected = @media1.to_hash[:css]
-        @media2.to_hash[:css].each do |k, v|
-          expected[k] ||= []
-          expected[k] += v
-        end
-        result = @combined.to_hash[:css]
-        assert_equal(expected, result)
-      end
-    end
-  end
-
-  describe 'Widget instance' do
-    should 'return an instance of Media when calling #media' do
-      widget = Widgets::Widget.new
-      assert_kind_of(Widgets::Media, widget.media)
-    end
-  end
-
-  describe 'TextInput widget' do
-
-    describe 'with empty attributes' do
-      should 'correctly render' do
+module WidgetTests
+  class Test_TextInput_widget < BureaucratTestCase
+    class Test_with_empty_attributes < BureaucratTestCase
+      def test_correctly_render
         input = Widgets::TextInput.new
         expected = normalize_html('<input type="text" value="hi" name="test" />')
         rendered = normalize_html(input.render('test', 'hi'))
@@ -103,17 +11,17 @@ class TestWidgets < BureaucratTestCase
       end
     end
 
-    describe 'with attributes' do
-      should 'correctly render' do
-        input = Widgets::TextInput.new(:attribute => 'value')
+    class Test_with_attributes < BureaucratTestCase
+      def test_correctly_render
+        input = Widgets::TextInput.new(attribute: 'value')
         expected = normalize_html('<input type="text" value="hi" name="test" attribute="value" />')
         rendered = normalize_html(input.render('test', 'hi'))
         assert_equal(expected, rendered)
       end
     end
 
-    describe 'without value' do
-      should 'not render a value' do
+    class Test_without_value < BureaucratTestCase
+      def test_not_render_a_value
         input = Widgets::TextInput.new
         expected = normalize_html('<input type="text" name="test" />')
         rendered = normalize_html(input.render('test', nil))
@@ -121,208 +29,320 @@ class TestWidgets < BureaucratTestCase
       end
     end
 
-    describe 'when copied' do
-      should 'have a copy of the attributes' do
-        input1 = Widgets::TextInput.new(:attribute => 2)
+    class Test_when_copied < BureaucratTestCase
+      def test_have_a_copy_of_the_attributes
+        input1 = Widgets::TextInput.new(attribute: 2)
         input2 = input1.dup
         assert_not_equal(input1.attrs.object_id, input2.attrs.object_id)
       end
     end
   end
 
-  describe 'PasswordInput widget' do
-    describe 'with render_value=true' do
-      should 'render correctly including value' do
-        input = Widgets::PasswordInput.new
-        excepted = normalize_html("<input name='test' type='password' value='secret'/>")
+  class Test_PasswordInput_widget < BureaucratTestCase
+    class Test_with_render_value_true < BureaucratTestCase
+      def test_render_correctly_including_value
+        input = Widgets::PasswordInput.new(nil, true)
+        expected = normalize_html("<input name='test' type='password' value='secret'/>")
         rendered = normalize_html(input.render('test', 'secret'))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
     end
 
-    describe 'with render_value=false' do
-      should 'render correctly not including value' do
+    class Test_with_render_value_false < BureaucratTestCase
+      def test_render_correctly_not_including_value
         input = Widgets::PasswordInput.new(nil, false)
-        excepted = normalize_html("<input name='test' type='password'/>")
+        expected = normalize_html("<input name='test' type='password'/>")
         rendered = normalize_html(input.render('test', 'secret'))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
     end
   end
 
-  describe 'HiddenInput widget' do
-    should 'correctly render' do
+  class Test_HiddenInput_widget < BureaucratTestCase
+    def test_correctly_render
       input = Widgets::HiddenInput.new
-      excepted = normalize_html("<input name='test' type='hidden' value='secret'/>")
+      expected = normalize_html("<input name='test' type='hidden' value='secret'/>")
       rendered = normalize_html(input.render('test', 'secret'))
-      assert_equal(excepted, rendered)
+      assert_equal(expected, rendered)
     end
   end
 
-  describe 'MultipleHiddenInput widget' do
-    should 'correctly render' do
+  class Test_MultipleHiddenInput_widget < BureaucratTestCase
+    def test_correctly_render
       input = Widgets::MultipleHiddenInput.new
-      excepted = normalize_html("<input name='test' type='hidden' value='v1'/>\n<input name='test' type='hidden' value='v2'/>")
+      expected = normalize_html("<input name='test[]' type='hidden' value='v1'/>\n<input name='test[]' type='hidden' value='v2'/>")
       rendered = normalize_html(input.render('test', ['v1', 'v2']))
-      assert_equal(excepted, rendered)
+      assert_equal(expected, rendered)
     end
     # TODO: value_from_datahash
   end
 
-  describe 'FileInput widget' do
-    should 'correctly render' do
+  class Test_FileInput_widget < BureaucratTestCase
+    def test_correctly_render
       input = Widgets::FileInput.new
-      excepted = normalize_html("<input name='test' type='file'/>")
+      expected = normalize_html("<input name='test' type='file'/>")
       rendered = normalize_html(input.render('test', "anything"))
-      assert_equal(excepted, rendered)
+      assert_equal(expected, rendered)
     end
     # TODO: value_from_datahash, has_changed?
   end
 
-  describe 'Textarea widget' do
-    should 'correctly render' do
-      input = Widgets::Textarea.new(:cols => '50', :rows => '15')
-      excepted = normalize_html("<textarea name='test' rows='15' cols='50'>hello</textarea>")
+  class Test_Textarea_widget < BureaucratTestCase
+    def test_correctly_render
+      input = Widgets::Textarea.new(cols: '50', rows: '15')
+      expected = normalize_html("<textarea name='test' rows='15' cols='50'>hello</textarea>")
       rendered = normalize_html(input.render('test', "hello"))
-      assert_equal(excepted, rendered)
+      assert_equal(expected, rendered)
+    end
+
+    def test_correctly_render_multiline
+      input = Widgets::Textarea.new(cols: '50', rows: '15')
+      expected = normalize_html("<textarea name='test' rows='15' cols='50'>hello\n\ntest</textarea>")
+      rendered = normalize_html(input.render('test', "hello\n\ntest"))
+      assert_equal(expected, rendered)
     end
   end
 
-  describe 'CheckboxInput widget' do
-    should 'correctly render with a false value' do
+  class Test_CheckboxInput_widget < BureaucratTestCase
+    def test_correctly_render_with_a_false_value
       input = Widgets::CheckboxInput.new
-      excepted = normalize_html("<input name='test' type='checkbox' value='false'/>")
-      rendered = normalize_html(input.render('test', 'false'))
-      assert_equal(excepted, rendered)
+      expected = normalize_html("<input name='test' type='checkbox'/>")
+      rendered = normalize_html(input.render('test', false))
+      assert_equal(expected, rendered)
     end
 
-    should 'correctly render with a true value' do
+    def test_correctly_render_with_a_true_value
       input = Widgets::CheckboxInput.new
-      excepted = normalize_html("<input name='test' type='checkbox' value='true'/>")
-      rendered = normalize_html(input.render('test', 'true'))
-      assert_equal(excepted, rendered)
+      expected ="<input checked='checked' name='test' type='checkbox'/>"
+      rendered = normalize_html(input.render('test', true))
+      assert_equal(expected, rendered)
     end
 
-    should 'correctly render with a non boolean value' do
+    def test_correctly_render_with_a_non_boolean_value
       input = Widgets::CheckboxInput.new
-      excepted = normalize_html("<input name='test' type='checkbox' value='anything'/>")
+      expected = "<input checked='checked' name='test' type='checkbox' value='anything'/>"
       rendered = normalize_html(input.render('test', 'anything'))
-      assert_equal(excepted, rendered)
+      assert_equal(expected, rendered)
     end
     # TODO: value_from_datahash, has_changed?
   end
 
-  describe 'Select widget' do
-    def setup
-      @choices = [['1', 'One'], ['2', 'Two']]
-      @groupchoices = [['numbers', ['1', 'One'], ['2', 'Two']],
-                       ['words', [['spoon', 'Spoon'], ['banana', 'Banana']]]]
-    end
-
-    describe 'with empty choices' do
-      should 'correctly render' do
+  module SelectWidgetTests
+    class Test_with_empty_choices < BureaucratTestCase
+      def test_correctly_render
         input = Widgets::Select.new
-        excepted = normalize_html("<select name='test'>\n</select>")
+        expected = normalize_html("<select name='test'>\n</select>")
         rendered = normalize_html(input.render('test', 'hello'))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
     end
 
-    describe 'with flat choices' do
-      should 'correctly render (none selected)' do
+    class Test_with_flat_choices < BureaucratTestCase
+      def setup
+        @choices = [['1', 'One'], ['2', 'Two']]
+      end
+
+      def test_correctly_render_none_selected
         input = Widgets::Select.new(nil, @choices)
-        excepted = normalize_html("<select name='test'>\n<option value='1'>One</option>\n<option value='2'>Two</option>\n</select>")
+        expected = normalize_html("<select name='test'>\n<option value='1'>One</option>\n<option value='2'>Two</option>\n</select>")
         rendered = normalize_html(input.render('test', 'hello'))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
 
-      should 'correctly render (with selected)' do
+      def test_correctly_render_with_selected
         input = Widgets::Select.new(nil, @choices)
-        excepted = normalize_html("<select name='test'>\n<option value='1'>One</option>\n<option value='2' selected='selected'>Two</option>\n</select>")
+        expected = normalize_html("<select name='test'>\n<option value='1'>One</option>\n<option value='2' selected='selected'>Two</option>\n</select>")
         rendered = normalize_html(input.render('test', '2'))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
     end
 
-    describe 'with group choices' do
-      should 'correctly render (none selected)' do
+    class Test_with_group_choices < BureaucratTestCase
+      def setup
+        @groupchoices = [['numbers', ['1', 'One'], ['2', 'Two']],
+                         ['words', [['spoon', 'Spoon'], ['banana', 'Banana']]]]
+      end
+
+      def test_correctly_render_none_selected
         input = Widgets::Select.new(nil, @groupchoices)
-        excepted = normalize_html("<select name='test'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon'>Spoon</option>\n<option value='banana'>Banana</option>\n</optgroup>\n</select>")
+        expected = normalize_html("<select name='test'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon'>Spoon</option>\n<option value='banana'>Banana</option>\n</optgroup>\n</select>")
         rendered = normalize_html(input.render('test', 'hello'))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
 
-      should 'correctly render (with selected)' do
+      def test_correctly_render_with_selected
         input = Widgets::Select.new(nil, @groupchoices)
-        excepted = normalize_html("<select name='test'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon'>Spoon</option>\n<option value='banana' selected='selected'>Banana</option>\n</optgroup>\n</select>")
+        expected = normalize_html("<select name='test'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon'>Spoon</option>\n<option value='banana' selected='selected'>Banana</option>\n</optgroup>\n</select>")
         rendered = normalize_html(input.render('test', 'banana'))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
+      end
+    end
+
+    class Test_with_simple_choices < BureaucratTestCase
+      def setup
+        @simplechoices = [ "able", "baker", "charlie" ]
+      end
+
+      def test_correctly_render_none_selected
+        input = Widgets::Select.new(nil, @simplechoices)
+        expected = normalize_html("<select name='test'>\n<option value='able'>able</option>\n<option value='baker'>baker</option>\n<option value='charlie'>charlie</option>\n</select>")
+        rendered = normalize_html(input.render('test', 'hello'))
+        assert_equal(expected, rendered)
+      end
+
+      def test_correctly_render_with_selected
+        input = Widgets::Select.new(nil, @simplechoices)
+        expected = normalize_html("<select name='test'>\n<option value='able'>able</option>\n<option value='baker' selected='selected'>baker</option>\n<option value='charlie'>charlie</option>\n</select>")
+        rendered = normalize_html(input.render('test', 'baker'))
+        assert_equal(expected, rendered)
+      end
+    end
+
+    class Test_with_option_choices < BureaucratTestCase
+      def setup
+        @optionchoices = [[{ value: "foo", disabled: "disabled", onSelect: "doSomething();" }, "Foo"],
+                          [{ value: "bar" }, "Bar"]]
+        @optionchoicesselected = [[{ value: "foo", disabled: "disabled" }, "Foo"],
+                                  [{ value: "bar", selected: "selected" }, "Bar"]]
+      end
+
+      def test_correctly_render_none_selected
+        input = Widgets::Select.new(nil, @optionchoices)
+        expected = normalize_html("<select name='test'>\n<option value='foo' disabled='disabled' onSelect='doSomething();'>Foo</option>\n<option value='bar'>Bar</option>\n</select>")
+        rendered = normalize_html(input.render('test', 'hello'))
+        assert_equal(expected, rendered)
+      end
+
+      def test_correctly_render_traditional_selected
+        input = Widgets::Select.new(nil, @optionchoices)
+        expected = normalize_html("<select name='test'>\n<option value='foo' disabled='disabled' onSelect='doSomething();'>Foo</option>\n<option value='bar' selected='selected'>Bar</option>\n</select>")
+        rendered = normalize_html(input.render('test', 'bar'))
+        assert_equal(expected, rendered)
+      end
+
+      def test_correctly_render_option_selected
+        input = Widgets::Select.new(nil, @optionchoicesselected)
+        expected = normalize_html("<select name='test'>\n<option value='foo' disabled='disabled'>Foo</option>\n<option value='bar' selected='selected'>Bar</option>\n</select>")
+        rendered = normalize_html(input.render('test', 'hello'))
+        assert_equal(expected, rendered)
       end
     end
   end
 
-  describe 'NullBooleanSelect widget' do
-    should 'correctly render with "Unknown" as the default value when none is selected' do
+  class Test_NullBooleanSelect_widget < BureaucratTestCase
+    def test_correctly_render_with_Unknown_as_the_default_value_when_none_is_selected
       input = Widgets::NullBooleanSelect.new
-      excepted = normalize_html("<select name='test'>\n<option selected='selected' value='1'>Unknown</option>\n<option value='2'>Yes</option>\n<option value='3'>No</option>\n</select>")
+      expected = normalize_html("<select name='test'>\n<option selected='selected' value='1'>Unknown</option>\n<option value='2'>Yes</option>\n<option value='3'>No</option>\n</select>")
       rendered = normalize_html(input.render('test', nil))
-      assert_equal(excepted, rendered)
+      assert_equal(expected, rendered)
     end
 
-    should 'correctly render (with selected)' do
+    def test_correctly_render_with_selected
       input = Widgets::NullBooleanSelect.new
-      excepted = normalize_html("<select name='test'>\n<option value='1'>Unknown</option>\n<option selected='selected' value='2'>Yes</option>\n<option value='3'>No</option>\n</select>")
+      expected = normalize_html("<select name='test'>\n<option value='1'>Unknown</option>\n<option selected='selected' value='2'>Yes</option>\n<option value='3'>No</option>\n</select>")
       rendered = normalize_html(input.render('test', '2'))
-      assert_equal(excepted, rendered)
+      assert_equal(expected, rendered)
     end
   end
 
-  describe 'SelectMultiple widget' do
-    def setup
-      @choices = [['1', 'One'], ['2', 'Two']]
-      @groupchoices = [['numbers', ['1', 'One'], ['2', 'Two']],
-                       ['words', [['spoon', 'Spoon'], ['banana', 'Banana']]]]
-    end
-
-    describe 'with empty choices' do
-      should 'correctly render' do
+  module SelectMultipleTests
+    class Test_with_empty_choices < BureaucratTestCase
+      def test_correctly_render
         input = Widgets::SelectMultiple.new
-        excepted = normalize_html("<select name='test' multiple='multiple'>\n</select>")
-        rendered = normalize_html(input.render('test', 'hello'))
-        assert_equal(excepted, rendered)
+        expected = normalize_html("<select name='test[]' multiple='multiple'>\n</select>")
+        rendered = normalize_html(input.render('test', ['hello']))
+        assert_equal(expected, rendered)
       end
     end
 
-    describe 'with flat choices' do
-      should 'correctly render (none selected)' do
+    class Test_with_flat_choices < BureaucratTestCase
+      def setup
+        @choices = [['1', 'One'], ['2', 'Two']]
+      end
+
+      def test_correctly_render_none_selected
         input = Widgets::SelectMultiple.new(nil, @choices)
-        excepted = normalize_html("<select name='test' multiple='multiple'>\n<option value='1'>One</option>\n<option value='2'>Two</option>\n</select>")
-        rendered = normalize_html(input.render('test', 'hello'))
-        assert_equal(excepted, rendered)
+        expected = normalize_html("<select name='test[]' multiple='multiple'>\n<option value='1'>One</option>\n<option value='2'>Two</option>\n</select>")
+        rendered = normalize_html(input.render('test', ['hello']))
+        assert_equal(expected, rendered)
       end
 
-      should 'correctly render (with selected)' do
+      def test_correctly_render_with_selected
         input = Widgets::SelectMultiple.new(nil, @choices)
-        excepted = normalize_html("<select name='test' multiple='multiple'>\n<option value='1' selected='selected'>One</option>\n<option value='2' selected='selected'>Two</option>\n</select>")
+        expected = normalize_html("<select name='test[]' multiple='multiple'>\n<option value='1' selected='selected'>One</option>\n<option value='2' selected='selected'>Two</option>\n</select>")
         rendered = normalize_html(input.render('test', ['1', '2']))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
     end
 
-    describe 'with group choices' do
-      should 'correctly render (none selected)' do
+    class Test_with_group_choices < BureaucratTestCase
+      def setup
+        @groupchoices = [['numbers', ['1', 'One'], ['2', 'Two']],
+                         ['words', [['spoon', 'Spoon'], ['banana', 'Banana']]]]
+      end
+
+      def test_correctly_render_none_selected
         input = Widgets::SelectMultiple.new(nil, @groupchoices)
-        excepted = normalize_html("<select name='test' multiple='multiple'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon'>Spoon</option>\n<option value='banana'>Banana</option>\n</optgroup>\n</select>")
-        rendered = normalize_html(input.render('test', 'hello'))
-        assert_equal(excepted, rendered)
+        expected = normalize_html("<select name='test[]' multiple='multiple'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon'>Spoon</option>\n<option value='banana'>Banana</option>\n</optgroup>\n</select>")
+        rendered = normalize_html(input.render('test', ['hello']))
+        assert_equal(expected, rendered)
       end
 
-      should 'correctly render (with selected)' do
+      def test_correctly_render_with_selected
         input = Widgets::SelectMultiple.new(nil, @groupchoices)
-        excepted = normalize_html("<select name='test' multiple='multiple'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon' selected='selected'>Spoon</option>\n<option value='banana' selected='selected'>Banana</option>\n</optgroup>\n</select>")
+        expected = normalize_html("<select name='test[]' multiple='multiple'>\n<optgroup label='numbers'>\n<option value='1'/>\n<option value='One'/>\n</optgroup>\n<optgroup label='words'>\n<option value='spoon' selected='selected'>Spoon</option>\n<option value='banana' selected='selected'>Banana</option>\n</optgroup>\n</select>")
         rendered = normalize_html(input.render('test', ['banana', 'spoon']))
-        assert_equal(excepted, rendered)
+        assert_equal(expected, rendered)
       end
     end
   end
+
+  class Test_RadioSelect_widget < BureaucratTestCase
+    def test_correctly_render_none_selected
+      input = Widgets::RadioSelect.new(nil, [['1', 'One'], ['2', 'Two']])
+      expected = normalize_html("<ul>\n<li><label for='id_radio_0'><input name='radio' id='id_radio_0' type='radio' value='1'/> One</label></li>\n<li><label for='id_radio_1'><input name='radio' id='id_radio_1' type='radio' value='2'/> Two</label></li>\n</ul>")
+      rendered = normalize_html(input.render('radio', '', id: 'id_radio'))
+      assert_equal(expected, rendered)
+    end
+
+    def test_correctly_render_with_selected
+      input = Widgets::RadioSelect.new(nil, [['1', 'One'], ['2', 'Two']])
+      expected = normalize_html("<ul>\n<li><label for='id_radio_0'><input checked='checked' name='radio' id='id_radio_0' type='radio' value='1'/> One</label></li>\n<li><label for='id_radio_1'><input name='radio' id='id_radio_1' type='radio' value='2'/> Two</label></li>\n</ul>")
+      rendered = normalize_html(input.render('radio', '1', id: 'id_radio'))
+      assert_equal(expected, rendered)
+    end
+  end
+
+  module CheckboxSelectMultipleTests
+    class Test_with_empty_choices < BureaucratTestCase
+      def test_render_an_empty_ul
+        input = Widgets::CheckboxSelectMultiple.new
+        expected = normalize_html("<ul>\n</ul>")
+        rendered = normalize_html(input.render('test', ['hello'], id: 'id_checkboxes'))
+        assert_equal(expected, rendered)
+      end
+    end
+
+    class Test_with_choices < BureaucratTestCase
+      def setup
+        @choices = [['1', 'One'], ['2', 'Two'], ['3', 'Three']]
+      end
+
+      def test_correctly_renders_none_selected
+        input = Widgets::CheckboxSelectMultiple.new(nil, @choices)
+        expected = normalize_html("<ul>\n<li><label for='id_checkboxes_0'><input name='test[]' id='id_checkboxes_0' type='checkbox' value='1'/> One</label></li>\n<li><label for='id_checkboxes_1'><input name='test[]' id='id_checkboxes_1' type='checkbox' value='2'/> Two</label></li>\n<li><label for='id_checkboxes_2'><input name='test[]' id='id_checkboxes_2' type='checkbox' value='3'/> Three</label></li>\n</ul>")
+        rendered = normalize_html(input.render('test', ['hello'], id: 'id_checkboxes'))
+        assert_equal(expected, rendered)
+      end
+
+      def test_correctly_renders_with_selected
+        input = Widgets::CheckboxSelectMultiple.new(nil, @choices)
+        expected = normalize_html("<ul>\n<li><label for='id_checkboxes_0'><input checked='checked' name='test[]' id='id_checkboxes_0' type='checkbox' value='1'/> One</label></li>\n<li><label for='id_checkboxes_1'><input checked='checked' name='test[]' id='id_checkboxes_1' type='checkbox' value='2'/> Two</label></li>\n<li><label for='id_checkboxes_2'><input name='test[]' id='id_checkboxes_2' type='checkbox' value='3'/> Three</label></li>\n</ul>")
+        rendered = normalize_html(input.render('test', ['1', '2'],
+                                               id: 'id_checkboxes'))
+        assert_equal(expected, rendered)
+      end
+    end
+  end
+
 end