simple_form_awesome 2.2.0

data/test/inputs/grouped_collection_select_input_test.rb

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+require 'test_helper'
+
+class GroupedCollectionSelectInputTest < ActionView::TestCase
+  test 'grouped collection accepts array collection form' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      :collection => [['Authors', ['Jose', 'Carlos']], ['General', ['Bob', 'John']]],
+      :group_method => :last
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option', 'Jose'
+        assert_select 'option', 'Carlos'
+      end
+
+      assert_select 'optgroup[label=General]' do
+        assert_select 'option', 'Bob'
+        assert_select 'option', 'John'
+      end
+    end
+  end
+
+  test 'grouped collection accepts empty array collection form' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      :collection => [],
+      :group_method => :last
+
+    assert_select 'select.grouped_select#user_tag_ids'
+  end
+
+
+  test 'grouped collection accepts proc as collection' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      :collection => Proc.new { [['Authors', ['Jose', 'Carlos']], ['General', ['Bob', 'John']]] },
+      :group_method => :last
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option', 'Jose'
+        assert_select 'option', 'Carlos'
+      end
+
+      assert_select 'optgroup[label=General]' do
+        assert_select 'option', 'Bob'
+        assert_select 'option', 'John'
+      end
+    end
+  end
+
+  test 'grouped collection accepts hash collection form' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      :collection => { 'Authors' => ['Jose', 'Carlos'], 'General' => ['Bob', 'John'] },
+      :group_method => :last
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option', 'Jose'
+        assert_select 'option', 'Carlos'
+      end
+
+      assert_select 'optgroup[label=General]' do
+        assert_select 'option', 'Bob'
+        assert_select 'option', 'John'
+      end
+    end
+  end
+
+  test 'grouped collection accepts group_label_method option' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      :collection => { ['Jose', 'Carlos'] => 'Authors' },
+      :group_method => :first,
+      :group_label_method => :last
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option', 'Jose'
+        assert_select 'option', 'Carlos'
+      end
+    end
+  end
+
+  test 'grouped collection accepts label and value methods options' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      :collection => { 'Authors' => ['Jose', 'Carlos'] },
+      :group_method => :last,
+      :label_method => :upcase,
+      :value_method => :downcase
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option[value=jose]', 'JOSE'
+        assert_select 'option[value=carlos]', 'CARLOS'
+      end
+    end
+  end
+
+  test 'grouped collection with associations' do
+    tag_groups = [
+      TagGroup.new(1, "Group of Tags", [Tag.new(1, "Tag 1"), Tag.new(2, "Tag 2")]),
+      TagGroup.new(2, "Other group", [Tag.new(3, "Tag 3"), Tag.new(4,"Tag 4")])
+    ]
+
+    with_input_for @user, :tag_ids, :grouped_select,
+      :collection => tag_groups, :group_method => :tags
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Group of Tags]' do
+        assert_select 'option[value=1]', 'Tag 1'
+        assert_select 'option[value=2]', 'Tag 2'
+      end
+
+      assert_select 'optgroup[label=Other group]' do
+        assert_select 'option[value=3]', 'Tag 3'
+        assert_select 'option[value=4]', 'Tag 4'
+      end
+    end
+  end
+end

data/test/inputs/hidden_input_test.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+require 'test_helper'
+
+class HiddenInputTest < ActionView::TestCase
+  test 'input should generate a hidden field' do
+    with_input_for @user, :name, :hidden
+    assert_no_select 'input[type=text]'
+    assert_select 'input#user_name[type=hidden]'
+  end
+
+  test 'hint should not be generated for hidden fields' do
+    store_translations(:en, :simple_form => { :hints => { :user => { :name => "text" } } }) do
+      with_input_for @user, :name, :hidden
+      assert_no_select 'span.hint'
+    end
+  end
+
+  test 'label should not be generated for hidden inputs' do
+    with_input_for @user, :name, :hidden
+    assert_no_select 'label'
+  end
+
+  test 'required/optional options should not be generated for hidden inputs' do
+    with_input_for @user, :name, :hidden
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_no_select 'input.optional'
+    assert_select 'input.hidden#user_name'
+  end
+end

data/test/inputs/numeric_input_test.rb

