simple_form 3.0.4 → 3.1.0

data/test/inputs/numeric_input_test.rb

@@ -2,140 +2,140 @@
 require 'test_helper'
 
 class NumericInputTest < ActionView::TestCase
-  test 'input should generate an integer text field for integer attributes ' do
+  test 'input generates 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
+  test 'input generates 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
+  test 'input generates 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
+  test 'input does 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
+  test 'input does 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
+  test 'input infers 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]'
+    assert_select 'input[min="18"]'
   end
 
-  test 'input should infer min value from integer attributes with greater than validation using symbol' do
+  test 'input infers 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]'
+    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
+  test 'input infers 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]'
+    assert_select 'input[min="1"]'
 
     with_input_for @validating_user, :attempts, :integer
-    assert_select 'input[min=1]'
+    assert_select 'input[min="1"]'
   end
 
-  test 'input should infer min value from integer attributes with greater than validation using proc' do
+  test 'input infers 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]'
+    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
+  test 'input infers 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]'
+    assert_select 'input[min="19"]'
 
     with_input_for @other_validating_user, :attempts, :integer
-    assert_select 'input[min=19]'
+    assert_select 'input[min="19"]'
   end
 
-  test 'input should infer max value from attributes with less than validation' do
+  test 'input infers 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]'
+    assert_select 'input[max="99"]'
   end
 
-  test 'input should infer max value from attributes with less than validation using symbol' do
+  test 'input infers 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]'
+    assert_select 'input[max="99"]'
   end
 
-  test 'input should infer max value from attributes with less than or equal to validation using symbol' do
+  test 'input infers 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]'
+    assert_select 'input[max="100"]'
 
     with_input_for @validating_user, :attempts, :integer
-    assert_select 'input[max=100]'
+    assert_select 'input[max="100"]'
   end
 
-  test 'input should infer max value from attributes with less than validation using proc' do
+  test 'input infers 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]'
+    assert_select 'input[max="118"]'
   end
 
-  test 'input should infer max value from attributes with less than or equal to validation using proc' do
+  test 'input infers 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]'
+    assert_select 'input[max="119"]'
 
     with_input_for @other_validating_user, :attempts, :integer
-    assert_select 'input[max=119]'
+    assert_select 'input[max="119"]'
   end
 
-  test 'input should have step value of any except for integer attribute' do
+  test 'input has 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]'
+    assert_select 'input[step="1"]'
   end
 
-  test 'numeric input should not generate placeholder by default' do
+  test 'numeric input does 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
+  test 'numeric input accepts the placeholder option' do
     with_input_for @user, :age, :integer, placeholder: 'Put in your age'
-    assert_select 'input.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
+  test 'numeric input uses 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]'
+      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
+  test 'when not using HTML5 input does 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]"
@@ -143,7 +143,7 @@ class NumericInputTest < ActionView::TestCase
     end
   end
 
-  test 'when not using HTML5 input should not use min or max or step attributes' do
+  test 'when not using HTML5 input does 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]"
@@ -154,18 +154,18 @@ class NumericInputTest < ActionView::TestCase
   end
 
   [:integer, :float, :decimal].each do |type|
-    test "#{type} input should infer min value from attributes with greater than or equal validation" do
+    test "#{type} input infers min value from attributes with greater than or equal validation" do
       with_input_for @validating_user, :age, type
-      assert_select 'input[min=18]'
+      assert_select 'input[min="18"]'
     end
 
-    test "#{type} input should infer the max value from attributes with less than or equal to validation" do
+    test "#{type} input infers 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]'
+      assert_select 'input[max="99"]'
     end
   end
 
-  test 'min_max should not emit max value as bare string' do
+  test 'min_max does 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}

data/test/inputs/priority_input_test.rb

@@ -2,46 +2,46 @@
 require 'test_helper'
 
 class PriorityInputTest < ActionView::TestCase
-  test 'input should generate a country select field' do
+  test 'input generates 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]'
+    assert_no_select 'select option[value=""][disabled=disabled]'
   end
 
-  test 'input should generate a country select with SimpleForm default' do
+  test 'input generates 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]'
+      assert_select 'select option[value=""][disabled=disabled]'
     end
   end
 
-  test 'input should generate a time zone select field' do
+  test 'input generates 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]'
+    assert_no_select 'select option[value=""][disabled=disabled]'
   end
 
-  test 'input should generate a time zone select field with default' do
+  test 'input generates 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=]'
+    assert_no_select 'select option[value=""]'
   end
 
-  test 'input should generate a time zone select using options priority' do
+  test 'input generates 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=]', /^$/
+    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
+  test 'priority input does not generate invalid required html attribute' do
     with_input_for @user, :country, :country
     assert_select 'select.required'
     assert_no_select 'select[required]'
   end
 
-  test 'priority input should not generate invalid aria-required html attribute' do
+  test 'priority input does not generate invalid aria-required html attribute' do
     with_input_for @user, :country, :country
     assert_select 'select.required'
     assert_no_select 'select[aria-required]'

data/test/inputs/readonly_test.rb

@@ -1,98 +1,98 @@
 require 'test_helper'
 
 class ReadonlyTest < ActionView::TestCase
-  test 'string input should generate readonly elements when readonly option is true' do
+  test 'string input generates 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
+  test 'text input generates 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
+  test 'numeric input generates 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
+  test 'date input generates 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
+  test 'datetime input generates 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
+  test 'string input generates 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
+  test 'text input generates 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
+  test 'numeric input generates 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
+  test 'date input generates 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
+  test 'datetime input generates 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
+  test 'string input generates 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
+  test 'text input generates 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
+  test 'numeric input generates 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
+  test 'date input generates 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
+  test 'datetime input generates 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
+  test 'input generates 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
+  test 'input does 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
+  test 'input does 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
+  test 'input does 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]'

data/test/inputs/required_test.rb

@@ -2,26 +2,26 @@ 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
+  test 'builder input obtains 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
+  test 'builder input allows 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
+  test 'builder input is 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
+  test 'builder input does 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'
@@ -29,7 +29,7 @@ class RequiredTest < ActionView::TestCase
     end
   end
 
-  test 'when not using browser validations, input should not generate required html attribute' do
+  test 'when not using browser validations, input does not generate required html attribute' do
     swap SimpleForm, browser_validations: false do
       with_input_for @user, :name, :string
       assert_select 'input[type=text].required'
@@ -37,7 +37,7 @@ class RequiredTest < ActionView::TestCase
     end
   end
 
-  test 'builder input should allow disabling required when ActiveModel::Validations is not included' do
+  test 'builder input allows 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]'
@@ -53,14 +53,14 @@ class RequiredTest < ActionView::TestCase
   end
 
   # VALIDATORS :if :unless
-  test 'builder input should not be required when ActiveModel::Validations is included and if option is present' do
+  test 'builder input does 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
+  test 'builder input does 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]'
@@ -68,7 +68,7 @@ class RequiredTest < ActionView::TestCase
   end
 
   # VALIDATORS :on
-  test 'builder input should be required when validation is on create and is not persisted' do
+  test 'builder input is 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'
@@ -76,14 +76,14 @@ class RequiredTest < ActionView::TestCase
     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
+  test 'builder input does 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
+  test 'builder input is required when validation is on save' do
     with_form_for @validating_user, :credit_limit
     assert_select 'input.required'
     assert_select 'input[required]'
@@ -96,14 +96,14 @@ class RequiredTest < ActionView::TestCase
     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
+  test 'builder input is 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
+  test 'builder input does 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'