releaf-i18n_database 0.2.1 → 1.0.3

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

@@ -0,0 +1,13 @@
+require "rails_helper"
+
+describe Releaf::I18nDatabase::Configuration do
+  subject{ described_class.new(translation_auto_creation: true,
+                               translation_auto_creation_patterns: [1, 2],
+                               translation_auto_creation_exclusion_patterns: [3, 4]) }
+
+  it do
+    is_expected.to have_attributes(translation_auto_creation: true)
+    is_expected.to have_attributes(translation_auto_creation_patterns: [1, 2])
+    is_expected.to have_attributes(translation_auto_creation_exclusion_patterns: [3, 4])
+  end
+end

data/spec/lib/{i18n_database → releaf/i18n_database}/humanize_missing_translations_spec.rb

@@ -2,12 +2,18 @@ require "rails_helper"
 
 describe Releaf::I18nDatabase::HumanizeMissingTranslations do
   describe ".call" do
-    context "when exception is I18n::MissingTranslation" do
+    context "when key is present and exception is I18n::MissingTranslation" do
       it "humanizes missing translations" do
         expect(I18n.t("some.missing translation")).to eq("Missing translation")
       end
     end
 
+    context "when key is not present and exception is I18n::MissingTranslation" do
+      it "does not intercept it" do
+        expect(I18n.t(nil)).to eq("translation missing: en.no key")
+      end
+    end
+
     context "when exception is not I18n::MissingTranslation" do
       it "does not intercept it" do
         allow(I18n::Backend::Transliterator).to receive(:get).and_raise(I18n::ArgumentError)

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

