case_form 0.0.3

data/test/element/inputs/datetime/time_zone_input_test.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+require 'test_helper'
+
+class TimeZoneInputTest < ActionView::TestCase
+  def time_zone_case_form_for(object, attribute, options={})
+    concat(case_form_for(object) { |f| f.time_zone(attribute, options) })
+  end
+  
+  test "should generate time zone input" do
+    time_zone_case_form_for(@user, :firstname)
+    assert_select "select", 1
+  end
+  
+  test "should generate time zone without blank" do
+    time_zone_case_form_for(@user, :firstname, :blank => false)
+    assert_select("select") { assert_select "option", :count => 0 , :text => "" }
+  end
+  
+  test "should generate time zone with blank" do
+    time_zone_case_form_for(@user, :firstname, :blank => true)
+    assert_select("select") { assert_select "option", :count => 1 , :text => "" }
+  end
+  
+  # TODO fixit
+  # test "should generate time zone with selected zone" do
+  #   zone = "Warsaw"
+  #   time_zone_case_form_for(@user, :firstname, :time_zone => zone)
+  #   assert_select("select") { assert_select "option[selected=selected]", 1 }
+  # end
+  
+  test "should generate time zone with priority zones" do
+    zones = [::ActiveSupport::TimeZone['Warsaw'], ::ActiveSupport::TimeZone['London']]
+    time_zone_case_form_for(@user, :firstname, :priority_zones => zones)
+    assert_select("select") { assert_select "option[disabled=disabled]", 1 }
+  end
+  
+  test "should generate time zone with html class" do
+    html_class = "Warsaw"
+    time_zone_case_form_for(@user, :firstname, :class => html_class)
+    assert_select("select.#{html_class}")
+  end
+end

data/test/element/inputs/file_input_test.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+require 'test_helper'
+
+class FileInputTest < ActionView::TestCase
+  def file_case_form_for(object, attribute, options={})
+    concat(case_form_for(object) { |f| f.file(attribute, options) })
+  end
+  
+  test "should generate file input" do
+    file_case_form_for(@user, :firstname)
+    assert_select "input[type=file]", 1
+  end
+end

data/test/element/inputs/hidden_input_test.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+require 'test_helper'
+
+class HiddenInputTest < ActionView::TestCase
+  def hidden_case_form_for(object, attribute, options={})
+    concat(case_form_for(object) { |f| f.hidden(attribute, options) })
+  end
+  
+  test "should generate hidden input" do
+    hidden_case_form_for(@user, :firstname)
+    assert_select "input[type=hidden]", 3 # +1 _utf and _method
+  end
+end

data/test/element/inputs/number_input_test.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+require 'test_helper'
+
+class NumberInputTest < ActionView::TestCase
+  def number_case_form_for(object, attribute, options={})
+    concat(case_form_for(object) { |f| f.number(attribute, options) })
+  end
+  
+  test "should generate number input" do
+    number_case_form_for(@valid_user, :height)
+    assert_select "input[type=number]", 1
+  end
+  
+  test "should generate range input" do
+    concat(case_form_for(@valid_user) { |f| f.range(:height) } )
+    assert_select "input[type=range]", 1
+  end
+  
+  test "should generate number input with min and max from column attribute" do
+    number_case_form_for(@valid_user, :height)
+    assert_select "input[type=number][min=-99.999][max=99.999]", 1
+  end
+  
+  test "should generate number input with min and max from validation" do
+    number_case_form_for(@valid_user, :valid_height)
+    assert_select "input[type=number][min=0][max=280]", 1
+  end
+  
+  test "should generate number input with min from validation" do
+    number_case_form_for(@valid_user, :min_height)
+    assert_select "input[type=number][min=0]", 1
+    assert_select "input[type=number][max]", 0
+  end
+  
+  test "should generate number input with max from validation" do
+    number_case_form_for(@valid_user, :max_height)
+    assert_select "input[type=number][min]", 0
+    assert_select "input[type=number][max=280]", 1
+  end
+  
+  test "should generate number input with step from column attribute" do
+    number_case_form_for(@valid_user, :height)
+    assert_select "input[type=number][step=0.001]", 1
+  end
+  
+  test "should generate number input with default step from validation" do
+    number_case_form_for(@valid_user, :valid_height)
+    assert_select "input[type=number][step=1]", 1
+  end
+end

