i18n-active_record 0.4.0 → 1.1.0

data/test/active_record_test.rb

@@ -1,136 +1,175 @@
-require_relative './test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class I18nBackendActiveRecordTest < I18n::TestCase
   def setup
+    super
+
+    I18n::Backend::ActiveRecord::Translation.destroy_all
     I18n.backend = I18n::Backend::ActiveRecord.new
-    store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
+
+    store_translations(:en, foo: { bar: 'bar', baz: 'baz' })
   end
 
   def teardown
-    I18n::Backend::ActiveRecord::Translation.destroy_all
     I18n::Backend::ActiveRecord.instance_variable_set :@config, I18n::Backend::ActiveRecord::Configuration.new
+
     super
   end
 
-  test "store_translations does not allow ambiguous keys (1)" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => 'foo')
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
+  class WithoutCacheTest < I18nBackendActiveRecordTest
+    def setup
+      super
 
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
-    assert_equal %w(bar baz), translations.map(&:value)
+      I18n::Backend::ActiveRecord.config.cache_translations = false
+    end
 
-    assert_equal({ :bar => 'bar', :baz => 'baz' }, I18n.t(:foo))
-  end
+    test 'store_translations does not allow ambiguous keys (1)' do
+      store_translations(:en, foo: 'foo')
+      store_translations(:en, foo: { bar: 'bar' })
+      store_translations(:en, foo: { baz: 'baz' })
 
-  test "store_translations does not allow ambiguous keys (2)" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
-    I18n.backend.store_translations(:en, :foo => 'foo')
+      translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
+      assert_equal %w[bar baz], translations.map(&:value)
 
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
-    assert_equal %w(foo), translations.map(&:value)
+      assert_equal({ bar: 'bar', baz: 'baz' }, I18n.t(:foo))
+    end
 
-    assert_equal 'foo', I18n.t(:foo)
-  end
+    test 'store_translations does not allow ambiguous keys (2)' do
+      store_translations(:en, foo: { bar: 'bar' })
+      store_translations(:en, foo: { baz: 'baz' })
+      store_translations(:en, foo: 'foo')
 
-  test "can store translations with keys that are translations containing special chars" do
-    I18n.backend.store_translations(:es, :"Pagina's" => "Pagina's" )
-    assert_equal "Pagina's", I18n.t(:"Pagina's", :locale => :es)
-  end
+      translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').all
+      assert_equal %w[foo], translations.map(&:value)
 
-  test "missing translations table does not cause an error in #available_locales" do
-    I18n::Backend::ActiveRecord::Translation.expects(:available_locales).raises(::ActiveRecord::StatementInvalid, 'msg')
-    assert_equal [], I18n.backend.available_locales
-  end
+      assert_equal 'foo', I18n.t(:foo)
+    end
 
-  test "expand_keys" do
-    assert_equal %w(foo foo.bar foo.bar.baz), I18n.backend.send(:expand_keys, :'foo.bar.baz')
-  end
+    test 'can store translations with keys that are translations containing special chars' do
+      store_translations(:es, "Pagina's": "Pagina's")
 
-  test "available_locales returns uniq locales" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
-    I18n.backend.store_translations(:de, :foo1 => 'foo')
-    I18n.backend.store_translations(:de, :foo2 => 'foo')
-    I18n.backend.store_translations(:uk, :foo3 => 'foo')
-
-    available_locales = I18n::Backend::ActiveRecord::Translation.available_locales
-    assert_equal 3, available_locales.size
-    assert_includes available_locales, :en
-    assert_includes available_locales, :de
-    assert_includes available_locales, :uk
-  end
+      assert_equal "Pagina's", I18n.t(:"Pagina's", locale: :es)
+    end
 
-  test "the default configuration has cleanup_with_destroy == false" do
-    refute I18n::Backend::ActiveRecord.config.cleanup_with_destroy
-  end
+    test 'missing translations table does not cause an error in #available_locales' do
+      I18n::Backend::ActiveRecord::Translation
+        .expects(:available_locales)
+        .raises(::ActiveRecord::StatementInvalid, 'msg')
+      assert_equal [], I18n.backend.available_locales
+    end
 