@@ -0,0 +1,151 @@
+require "rails_helper"
+
+describe Releaf::I18nDatabase::ParseSpreadsheetTranslations do
+  let(:translation){ Releaf::I18nDatabase::I18nEntry.new }
+  let(:fixture_path){ File.expand_path('../../../fixtures/translations_import.xlsx', __dir__) }
+  let(:error_message){ "Don't know how to open file #{fixture_path}" }
+  subject{ described_class.new(file_path: fixture_path, extension: "xlsx") }
+
+  describe "#call" do
+    it "returns translations" do
+      allow(subject).to receive(:translations).and_return("x")
+      expect(subject.call).to eq("x")
+    end
+  end
+
+  describe "#rows" do
+    let(:spreadsheet){ Roo::Spreadsheet.open(fixture_path) }
+
+    before do
+      allow(subject).to receive(:spreadsheet).and_return(spreadsheet)
+    end
+
+    it "returns speadsheet casted to array" do
+      allow(spreadsheet).to receive(:to_a).and_return([1, 2])
+      expect(subject.rows).to eq([1, 2])
+    end
+
+    it "caches casted array" do
+      expect(spreadsheet).to receive(:to_a).and_return([1, 2]).once
+      subject.rows
+      subject.rows
+    end
+  end
+
+  describe "#data_rows" do
+    it "returns all rows except first and one with empty first value (key)" do
+      allow(subject).to receive(:rows).and_return([[1, 2, 3], [:a, 2, 3], [nil, 2, 4], ["", 4, 1], [6, 2, ""]])
+      expect(subject.data_rows).to eq([[:a, 2, 3], [6, 2, ""]])
+    end
+  end
+
+  describe "#locales" do
+    it "returns all non blank values from first row" do
+      allow(subject).to receive(:rows).and_return([["lv", "", "de", nil, "en"], [:a, 2, 3], [6, 2, ""]])
+      expect(subject.locales).to eq(["lv", "de", "en"])
+    end
+
+    it "caches resolved values" do
+      expect(subject).to receive(:rows).and_return([["lv", "", "de", nil, "en"], [:a, 2, 3], [6, 2, ""]]).once
+      subject.locales
+      subject.locales
+    end
+  end
+
+  describe "#spreadsheet" do
+    it "returns Roo spreadsheet instance" do
+      allow(Roo::Spreadsheet).to receive(:open).with(fixture_path, extension: "xlsx", file_warning: :ignore).and_return("instance")
+      expect(subject.spreadsheet).to eq("instance")
+    end
+
+
+    context "when opening the file raises an unsupported content error" do
+      it "raises Releaf::TranslationsImporter::UnsupportedFileFormatError" do
+        error = ArgumentError.new("error message")
+        allow(Roo::Spreadsheet).to receive(:open).and_raise( error )
+        expect(subject).to receive(:file_format_error?).with( "ArgumentError", "error message").and_return true
+        expect{ subject.spreadsheet }.to raise_error(described_class::UnsupportedFileFormatError)
+      end
+    end
+
+    context "when opening the file raises any other error" do
+      it "raises Releaf::TranslationsImporter::UnsupportedFileFormatError" do
+        error = ArgumentError.new("error message")
+        allow(Roo::Spreadsheet).to receive(:open).and_raise( error )
+        expect(subject).to receive(:file_format_error?).with( "ArgumentError", "error message").and_return false
+        expect{ subject.spreadsheet }.to raise_error( error )
+      end
+    end
+
+  end
+
+  describe "#file_format_error?" do
+
+    context "when given error is an ArgumentError" do
+      context "when the message contains 'Don't know how to open file'" do
+        it "returns true" do
+          expect(subject.file_format_error?("ArgumentError", error_message)).to be true
+        end
+      end
+      context "when the message is different" do
+        it "returns false" do
+          expect(subject.file_format_error?("ArgumentError", "error message")).to be false
+        end
+      end
+    end
+
+    context "when the error is a Zip::ZipError" do
+      it "returns true" do
+        expect(subject.file_format_error?("Zip::ZipError", "error message")).to be true
+      end
+    end
+
+    context "when the error is a Ole::Storage::FormatError" do
+      it "returns true" do
+        expect(subject.file_format_error?("Ole::Storage::FormatError", "error message")).to be true
+      end
+    end
+
+
+  end
+
+
+  describe "#translations" do
+    it "returns array of processed `Releaf::I18nDatabase::Translation` instances" do
+      allow(subject).to receive(:data_rows).and_return([[1, 2, 3], [:a, nil, 3], [6, 2, ""]])
+      allow(subject).to receive(:translation_instance).with(1, ["2", "3"]).and_return("t1")
+      allow(subject).to receive(:translation_instance).with(:a, ["", "3"]).and_return("t2")
+      allow(subject).to receive(:translation_instance).with(6, ["2", ""]).and_return("t3")
+      expect(subject.translations).to eq(["t1", "t2", "t3"])
+    end
+  end
+
+  describe "#translation_instance" do
+    it "returns first or initialized translation for given key and given localizations built" do
+      where_scope = Releaf::I18nDatabase::I18nEntry.where(key: ["sommmmquery"])
+      allow(Releaf::I18nDatabase::I18nEntry).to receive(:where).with(key: "as.ld").and_return(where_scope)
+      allow(where_scope).to receive(:first_or_initialize).and_return(translation)
+
+      expect(subject).to receive(:maintain_translation_locales).with(translation, ["x", "y"])
+      expect(subject.translation_instance("as.ld", ["x", "y"])).to eq(translation)
+    end
+  end
+
+  describe "#maintain_translation_locales" do
+    before do
+      allow(subject).to receive(:locales).and_return(["en", "de", "ge", "lv"])
+      translation.i18n_entry_translation.build(locale: "de", text: "po")
+      translation.i18n_entry_translation.build(locale: "ge", text: "x")
+    end
+
+    it "builds translation data for all missing locales" do
+      expect{ subject.maintain_translation_locales(translation, ["ent", "det", "get", "lvt"]) }
+        .to change{ translation.i18n_entry_translation.map{|td| td.locale } }.from(["de", "ge"]).to(["de", "ge", "en", "lv"])
+    end
+
+    it "overwrites existing translation data localizations only if new localizations is not empty" do
+      expect{ subject.maintain_translation_locales(translation, ["ent", "", "get", "lvt"]) }
+        .to change{ translation.i18n_entry_translation.map{|td| [td.locale, td.text] } }.to([["de", "po"], ["ge", "get"], ["en", "ent"], ["lv", "lvt"]])
+    end
+  end
+end

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