data/test/element/inputs/search_input_test.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+require 'test_helper'
+
+class SearchInputTest < ActionView::TestCase
+  def search_case_form_for(object, attribute, options={})
+    concat(case_form_for(object) { |f| f.search(attribute, options) })
+  end
+  
+  test "should generate search input" do
+    search_case_form_for(@user, :firstname)
+    assert_select "input[type=search]", 1
+  end
+end

data/test/element/inputs/string_input_test.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+require 'test_helper'
+
+class StringInputTest < ActionView::TestCase
+  def string_case_form_for(object, method, attribute, options={})
+    concat(case_form_for(object) { |f| f.send(method, attribute, options) })
+  end
+  
+  test "should generate string input" do
+    string_case_form_for(@user, :string, :firstname)
+    assert_select "input[type=text]", 1
+  end
+  
+  test "should generate email input" do
+    string_case_form_for(@user, :email, :firstname)
+    assert_select "input[type=email]", 1
+  end
+  
+  test "should generate password input" do
+    string_case_form_for(@user, :password, :firstname)
+    assert_select "input[type=password]", 1
+  end
+  
+  test "should generate telephone input" do
+    string_case_form_for(@user, :telephone, :firstname)
+    assert_select "input[type=tel]", 1
+  end
+  
+  test "should generate url input" do
+    string_case_form_for(@user, :url, :firstname)
+    assert_select "input[type=url]", 1
+  end
+end

data/test/element/inputs/text_input_test.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+require 'test_helper'
+
+class SearchInputTest < ActionView::TestCase
+  def text_case_form_for(object, attribute, options={})
+    concat(case_form_for(object) { |f| f.text(attribute, options) })
+  end
+  
+  test "should generate text input" do
+    text_case_form_for(@user, :description)
+    assert_select "textarea", 1
+  end
+end

data/test/element/label_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class LabelTest < ActionView::TestCase
+  def label_case_form_for(object, attribute, options={})
+    concat(case_form_for(object) { |f| f.label(attribute, options) })
+  end
+  
+  test "should generate label" do
+    label_case_form_for(@user, :firstname)
+    assert_select "label[for=user_firstname]"
+  end
+  
+  test "should generate label with text" do
+    label_case_form_for(@user, :firstname, :text => "Enter firstname")
+    assert_select "label[for=user_firstname]", "Enter firstname"
+  end
+  
+  test "should generate label with default HTML class" do
+    label_case_form_for(@user, :firstname)
+    assert_select "label[for=user_firstname].label"
+  end
+  
+  test "should generate label with specific HTML class" do
+    specific_class = "some_class"
+    label_case_form_for(@user, :firstname, :class => specific_class)
+    assert_select "label[for=user_firstname].#{specific_class}"
+  end
+  
+  test "should generate label with default HTML id" do
+    label_case_form_for(@user, :firstname)
+    assert_select "label[for=user_firstname]#user_firstname_label"
+  end
+  
+  test "should generate label with specific HTML id" do
+    specific_id = "some_id"
+    label_case_form_for(@user, :firstname, :id => specific_id)
+    assert_select "label[for=user_firstname]##{specific_id}"
+  end
+  
+  test "should generate label with wrong options" do
+    assert_raise(ArgumentError) { label_case_form_for(@user, :firstname, :foo => :bar) }
+  end
+  
+  test "should generate label with custom data (HTML attribute)" do
+    label_case_form_for(@user, :firstname, :custom => { :foo => :bar })
+    assert_select "label[for=user_firstname][data-foo=bar]", 1
+  end
+  
+  test "should generate label with invalid custom data (HTML attribute)" do
+    assert_raise(ArgumentError) { label_case_form_for(@user, :firstname, :custom => :foo) }
+  end
+  
+  test "should generate label as required" do
+    label_case_form_for(@user, :firstname, :required => true)
+    assert_select "label[for=user_firstname]", "Firstname*"
+  end
+  
+  test "should generate label as not required" do
+    label_case_form_for(@user, :firstname, :required => false)
+    assert_select "label[for=user_firstname]", "Firstname"
+  end
+end

data/test/element/nested_model_test.rb