@@ -0,0 +1,173 @@
+# encoding: UTF-8
+require 'test_helper'
+
+class NumericInputTest < ActionView::TestCase
+  test 'input should generate an integer text field for integer attributes ' do
+    with_input_for @user, :age, :integer
+    assert_select 'input[type=number].integer#user_age'
+  end
+
+  test 'input should generate a float text field for float attributes ' do
+    with_input_for @user, :age, :float
+    assert_select 'input[type=number].float#user_age'
+  end
+
+  test 'input should generate a decimal text field for decimal attributes ' do
+    with_input_for @user, :age, :decimal
+    assert_select 'input[type=number].decimal#user_age'
+  end
+
+  test 'input should not generate min attribute by default' do
+    with_input_for @user, :age, :integer
+    assert_no_select 'input[min]'
+  end
+
+  test 'input should not generate max attribute by default' do
+    with_input_for @user, :age, :integer
+    assert_no_select 'input[max]'
+  end
+
+  test 'input should infer min value from integer attributes with greater than validation' do
+    with_input_for @other_validating_user, :age, :float
+    assert_no_select 'input[min]'
+
+    with_input_for @other_validating_user, :age, :integer
+    assert_select 'input[min=18]'
+  end
+
+  test 'input should infer min value from integer attributes with greater than validation using symbol' do
+    with_input_for @validating_user, :amount, :float
+    assert_no_select 'input[min]'
+
+    with_input_for @validating_user, :amount, :integer
+    assert_select 'input[min=11]'
+  end
+
+  test 'input should infer min value from integer attributes with greater than or equal to validation using symbol' do
+    with_input_for @validating_user, :attempts, :float
+    assert_select 'input[min=1]'
+
+    with_input_for @validating_user, :attempts, :integer
+    assert_select 'input[min=1]'
+  end
+
+  test 'input should infer min value from integer attributes with greater than validation using proc' do
+    with_input_for @other_validating_user, :amount, :float
+    assert_no_select 'input[min]'
+
+    with_input_for @other_validating_user, :amount, :integer
+    assert_select 'input[min=20]'
+  end
+
+  test 'input should infer min value from integer attributes with greater than or equal to validation using proc' do
+    with_input_for @other_validating_user, :attempts, :float
+    assert_select 'input[min=19]'
+
+    with_input_for @other_validating_user, :attempts, :integer
+    assert_select 'input[min=19]'
+  end
+
+  test 'input should infer max value from attributes with less than validation' do
+    with_input_for @other_validating_user, :age, :float
+    assert_no_select 'input[max]'
+
+    with_input_for @other_validating_user, :age, :integer
+    assert_select 'input[max=99]'
+  end
+
+  test 'input should infer max value from attributes with less than validation using symbol' do
+    with_input_for @validating_user, :amount, :float
+    assert_no_select 'input[max]'
+
+    with_input_for @validating_user, :amount, :integer
+    assert_select 'input[max=99]'
+  end
+
+  test 'input should infer max value from attributes with less than or equal to validation using symbol' do
+    with_input_for @validating_user, :attempts, :float
+    assert_select 'input[max=100]'
+
+    with_input_for @validating_user, :attempts, :integer
+    assert_select 'input[max=100]'
+  end
+
+  test 'input should infer max value from attributes with less than validation using proc' do
+    with_input_for @other_validating_user, :amount, :float
+    assert_no_select 'input[max]'
+
+    with_input_for @other_validating_user, :amount, :integer
+    assert_select 'input[max=118]'
+  end
+
+  test 'input should infer max value from attributes with less than or equal to validation using proc' do
+    with_input_for @other_validating_user, :attempts, :float
+    assert_select 'input[max=119]'
+
+    with_input_for @other_validating_user, :attempts, :integer
+    assert_select 'input[max=119]'
+  end
+
+  test 'input should have step value of any except for integer attribute' do
+    with_input_for @validating_user, :age, :float
+    assert_select 'input[step="any"]'
+
+    with_input_for @validating_user, :age, :integer
+    assert_select 'input[step=1]'
+  end
+
+  test 'numeric input should not generate placeholder by default' do
+    with_input_for @user, :age, :integer
+    assert_no_select 'input[placeholder]'
+  end
+
+  test 'numeric input should accept the placeholder option' do
+    with_input_for @user, :age, :integer, :placeholder => 'Put in your age'
+    assert_select 'input.integer[placeholder=Put in your age]'
+  end
+
+  test 'numeric input should use i18n to translate placeholder text' do
+    store_translations(:en, :simple_form => { :placeholders => { :user => {
+      :age => 'Age goes here'
+    } } }) do
+      with_input_for @user, :age, :integer
+      assert_select 'input.integer[placeholder=Age goes here]'
+    end
+  end
+
+  # Numeric input but HTML5 disabled
+  test ' when not using HTML5 input should not generate field with type number and use text instead' do
+    swap_wrapper do
+      with_input_for @user, :age, :integer
+      assert_no_select "input[type=number]"
+      assert_no_select "input#user_age[text]"
+    end
+  end
+
+  test 'when not using HTML5 input should not use min or max or step attributes' do
+    swap_wrapper do
+      with_input_for @validating_user, :age, :integer
+      assert_no_select "input[type=number]"
+      assert_no_select "input[min]"
+      assert_no_select "input[max]"
+      assert_no_select "input[step]"
+    end
+  end
+
+  [:integer, :float, :decimal].each do |type|
+    test "#{type} input should infer min value from attributes with greater than or equal validation" do
+      with_input_for @validating_user, :age, type
+      assert_select 'input[min=18]'
+    end
+
+    test "#{type} input should infer the max value from attributes with less than or equal to validation" do
+      with_input_for @validating_user, :age, type
+      assert_select 'input[max=99]'
+    end
+  end
+
+  test 'min_max should not emit max value as bare string' do
+    with_input_for @other_validating_user, :age, :integer
+    assert_select 'input[max]'
+    assert_no_select 'div', %r{^99}
+  end
+end

