kotovalexarian-likes-github/rails--rails
1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
Code Releases Activity

Fix inflector test by using dup inflections when it needs to be changed

Browse source 
This is not something that is failing at the moment, but can do it
eventually. I had the issue with db62081 as the HEAD and with the
following change:

```
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -101,6 +101,7 @@ class InflectorTest < ActiveSupport::TestCase
   def test_acronyms
     ActiveSupport::Inflector.inflections do |inflect|
       inflect.acronym("API")
+      inflect.acronym("HTM")
       inflect.acronym("HTML")
       inflect.acronym("HTTP")
       inflect.acronym("RESTful")
```

I was expecting only `test_acronyms` to fail, but with a specific `seed`
others were also failing: `ruby -w -I"lib:test" test/inflector_test.rb
--seed 4313`.

Now, `inflections` instance is duplicated on `setup` and restored on
`teardown`.

I decided to benchmark and check the impact of the patch and it seems
to me to be fine.

```
Calculating -------------------------------------
     without changes     1.000  i/100ms
      with setup dup     1.000  i/100ms
      with block dup     1.000  i/100ms
-------------------------------------------------
     without changes      0.817  (± 0.0%) i/s -      5.000  in
     6.119916s
      with setup dup      0.784  (± 0.0%) i/s -      4.000
      with block dup      0.797  (± 0.0%) i/s -      4.000
```

Where `with setup dup` duplicates on setup for each test and `with block`
duplicates for just for tests that actually modify `inflections`.
This commit is contained in:
Roque Pinel 2015-06-14 23:46:18 -04:00
parent 7e30085bd0
commit c1a694d9d2
1 changed files with 64 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

146
activesupport/test/inflector_test.rb
View file

