dry_crud 1.7.0 → 2.0.0

data/lib/generators/dry_crud/templates/test/{unit/helpers/standard_form_builder_test.rb → helpers/crud/form_builder_test.rb}

@@ -1,12 +1,16 @@
+# encoding: UTF-8
 require 'test_helper'
-require 'crud_test_model'
+require 'support/crud_test_model'
 
-class StandardFormBuilderTest < ActionView::TestCase
+# Test Crud::FormBuilder
+class Crud::FormBuilderTest < ActionView::TestCase
 
+  include FormatHelper
+  include I18nHelper
   include CrudTestHelper
 
   # set dummy helper class for ActionView::TestCase
-  self.helper_class = StandardHelper
+  self.helper_class = UtilityHelper
 
   attr_reader :form, :entry
 
@@ -15,206 +19,219 @@ class StandardFormBuilderTest < ActionView::TestCase
 
   def create_form
     @entry = CrudTestModel.first
-    @form = StandardFormBuilder.new(:entry, @entry, self, {}, lambda {|form| form })
+<% if Rails.version < '4.0' -%>
+    @form = Crud::FormBuilder.new(:entry, @entry, self, {},
+                                  ->(form) { form })
+<% else -%>
+    @form = Crud::FormBuilder.new(:entry, @entry, self, {})
+<% end -%>
   end
 
-  test "input_field dispatches string attr to string_field" do
+  test 'input_field dispatches string attr to string_field' do
     assert_equal form.string_field(:name), form.input_field(:name)
     assert form.string_field(:name).html_safe?
   end
 
-  test "input_field dispatches password attr to password_field" do
+  test 'input_field dispatches password attr to password_field' do
     assert_equal form.password_field(:password), form.input_field(:password)
     assert form.password_field(:name).html_safe?
   end
 
-  test "input_field dispatches text attr to text_area" do
+  test 'input_field dispatches email attr to email_field' do
+    assert_equal form.email_field(:email), form.input_field(:email)
+    assert form.email_field(:name).html_safe?
+  end
+
+  test 'input_field dispatches text attr to text_area' do
     assert_equal form.text_area(:remarks), form.input_field(:remarks)
     assert form.text_area(:remarks).html_safe?
   end
 
-  test "input_field dispatches integer attr to integer_field" do
+  test 'input_field dispatches integer attr to integer_field' do
     assert_equal form.integer_field(:children), form.input_field(:children)
     assert form.integer_field(:children).html_safe?
   end
 
-  test "input_field dispatches boolean attr to boolean_field" do
+  test 'input_field dispatches boolean attr to boolean_field' do
     assert_equal form.boolean_field(:human), form.input_field(:human)
     assert form.boolean_field(:human).html_safe?
   end
 
-  test "input_field dispatches date attr to date_field" do
+  test 'input_field dispatches date attr to date_field' do
     assert_equal form.date_field(:birthdate), form.input_field(:birthdate)
     assert form.date_field(:birthdate).html_safe?
   end
 
-  test "input_field dispatches belongs_to attr to select field" do
-    assert_equal form.belongs_to_field(:companion_id), form.input_field(:companion_id)
+  test 'input_field dispatches belongs_to attr to select field' do
+    assert_equal form.belongs_to_field(:companion_id),
+                 form.input_field(:companion_id)
     assert form.belongs_to_field(:companion_id).html_safe?
   end
 
-  test "input_field dispatches has_and_belongs_to_many attr to select field" do
+  test 'input_field dispatches has_and_belongs_to_many attr to select field' do
     assert_equal form.has_many_field(:other_ids), form.input_field(:other_ids)
     assert form.has_many_field(:other_ids).html_safe?
   end
 
-  test "input_field dispatches has_many attr to select field" do
+  test 'input_field dispatches has_many attr to select field' do
     assert_equal form.has_many_field(:more_ids), form.input_field(:more_ids)
     assert form.has_many_field(:more_ids).html_safe?
   end
 