data/test/inputs/priority_input_test.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+require 'test_helper'
+
+class PriorityInputTest < ActionView::TestCase
+  test 'input should generate a country select field' do
+    with_input_for @user, :country, :country
+    assert_select 'select#user_country'
+    assert_select 'select option[value=Brazil]', 'Brazil'
+    assert_no_select 'select option[value=][disabled=disabled]'
+  end
+
+  test 'input should generate a country select with SimpleForm default' do
+    swap SimpleForm, :country_priority => [ 'Brazil' ] do
+      with_input_for @user, :country, :country
+      assert_select 'select option[value=][disabled=disabled]'
+    end
+  end
+
+  test 'input should generate a time zone select field' do
+    with_input_for @user, :time_zone, :time_zone
+    assert_select 'select#user_time_zone'
+    assert_select 'select option[value=Brasilia]', '(GMT-03:00) Brasilia'
+    assert_no_select 'select option[value=][disabled=disabled]'
+  end
+
+  test 'input should generate a time zone select field with default' do
+    with_input_for @user, :time_zone, :time_zone, :default => 'Brasilia'
+    assert_select 'select option[value=Brasilia][selected=selected]'
+    assert_no_select 'select option[value=]'
+  end
+
+  test 'input should generate a time zone select using options priority' do
+    with_input_for @user, :time_zone, :time_zone, :priority => /Brasilia/
+    assert_select 'select option[value=][disabled=disabled]'
+    assert_no_select 'select option[value=]', /^$/
+  end
+
+  test 'priority input should not generate invalid required html attribute' do
+    with_input_for @user, :country, :country
+    assert_select 'select.required'
+    assert_no_select 'select[required]'
+  end
+end

data/test/inputs/readonly_test.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+class ReadonlyTest < ActionView::TestCase
+  test 'string input should generate readonly elements when readonly option is true' do
+    with_input_for @user, :name, :string, :readonly => true
+    assert_select 'input.string.readonly[readonly]'
+  end
+
+  test 'text input should generate readonly elements when readonly option is true' do
+    with_input_for @user, :description, :text, :readonly => true
+    assert_select 'textarea.text.readonly[readonly]'
+  end
+
+  test 'numeric input should generate readonly elements when readonly option is true' do
+    with_input_for @user, :age, :integer, :readonly => true
+    assert_select 'input.integer.readonly[readonly]'
+  end
+
+  test 'date input should generate readonly elements when readonly option is true' do
+    with_input_for @user, :born_at, :date, :readonly => true
+    assert_select 'select.date.readonly[readonly]'
+  end
+
+  test 'datetime input should generate readonly elements when readonly option is true' do
+    with_input_for @user, :created_at, :datetime, :readonly => true
+    assert_select 'select.datetime.readonly[readonly]'
+  end
+
+  test 'string input should generate readonly elements when readonly option is false' do
+    with_input_for @user, :name, :string, :readonly => false
+    assert_no_select 'input.string.readonly[readonly]'
+  end
+
+  test 'text input should generate readonly elements when readonly option is false' do
+    with_input_for @user, :description, :text, :readonly => false
+    assert_no_select 'textarea.text.readonly[readonly]'
+  end
+
+  test 'numeric input should generate readonly elements when readonly option is false' do
+    with_input_for @user, :age, :integer, :readonly => false
+    assert_no_select 'input.integer.readonly[readonly]'
+  end
+
+  test 'date input should generate readonly elements when readonly option is false' do
+    with_input_for @user, :born_at, :date, :readonly => false
+    assert_no_select 'select.date.readonly[readonly]'
+  end
+
+  test 'datetime input should generate readonly elements when readonly option is false' do
+    with_input_for @user, :created_at, :datetime, :readonly => false
+    assert_no_select 'select.datetime.readonly[readonly]'
+  end
+
+  test 'string input should generate readonly elements when readonly option is not present' do
+    with_input_for @user, :name, :string
+    assert_no_select 'input.string.readonly[readonly]'
+  end
+
+  test 'text input should generate readonly elements when readonly option is not present' do
+    with_input_for @user, :description, :text
+    assert_no_select 'textarea.text.readonly[readonly]'
+  end
+
+  test 'numeric input should generate readonly elements when readonly option is not present' do
+    with_input_for @user, :age, :integer
+    assert_no_select 'input.integer.readonly[readonly]'
+  end
+
+  test 'date input should generate readonly elements when readonly option is not present' do
+    with_input_for @user, :born_at, :date
+    assert_no_select 'select.date.readonly[readonly]'
+  end
+
+  test 'datetime input should generate readonly elements when readonly option is not present' do
+    with_input_for @user, :created_at, :datetime
+    assert_no_select 'select.datetime.readonly[readonly]'
+  end
+
+  test 'input should generate readonly attribute when the field is readonly and the object is persisted' do
+    with_input_for @user, :credit_card, :string, :readonly => :lookup
+    assert_select 'input.string.readonly[readonly]'
+  end
+
+  test 'input should not generate readonly attribute when the field is readonly and the object is not persisted' do
+    @user.new_record!
+    with_input_for @user, :credit_card, :string, :readonly => :lookup
+    assert_no_select 'input.string.readonly[readonly]'
+  end
+
+  test 'input should not generate readonly attribute when the field is not readonly and the object is persisted' do
+    with_input_for @user, :name, :string
+    assert_no_select 'input.string.readonly[readonly]'
+  end
+
+  test 'input should not generate readonly attribute when the component is not used' do
+    swap_wrapper do
+      with_input_for @user, :credit_card, :string
+      assert_no_select 'input.string.readonly[readonly]'
+    end
+  end
+end