-  test "the configuration supports cleanup_with_destroy being set" do
-    I18n::Backend::ActiveRecord.configure do |config|
-      config.cleanup_with_destroy = true
+    test 'expand_keys' do
+      assert_equal %w[foo foo.bar foo.bar.baz], I18n.backend.send(:expand_keys, :'foo.bar.baz')
     end
 
-    assert I18n::Backend::ActiveRecord.config.cleanup_with_destroy
-  end
+    test 'available_locales returns uniq locales' do
+      store_translations(:en, foo: { bar: 'bar' })
+      store_translations(:en, foo: { baz: 'baz' })
+      store_translations(:de, foo1: 'foo')
+      store_translations(:de, foo2: 'foo')
+      store_translations(:uk, foo3: 'foo')
+
+      available_locales = I18n::Backend::ActiveRecord::Translation.available_locales
+      assert_equal 3, available_locales.size
+      assert_includes available_locales, :en
+      assert_includes available_locales, :de
+      assert_includes available_locales, :uk
+    end
 
-  test "fetching subtree of translations" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, foo: { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } })
-    assert_equal I18n.t(:foo), { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } }
-  end
+    test 'the default configuration has cleanup_with_destroy == false' do
+      refute I18n::Backend::ActiveRecord.config.cleanup_with_destroy
+    end
 
-  test "build_translation_hash_by_key" do
-    translation = I18n::Backend::ActiveRecord::Translation.new(value: 'translation', key: 'foo.bar.fizz.buzz')
-    expected_hash = { 'bar' => { 'fizz' => { 'buzz' => 'translation' } } }
-    assert_equal I18n.backend.send(:build_translation_hash_by_key, 'foo', translation), expected_hash
-  end
+    test 'the configuration supports cleanup_with_destroy being set' do
+      I18n::Backend::ActiveRecord.configure do |config|
+        config.cleanup_with_destroy = true
+      end
 
-  test "returning all keys via ." do
-    expected_hash = {:foo => { :bar => 'bar', :baz => 'baz' }}
-    assert_equal expected_hash, I18n.t('.')
-  end
+      assert I18n::Backend::ActiveRecord.config.cleanup_with_destroy
+    end
 
-  test "accessing keys with a trailing/leading period" do
-    expected_hash = { :bar => 'bar', :baz => 'baz' }
-    assert_equal expected_hash, I18n.t('foo')
-    assert_equal expected_hash, I18n.t('.foo')
-    assert_equal expected_hash, I18n.t('foo.')
-    assert_equal expected_hash, I18n.t('.foo.')
-    assert_equal expected_hash, I18n.t('.foo.')
-  end
+    test 'fetching subtree of translations' do
+      store_translations(:en, foo: { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } })
 
-  test "returning all keys via . when there are no keys" do
-    I18n.t('.') # Fixes test flakiness by loading available locales
-    I18n::Backend::ActiveRecord::Translation.destroy_all
+      assert_equal I18n.t(:foo), { bar: { fizz: 'buzz', spuz: 'zazz' }, baz: { fizz: 'buzz' } }
+    end
 
-    assert_equal "translation missing: en.no key", I18n.t('.')
-  end
+    test 'build_translation_hash_by_key' do
+      translation = I18n::Backend::ActiveRecord::Translation.new(value: 'translation', key: 'foo.bar.fizz.buzz')
+      expected_hash = { 'bar' => { 'fizz' => { 'buzz' => 'translation' } } }
 
-  test "intially unitinitialized" do
-    refute I18n.backend.initialized?
-    I18n.backend.init_translations
-    assert I18n.backend.initialized?
-    I18n.backend.reload!
-    refute I18n.backend.initialized?
-    I18n.backend.init_translations
-    assert I18n.backend.initialized?
-  end
+      assert_equal I18n.backend.send(:build_translation_hash_by_key, 'foo', translation), expected_hash
+    end
+
+    test 'returning all keys via .' do
+      expected_hash = { foo: { bar: 'bar', baz: 'baz' } }
+
+      assert_equal expected_hash, I18n.t('.')
+    end
+
+    test 'accessing keys with a trailing/leading period' do
+      expected_hash = { bar: 'bar', baz: 'baz' }
+
+      assert_equal expected_hash, I18n.t('foo')
+      assert_equal expected_hash, I18n.t('.foo')
+      assert_equal expected_hash, I18n.t('foo.')
+      assert_equal expected_hash, I18n.t('.foo.')
+      assert_equal expected_hash, I18n.t('.foo.')
+    end
+
+    test 'returning all keys via . when there are no keys' do
+      I18n.t('.') # Fixes test flakiness by loading available locales
+      I18n::Backend::ActiveRecord::Translation.destroy_all
+
+      assert_equal 'translation missing: en.no key', I18n.t('.')
+    end
+
+    test 'intially unitinitialized' do
+      refute I18n.backend.initialized?
+
+      I18n.backend.init_translations
+      assert I18n.backend.initialized?
 