@@ -0,0 +1,548 @@
+require "rails_helper"
+
+describe Releaf::I18nDatabase::TranslationsStore do
+  describe "#initialize" do
+    it "assigns updated at from `Releaf::I18nDatabase::Backend` last updated at timestamp" do
+      allow(Releaf::I18nDatabase::Backend).to receive(:translations_updated_at).and_return("x")
+      expect(subject.updated_at).to eq("x")
+    end
+
+    it "assigns empty hash to missing keys" do
+      expect(subject.missing_keys).to eq({})
+    end
+  end
+
+  describe "#config" do
+    it "returns Releaf.application.config" do
+      allow(Releaf.application).to receive(:config).and_return(:x)
+      expect(subject.config).to eq(:x)
+    end
+  end
+
+  describe "#expired?" do
+    context "when last translation update differs from last cache load" do
+      it "returns true" do
+        allow(Releaf::I18nDatabase::Backend).to receive(:translations_updated_at).and_return(1)
+        subject.updated_at = 2
+        expect(subject.expired?).to be true
+      end
+    end
+
+    context "when last translation update does not differ from last cache load" do
+      it "returns false" do
+        allow(Releaf::I18nDatabase::Backend).to receive(:translations_updated_at).and_return(1)
+        subject.updated_at = 1
+        expect(subject.expired?).to be false
+      end
+    end
+  end
+
+  describe "#exist?" do
+    context "when given key exists within stored keys hash" do
+      it "returns true" do
+        allow(subject).to receive(:stored_keys).and_return("asd.xxx" => true)
+        expect(subject.exist?("asd.xxx")).to be true
+      end
+    end
+
+    context "when given key does not exist within keys hash" do
+      it "returns false" do
+        allow(subject).to receive(:stored_keys).and_return("asd.xxyy" => true)
+        expect(subject.exist?("asd.xxx")).to be false
+      end
+    end
+  end
+
+  describe "#lookup" do
+    it "returns first valid and returnable result" do
+      allow(subject).to receive(:dig_valid_translation)
+        .with(:ru, ["admin", "menu", "translations"], true, count: 23).and_return("x1")
+      allow(subject).to receive(:returnable_result?)
+        .with("x1", count: 23).and_return(false)
+
+      allow(subject).to receive(:dig_valid_translation)
+        .with(:ru, ["admin", "translations"], false, count: 23).and_return("x2")
+      allow(subject).to receive(:returnable_result?)
+        .with("x2", count: 23).and_return(true)
+
+      expect(subject.lookup(:ru, "admin.menu.translations", count: 23)).to eq("x2")
+    end
+
+    it "iterates throught all translation scopes until last key" do
+      expect(subject).to receive(:dig_valid_translation)
+        .with(:ru, ["admin", "menu", "another", "translations"], true, count: 23).and_return(nil)
+      expect(subject).to receive(:dig_valid_translation)
+        .with(:ru, ["admin", "menu", "translations"], false, count: 23).and_return(nil)
+      expect(subject).to receive(:dig_valid_translation)
+        .with(:ru, ["admin", "translations"], false, count: 23).and_return(nil)
+      expect(subject).to receive(:dig_valid_translation)
+        .with(:ru, ["translations"], false, count: 23).and_return("x1")
+
+      subject.lookup(:ru, "admin.menu.another.translations", count: 23)
+    end
+
+    context "when no matches found" do
+      it "returns nil" do
+        allow(subject).to receive(:dig_valid_translation).and_return(nil)
+        expect(subject.lookup(:ru, "admin.menu.translations", count: 23)).to be nil
+      end
+    end
+  end
+
+  describe "#dig_translation" do
+    before do
+      allow(subject).to receive(:stored_translations).and_return(
+        lv: {
+          admin: {
+            some_scope: {
+              save: "Saglabāt"
+            }
+          }
+        },
+        lt: {
+          public: {
+            another_scope: {
+              email: "E-pastas"
+            }
+          }
+        }
+      )
+    end
+
+    it "dig given locale prefixed keys hash against stored translations and returns matched value (String or Hash)" do
+      expect(subject.dig_translation(:lv, [:admin, :some_scope, :save])).to eq("Saglabāt")
+      expect(subject.dig_translation(:lt, [:public, :another_scope, :email])).to eq("E-pastas")
+      expect(subject.dig_translation(:lt, [:public, :another_scope])).to eq(email: "E-pastas")
+    end
+
+    context "when no match found" do
+      it "returns nil" do
+        expect(subject.dig_translation(:lt, [:admin, :some_scope, :save])).to be nil
+        expect(subject.dig_translation(:lt, [:public, :email])).to be nil
+        expect(subject.dig_translation(:ge, [:public, :email])).to be nil
+      end
+    end
+  end
+
+  describe "#dig_valid_translation" do
+    before do
+      allow(subject).to receive(:dig_translation).with(:de, [:admin, :save]).and_return("translated_value")
+    end
+
+    context "when digged translation has valid result" do
+      it "returns digged translation result" do
+        allow(subject).to receive(:invalid_result?).with(:de, "translated_value", true, a: :b).and_return(false)
+        expect(subject.dig_valid_translation(:de, [:admin, :save], true, a: :b)).to eq("translated_value")
+      end
+    end
+
+    context "when digged translation has invalid result" do
+      it "returns nil" do
+        allow(subject).to receive(:invalid_result?).with(:de, "translated_value", true, a: :b).and_return(true)
+        expect(subject.dig_valid_translation(:de, [:admin, :save], true, a: :b)).to be nil
+      end
+    end
+  end
+
+  describe "#invalid_result?" do
+    before do
+      allow(subject).to receive(:invalid_nonpluralized_result?).with("xx", true, a: :b).and_return(false)
+      allow(subject).to receive(:invalid_pluralized_result?).with(:ge, "xx", a: :b).and_return(false)
+    end
+
+    context "when invalid nonplurarized result" do
+      it "returns true" do
+        allow(subject).to receive(:invalid_nonpluralized_result?).with("xx", true, a: :b).and_return(true)
+        expect(subject.invalid_result?(:ge, "xx", true, a: :b)).to be true
+      end
+    end
+
+    context "when invalid plurarized result" do
+      it "returns true" do
+        allow(subject).to receive(:invalid_pluralized_result?).with(:ge, "xx", a: :b).and_return(true)
+        expect(subject.invalid_result?(:ge, "xx", true, a: :b)).to be true
+      end
+    end
+
+    context "when no invalid nonplurarized or pluralized result" do
+      it "returns false" do
+        expect(subject.invalid_result?(:ge, "xx", true, a: :b)).to be false
+      end
+    end
+  end
+
+  describe "#invalid_nonpluralized_result?" do
+    context "when hash result, not first lookup and options without count" do
+      it "returns true" do
+        expect(subject.invalid_nonpluralized_result?({a: :b}, false, scope: "xxx")).to be true
+      end
+    end
+
+    context "when hash result, first lookup and options without count" do
+      it "returns false" do
+        expect(subject.invalid_nonpluralized_result?({a: :b}, true, scope: "xxx")).to be false
+      end
+    end
+
+    context "when hash result, not first lookup and options with count" do
+      it "returns false" do
+        expect(subject.invalid_nonpluralized_result?({a: :b}, false, count: 43, scope: "xxx")).to be false
+      end
+    end
+
+    context "when non hash result, not first lookup and options without count" do
+      it "returns false" do
+        expect(subject.invalid_nonpluralized_result?("x", false, scope: "xxx")).to be false
+      end
+    end
+  end
+
+  describe "#invalid_pluralized_result?" do
+    before do
+      allow(subject).to receive(:valid_pluralized_result?).with(:ge, 12, a: :b).and_return(false)
+    end
+
+    context "when hash result, options has count and invalid pluralized result" do
+      it "returns true" do
+        expect(subject.invalid_pluralized_result?(:ge, {a: :b}, {count: 12})).to be true
+      end
+    end
+
+    context "when non hash result, options has count and invalid pluralized result" do
+      it "returns false" do
+        expect(subject.invalid_pluralized_result?(:ge, "X", {count: 12})).to be false
+      end
+    end
+
+    context "when hash result, options has no count value and invalid pluralized result" do
+      it "returns false" do
+        expect(subject.invalid_pluralized_result?(:ge, {a: :b}, {scope: "xx.xx"})).to be false
+      end
+    end
+
+    context "when hash result, options has count and valid pluralized result" do
+      it "returns false" do
+        allow(subject).to receive(:valid_pluralized_result?).with(:ge, 12, a: :b).and_return(true)
+        expect(subject.invalid_pluralized_result?(:ge, {a: :b}, {count: 12})).to be false
+      end
+    end
+  end
+
+  describe "#valid_pluralized_result?" do
+    before do
+      allow(TwitterCldr::Formatters::Plurals::Rules).to receive(:rule_for)
+        .with(2, :lv).and_return(:few)
+    end
+
+    context "when unsupported locale given" do
+      it "return false" do
+        allow(TwitterCldr).to receive(:supported_locale?).with(:lv).and_return(false)
+        expect(subject.valid_pluralized_result?(:lv, 2, few: "x", many: "y")).to be false
+      end
+    end
+
+    context "when given hash contains valid result for given locale and count" do
+      before do
+        allow(TwitterCldr).to receive(:supported_locale?).with(:lv).and_return(true)
+      end
+
+      context "when given hash contains valid result for given locale and count" do
+        it "return true" do
+          expect(subject.valid_pluralized_result?(:lv, 2, few: "x", many: "y")).to be true
+        end
+      end
+
+      context "when given hash contains valid result for given locale and count" do
+        it "return true" do
+          expect(subject.valid_pluralized_result?(:lv, 2, one: "x", many: "y")).to be false
+        end
+      end
+    end
+  end
+
+  describe "#returnable_result?" do
+    context "when given result is not blank" do
+      it "returns true" do
+        expect(subject.returnable_result?("x", a: "b")).to be true
+      end
+    end
+
+    context "when `inherit_scopes` option value is boolean `false`" do
+      it "returns true" do
+        expect(subject.returnable_result?(nil, inherit_scopes: false)).to be true
+      end
+    end
+
+    context "when given result is blank and `inherit_scopes` option value is not boolean `false`" do
+      it "returns false" do
+        expect(subject.returnable_result?(nil, inherit_scopes: true)).to be false
+        expect(subject.returnable_result?(nil, a: "b")).to be false
+      end
+    end
+  end
+
+  describe "#localization_data" do
+    it "returns hash with all non empty translations with locale prefixed key and localization as value" do
+      i18n_entry_1 = Releaf::I18nDatabase::I18nEntry.create(key: "some.food")
+      i18n_entry_1.i18n_entry_translation.create(locale: "lv", text: "suņi")
+      i18n_entry_1.i18n_entry_translation.create(locale: "en", text: "dogs")
+
+      i18n_entry_2 = Releaf::I18nDatabase::I18nEntry.create(key: "some.good")
+      i18n_entry_2.i18n_entry_translation.create(locale: "lv", text: "xx")
+      i18n_entry_2.i18n_entry_translation.create(locale: "en", text: "")
+
+      expect(subject.localization_data).to eq("lv.some.food" => "suņi", "en.some.food" => "dogs",
+                                              "lv.some.good" => "xx")
+    end
+
+    it "caches built hash" do
+      expect(described_class.cached_instance_methods).to include(:localization_data)
+    end
+  end
+
+  describe "#stored_keys" do
+    it "returns hash with existing translation keys" do
+      Releaf::I18nDatabase::I18nEntry.create(key: "some.food")
+      Releaf::I18nDatabase::I18nEntry.create(key: "some.good")
+      expect(subject.stored_keys).to eq("some.food" => true, "some.good" => true)
+    end
+
+    it "caches built hash" do
+      expect(described_class.cached_instance_methods).to include(:stored_keys)
+    end
+  end
+
+  describe "#stored_translations" do
+    it "returns deep merged hash from all key translation hashes" do
+      allow(subject).to receive(:stored_keys).and_return("some.food" => true, "some.good" => true)
+      allow(subject).to receive(:key_hash).with("some.food").and_return(lv: {a: "a1"}, en: {d: {e: "ee"}})
+      allow(subject).to receive(:key_hash).with("some.good").and_return(lv: {b: "b2"}, en: {d: {u: "ll"}})
+      expect(subject.stored_translations).to eq(lv: {a: "a1", b: "b2"}, en: {d: {e: "ee", u: "ll"}})
+    end
+
+    context "when no keys exists" do
+      it "returns empty hash" do
+        allow(subject).to receive(:stored_keys).and_return({})
+        expect(subject.stored_translations).to eq({})
+      end
+    end
+
+    it "caches built hash" do
+      expect(described_class.cached_instance_methods).to include(:stored_translations)
+    end
+  end
+
+  describe "#key_hash" do
+    it "build stored translation hash with keys and translated values for given key" do
+      allow(subject.config).to receive(:all_locales).and_return([:ge, :de])
+      allow(subject).to receive(:localization_data).and_return(
+        "lv.admin.releaf_i18n_database_translations.Save" => "zc",
+        "ge.admin.Save" => "asdasd",
+        "de.admin.releaf_i18n_database_translations.Save" => "Seiv",
+        "de.admin.releaf_i18n_database_translations.Cancel" => "dCancel",
+        "ge.admin.releaf_i18n_database_translations.Cancel" => "gCancel",
+      )
+
+      expect(subject.key_hash("admin.releaf_i18n_database_translations.Save")).to eq(
+        ge: {
+          admin: {
+            releaf_i18n_database_translations: {
+              Save: nil
+            }
+          }
+        },
+        de: {
+          admin: {
+            releaf_i18n_database_translations: {
+              Save: "Seiv"
+            }
+          }
+        }
+      )
+
+      expect(subject.key_hash("admin.releaf_i18n_database_translations.Cancel")).to eq(
+        ge: {
+          admin: {
+            releaf_i18n_database_translations: {
+              Cancel: "gCancel"
+            }
+          }
+        },
+        de: {
+          admin: {
+            releaf_i18n_database_translations: {
+              Cancel: "dCancel"
+            }
+          }
+        }
+      )
+    end
+  end
+
+  describe "#missing?" do
+    context "when given locale and key combination exists within missing keys hash" do
+      it "returns true" do
+        allow(subject).to receive(:missing_keys).and_return("lv.asd.xxx" => true)
+        expect(subject.missing?(:lv, "asd.xxx")).to be true
+      end
+    end
+
+    context "when given locale and key combination does not exist missing keys hash" do
+      it "returns false" do
+        allow(subject).to receive(:missing_keys).and_return("en.asd.xxx" => true)
+        expect(subject.missing?(:lv, "asd.xxx")).to be false
+      end
+    end
+  end
+
+  describe "#missing" do
+    it "adds given locale and key combination as missing" do
+      expect{ subject.missing(:de, "as.pasd", a: "x") }.to change { subject.missing_keys["de.as.pasd"] }
+        .from(nil).to(true)
+    end
+
+    context "when missing translation creation is available for given key and options" do
+      it "creates missing translation" do
+        allow(subject).to receive(:auto_create?).with("ps.asda", a: "x").and_return(true)
+        expect(subject).to receive(:auto_create).with("ps.asda", a: "x")
+        subject.missing(:de, "ps.asda", a: "x")
+      end
+    end
+
+    context "when missing translation creation is not available for given key and options" do
+      it "does not create missing translation" do
+        allow(subject).to receive(:auto_create?).with("ps.asda", a: "x").and_return(false)
+        expect(subject).to_not receive(:auto_create)
+        subject.missing(:de, "ps.asda", a: "x")
+      end
+    end
+  end
+
+  describe "#auto_create?" do
+    before do
+      allow(subject.config.i18n_database ).to receive(:translation_auto_creation).and_return(true)
+      allow(subject).to receive(:stored_keys).and_return("xxxome.save" => "xxxome.save")
+      allow(subject).to receive(:auto_creation_inclusion?).with("some.save").and_return(true)
+      allow(subject).to receive(:auto_creation_exception?).with("some.save").and_return(false)
+    end
+
+    context "when missing translation creation is enabled globally by i18n config and not disabled by `auto_create` option" do
+      it "returns true" do
+        expect(subject.auto_create?("some.save", {})).to be true
+        expect(subject.auto_create?("some.save", auto_create: true)).to be true
+        expect(subject.auto_create?("some.save", auto_create: nil)).to be true
+      end
+    end
+
+    context "when no auto creation inclusion" do
+      it "returns false" do
+        allow(subject).to receive(:auto_creation_inclusion?).with("some.save").and_return(false)
+        expect(subject.auto_create?("some.save", {})).to be false
+      end
+    end
+
+    context "when auto creation exception" do
+      it "returns false" do
+        allow(subject).to receive(:auto_creation_exception?).with("some.save").and_return(true)
+        expect(subject.auto_create?("some.save", {})).to be false
+      end
+    end
+
+    context "when missing translation creation is disabled globally by i18n config" do
+      it "returns false" do
+        allow(subject.config.i18n_database ).to receive(:translation_auto_creation).and_return(false)
+        expect(subject.auto_create?("some.save", {})).to be false
+      end
+    end
+
+    context "when missing translation creation is disabled by `auto_create` option" do
+      it "returns false" do
+        expect(subject.auto_create?("some.save", auto_create: false)).to be false
+      end
+    end
+
+    context "when key already exists within stored keys hash" do
+      it "returns false" do
+        allow(subject).to receive(:stored_keys).and_return("some.save" => "some.save")
+        expect(subject.auto_create?("some.save", {})).to be false
+      end
+    end
+  end
+
+  describe "#auto_creation_inclusion?" do
+    context "when given key matches any auto creation pattern" do
+      it "returns true" do
+        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_patterns).and_return([/^another\./, /^some\./])
+        expect(subject.auto_creation_inclusion?("some.save")).to be true
+      end
+    end
+
+    context "when given key matches no auto creation pattern" do
+      it "returns false" do
+        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_patterns).and_return([/^another\./, /^foo\./])
+        expect(subject.auto_creation_inclusion?("some.save")).to be false
+      end
+    end
+  end
+
+  describe "#auto_creation_exception?" do
+    context "when given key matches any auto creation exception pattern" do
+      it "returns true" do
+        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_exclusion_patterns).and_return([/^another\./, /^some\./])
+        expect(subject.auto_creation_exception?("some.save")).to be true
+      end
+    end
+
+    context "when given key matches no auto creation exception pattern" do
+      it "returns false" do
+        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_exclusion_patterns).and_return([/^another\./, /^foo\./])
+        expect(subject.auto_creation_exception?("some.save")).to be false
+      end
+    end
+  end
+
+  describe "#auto_create" do
+    before do
+      allow(Releaf::I18nDatabase::Backend).to receive(:locales_pluralizations).and_return([:one, :many, :other])
+    end
+
+    context "when pluralizable translation given" do
+      it "creates translation for each pluralization form" do
+        allow(subject).to receive(:pluralizable_translation?).with(a: "b").and_return(true)
+        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd.one")
+        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd.many")
+        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd.other")
+        subject.auto_create("aasd.oihgja.sd", a: "b")
+      end
+    end
+
+    context "when non pluralizable translation given" do
+      it "creates translation" do
+        allow(subject).to receive(:pluralizable_translation?).with(a: "b").and_return(false)
+        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd")
+        subject.auto_create("aasd.oihgja.sd", a: "b")
+      end
+    end
+  end
+
+  describe "#pluralizable_translation?" do
+    context "when given options has count key and `create_plurals` key is true" do
+      it "returns true" do
+        expect(subject.pluralizable_translation?(count: 3, create_plurals: true)).to be true
+      end
+    end
+
+    context "when given options has count key and `create_plurals` key is not true" do
+      it "returns false" do
+        expect(subject.pluralizable_translation?(count: 3, create_plurals: false)).to be false
+        expect(subject.pluralizable_translation?(count: 3)).to be false
+      end
+    end
+
+    context "when given options has no count key and `create_plurals` key is true" do
+      it "returns false" do
+        expect(subject.pluralizable_translation?(create_plurals: true)).to be false
+      end
+    end
+  end
+end