data/test/inputs/required_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class RequiredTest < ActionView::TestCase
+  # REQUIRED AND PRESENCE VALIDATION
+  test 'builder input should obtain required from ActiveModel::Validations when it is included' do
+    with_form_for @validating_user, :name
+    assert_select 'input.required[required]#validating_user_name'
+    with_form_for @validating_user, :status
+    assert_select 'input.optional#validating_user_status'
+  end
+
+  test 'builder input should allow overriding required when ActiveModel::Validations is included' do
+    with_form_for @validating_user, :name, :required => false
+    assert_select 'input.optional#validating_user_name'
+    with_form_for @validating_user, :status, :required => true
+    assert_select 'input.required[required]#validating_user_status'
+  end
+
+  test 'builder input should be required by default when ActiveModel::Validations is not included' do
+    with_form_for @user, :name
+    assert_select 'input.required[required]#user_name'
+  end
+
+  test 'builder input should not be required by default when ActiveModel::Validations is not included if option is set to false' do
+    swap SimpleForm, :required_by_default => false do
+      with_form_for @user, :name
+      assert_select 'input.optional#user_name'
+      assert_no_select 'input[required]'
+    end
+  end
+
+  test 'when not using browser validations, input should not generate required html attribute' do
+    swap SimpleForm, :browser_validations => false do
+      with_input_for @user, :name, :string
+      assert_select 'input[type=text].required'
+      assert_no_select 'input[type=text][required]'
+    end
+  end
+
+  test 'builder input should allow disabling required when ActiveModel::Validations is not included' do
+    with_form_for @user, :name, :required => false
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#user_name'
+  end
+
+  test 'when not the required component the input does not have the required attribute but has the required class' do
+    swap_wrapper do
+      with_input_for @user, :name, :string
+      assert_select 'input[type=text].required'
+      assert_no_select 'input[type=text][required]'
+    end
+  end
+
+  # VALIDATORS :if :unless
+  test 'builder input should not be required when ActiveModel::Validations is included and if option is present' do
+    with_form_for @validating_user, :age
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_age'
+  end
+
+  test 'builder input should not be required when ActiveModel::Validations is included and unless option is present' do
+    with_form_for @validating_user, :amount
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_amount'
+  end
+
+  # VALIDATORS :on
+  test 'builder input should be required when validation is on create and is not persisted' do
+    @validating_user.new_record!
+    with_form_for @validating_user, :action
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_action'
+  end
+
+  test 'builder input should not be required when validation is on create and is persisted' do
+    with_form_for @validating_user, :action
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_action'
+  end
+
+  test 'builder input should be required when validation is on save' do
+    with_form_for @validating_user, :credit_limit
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_credit_limit'
+
+    @validating_user.new_record!
+    with_form_for @validating_user, :credit_limit
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_credit_limit'
+  end
+
+  test 'builder input should be required when validation is on update and is persisted' do
+    with_form_for @validating_user, :phone_number
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_phone_number'
+  end
+
+  test 'builder input should not be required when validation is on update and is not persisted' do
+    @validating_user.new_record!
+    with_form_for @validating_user, :phone_number
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_phone_number'
+  end
+end