-  test "translations returns all translations" do
-    expected_hash = { :en => { :foo => { :bar => 'bar', :baz => 'baz' } } }
-    I18n.backend.init_translations
-    assert_equal expected_hash, I18n.backend.send(:translations)
-    assert I18n.backend.initialized?
+      I18n.backend.reload!
+      refute I18n.backend.initialized?
+
+      I18n.backend.init_translations
+      assert I18n.backend.initialized?
+    end
+
+    test 'translations returns all translations' do
+      expected_hash = { en: { foo: { bar: 'bar', baz: 'baz' } } }
+      I18n.backend.init_translations
+
+      assert_equal expected_hash, I18n.backend.send(:translations)
+      assert I18n.backend.initialized?
+    end
+
+    test 'translations initialized with do_init argument' do
+      expected_hash = { en: { foo: { bar: 'bar', baz: 'baz' } } }
+
+      refute I18n.backend.initialized?
+      assert_equal expected_hash, I18n.backend.send(:translations, do_init: true)
+      assert I18n.backend.initialized?
+    end
   end
 
-  test "translations initialized with do_init argument" do
-    expected_hash = { :en => { :foo => { :bar => 'bar', :baz => 'baz' } } }
-    refute I18n.backend.initialized?
-    assert_equal expected_hash, I18n.backend.send(:translations, { do_init: true })
-    assert I18n.backend.initialized?
+  class WithCacheTest < WithoutCacheTest
+    def setup
+      super
+
+      I18n::Backend::ActiveRecord.config.cache_translations = true
+    end
+
+    test 'reinitialization when the DB is empty' do
+      I18n::Backend::ActiveRecord::Translation.destroy_all
+
+      I18n.backend.init_translations
+      I18n.backend.expects(:init_translations).never
+
+      I18n.t('foo')
+    end
   end
 end

data/test/api_test.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class I18nActiveRecordApiTest < I18n::TestCase
   def setup
     I18n.backend = I18n::Backend::ActiveRecord.new
+
     super
   end
 
@@ -23,7 +26,7 @@ class I18nActiveRecordApiTest < I18n::TestCase
   include I18n::Tests::Localization::Time
   include I18n::Tests::Localization::Procs if can_store_procs?
 
-  test "make sure we use an ActiveRecord backend" do
+  test 'make sure we use an ActiveRecord backend' do
     assert_equal I18n::Backend::ActiveRecord, I18n.backend.class
   end
 end

data/test/missing_test.rb

@@ -1,70 +1,107 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class I18nActiveRecordMissingTest < I18n::TestCase
-  class Backend < I18n::Backend::ActiveRecord
+  class BackendWithMissing < I18n::Backend::ActiveRecord
     include I18n::Backend::ActiveRecord::Missing
   end
 
   def setup
-    I18n.backend.store_translations(:en, :bar => 'Bar', :i18n => { :plural => { :keys => [:zero, :one, :other] } })
-    I18n.backend = I18n::Backend::Chain.new(Backend.new, I18n.backend)
-    I18n::Backend::ActiveRecord::Translation.delete_all
-  end
+    super
+
+    I18n::Backend::ActiveRecord::Translation.destroy_all
+    I18n.backend = BackendWithMissing.new
 
-  test "can persist interpolations" do
-    translation = I18n::Backend::ActiveRecord::Translation.new(:key => 'foo', :value => 'bar', :locale => :en)
-    translation.interpolations = %w(count name)
-    translation.save
-    assert translation.valid?
+    store_translations(:en, bar: 'Bar', i18n: { plural: { keys: %i[zero one other] } })
   end
 
-  test "lookup persists the key" do
-    I18n.t('foo.bar.baz')
+  def teardown
+    I18n::Backend::ActiveRecord.instance_variable_set :@config, I18n::Backend::ActiveRecord::Configuration.new
 