-  test "input_fields concats multiple fields" do
+  test 'input_fields concats multiple fields' do
     result = form.labeled_input_fields(:name, :remarks, :children)
     assert result.html_safe?
-    assert result.include?(form.input_field(:name))
+    assert result.include?(form.input_field(:name, required: 'required'))
     assert result.include?(form.input_field(:remarks))
     assert result.include?(form.input_field(:children))
   end
 
-  test "labeld_input_field adds required mark" do
+  test 'labeld_input_field adds required mark' do
     result = form.labeled_input_field(:name)
-    assert result.include?(StandardFormBuilder::REQUIRED_MARK)
+    assert result.include?(Crud::FormBuilder::REQUIRED_MARK)
     result = form.labeled_input_field(:remarks)
-    assert !result.include?(StandardFormBuilder::REQUIRED_MARK)
+    assert !result.include?(Crud::FormBuilder::REQUIRED_MARK)
   end
 
-  test "labeld_input_field adds help text" do
-    result = form.labeled_input_field(:name, :help => 'Some Help')
+  test 'labeld_input_field adds help text' do
+    result = form.labeled_input_field(:name, help: 'Some Help')
     assert result.include?(form.help_block('Some Help'))
-    assert result.include?(StandardFormBuilder::REQUIRED_MARK)
+    assert result.include?(Crud::FormBuilder::REQUIRED_MARK)
   end
 
-  test "belongs_to_field has all options by default" do
+  test 'belongs_to_field has all options by default' do
     f = form.belongs_to_field(:companion_id)
     assert_equal 7, f.scan('</option>').size
   end
 
-  test "belongs_to_field with :list option" do
+  test 'belongs_to_field with :list option' do
     list = CrudTestModel.all
-    f = form.belongs_to_field(:companion_id, :list => [list.first, list.second])
+    f = form.belongs_to_field(:companion_id,
+                              list: [list.first, list.second])
     assert_equal 3, f.scan('</option>').size
   end
 
-  test "belongs_to_field with instance variable" do
+  test 'belongs_to_field with instance variable' do
     list = CrudTestModel.all
     @companions = [list.first, list.second]
     f = form.belongs_to_field(:companion_id)
     assert_equal 3, f.scan('</option>').size
   end
 
-  test "belongs_to_field with empty list" do
+  test 'belongs_to_field with empty list' do
     @companions = []
     f = form.belongs_to_field(:companion_id)
-    assert_match /none available/m, f
+    assert_match t('global.associations.none_available'), f
     assert_equal 0, f.scan('</option>').size
   end
 
-  test "has_and_belongs_to_many_field has all options by default" do
+  test 'has_and_belongs_to_many_field has all options by default' do
     f = form.has_many_field(:other_ids)
     assert_equal 6, f.scan('</option>').size
   end
 
-  test "has_and_belongs_to_many_field with :list option" do
+  test 'has_and_belongs_to_many_field with :list option' do
     list = OtherCrudTestModel.all
-    f = form.has_many_field(:other_ids, :list => [list.first, list.second])
+    f = form.has_many_field(:other_ids, list: [list.first, list.second])
     assert_equal 2, f.scan('</option>').size
   end
 
-  test "has_and_belongs_to_many_field with instance variable" do
+  test 'has_and_belongs_to_many_field with instance variable' do
     list = OtherCrudTestModel.all
     @others = [list.first, list.second]
     f = form.has_many_field(:other_ids)
     assert_equal 2, f.scan('</option>').size
   end
 
-  test "has_and_belongs_to_many_field with empty list" do
+  test 'has_and_belongs_to_many_field with empty list' do
     @others = []
     f = form.has_many_field(:other_ids)
-    assert_match /none available/m, f
+    assert_match t('global.associations.none_available'), f
     assert_equal 0, f.scan('</option>').size
   end
 
-  test "has_many_field has all options by default" do
+  test 'has_many_field has all options by default' do
     f = form.has_many_field(:more_ids)
     assert_equal 6, f.scan('</option>').size
   end
 