@@ -0,0 +1,163 @@
+# coding: utf-8
+require 'test_helper'
+
+class NestedModelTest < ActionView::TestCase
+  # non association
+  test "shouldn't generate association input for non association method" do
+    assert_raise(ArgumentError) { concat(case_form_for(@user) { |f| f.belongs_to(:non_association) }) }
+  end
+  
+  # :belongs_to association
+  test "should generate association input for :belongs_to association" do
+    concat(case_form_for(@user) { |f| concat(f.belongs_to(:special_country)) })
+    assert_select "select", 1
+  end
+  
+  test "should generate association input for :belongs_to association with specified input" do
+    concat(case_form_for(@user) { |f| concat(f.belongs_to(:country, :as => :radio)) })
+    assert_select "input[type=radio]", 5
+  end
+  
+  test "should generate nasted inputs for :belongs_to association with block" do
+    concat(case_form_for(@user) { |f| concat(f.belongs_to(:country) { |c| concat(c.attribute(:name)) }) })
+    assert_select "fieldset", 1
+    assert_select("div.country_association_inputs", 1) { assert_select "input[type=text]", 1 }
+  end
+  
+  test "should generate nasted inputs for :belongs_to association without block and defined :accept_* method" do
+    concat(case_form_for(@user) { |f| concat(f.belongs_to(:country)) })
+    assert_select "fieldset", 1
+    assert_select("div.country_association_inputs", 1) { assert_select "input[type=text]", 2 }
+  end
+  
+  test "should generate nasted inputs for :belongs_to association without block and defined :fields option" do
+    concat(case_form_for(@user) { |f| concat(f.belongs_to(:country, :fields => :name)) })
+    assert_select("div.country_association_inputs", 1) { assert_select "input[type=text]", 1 }
+  end
+  
+  test "shouldn't generate nested inputs for :belongs_to association without defined :accept_* method" do
+    assert_raise(NoMethodError) { concat(case_form_for(@user) { |f| f.belongs_to(:special_country) { |c| c.attribute(:name) } }) }
+  end
+  
+  test "should generate nasted inputs for :belongs_to association with empty object and block" do
+    @user.country = nil
+    concat(case_form_for(@user) { |f| concat(f.belongs_to(:country) { |c| concat(c.attribute(:name)) }) })
+    assert_select("div.country_association_inputs", 1) { assert_select "input[type=text]", 1 }
+    @user.country = @country
+  end
+  
+  test "should generate nasted inputs for :belongs_to association with empty object and without block" do
+    @user.country = nil
+    concat(case_form_for(@user) { |f| concat(f.belongs_to(:country)) })
+    assert_select("div.country_association_inputs", 1) { assert_select "input[type=text]", 2 }
+    @user.country = @country
+  end
+  
+  # :has_one association
+  test "should generate nasted inputs for :has_one association" do
+    concat(case_form_for(@user) { |f| concat(f.has_one(:profile)) })
+    assert_select "fieldset", 1
+    assert_select "div.profile_association_inputs", 1 do
+      assert_select "input[type=email]", 1
+      assert_select "input[type=text]", 1
+    end
+  end
+  
+  test "should generate nasted inputs for :has_one association with block" do
+    concat(case_form_for(@user) { |f| concat(f.has_one(:profile) { |p| concat(p.attribute(:email)) }) })
+    assert_select "fieldset", 1
+    assert_select("div.profile_association_inputs", 1) { assert_select "input[type=email]", 1 }
+  end
+  
+  test "should generate nasted inputs for :has_one association without block and with defined :fields option" do
+    concat(case_form_for(@user) { |f| concat(f.has_one(:profile, :fields => :twitter)) })
+    assert_select "div.profile_association_inputs", 1 do
+      assert_select "input[type=email]", 0
+      assert_select "input[type=text]", 1
+    end
+  end
+  
+  test "shouldn't generate nested inputs for :has_one association without defined :accept_* method" do
+    assert_raise(NoMethodError) { concat(case_form_for(@user) { |f| f.has_one(:special_profile) { |c| c.attribute(:email) } }) }
+  end
+  
+  test "shouldn't generate association input for :has_one association" do
+    assert_raise(ArgumentError) { concat(case_form_for(@user) { |f| f.has_one(:profile, :as => :select) }) }
+  end
+  
+  test "should generate nasted inputs for :has_one association with empty object and block" do
+    @user.profile = nil
+    concat(case_form_for(@user) { |f| concat(f.has_one(:profile) { |p| concat(p.attribute(:email)) }) })
+    assert_select("div.profile_association_inputs", 1) { assert_select "input[type=email]", 1 }
+    @user.profile = @profile
+  end
+  
+  test "should generate nasted inputs for :has_one association with empty object and without block" do
+    @user.profile = nil
+    concat(case_form_for(@user) { |f| concat(f.has_one(:profile)) })
+    assert_select("div.profile_association_inputs", 1) { assert_select "input[type=email]", 1 }
+    @user.profile = @profile
+  end
+  
+  # :has_many association
+  test "should generate association input for :has_many association" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:special_projects)) })
+    assert_select "input[type=checkbox]", 5
+  end
+  
+  test "should generate association input for :has_many association with specified input" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects, :as => :radio)) })
+    assert_select "input[type=radio]", 5
+  end
+  
+  test "should generate nasted inputs for :has_many association with block" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects) { |c| concat(c.attribute(:name)) }) })
+    assert_select "fieldset", 1 # 2 Projects in collection 
+    assert_select("div.projects_association_inputs", 2) { assert_select "input[type=text]", 2 }
+  end
+  
+  test "should generate nasted inputs for :has_many association without block and defined :accept_* method" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects)) })
+    assert_select "fieldset", 2 # 2 Projects in collection + 1 new
+    assert_select("div.projects_association_inputs", 3) { assert_select "input[type=text]", 6 }
+  end
+  
+  test "should generate nasted inputs for :has_many association without block and with defined :fields option" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects, :fields => :name)) })
+    assert_select "fieldset", 2 # 2 Projects in collection + 1 new
+    assert_select("div.projects_association_inputs", 3) { assert_select "input[type=text]", 3 }
+  end
+  
+  test "shouldn't generate nested inputs for :has_many association without defined :accept_* method" do
+    assert_raise(NoMethodError) { concat(case_form_for(@user) { |f| f.has_many(:special_projects) { |c| c.attribute(:name) } }) }
+  end
+  
+  test "should generate nasted inputs for :has_many association with specified collection" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects, :collection => Project.extra)) })
+    assert_select("div.projects_association_inputs", 4) { assert_select "input[type=text]", 8 }
+  end
+  
+  test "shouldn't generate nasted inputs for :has_many association with empty object and block" do
+    @user.projects = nil
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects) { |a| concat(a.attribute(:name)) }) })
+    assert_select("div.projects_association_inputs", 0)
+    @user.projects = @projects
+  end
+  
+  test "should generate nasted inputs for :has_many association with empty object and without block" do
+    @user.projects = nil
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects)) })
+    assert_select("div.projects_association_inputs", 1) { assert_select "input[type=text]", 2 }
+    @user.projects = @projects
+  end
+  
+  test "should generate nasted inputs for :has_many association without :generator" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects, :generator => false)) })
+    assert_select "a[data-action=new]", 0
+  end
+  
+  test "should generate nasted inputs for :has_many association without :destructor" do
+    concat(case_form_for(@user) { |f| concat(f.has_many(:projects, :destructor => false)) })
+    assert_select "input[type=checkbox]", 2
+  end
+end