-    assert_equal 1, I18n::Backend::ActiveRecord::Translation.count
-    assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+    super
   end
 
-  test "lookup does not persist the key twice" do
-    2.times { I18n.t('foo.bar.baz') }
-    assert_equal 1, I18n::Backend::ActiveRecord::Translation.count
-    assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
-  end
+  class WithoutCacheTest < I18nActiveRecordMissingTest
+    def setup
+      super
 
-  test "lookup persists interpolation keys when looked up directly" do
-    I18n.t('foo.bar.baz', :cow => "lucy" )  # creates stub translation.
-    translation_stub = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo.bar.baz').first
-    assert translation_stub.interpolates?(:cow)
-  end
+      I18n::Backend::ActiveRecord.config.cache_translations = false
+    end
 
-  test "creates one stub per pluralization" do
-    I18n.t('foo', :count => 999)
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).where key: %w{ foo.zero foo.one foo.other }
-    assert_equal 3, translations.length
-  end
+    test 'can persist interpolations' do
+      translation = I18n::Backend::ActiveRecord::Translation.new(key: 'foo', value: 'bar', locale: :en)
+      translation.interpolations = %w[count name]
+      translation.save
 
-  test "creates no stub for base key in pluralization" do
-    I18n.t('foo', :count => 999)
-    assert_equal 3, I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo").count
-    assert !I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key("foo")
-  end
+      assert translation.valid?
+    end
 
-  test "creates a stub when a custom separator is used" do
-    I18n.t('foo|baz', :separator => '|')
-    I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo.baz").first.update_attributes(:value => 'baz!')
-    assert_equal 'baz!', I18n.t('foo|baz', :separator => '|')
-  end
+    test 'lookup persists the key' do
+      I18n.t('foo.bar.baz')
+
+      assert_equal 3, I18n::Backend::ActiveRecord::Translation.count
+      assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+    end
+
+    test 'lookup does not persist the key twice' do
+      2.times { I18n.t('foo.bar.baz') }
+
+      assert_equal 3, I18n::Backend::ActiveRecord::Translation.count
+      assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+    end
+
+    test 'lookup persists interpolation keys when looked up directly' do
+      I18n.t('foo.bar.baz', cow: 'lucy')  # creates stub translation.
+      translation_stub = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo.bar.baz').first
 
-  test "creates a stub per pluralization when a custom separator is used" do
-    I18n.t('foo|bar', :count => 999, :separator => '|')
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).where key: %w{ foo.bar.zero foo.bar.one foo.bar.other }
-    assert_equal 3, translations.length
+      assert translation_stub.interpolates?(:cow)
+    end
+
+    test 'creates one stub per pluralization' do
+      I18n.t('foo', count: 999)
+      translations = I18n::Backend::ActiveRecord::Translation.locale(:en).where(key: %w[foo.zero foo.one foo.other])
+
+      assert_equal 3, translations.length
+    end
+
+    test 'creates no stub for base key in pluralization' do
+      I18n.t('foo', count: 999)
+
+      assert_equal 3, I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo').count
+      assert !I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo')
+    end
+
+    test 'creates a stub when a custom separator is used' do
+      I18n.t('foo|baz', separator: '|')
+      I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo.baz').first.update(value: 'baz!')
+
+      assert_equal 'baz!', I18n.t('foo|baz', separator: '|')
+    end
+
+    test 'creates a stub per pluralization when a custom separator is used' do
+      I18n.t('foo|bar', count: 999, separator: '|')
+      translations = I18n::Backend::ActiveRecord::Translation
+        .locale(:en)
+        .where(key: %w[foo.bar.zero foo.bar.one foo.bar.other])
+
+      assert_equal 3, translations.length
+    end
+
+    test 'creates a stub when a custom separator is used and the key contains the flatten separator(a dot character)' do
+      key = 'foo|baz.zab'
+      I18n.t(key, separator: '|')
+      I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo.baz\001zab").first.update(value: 'baz!')
+
+      assert_equal 'baz!', I18n.t(key, separator: '|')
+    end
   end
 
-  test "creates a stub when a custom separator is used and the key contains the flatten separator (a dot character)" do
-    key = 'foo|baz.zab'
-    I18n.t(key, :separator => '|')
-    I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo.baz\001zab").first.update_attributes(:value => 'baz!')
-    assert_equal 'baz!', I18n.t(key, :separator => '|')
+  class WithCacheTest < WithoutCacheTest
+    def setup
+      super
+
+      I18n::Backend::ActiveRecord.config.cache_translations = true
+    end
   end
 end

