releaf-i18n_database 2.0.0 → 2.0.1

data/spec/features/translations_spec.rb

@@ -1,426 +0,0 @@
-require 'rails_helper'
-feature "Translations" do
-  background(create_translations: true) do
-    auth_as_user
-
-    translation_1 = Releaf::I18nDatabase::I18nEntry.create(key: 'test.key1')
-    translation_2 = Releaf::I18nDatabase::I18nEntry.create(key: 'great.stuff')
-    translation_3 = Releaf::I18nDatabase::I18nEntry.create(key: 'geek.stuff')
-    translation_1.i18n_entry_translation.create(locale: 'en', text: 'testa atslēga')
-    translation_2.i18n_entry_translation.create(locale: 'en', text: 'awesome stuff')
-    translation_2.i18n_entry_translation.create(locale: 'lv', text: 'lieliska manta')
-    translation_3.i18n_entry_translation.create(locale: 'en', text: 'geek stuff')
-    translation_3.i18n_entry_translation.create(locale: 'lv', text: 'nūģu lieta')
-  end
-
-  scenario "blank only filtering", js: true, create_translations: true  do
-    visit releaf_i18n_database_translations_path
-    expect(page).to have_number_of_resources(3)
-
-    check "Only blank"
-    expect(page).to have_number_of_resources(1)
-
-    click_link "Edit"
-    expect(page).to have_css(".table tbody.list tr", count: 1)
-
-    within ".table tr.item:first-child" do
-      fill_in "translations[][localizations][lv]", with: "lv tulkojums"
-      fill_in "translations[][localizations][en]", with: "en translation"
-    end
-    click_button "Save"
-    expect(page).to have_notification("Update succeeded")
-
-    # TODO: fix when phantomjs will have file download implemented
-    #click_link "Export"
-    #filename = page.response_headers["Content-Disposition"].split("=")[1].gsub("\"","")
-    #tmp_file = Dir.tmpdir + '/' + filename
-    #File.open(tmp_file, "wb") { |f| f.write(page.body) }
-    #fixture_path = File.expand_path('../fixtures/blank_translations_exported.xlsx', __dir__)
-    #expect(tmp_file).to match_excel(fixture_path)
-    #File.delete(tmp_file)
-
-    click_link "Back to list"
-    expect(page).to have_number_of_resources(0)
-
-    uncheck "Only blank"
-    expect(page).to have_number_of_resources(3)
-  end
-
-  scenario "index", create_translations: true do
-    visit releaf_i18n_database_translations_path
-    expect( page ).to have_content 'test.key1'
-    expect( page ).to have_content 'great.stuff'
-    expect( page ).to have_content 'geek.stuff'
-
-    expect( page ).to have_content 'testa atslēga'
-    expect( page ).to have_content 'awesome stuff'
-    expect( page ).to have_content 'lieliska manta'
-    expect( page ).to have_content 'geek stuff'
-    expect( page ).to have_content 'nūģu lieta'
-  end
-
-  scenario "Editing", js: true, create_translations: true do
-    visit releaf_i18n_database_translations_path
-
-    fill_in 'search', with: "stuff"
-    expect(page).to have_number_of_resources(2)
-    click_link "Edit"
-
-    within ".table tr.item:first-child" do
-      expect(find_field("translations[][key]").value).to eq("geek.stuff")
-      fill_in "translations[][key]", with: ""
-      fill_in "translations[][localizations][lv]", with: "lv tulkojums"
-      fill_in "translations[][localizations][en]", with: "en translation"
-    end
-
-    click_button "Save"
-    expect(page).to have_notification("Update failed", :error)
-
-    within ".table tr.item:last-child" do
-      click_button "Remove"
-    end
-    expect(page).to have_css(".table tr.item", count: 1) # wait for fade out to complete
-
-    within ".table tr.item:first-child" do
-      fill_in "translations[][key]", with: "great.stuff"
-    end
-
-    click_button "Save"
-    expect(page).to have_notification("Update succeeded")
-
-    # rename key
-    within ".table tr.item:first-child" do
-      fill_in "translations[][key]", with: "another.great.stuff"
-    end
-    click_button "Save"
-    expect(page).to have_notification("Update succeeded")
-
-    click_link "Back to list"
-    expect(page).to have_number_of_resources(1)
-    expect(page).to have_content 'lv tulkojums'
-    expect(page).to have_content 'en translation'
-  end
-
-  scenario "Do not save empty translations", create_translations: true do
-    visit releaf_i18n_database_translations_path
-    click_link "Edit"
-    click_button "Save"
-
-    expect(Releaf::I18nDatabase::I18nEntryTranslation.where(text: "").count).to eq(0)
-  end
-
-  scenario "Import excel file with translations", js: true, create_translations: true do
-    visit releaf_i18n_database_translations_path
-    expect(page).to have_no_css(".table td span", text: "Eksports")
-    expect(page).to have_no_css(".table td span", text: "Export")
-    expect(page).to have_no_css(".table td span", text: "jauns")
-
-    script = "$('form.import').css({display: 'block'});"
-    page.execute_script(script)
-
-    fixture_path = File.expand_path('../fixtures/translations_import.xlsx', __dir__)
-
-    within('form.import') do
-      attach_file(:import_file, fixture_path)
-    end
-
-    expect(page).to have_css(".breadcrumbs li:last-child", text: "Import")
-    find(:css, 'input[name="translations[][localizations][lv]"][value="Eksports"]')
-    find(:css, 'input[name="translations[][localizations][en]"][value="Export"]')
-
-    click_button "Import"
-    expect(page).to have_notification("successfuly imported 4 translations")
-
-    visit releaf_i18n_database_translations_path
-    expect(page).to have_css(".table td span", text: "Eksports")
-    expect(page).to have_css(".table td span", text: "Export")
-    expect(page).to have_css(".table td span", text: "jauns")
-  end
-
-  scenario "Import unsupported file", js: true, create_translations: true do
-    visit releaf_i18n_database_translations_path
-
-    script = "$('form.import').css({display: 'block'});"
-    page.execute_script(script)
-
-    fixture_path = File.expand_path('../fixtures/unsupported_import_file.png', __dir__)
-
-    within('form.import') do
-      attach_file(:import_file, fixture_path)
-    end
-
-    expect(page).to have_notification("Unsupported file format", "error")
-  end
-
-  scenario "Import corrupt xls file", js: true, create_translations: true do
-    visit releaf_i18n_database_translations_path
-
-    script = "$('form.import').css({display: 'block'});"
-    page.execute_script(script)
-
-    fixture_path = File.expand_path('../fixtures/invalid.xls', __dir__)
-
-    within('form.import') do
-      attach_file(:import_file, fixture_path)
-    end
-
-    expect(page).to have_notification("Unsupported file format", "error")
-  end
-
-
-  scenario "Import corrupt xlsx file", js: true, create_translations: true do
-    visit releaf_i18n_database_translations_path
-
-    script = "$('form.import').css({display: 'block'});"
-    page.execute_script(script)
-
-    fixture_path = File.expand_path('../fixtures/invalid.xlsx', __dir__)
-
-    within('form.import') do
-      attach_file(:import_file, fixture_path)
-    end
-
-    expect(page).to have_notification("Unsupported file format", "error")
-  end
-
-
-  scenario "Export translations", create_translations: true do
-    visit releaf_i18n_database_translations_path
-    click_link "Export"
-
-    expect(page.response_headers["Content-Type"]).to eq('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet; charset=utf-8')
-
-    filename = page.response_headers["Content-Disposition"].split("=")[1].gsub("\"","")
-    tmp_file = Dir.tmpdir + '/' + filename
-    File.open(tmp_file, "wb") { |f| f.write(page.body) }
-
-    fixture_path = File.expand_path('../fixtures/all_translations_exported.xlsx', __dir__)
-    expect(tmp_file).to match_excel(fixture_path)
-
-    File.delete(tmp_file)
-  end
-
-  describe "Lookup" do
-    background do
-      Releaf::I18nDatabase::Backend.reset_cache
-      allow( Releaf.application.config.i18n_database ).to receive(:translation_auto_creation).and_return(true)
-    end
-
-    context "when translation exists within higher level key (instead of being scope)" do
-      it "returns nil (Humanize key)" do
-        translation = Releaf::I18nDatabase::I18nEntry.create(key: "some.food")
-        translation.i18n_entry_translation.create(locale: "lv", text: "suņi")
-
-        expect(I18n.t("some.food", locale: "lv")).to eq("suņi")
-        expect(I18n.t("some.food.asd", locale: "lv")).to eq("Asd")
-      end
-    end
-
-    context "when pluralized translation requested" do
-      context "when valid pluralized data matched" do
-        it "returns pluralized translation" do
-          translation = Releaf::I18nDatabase::I18nEntry.create(key: "dog.other")
-          translation.i18n_entry_translation.create(locale: "lv", text: "suņi")
-
-          expect(I18n.t("dog", locale: "lv", count: 2)).to eq("suņi")
-        end
-      end
-
-      context "when invalid pluralized data matched" do
-        it "returns nil (Humanize key)" do
-          translation = Releaf::I18nDatabase::I18nEntry.create(key: "dog.food")
-          translation.i18n_entry_translation.create(locale: "lv", text: "suņi")
-
-          expect(I18n.t("dog", locale: "lv", count: 2)).to eq("Dog")
-        end
-      end
-    end
-
-    context "when same translations with different cases exists" do
-      it "returns case sensitive translation" do
-        translation = Releaf::I18nDatabase::I18nEntry.create(key: "Save")
-        translation.i18n_entry_translation.create(locale: "lv", text: "Saglabāt")
-
-        expect(I18n.t("save", locale: "lv")).to eq("Save")
-        expect(I18n.t("Save", locale: "lv")).to eq("Saglabāt")
-      end
-    end
-
-    context "existing translation" do
-      context "when translations hash exists in parent scope" do
-        before do
-          translation = Releaf::I18nDatabase::I18nEntry.create(key: "dog.other")
-          translation.i18n_entry_translation.create(locale: "en", text: "dogs")
-        end
-
-        context "when pluralized translation requested" do
-          it "returns pluralized translation" do
-            expect(I18n.t("admin.controller.dog", count: 2)).to eq("dogs")
-          end
-        end
-
-        context "when non pluralized translation requested" do
-          it "returns nil" do
-            expect(I18n.t("admin.controller.dog")).to eq("Dog")
-          end
-        end
-      end
-
-      context "when ignorable pattern" do
-        it "does not auto create missing translation" do
-          expect{ I18n.t("attributes.title") }.to_not change{ Releaf::I18nDatabase::I18nEntry.count }
-        end
-      end
-
-      context "in parent scope" do
-        context "nonexistent translation in given scope" do
-          it "uses parent scope" do
-            translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
-            translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
-            expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv")).to eq("Tukšs")
-          end
-
-          context "when `inherit_scopes` option is `false`" do
-            it "does not lookup upon higher level scopes" do
-              translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
-              translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
-              expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv", inherit_scopes: false)).to eq("Blank")
-            end
-          end
-        end
-
-        context "and empty translation value in given scope" do
-          it "uses parent scope" do
-            translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.roles.blank")
-            translation.i18n_entry_translation.create(locale: "lv", text: "")
-
-            parent_translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
-            parent_translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
-
-            expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv")).to eq("Tukšs")
-          end
-        end
-
-        context "and existing translation value in given scope" do
-          it "uses given scope" do
-            translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.roles.blank")
-            translation.i18n_entry_translation.create(locale: "lv", text: "Tukša vērtība")
-
-            parent_translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
-            parent_translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
-
-            expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv")).to eq("Tukša vērtība")
-          end
-        end
-      end
-
-      context "when scope defined" do
-        it "uses given scope" do
-          translation = Releaf::I18nDatabase::I18nEntry.create(key: "admin.content.cancel")
-          translation.i18n_entry_translation.create(locale: "lv", text: "Atlikt")
-          expect(I18n.t("cancel", scope: "admin.content", locale: "lv")).to eq("Atlikt")
-        end
-      end
-    end
-
-    context "nonexistent translation" do
-      context "loading multiple times" do
-        it "queries db only for the first time" do
-          I18n.t("save", scope: "admin.xx")
-          expect(Releaf::I18nDatabase::I18nEntry).not_to receive(:where)
-          I18n.t("save", scope: "admin.xx")
-        end
-      end
-
-      context "with nonexistent translation" do
-        before do
-          allow(Releaf.application.config).to receive(:all_locales).and_return(["ru", "lv"])
-          allow(I18n).to receive(:locale_available?).and_return(true)
-        end
-
-        it "creates empty translation" do
-          expect { I18n.t("save") }.to change { Releaf::I18nDatabase::I18nEntry.where(key: "save").count }.by(1)
-        end
-
-        context "when count option passed" do
-          context "when create_plurals option not passed" do
-            it "creates empty translation" do
-              expect { I18n.t("animals.horse", count: 1) }.to change { Releaf::I18nDatabase::I18nEntry.where(key: "animals.horse").count }.by(1)
-            end
-          end
-
-          context "when negative create_plurals option passed" do
-            it "creates empty translation" do
-              expect { I18n.t("animals.horse", create_plurals: false, count: 1) }.to change { Releaf::I18nDatabase::I18nEntry.where(key: "animals.horse").count }.by(1)
-            end
-          end
-
-          context "when positive create_plurals option passed" do
-            it "creates pluralized translations for all Releaf locales" do
-              result = ["animals.horse.one", "animals.horse.other", "animals.horse.zero"]
-              expect{ I18n.t("animals.horse", count: 1, create_plurals: true) }.to change{ Releaf::I18nDatabase::I18nEntry.pluck(:key).sort }.
-                from([]).to(result.sort)
-            end
-          end
-        end
-      end
-    end
-
-    context "when scope requested" do
-      it "returns all scope translations" do
-        translation_1 = Releaf::I18nDatabase::I18nEntry.create(key: "admin.content.cancel")
-        translation_1.i18n_entry_translation.create(locale: "lv", text: "Atlikt")
-
-        translation_2 = Releaf::I18nDatabase::I18nEntry.create(key: "admin.content.save")
-        translation_2.i18n_entry_translation.create(locale: "lv", text: "Saglabāt")
-
-        expect(I18n.t("admin.content", locale: "lv")).to eq(cancel: "Atlikt", save: "Saglabāt")
-        expect(I18n.t("admin.content", locale: "en")).to eq(cancel: nil, save: nil)
-      end
-    end
-  end
-
-
-  describe "pluralization" do
-
-    before do
-      locales = [:lv, :ru]
-      allow(I18n.config).to receive(:available_locales).and_return(locales)
-      allow(Releaf.application.config).to receive(:available_locales).and_return(locales)
-      allow(Releaf.application.config).to receive(:all_locales).and_return(locales)
-
-      I18n.reload!
-
-      [:few, :many, :one, :other, :zero].each do |rule|
-        translation = Releaf::I18nDatabase::I18nEntry.create!(key: "public.years.#{rule}")
-        locales.each do |locale|
-          translation.i18n_entry_translation.create!( locale: locale.to_s, text: "years #{locale} #{rule} XX" )
-        end
-      end
-
-      Releaf::I18nDatabase::Backend.reset_cache
-    end
-
-    after do
-      # force I18n reloading to restore the original state.
-      # for this to work, the stubs must be removed beforehand
-      allow(I18n.config).to receive(:available_locales).and_call_original
-      allow(Releaf.application.config).to receive(:available_locales).and_call_original
-      allow(Releaf.application.config).to receive(:all_locales).and_call_original
-      I18n.reload!
-    end
-
-    it "uses rails-i18n pluralization mechanism to detect correct pluralization keys" do
-      expect(I18n.t("years", scope: "public", count: 0, locale: :lv)).to eq 'years lv zero XX'
-      expect(I18n.t("years", scope: "public", count: 1, locale: :lv)).to eq 'years lv one XX'
-      expect(I18n.t("years", scope: "public", count: 3, locale: :lv)).to eq 'years lv other XX'
-
-      expect(I18n.t("years", scope: "public", count: 1, locale: :ru)).to eq 'years ru one XX'
-      expect(I18n.t("years", scope: "public", count: 3, locale: :ru)).to eq 'years ru few XX'
-      expect(I18n.t("years", scope: "public", count: 5, locale: :ru)).to eq 'years ru many XX'
-    end
-
-  end
-
-
-end