data/test/element/nested_models/handles/destructor_handle_test.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+require 'test_helper'
+
+class DestructorHandleTest < ActionView::TestCase
+  def destructor_case_form_for(object, association, options={})
+    concat(case_form_for(object) { |f| concat(f.association(association) { |d| concat(d.destroy_object(options)) }) })
+  end
+  
+  test "should generate destructor" do
+    destructor_case_form_for(@user, :projects)
+    assert_select "fieldset", 1 # 2x Project object
+    assert_select "input[type=checkbox]", 2
+  end
+  
+  test "should generate destructor as link" do
+    destructor_case_form_for(@user, :projects, :as => :link)
+    assert_select "fieldset", 1 # 2x Project object
+    assert_select "a[data-action=destroy]", 2
+  end
+  
+  test "should generate destructor with text" do
+    text = "Usun"
+    destructor_case_form_for(@user, :projects, :text => text)
+    assert_select "fieldset", 1 # 2x Project object
+    assert_select "input[type=checkbox]", 2
+    assert_select "label", :count => 2, :text => text
+  end
+  
+  test "should generate destructor as link with text" do
+    text = "Usun"
+    destructor_case_form_for(@user, :projects, :as => :link, :text => text)
+    assert_select "fieldset", 1 # 2x Project object
+    assert_select "a[data-action=destroy]", :count => 2, :text => text
+  end
+end