simple_form 2.0.0 → 3.5.1

data/test/inputs/grouped_collection_select_input_test.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
 # 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
+      collection: [['Authors', %w[Jose Carlos]], ['General', %w[Bob John]]],
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -22,8 +23,8 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   test 'grouped collection accepts empty array collection form' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => [],
-      :group_method => :last
+      collection: [],
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids'
   end
@@ -31,8 +32,8 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   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
+      collection: proc { [['Authors', %w[Jose Carlos]], ['General', %w[Bob John]]] },
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -49,8 +50,8 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   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
+      collection: { Authors: %w[Jose Carlos], General: %w[Bob John] },
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -67,9 +68,9 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   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
+      collection: { %w[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
@@ -79,12 +80,63 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
     end
   end
 
+  test 'grouped collection finds default label methods on the group objects' do
+    option_list = %w[Jose Carlos]
+
+    GroupedClass = Struct.new(:to_label, :options)
+    group = GroupedClass.new("Authors", option_list)
+
+    with_input_for @user, :tag_ids, :grouped_select,
+      collection: [group],
+      group_method: :options
+
+    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 collections finds the default label method from the first non-empty object' do
+    Agent = Struct.new(:id, :name)
+    agents = [["First", []], ["Second", [Agent.new(7, 'Bond'), Agent.new(47, 'Hitman')]]]
+
+    with_input_for @user, :tag_ids, :grouped_select,
+      collection: agents,
+      group_label_method: :first,
+      group_method: :last,
+      include_blank: false
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Second]' do
+        assert_select 'option[value="7"]', 'Bond'
+        assert_select 'option[value="47"]', 'Hitman'
+      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
+      collection: { Authors: %w[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 allows overriding label and value methods using a lambda' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      collection: { Authors: %w[Jose Carlos] },
+      group_method: :last,
+      label_method: ->(i) { i.upcase },
+      value_method: ->(i) { i.downcase }
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -97,21 +149,34 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
   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")])
+      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
+      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'
+      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
 
-      assert_select 'optgroup[label=Other group]' do
-        assert_select 'option[value=3]', 'Tag 3'
-        assert_select 'option[value=4]', 'Tag 4'
+  test 'grouped collection accepts html options as the last element of collection' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      collection: [['Authors', [['Jose', 'jose', class: 'foo'], ['Carlos', 'carlos', class: 'bar']]]],
+      group_method: :last
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option.foo', 'Jose'
+        assert_select 'option.bar', 'Carlos'
       end
     end
   end

data/test/inputs/hidden_input_test.rb

@@ -1,29 +1,31 @@
+# frozen_string_literal: true
 # encoding: UTF-8
 require 'test_helper'
 
 class HiddenInputTest < ActionView::TestCase
-  test 'input should generate a hidden field' do
+  test 'input generates 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
+  test 'hint does 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
+  test 'label does 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
+  test 'required/aria-required/optional options does 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[aria-required]'
     assert_no_select 'input.optional'
     assert_select 'input.hidden#user_name'
   end

data/test/inputs/numeric_input_test.rb

@@ -1,141 +1,145 @@
+# frozen_string_literal: true
 # encoding: UTF-8
 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"]'
+
+    with_input_for @validating_user, :age, :integer, as: :decimal, input_html: { step: 0.5 }
+    assert_select 'input[step="0.5"]'
   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
-    with_input_for @user, :age, :integer, :placeholder => 'Put in your age'
-    assert_select 'input.integer[placeholder=Put in your age]'
+  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"]'
   end
 
-  test 'numeric input should use i18n to translate placeholder text' do
-    store_translations(:en, :simple_form => { :placeholders => { :user => {
-      :age => 'Age goes here'
+  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 +147,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]"
@@ -153,15 +157,21 @@ class NumericInputTest < ActionView::TestCase
     end
   end
 
-  [:integer, :float, :decimal].each do |type|
-    test "#{type} input should infer min value from attributes with greater than or equal validation" do
+  %i[integer float decimal].each do |type|
+    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 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}
+  end
 end

data/test/inputs/priority_input_test.rb

@@ -1,43 +1,58 @@
+# frozen_string_literal: true
 # encoding: UTF-8
 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]'
+    if ActionPack::VERSION::STRING >= '5'
+      assert_select 'select option[value=BR]', 'Brazil'
+    elsif ActionPack::VERSION::STRING < '5'
+      assert_select 'select option[value=Brazil]', 'Brazil'
+    end
+    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
+  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]'
+      if ActionPack::VERSION::STRING >= '5'
+        assert_select 'select option[value="---------------"][disabled=disabled]'
+      elsif ActionPack::VERSION::STRING < '5'
+        assert_select 'select option[value=""][disabled=disabled]'
+      end
     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
-    with_input_for @user, :time_zone, :time_zone, :default => 'Brasilia'
+  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
-    with_input_for @user, :time_zone, :time_zone, :priority => /Brasilia/
-    assert_select 'select option[value=][disabled=disabled]'
-    assert_no_select 'select option[value=]', /^$/
+  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=""]', /^$/
   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 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]'
+  end
 end

data/test/inputs/readonly_test.rb

@@ -1,58 +1,99 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class ReadonlyTest < ActionView::TestCase
-  test 'input should generate readonly elements based on the readonly option' do
-    with_input_for @user, :name, :string, :readonly => true
+  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]'
-    with_input_for @user, :description, :text, :readonly => true
+  end
+
+  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]'
-    with_input_for @user, :age, :integer, :readonly => true
+  end
+
+  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]'
-    with_input_for @user, :born_at, :date, :readonly => true
+  end
+
+  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]'
-    with_input_for @user, :created_at, :datetime, :readonly => true
+  end
+
+  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 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 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
 
-    with_input_for @user, :name, :string, :readonly => false
-    assert_select 'input.string:not(.readonly[readonly])'
-    with_input_for @user, :description, :text, :readonly => false
-    assert_select 'textarea.text:not(.readonly[readonly])'
-    with_input_for @user, :age, :integer, :readonly => false
-    assert_select 'input.integer:not(.readonly[readonly])'
-    with_input_for @user, :born_at, :date, :readonly => false
-    assert_select 'select.date:not(.readonly[readonly])'
-    with_input_for @user, :created_at, :datetime, :readonly => false
-    assert_select 'select.datetime:not(.readonly[readonly])'
+  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 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 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 generates readonly elements when readonly option is not present' do
     with_input_for @user, :name, :string
-    assert_select 'input.string:not(.readonly[readonly])'
+    assert_no_select 'input.string.readonly[readonly]'
+  end
+
+  test 'text input generates readonly elements when readonly option is not present' do
     with_input_for @user, :description, :text
-    assert_select 'textarea.text:not(.readonly[readonly])'
+    assert_no_select 'textarea.text.readonly[readonly]'
+  end
+
+  test 'numeric input generates readonly elements when readonly option is not present' do
     with_input_for @user, :age, :integer
-    assert_select 'input.integer:not(.readonly[readonly])'
+    assert_no_select 'input.integer.readonly[readonly]'
+  end
+
+  test 'date input generates readonly elements when readonly option is not present' do
     with_input_for @user, :born_at, :date
-    assert_select 'select.date:not(.readonly[readonly])'
+    assert_no_select 'select.date.readonly[readonly]'
+  end
+
+  test 'datetime input generates readonly elements when readonly option is not present' do
     with_input_for @user, :created_at, :datetime
-    assert_select 'select.datetime:not(.readonly[readonly])'
+    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
+  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
+    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]'