data/test/test_helper.rb

@@ -1,8 +1,8 @@
-$KCODE = 'u' if RUBY_VERSION <= '1.9'
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'test_declarative'
 
 require 'i18n/active_record'
@@ -15,67 +15,79 @@ rescue LoadError => e
   puts "can't use ActiveRecord backend because: #{e.message}"
 rescue ::ActiveRecord::ConnectionNotEstablished
   require 'i18n/backend/active_record'
+
   case ENV['DB']
   when 'postgres'
-    ::ActiveRecord::Base.establish_connection adapter: 'postgresql', database: 'i18n_unittest', username: ENV['PG_USER'] || 'i18n', password: '', host: 'localhost'
+    ::ActiveRecord::Base.establish_connection(
+      adapter: 'postgresql',
+      database: 'i18n_unittest',
+      username: ENV['PG_USER'] || 'postgres',
+      password: ENV['PG_PASSWORD'] || 'postgres',
+      host: 'localhost'
+    )
   when 'mysql'
-    ::ActiveRecord::Base.establish_connection adapter: 'mysql2', database: 'i18n_unittest', username: 'root', password: '', host: 'localhost'
+    ::ActiveRecord::Base.establish_connection(
+      adapter: 'mysql2',
+      database: 'i18n_unittest',
+      username: ENV['MYSQL_USER'] || 'root',
+      password: ENV['MYSQL_PASSWORD'] || '',
+      host: '127.0.0.1'
+    )
   else
     ::ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
   end
+
   ::ActiveRecord::Migration.verbose = false
-  ::ActiveRecord::Schema.define(:version => 1) do
-    create_table :translations, :force => true do |t|
+  ::ActiveRecord::Schema.define(version: 1) do
+    create_table :translations, force: true do |t|
       t.string :locale
       t.string :key
       t.text :value
       t.text :interpolations
-      t.boolean :is_proc, :default => false
+      t.boolean :is_proc, default: false
     end
-    add_index :translations, [:locale, :key], :unique => true
+    add_index :translations, %i[locale key], unique: true
   end
 end
 
 TEST_CASE = defined?(Minitest::Test) ? Minitest::Test : MiniTest::Unit::TestCase
 
-class TEST_CASE
-  alias :assert_raise :assert_raises
-  alias :assert_not_equal :refute_equal
+class TEST_CASE # rubocop:disable Naming/ClassAndModuleCamelCase
+  alias assert_raise assert_raises
+  alias assert_not_equal refute_equal
 
-  def assert_nothing_raised(*args)
+  def assert_nothing_raised(*_args)
     yield
   end
 end
 
-class I18n::TestCase < TEST_CASE
-  def setup
-    I18n.enforce_available_locales = false
-    I18n.available_locales = []
-    I18n.locale = :en
-    I18n.default_locale = :en
-    I18n.load_path = []
-    super
-  end
-
-  def teardown
-    I18n.enforce_available_locales = false
-    I18n.available_locales = []
-    I18n.locale = :en
-    I18n.default_locale = :en
-    I18n.load_path = []
-    I18n.backend = nil
-    super
-  end
+module I18n
+  class TestCase < TEST_CASE
+    def setup
+      I18n.enforce_available_locales = false
+      I18n.available_locales = []
+      I18n.locale = :en
+      I18n.default_locale = :en
+      I18n.load_path = []
+      super
+    end
 
-  def translations
-    I18n.backend.instance_variable_get(:@translations)
-  end
+    def teardown
+      I18n.enforce_available_locales = false
+      I18n.available_locales = []
+      I18n.locale = :en
+      I18n.default_locale = :en
+      I18n.load_path = []
+      I18n.backend = nil
+      super
+    end
 
-  def store_translations(locale, data)
-    I18n.backend.store_translations(locale, data)
-  end
+    def store_translations(locale, data)
+      I18n.backend.store_translations(locale, data)
+    end
 
-  def locales_dir
-    File.dirname(__FILE__) + '/test_data/locales'
+    def locales_dir
+      "#{File.dirname(__FILE__)}/test_data/locales"
+    end
   end
 end