-  test "has_many_field with :list option" do
+  test 'has_many_field with :list option' do
     list = OtherCrudTestModel.all
-    f = form.has_many_field(:more_ids, :list => [list.first, list.second])
+    f = form.has_many_field(:more_ids, list: [list.first, list.second])
     assert_equal 2, f.scan('</option>').size
   end
 
-  test "has_many_field with instance variable" do
+  test 'has_many_field with instance variable' do
     list = OtherCrudTestModel.all
     @mores = [list.first, list.second]
     f = form.has_many_field(:more_ids)
     assert_equal 2, f.scan('</option>').size
   end
 
-  test "has_many_field with empty list" do
+  test 'has_many_field with empty list' do
     @mores = []
     f = form.has_many_field(:more_ids)
-    assert_match /none available/m, f
+    assert_match t('global.associations.none_available'), f
     assert_equal 0, f.scan('</option>').size
   end
 
-  test "string_field sets maxlength attribute if limit" do
+  test 'string_field sets maxlength attribute if limit' do
     assert_match /maxlength="50"/, form.string_field(:name)
   end
 
-  test "label creates captionized label" do
+  test 'label creates captionized label' do
     assert_match /label [^>]*for.+Gugus dada/, form.label(:gugus_dada)
     assert form.label(:gugus_dada).html_safe?
   end
 
-  test "classic label still works" do
-    assert_match /label [^>]*for.+hoho/, form.label(:gugus_dada, "hoho")
-    assert form.label(:gugus_dada, "hoho").html_safe?
+  test 'classic label still works' do
+    assert_match /label [^>]*for.+hoho/, form.label(:gugus_dada, 'hoho')
+    assert form.label(:gugus_dada, 'hoho').html_safe?
   end
 
-  test "labeled_text_field create label" do
+  test 'labeled_text_field create label' do
     assert_match /label [^>]*for.+input/m, form.labeled_string_field(:name)
     assert form.labeled_string_field(:name).html_safe?
   end
 
-  test "labeled field creates label" do
-    result = form.labeled("gugus", "<input type='text' name='gugus' />".html_safe)
+  test 'labeled field creates label' do
+    result = form.labeled('gugus',
+                          "<input type='text' name='gugus' />".html_safe)
     assert result.html_safe?
     assert_match /label [^>]*for.+<input/m, result
   end
 
-  test "labeled field creates label and block" do
-    result = form.labeled("gugus") { "<input type='text' name='gugus' />".html_safe }
+  test 'labeled field creates label and block' do
+    result = form.labeled('gugus') do
+      "<input type='text' name='gugus' />".html_safe
+    end
     assert result.html_safe?
     assert_match /label [^>]*for.+<input/m, result
   end
 
-  test "labeled field creates label with caption" do
-    result = form.labeled("gugus", 'Caption', "<input type='text' name='gugus' />".html_safe)
+  test 'labeled field creates label with caption' do
+    result = form.labeled('gugus',
+                          'Caption',
+                          "<input type='text' name='gugus' />".html_safe)
     assert result.html_safe?
     assert_match /label [^>]*for.+>Caption<\/label>.*<input/m, result
   end
 
-  test "labeled field creates label with caption and block" do
-    result = form.labeled("gugus", 'Caption') { "<input type='text' name='gugus' />".html_safe }
+  test 'labeled field creates label with caption and block' do
+    result = form.labeled('gugus', 'Caption') do
+      "<input type='text' name='gugus' />".html_safe
+    end
     assert result.html_safe?
     assert_match /label [^>]*for.+>Caption<\/label>.*<input/m, result
   end
 
-  test "required mark is shown" do
-    assert_equal StandardFormBuilder::REQUIRED_MARK, form.required_mark(:name)
-    assert_equal "", form.required_mark(:rating)
-    assert_equal "", form.required_mark(:anything)
-  end
-
-  test "method missing still works" do
+  test 'method missing still works' do
     assert_raise(NoMethodError) do
       form.blabla
     end
   end
 
