discourse/spec/lib/freedom_patches/translate_accelerator_spec.rb

321 lines
11 KiB
Ruby

# frozen_string_literal: true
RSpec.describe "translate accelerator" do
before do
@original_i18n_load_path = I18n.load_path.dup
I18n.load_path += Dir["#{Rails.root}/spec/fixtures/i18n/translate_accelerator.*.yml"]
I18n.reload!
end
after do
I18n.load_path = @original_i18n_load_path
I18n.reload!
end
def override_translation(locale, key, value)
expect(I18n.exists?(key, locale)).to eq(true)
override = TranslationOverride.upsert!(locale, key, value)
expect(override.persisted?).to eq(true)
end
it "supports raising if requested, and cache bypasses" do
expect { I18n.t("i_am_an_unknown_key99", raise: true) }.to raise_error(
I18n::MissingTranslationData,
)
orig = I18n.t("i_am_an_unknown_key99")
expect(I18n.t("i_am_an_unknown_key99").object_id).to eq(orig.object_id)
expect(I18n.t("i_am_an_unknown_key99")).to eq("translation missing: en.i_am_an_unknown_key99")
end
it "returns the correct language" do
expect(I18n.t("foo", locale: :en)).to eq("Foo in :en")
expect(I18n.t("foo", locale: :de)).to eq("Foo in :de")
I18n.with_locale(:en) { expect(I18n.t("foo")).to eq("Foo in :en") }
I18n.with_locale(:de) { expect(I18n.t("foo")).to eq("Foo in :de") }
end
it "converts language keys to symbols" do
expect(I18n.t("foo", locale: :en)).to eq("Foo in :en")
expect(I18n.t("foo", locale: "en")).to eq("Foo in :en")
expect(I18n.instance_variable_get(:@loaded_locales)).to contain_exactly(:en)
end
it "overrides for both string and symbol keys" do
key = "user.email.not_allowed"
text_overridden = "foobar"
expect(I18n.t(key)).to be_present
override_translation("en", key, text_overridden)
expect(I18n.t(key)).to eq(text_overridden)
expect(I18n.t(key.to_sym)).to eq(text_overridden)
end
describe ".overrides_by_locale" do
it "should cache overrides for each locale" do
override_translation("en", "got", "summer")
override_translation("zh_TW", "got", "冬季")
I18n.overrides_by_locale("en")
I18n.overrides_by_locale("zh_TW")
expect(I18n.instance_variable_get(:@overrides_by_site)).to eq(
"default" => {
en: {
"got" => "summer",
},
zh_TW: {
"got" => "冬季",
},
},
)
end
end
describe "plugins" do
before do
DiscoursePluginRegistry.register_locale(
"foo",
name: "Foo",
nativeName: "Foo Bar",
plural: {
keys: %i[one few other],
rule:
lambda do |n|
return :one if n == 1
return :few if n < 10
:other
end,
},
)
LocaleSiteSetting.reset!
I18n.reload!
end
after do
DiscoursePluginRegistry.reset!
LocaleSiteSetting.reset!
end
it "loads plural rules from plugins" do
I18n.locale = :foo
expect(I18n.t("i18n.plural.keys")).to eq(%i[one few other])
expect(I18n.t("items", count: 1)).to eq("one item")
expect(I18n.t("items", count: 3)).to eq("some items")
expect(I18n.t("items", count: 20)).to eq("20 items")
end
end
describe "with overrides" do
before { I18n.locale = :en }
it "returns the overridden key" do
override_translation("en", "foo", "Overwritten foo")
expect(I18n.t("foo")).to eq("Overwritten foo")
override_translation("en", "foo", "new value")
expect(I18n.t("foo")).to eq("new value")
end
it "returns the overridden key after switching the locale" do
override_translation("en", "foo", "Overwritten foo in EN")
override_translation("de", "foo", "Overwritten foo in DE")
expect(I18n.t("foo")).to eq("Overwritten foo in EN")
I18n.locale = :de
expect(I18n.t("foo")).to eq("Overwritten foo in DE")
end
it "can be searched" do
override_translation("en", "wat", "Overwritten value")
expect(I18n.search("wat")).to include("wat" => "Overwritten value")
expect(I18n.search("Overwritten")).to include("wat" => "Overwritten value")
override_translation("en", "wat", "Overwritten with (parentheses)")
expect(I18n.search("Overwritten with (")).to include(
"wat" => "Overwritten with (parentheses)",
)
end
it "supports disabling" do
orig_title = I18n.t("title")
override_translation("en", "title", "overridden title")
I18n.overrides_disabled { expect(I18n.t("title")).to eq(orig_title) }
expect(I18n.t("title")).to eq("overridden title")
end
it "supports interpolation" do
override_translation("en", "world", "my %{world}")
expect(I18n.t("world", world: "foo")).to eq("my foo")
end
it "supports interpolation named count" do
override_translation("en", "wat", "goodbye %{count}")
expect(I18n.t("wat", count: 123)).to eq("goodbye 123")
end
it "ignores interpolation named count if it is not applicable" do
override_translation("en", "wat", "bar")
expect(I18n.t("wat", count: 1)).to eq("bar")
end
it "supports one and other" do
override_translation("en", "items.one", "one fish")
override_translation("en", "items.other", "%{count} fishies")
expect(I18n.t("items", count: 13)).to eq("13 fishies")
expect(I18n.t("items", count: 1)).to eq("one fish")
end
it "works with strings and symbols for non-pluralized string when count is given" do
override_translation("en", "fish", "trout")
expect(I18n.t(:fish, count: 1)).to eq("trout")
expect(I18n.t("fish", count: 1)).to eq("trout")
end
it "supports one and other with fallback locale" do
override_translation("en_GB", "items.one", "one fish")
override_translation("en_GB", "items.other", "%{count} fishies")
I18n.with_locale(:en_GB) do
expect(I18n.t("items", count: 13)).to eq("13 fishies")
expect(I18n.t("items", count: 1)).to eq("one fish")
end
end
it "supports one and other when only a single pluralization key is overridden" do
override_translation("en", "keys.magic.other", "no magic keys")
expect(I18n.t("keys.magic", count: 1)).to eq("one magic key")
expect(I18n.t("keys.magic", count: 2)).to eq("no magic keys")
end
it "returns the overridden text when falling back" do
override_translation("en", "got", "summer")
expect(I18n.t("got")).to eq("summer")
expect(I18n.with_locale(:zh_TW) { I18n.t("got") }).to eq("summer")
override_translation("en", "throne", "%{title} is the new queen")
expect(I18n.t("throne", title: "snow")).to eq("snow is the new queen")
expect(I18n.with_locale(:en) { I18n.t("throne", title: "snow") }).to eq(
"snow is the new queen",
)
end
it "returns override if it exists before falling back" do
expect(I18n.t("got", default: "")).to eq("winter")
expect(I18n.with_locale(:ru) { I18n.t("got", default: "") }).to eq("winter")
override_translation("ru", "got", "summer")
expect(I18n.t("got", default: "")).to eq("winter")
expect(I18n.with_locale(:ru) { I18n.t("got", default: "") }).to eq("summer")
end
it "does not affect ActiveModel::Naming#human" do
Fish = Class.new(ActiveRecord::Base)
override_translation("en", "fish", "fake fish")
expect(Fish.model_name.human).to eq("Fish")
end
it "works when the override contains an interpolation key" do
expect(I18n.t("foo_with_variable")).to eq("Foo in :en with %{variable}")
I18n.with_locale(:de) do
expect(I18n.t("foo_with_variable")).to eq("Foo in :de with %{variable}")
end
override_translation("en", "foo_with_variable", "Override in :en with %{variable}")
expect(I18n.t("foo_with_variable")).to eq("Override in :en with %{variable}")
I18n.with_locale(:de) do
expect(I18n.t("foo_with_variable")).to eq("Foo in :de with %{variable}")
end
override_translation("de", "foo_with_variable", "Override in :de with %{variable}")
expect(I18n.t("foo_with_variable")).to eq("Override in :en with %{variable}")
I18n.with_locale(:de) do
expect(I18n.t("foo_with_variable")).to eq("Override in :de with %{variable}")
end
end
end
describe "translation precedence" do
def translation_should_equal(key, expected_value)
I18n.locale = :en
expect(I18n.t(key, locale: :de)).to eq(expected_value)
expect(I18n.search(key, locale: :de)[key]).to eq(expected_value)
I18n.locale = :de
expect(I18n.t(key)).to eq(expected_value)
expect(I18n.search(key)[key]).to eq(expected_value)
end
context "with existing translations in current locale and fallback locale" do
context "with overrides in both locales" do
it "should return the override from the current locale" do
override_translation("de", "foo", "Override of foo in :de")
override_translation("en", "foo", "Override of foo in :en")
translation_should_equal("foo", "Override of foo in :de")
end
end
context "with override only in current locale" do
it "should return the override from the current locale" do
override_translation("de", "foo", "Override of foo in :de")
translation_should_equal("foo", "Override of foo in :de")
end
end
context "with override only in fallback locale" do
it "should return the translation from the current locale" do
override_translation("en", "foo", "Override of foo in :en")
translation_should_equal("foo", "Foo in :de")
end
end
context "with no overrides" do
it "should return the translation from the current locale" do
translation_should_equal("foo", "Foo in :de")
end
end
end
context "with existing translation in fallback locale" do
context "with overrides in both locales" do
it "should return the override from the current locale" do
override_translation("de", "fish", "Override of fish in :de")
override_translation("en", "fish", "Override of fish in :en")
translation_should_equal("fish", "Override of fish in :de")
end
end
context "with override only in current locale" do
it "should return the override from the current locale" do
override_translation("de", "fish", "Override of fish in :de")
translation_should_equal("fish", "Override of fish in :de")
end
end
context "with override only in fallback locale" do
it "should return the translation from the current locale" do
override_translation("en", "fish", "Override of fish in :en")
translation_should_equal("fish", "Override of fish in :en")
end
end
context "with no overrides" do
it "should return the translation from the fallback locale" do
translation_should_equal("fish", "original fish")
end
end
end
end
end