@ -8,6 +8,20 @@ class InflectorTest < ActiveSupport::TestCase
include InflectorTestCases include InflectorTestCases
include ConstantizeTestCases include ConstantizeTestCases
def setup
# Dups the singleton before each test, restoring the original inflections later.
#
# This helper is implemented by setting @__instance__ because in some tests
# there are module functions that access ActiveSupport::Inflector.inflections,
# so we need to replace the singleton itself.
@original_inflections = ActiveSupport::Inflector::Inflections.instance_variable_get(:@__instance__)[:en]
ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: @original_inflections.dup)
end
def teardown
ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: @original_inflections)
end
def test_pluralize_plurals def test_pluralize_plurals
assert_equal "plurals", ActiveSupport::Inflector.pluralize("plurals") assert_equal "plurals", ActiveSupport::Inflector.pluralize("plurals")
assert_equal "Plurals", ActiveSupport::Inflector.pluralize("Plurals") assert_equal "Plurals", ActiveSupport::Inflector.pluralize("Plurals")
@ -26,20 +40,18 @@ class InflectorTest < ActiveSupport::TestCase
end end
def test_uncountable_word_is_not_greedy def test_uncountable_word_is_not_greedy
with_dup do uncountable_word = "ors"
uncountable_word = "ors" countable_word = "sponsor"
countable_word = "sponsor"
ActiveSupport::Inflector.inflections.uncountable << uncountable_word ActiveSupport::Inflector.inflections.uncountable << uncountable_word
assert_equal uncountable_word, ActiveSupport::Inflector.singularize(uncountable_word) assert_equal uncountable_word, ActiveSupport::Inflector.singularize(uncountable_word)
assert_equal uncountable_word, ActiveSupport::Inflector.pluralize(uncountable_word) assert_equal uncountable_word, ActiveSupport::Inflector.pluralize(uncountable_word)
assert_equal ActiveSupport::Inflector.pluralize(uncountable_word), ActiveSupport::Inflector.singularize(uncountable_word) assert_equal ActiveSupport::Inflector.pluralize(uncountable_word), ActiveSupport::Inflector.singularize(uncountable_word)
assert_equal "sponsor", ActiveSupport::Inflector.singularize(countable_word) assert_equal "sponsor", ActiveSupport::Inflector.singularize(countable_word)
assert_equal "sponsors", ActiveSupport::Inflector.pluralize(countable_word) assert_equal "sponsors", ActiveSupport::Inflector.pluralize(countable_word)
assert_equal "sponsor", ActiveSupport::Inflector.singularize(ActiveSupport::Inflector.pluralize(countable_word)) assert_equal "sponsor", ActiveSupport::Inflector.singularize(ActiveSupport::Inflector.pluralize(countable_word))
end
end end
SingularToPlural.each do |singular, plural| SingularToPlural.each do |singular, plural|
@ -70,11 +82,9 @@ class InflectorTest < ActiveSupport::TestCase
def test_overwrite_previous_inflectors def test_overwrite_previous_inflectors
with_dup do assert_equal("series", ActiveSupport::Inflector.singularize("series"))
assert_equal("series", ActiveSupport::Inflector.singularize("series")) ActiveSupport::Inflector.inflections.singular "series", "serie"
ActiveSupport::Inflector.inflections.singular "series", "serie" assert_equal("serie", ActiveSupport::Inflector.singularize("series"))
assert_equal("serie", ActiveSupport::Inflector.singularize("series"))
end
end end
MixtureToTitleCase.each_with_index do |(before, titleized), index| MixtureToTitleCase.each_with_index do |(before, titleized), index|
@ -367,10 +377,8 @@ class InflectorTest < ActiveSupport::TestCase
%w{plurals singulars uncountables humans}.each do |inflection_type| %w{plurals singulars uncountables humans}.each do |inflection_type|
class_eval <<-RUBY, __FILE__, __LINE__ + 1 class_eval <<-RUBY, __FILE__, __LINE__ + 1
def test_clear_#{inflection_type} def test_clear_#{inflection_type}
with_dup do ActiveSupport::Inflector.inflections.clear :#{inflection_type}
ActiveSupport::Inflector.inflections.clear :#{inflection_type} assert ActiveSupport::Inflector.inflections.#{inflection_type}.empty?, \"#{inflection_type} inflections should be empty after clear :#{inflection_type}\"
assert ActiveSupport::Inflector.inflections.#{inflection_type}.empty?, \"#{inflection_type} inflections should be empty after clear :#{inflection_type}\"
end
end end
RUBY RUBY
end end
@ -405,73 +413,63 @@ class InflectorTest < ActiveSupport::TestCase
end end
def test_clear_all def test_clear_all
with_dup do ActiveSupport::Inflector.inflections do |inflect|
ActiveSupport::Inflector.inflections do |inflect| # ensure any data is present
# ensure any data is present inflect.plural(/(quiz)$/i, '\1zes')
inflect.plural(/(quiz)$/i, '\1zes') inflect.singular(/(database)s$/i, '\1')
inflect.singular(/(database)s$/i, '\1') inflect.uncountable('series')
inflect.uncountable('series') inflect.human("col_rpted_bugs", "Reported bugs")
inflect.human("col_rpted_bugs", "Reported bugs")
inflect.clear :all inflect.clear :all
assert inflect.plurals.empty? assert inflect.plurals.empty?
assert inflect.singulars.empty? assert inflect.singulars.empty?
assert inflect.uncountables.empty? assert inflect.uncountables.empty?
assert inflect.humans.empty? assert inflect.humans.empty?
end
end end
end end
def test_clear_with_default def test_clear_with_default
with_dup do ActiveSupport::Inflector.inflections do |inflect|
ActiveSupport::Inflector.inflections do |inflect| # ensure any data is present
# ensure any data is present inflect.plural(/(quiz)$/i, '\1zes')
inflect.plural(/(quiz)$/i, '\1zes') inflect.singular(/(database)s$/i, '\1')
inflect.singular(/(database)s$/i, '\1') inflect.uncountable('series')
inflect.uncountable('series') inflect.human("col_rpted_bugs", "Reported bugs")
inflect.human("col_rpted_bugs", "Reported bugs")
inflect.clear inflect.clear
assert inflect.plurals.empty? assert inflect.plurals.empty?
assert inflect.singulars.empty? assert inflect.singulars.empty?
assert inflect.uncountables.empty? assert inflect.uncountables.empty?
assert inflect.humans.empty? assert inflect.humans.empty?
end
end end
end end
Irregularities.each do |singular, plural| Irregularities.each do |singular, plural|
define_method("test_irregularity_between_#{singular}_and_#{plural}") do define_method("test_irregularity_between_#{singular}_and_#{plural}") do
with_dup do ActiveSupport::Inflector.inflections do |inflect|
ActiveSupport::Inflector.inflections do |inflect| inflect.irregular(singular, plural)
inflect.irregular(singular, plural) assert_equal singular, ActiveSupport::Inflector.singularize(plural)
assert_equal singular, ActiveSupport::Inflector.singularize(plural) assert_equal plural, ActiveSupport::Inflector.pluralize(singular)
assert_equal plural, ActiveSupport::Inflector.pluralize(singular)
end
end end
end end
end end
Irregularities.each do |singular, plural| Irregularities.each do |singular, plural|
define_method("test_pluralize_of_irregularity_#{plural}_should_be_the_same") do define_method("test_pluralize_of_irregularity_#{plural}_should_be_the_same") do
with_dup do ActiveSupport::Inflector.inflections do |inflect|
ActiveSupport::Inflector.inflections do |inflect| inflect.irregular(singular, plural)
inflect.irregular(singular, plural) assert_equal plural, ActiveSupport::Inflector.pluralize(plural)
assert_equal plural, ActiveSupport::Inflector.pluralize(plural)
end
end end
end end
end end
Irregularities.each do |singular, plural| Irregularities.each do |singular, plural|
define_method("test_singularize_of_irregularity_#{singular}_should_be_the_same") do define_method("test_singularize_of_irregularity_#{singular}_should_be_the_same") do
with_dup do ActiveSupport::Inflector.inflections do |inflect|
ActiveSupport::Inflector.inflections do |inflect| inflect.irregular(singular, plural)
inflect.irregular(singular, plural) assert_equal singular, ActiveSupport::Inflector.singularize(singular)
assert_equal singular, ActiveSupport::Inflector.singularize(singular)
end
end end
end end
end end
@ -503,12 +501,10 @@ class InflectorTest < ActiveSupport::TestCase
%w(plurals singulars uncountables humans acronyms).each do |scope| %w(plurals singulars uncountables humans acronyms).each do |scope|
define_method("test_clear_inflections_with_#{scope}") do define_method("test_clear_inflections_with_#{scope}") do
with_dup do # clear the inflections
# clear the inflections ActiveSupport::Inflector.inflections do |inflect|
ActiveSupport::Inflector.inflections do |inflect| inflect.clear(scope)
inflect.clear(scope) assert_equal [], inflect.send(scope)
assert_equal [], inflect.send(scope)
end
end end
end end
end end
@ -520,18 +516,4 @@ class InflectorTest < ActiveSupport::TestCase
assert_equal "HTTP", ActiveSupport::Inflector.pluralize("HTTP") assert_equal "HTTP", ActiveSupport::Inflector.pluralize("HTTP")
end end
# Dups the singleton and yields, restoring the original inflections later.
# Use this in tests what modify the state of the singleton.
#
# This helper is implemented by setting @__instance__ because in some tests
# there are module functions that access ActiveSupport::Inflector.inflections,
# so we need to replace the singleton itself.
def with_dup
original = ActiveSupport::Inflector::Inflections.instance_variable_get(:@__instance__)[:en]
ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: original.dup)
yield
ensure
ActiveSupport::Inflector::Inflections.instance_variable_set(:@__instance__, en: original)
end
end end