-  test "respond to still works" do
+  test 'respond to still works' do
     assert !form.respond_to?(:blalba)
     assert form.respond_to?(:text_field)
     assert form.respond_to?(:labeled_text_field)

data/lib/generators/dry_crud/templates/test/{unit/helpers/standard_table_builder_test.rb → helpers/crud/table_builder_test.rb}

@@ -1,22 +1,26 @@
+# encoding: UTF-8
 require 'test_helper'
 
-class StandardTableBuilderTest < ActionView::TestCase
+# Test Crud::TableBuilder
+class Crud::TableBuilderTest < ActionView::TestCase
 
   # set dummy helper class for ActionView::TestCase
-  self.helper_class = StandardHelper
+  self.helper_class = UtilityHelper
+
+  include FormatHelper
 
   attr_reader :table, :entries
 
   def setup
     @entries = %w(foo bahr)
-    @table = StandardTableBuilder.new(entries, self)
+    @table = Crud::TableBuilder.new(entries, self)
   end
 
   def format_size(obj)
     "#{obj.size} chars"
   end
 
-  test "html header" do
+  test 'html header' do
     table.attrs :upcase, :size
 
     dom = '<tr><th>Upcase</th><th>Size</th></tr>'
@@ -24,7 +28,7 @@ class StandardTableBuilderTest < ActionView::TestCase
     assert_dom_equal dom, table.send(:html_header)
   end
 
-  test "single attr row" do
+  test 'single attr row' do
     table.attrs :upcase, :size
 
     dom = '<tr><td>FOO</td><td>3 chars</td></tr>'
@@ -32,33 +36,33 @@ class StandardTableBuilderTest < ActionView::TestCase
     assert_dom_equal dom, table.send(:html_row, entries.first)
   end
 
-  test "custom row" do
-    table.col("Header", :class => 'hula') {|e| "Weights #{e.size} kg" }
+  test 'custom row' do
+    table.col('Header', class: 'hula') { |e| "Weights #{e.size} kg" }
 
     dom = '<tr><td class="hula">Weights 3 kg</td></tr>'
 
     assert_dom_equal dom, table.send(:html_row, entries.first)
   end
 
-  test "attr col output" do
+  test 'attr col output' do
     table.attrs :upcase
     col = table.cols.first
 
-    assert_equal "<th>Upcase</th>", col.html_header
-    assert_equal "FOO", col.content("foo")
-    assert_equal "<td>FOO</td>", col.html_cell("foo")
+    assert_equal '<th>Upcase</th>', col.html_header
+    assert_equal 'FOO', col.content('foo')
+    assert_equal '<td>FOO</td>', col.html_cell('foo')
   end
 
-  test "attr col content with custom format_size method" do
+  test 'attr col content with custom format_size method' do
     table.attrs :size
     col = table.cols.first
 
-    assert_equal "4 chars", col.content("abcd")
+    assert_equal '4 chars', col.content('abcd')
   end
 
-  test "two x two table" do
+  test 'two x two table' do
     dom = <<-FIN
-      <table class="table">
+      <table>
       <thead>
       <tr><th>Upcase</th><th>Size</th></tr>
       </thead>
@@ -68,18 +72,18 @@ class StandardTableBuilderTest < ActionView::TestCase
       </tbody>
       </table>
     FIN
-    dom.gsub!(/[\n\t]/, "").gsub!(/\s{2,}/, "")
+    dom.gsub!(/[\n\t]/, '').gsub!(/\s{2,}/, '')
 
     table.attrs :upcase, :size
 
     assert_dom_equal dom, table.to_html
   end
 
-  test "table with before and after cells" do
+  test 'table with before and after cells' do
     dom = <<-FIN
-      <table class="table">
+      <table>
       <thead>
-      <tr><th>head</th><th>Upcase</th><th>Size</th><th></th></tr>
+      <tr><th class='left'>head</th><th>Upcase</th><th>Size</th><th></th></tr>
       </thead>
       <tbody>
       <tr>