data/spec/fixtures/invalid.xls

@@ -1,3 +0,0 @@
-NOT REALLY
-A SPREADSHEET
-FILE

data/spec/fixtures/invalid.xlsx

@@ -1,3 +0,0 @@
-NOT REALLY
-A SPREADSHEET
-FILE

data/spec/lib/releaf/i18n_database/backend_spec.rb

@@ -1,200 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::Backend do
-  let(:translations_store){ Releaf::I18nDatabase::TranslationsStore.new }
-
-  describe ".configure_component" do
-    it "adds new `Releaf::I18nDatabase::Configuration` configuration with default config" do
-      stub_const("Releaf::I18nDatabase::Backend::DEFAULT_CONFIG", a: :b)
-      allow(Releaf::I18nDatabase::Configuration).to receive(:new)
-        .with(a: :b).and_return("_new")
-      expect(Releaf.application.config).to receive(:add_configuration).with("_new")
-      described_class.configure_component
-    end
-  end
-
-  describe ".reset_cache" do
-    it "reset translations cache to backend instance" do
-      subject.translations_cache = :x
-      allow(described_class).to receive(:backend_instance).and_return(subject)
-      expect{ described_class.reset_cache }.to change{ subject.translations_cache }.to(nil)
-    end
-  end
-
-  describe ".backend_instance" do
-    context "when I18n backend has chained backends" do
-      it "returns Releaf::I18nDatabase::Backend instance" do
-        backends = I18n::Backend::Chain.new(subject, I18n::Backend::Simple.new)
-        allow(I18n).to receive(:backend).and_return(backends)
-        expect(described_class.backend_instance).to eq(subject)
-      end
-
-      it "returns nil when chain hasn't Releaf::I18nDatabase::Backend instance" do
-        backends = I18n::Backend::Chain.new(I18n::Backend::Simple.new)
-        allow(I18n).to receive(:backend).and_return(backends)
-        expect(described_class.backend_instance).to be nil
-      end
-    end
-
-    context "when I18n backend has single backend and it is instance of Releaf::I18nDatabase::Backend" do
-      it "returns Releaf::I18nDatabase::Backend instance" do
-        allow(I18n).to receive(:backend).and_return(subject)
-        expect(described_class.backend_instance).to eq(subject)
-      end
-    end
-
-    context "when I18n backend has single backend and it is not instance of Releaf::I18nDatabase::Backend" do
-      it "returns nil" do
-        allow(I18n).to receive(:backend).and_return(I18n::Backend::Simple.new)
-        expect(described_class.backend_instance).to be nil
-      end
-    end
-  end
-
-  describe ".initialize_component" do
-    it "adds itself as i18n backend as primary backend while keeping Rails default simple backend as secondary" do
-      allow(I18n).to receive(:backend).and_return(:current_backend)
-      allow(I18n::Backend::Chain).to receive(:new).with(:new_backend, :current_backend).and_return(:x)
-      allow(described_class).to receive(:new).and_return(:new_backend)
-      expect(I18n).to receive(:backend=).with(:x)
-      described_class.initialize_component
-    end
-  end
-
-  describe ".locales_pluralizations" do
-    it "returns array all pluralization forms for releaf locales" do
-      allow(Releaf.application.config).to receive(:all_locales).and_return([:de, :ru])
-      allow(I18n).to receive(:t).with(:'i18n.plural.keys', locale: :de).and_return([:one, :other])
-      allow(I18n).to receive(:t).with(:'i18n.plural.keys', locale: :ru).and_return([:one, :few, :many])
-
-      expect(described_class.locales_pluralizations).to eq([:one, :other, :few, :many, :zero])
-    end
-  end
-
-  describe "#translations" do
-    let(:another_translations_store){ Releaf::I18nDatabase::TranslationsStore.new }
-
-    context "when translations has been loaded and is not expired" do
-      it "returns assigned translations hash instance" do
-        subject.translations_cache = translations_store
-        allow(translations_store).to receive(:expired?).and_return(false)
-        expect(Releaf::I18nDatabase::TranslationsStore).to_not receive(:new)
-        expect(subject.translations).to eq(translations_store)
-      end
-    end
-
-    context "when translations has been loaded and is expired" do
-      it "initializes new `TranslationsStore`, cache and return it" do
-        subject.translations_cache = translations_store
-        allow(translations_store).to receive(:expired?).and_return(true)
-        expect(Releaf::I18nDatabase::TranslationsStore).to receive(:new).and_return(another_translations_store)
-        expect(subject.translations).to eq(another_translations_store)
-      end
-    end
-
-    context "when translations has not been loaded" do
-      it "initializes new `TranslationsStore`, cache and return it" do
-        subject.translations_cache = nil
-        expect(Releaf::I18nDatabase::TranslationsStore).to receive(:new).and_return(another_translations_store)
-        expect(subject.translations).to eq(another_translations_store)
-      end
-    end
-  end
-
-  describe "#store_translations" do
-    it "pass given translations to simple translation backend" do
-      simple_backend = I18n.backend.backends.last
-      expect(simple_backend).to receive(:store_translations).with(:lv, {a: "x"}, {c: "d"})
-      subject.store_translations(:lv, {a: "x"}, {c: "d"})
-    end
-  end
-
-  describe ".translations_updated_at" do
-    it "returns translations updated_at from cached settings" do
-      allow(Releaf::Settings).to receive(:[]).with(described_class::UPDATED_AT_KEY).and_return("x")
-      expect(described_class.translations_updated_at).to eq("x")
-    end
-  end
-
-  describe ".translations_updated_at=" do
-    it "stores translations updated_at to cached settings" do
-      expect(Releaf::Settings).to receive(:[]=).with(described_class::UPDATED_AT_KEY, "xx")
-      described_class.translations_updated_at = "xx"
-    end
-  end
-
-  describe "#lookup" do
-    before do
-      allow(subject).to receive(:translations).and_return(translations_store)
-      allow(subject).to receive(:normalize_flat_keys).with(:lv, "some.localization", "_scope_", ":")
-        .and_return("xx.s.loc")
-    end
-
-    it "flattens key before passing further" do
-      expect(translations_store).to receive(:missing?).with(:lv, "xx.s.loc")
-      expect(translations_store).to receive(:lookup).with(:lv, "xx.s.loc", separator: ":", a: "b")
-      expect(translations_store).to receive(:missing).with(:lv, "xx.s.loc", separator: ":", a: "b")
-
-      subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")
-    end
-
-    context "when translation is known as missing" do
-      it "does not make lookup in translation hash, does not mark it as missing and return nil" do
-        allow(translations_store).to receive(:missing?).with(:lv, "xx.s.loc").and_return(true)
-        expect(translations_store).to_not receive(:lookup)
-        expect(translations_store).to_not receive(:missing)
-        expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
-      end
-    end
-
-    context "when translation is not known as missing" do
-      before do
-        allow(translations_store).to receive(:missing?).with(:lv, "xx.s.loc").and_return(false)
-      end
-
-      context "when lookup result is not nil" do
-        before do
-          allow(translations_store).to receive(:lookup).with(:lv, "xx.s.loc", separator: ":", a: "b").and_return("x")
-        end
-
-        it "returns lookup result" do
-          expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to eq("x")
-        end
-
-        it "does not mark translation as missing" do
-          expect(translations_store).to_not receive(:missing).with(:lv, "xx.s.loc", separator: ":", a: "b")
-          subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")
-        end
-      end
-
-      context "when lookup result is nil" do
-        before do
-          allow(translations_store).to receive(:lookup).with(:lv, "xx.s.loc", separator: ":", a: "b").and_return(nil)
-        end
-
-        it "returns nil" do
-          expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
-        end
-
-        it "marks translation as missing" do
-          expect(translations_store).to receive(:missing).with(:lv, "xx.s.loc", separator: ":", a: "b")
-          subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")
-        end
-      end
-    end
-
-    context "when database doesn't exists" do
-      it "returns an empty array" do
-        allow(Releaf::I18nDatabase::I18nEntry).to receive(:pluck).and_raise(ActiveRecord::NoDatabaseError.new("xxx"))
-        expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
-      end
-    end
-
-    context "when node table doesn't exist" do
-      it "returns an empty array" do
-        allow(Releaf::I18nDatabase::I18nEntry).to receive(:pluck).and_raise(ActiveRecord::StatementInvalid.new("xxx"))
-        expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
-      end
-    end
-  end
-end