@@ -97,30 +101,29 @@ class StandardTableBuilderTest < ActionView::TestCase
       </tbody>
       </table>
     FIN
-    dom.gsub!(/[\n\t]/, "").gsub!(/\s{2,}/, "")
+    dom.gsub!(/[\n\t]/, '').gsub!(/\s{2,}/, '')
 
-    table.col('head', :class => 'left') { |e| link_to e, "/" }
+    table.col('head', class: 'left') { |e| link_to e, '/' }
     table.attrs :upcase, :size
     table.col { |e| "Never #{e}" }
 
-
     assert_dom_equal dom, table.to_html
   end
 
-  test "empty entries collection renders empty table" do
+  test 'empty entries collection renders empty table' do
     dom = <<-FIN
-      <table class="table">
+      <table>
       <thead>
-      <tr><th>head</th><th>Upcase</th><th>Size</th><th></th></tr>
+      <tr><th class='left'>head</th><th>Upcase</th><th>Size</th><th></th></tr>
       </thead>
       <tbody>
       </tbody>
       </table>
     FIN
-    dom.gsub!(/[\n\t]/, "").gsub!(/\s{2,}/, "")
+    dom.gsub!(/[\n\t]/, '').gsub!(/\s{2,}/, '')
 
-   table = StandardTableBuilder.new([], self)
-    table.col('head', :class => 'left') { |e| link_to e, "/" }
+   table = Crud::TableBuilder.new([], self)
+    table.col('head', class: 'left') { |e| link_to e, '/' }
     table.attrs :upcase, :size
     table.col { |e| "Never #{e}" }
 

data/lib/generators/dry_crud/templates/test/helpers/custom_assertions_test.rb

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+require 'test_helper'
+require 'support/custom_assertions'
+require 'support/crud_test_model'
+
+# Test CustomAssertions
+class CustomAssertionsTest < ActiveSupport::TestCase
+
+  include CustomAssertions
+
+  include CrudTestHelper
+
+  setup :reset_db, :setup_db, :create_test_data
+  teardown :reset_db
+
+  test 'assert count succeeds if count matches' do
+    assert_nothing_raised do
+      assert_count 3, 'ba', 'barbabapa'
+    end
+  end
+
+  test 'assert count succeeds if count is zero' do
+    assert_nothing_raised do
+      assert_count 0, 'bo', 'barbabapa'
+    end
+  end
+
+  test 'assert count fails if count does not match' do
+    assert_raise(MiniTest::Assertion) do
+      assert_count 2, 'ba', 'barbabapa'
+    end
+  end
+
+  test 'assert valid record succeeds' do
+    assert_nothing_raised do
+      assert_valid crud_test_models('AAAAA')
+    end
+  end
+
+  test 'assert valid record fails for invalid' do
+    assert_raise(MiniTest::Assertion) do
+      assert_valid invalid_record
+    end
+  end
+
+  test 'assert not valid succeeds if record invalid' do
+    assert_nothing_raised do
+      assert_not_valid invalid_record
+    end
+  end
+
+  test 'assert not valid succeds if record invalid and invalid attrs given' do
+    assert_nothing_raised do
+      assert_not_valid invalid_record, :name, :rating
+    end
+  end
+
+  test 'assert not valid fails if record valid' do
+    assert_raise(MiniTest::Assertion) do
+      assert_not_valid crud_test_models('AAAAA')
+    end
+  end
+
+  test 'assert not valid fails if record invalid and valid attrs given' do
+    assert_raise(MiniTest::Assertion) do
+      assert_not_valid invalid_record, :name, :rating, :children
+    end
+  end
+
+  test 'assert not valid fails if not all invalid attrs given' do
+    assert_raise(MiniTest::Assertion) do
+      assert_not_valid invalid_record, :name
+    end
+  end
+
+  private
+
+  def invalid_record
+    m = crud_test_models('AAAAA')
+    m.name = nil
+    m.rating = 42
+    m
+  end
+
+end