bisu 3.0.1 → 3.1.0

data/spec/lib/bisu/dictionary_spec.rb

@@ -1,76 +0,0 @@
-describe Bisu::Dictionary do
-  subject(:dict) { Bisu::Dictionary.new(keys) }
-
-  describe ".initialize" do
-    let(:keys) { { "lang" => { "kNo1" => "text" } } }
-    it { expect { subject }.not_to raise_error }
-
-    context "when created with invalid type parameters" do
-      let(:keys) { "cenas" }
-      it { expect { subject }.to raise_error /expected Hash/ }
-    end
-
-    context "when created with an invalid json schema" do
-      let(:keys) { { "lang" => "text" } }
-      it { expect { subject }.to raise_error /lang.+expected Hash/ }
-    end
-
-    context "when created with an invalid json schema" do
-      let(:keys) { { "a-lang" => { "kNo1" => { "wtvr" => "text" } } } }
-      it { expect { subject }.to raise_error /a-lang.+kNo1.+expected String/ }
-    end
-
-    context "when given empty translations" do
-      let(:keys) { { "lang" => { "kNo1" => nil } } }
-      it { expect { subject }.not_to raise_error }
-    end
-  end
-
-  describe "#has_language?" do
-    let(:keys) { {
-      "lang1" => { "kNo1" => "no1-lang1" },
-      "lang2" => { "kNo1" => "no1-lang2", "kNo2" => "no1-lang2" },
-      "lang3" => { "kNo2" => "no2-lang3" }
-    } }
-
-    it "returns true if that language is translated" do
-      expect(dict.has_language?("lang2")).to be true
-    end
-
-    it "returns true if that language is only partially translated" do
-      expect(dict.has_language?("lang3")).to be true
-    end
-
-    it "returns false if that language does not exist in any key" do
-      expect(dict.has_language?("lang-no-available")).to be false
-    end
-
-    it "returns true if that language is in another case" do
-      expect(dict.has_language?("Lang2")).to be true
-    end
-  end
-
-  describe "#localize" do
-    let(:keys) { {
-      "english"    => { "kCray" => "You are crazy!" },
-      "portuguese" => { "kCray" => "Estás maluco!" },
-      "kriolo"     => { "kCray" => "Bo sta crazy!" }
-    } }
-
-    it "localizes a key" do
-      expect(dict.localize("kriolo", "kCray")).to eq "Bo sta crazy!"
-    end
-
-    it "returns nil when the key does not exist" do
-      expect(dict.localize("kriolo", "kDoesntExist")).to be nil
-    end
-
-    it "returns nil when language is not available" do
-      expect(dict.localize("finish", "kCray")).to be nil
-    end
-
-    it "localizes a key when the language is in another case" do
-      expect(dict.localize("krioLo", "kCray")).to eq "Bo sta crazy!"
-    end
-  end
-end

data/spec/lib/bisu/localizer_spec.rb

@@ -1,212 +0,0 @@
-describe Bisu::Localizer do
-  def translates(text, fallbacks: [], to:, lang: nil)
-    translation = localizer.localize(text, lang || language, locale, fallbacks)
-    expect(translation).to eq to
-  end
-
-  let(:language) { "Portuguese" }
-  let(:locale)   { "pt-PT" }
-
-  let(:keys) { {
-    language => {
-      "kTranslationKey"  => "Não sabes nada João das Neves",
-      "kTranslationKey2" => "Naaada!",
-      "k1ParameterKey"   => "Não sabes nada %{name}",
-      "k2ParametersKey"  => "Sabes %{perc} por cento %{name}",
-      "kNewLineSingle"   => "Não sabes nada\nJoão das Neves",
-      "kNewLineMultiple" => "Não sabes nada\\nJoão das Neves",
-
-      # type dependent translations
-      "kDoubleQuoted"    => "Não sabes nada \"João das Neves\"",
-      "kSingleQuoted"    => "Não sabes nada 'João das Neves'",
-      "kEllipsis"        => "Não sabes nada João das Neves...",
-      "kAmpersand"       => "Não sabes nada João das Neves T&C",
-      "kAtSign"          => "\@johnsnow sabes alguma coisa?",
-      "kPercentage"      => "Sabes 0% João das Neves."
-    },
-    "Spanish" => {
-      "kMissingTransKey" => "Sabes poco John Snow"
-    },
-    "English" => {
-      "kMissingTransKey" => "You know little John Snow"
-    }
-  } }
-
-  let(:kb) { Bisu::Dictionary.new(keys) }
-  let(:localizer) { Bisu::Localizer.new(kb, type) }
-
-  shared_examples_for "a localizer" do
-    it { expect { localizer }.not_to raise_error }
-
-    it { translates("a line with no key", to: "a line with no key") }
-
-    it { translates("this special key: $specialKComment1$", to: "this special key: This file was automatically generated based on a translation template.") }
-    it { translates("this special key: $specialKComment2$", to: "this special key: Remember to CHANGE THE TEMPLATE and not this file!") }
-    it { translates("this special key: $specialKLanguage$", to: "this special key: #{language}") }
-    it { translates("this special key: $specialKLocale$",   to: "this special key: #{locale}") }
-
-    it { translates("this key: $kTranslationKey$", to: "this key: Não sabes nada João das Neves") }
-    it { translates("this key: $kTranslationKey$", to: "this key: Não sabes nada João das Neves", lang: "portuguese") }
-    it { translates("this unknown key: $kUnknownKey$", to: "this unknown key: $kUnknownKey$") }
-    it { translates("this key with missing translations: $kMissingTransKey$", to: "this key with missing translations: $kMissingTransKey$") }
-    it { translates("this key with missing translations: $kMissingTransKey$", fallbacks: ["English"], to: "this key with missing translations: You know little John Snow") }
-    it { translates("this key with missing translations: $kMissingTransKey$", fallbacks: ["Spanish", "English"], to: "this key with missing translations: Sabes poco John Snow") }
-    it { translates("these 2 keys: $kTranslationKey$, $kTranslationKey2$", to: "these 2 keys: Não sabes nada João das Neves, Naaada!") }
-
-    it { translates("1 parameter: $k1ParameterKey$",                         to: "1 parameter: Não sabes nada %{name}") }
-    it { translates("1 parameter: $k1ParameterKey{name:%1$s}$",              to: "1 parameter: Não sabes nada %1$s") }
-    it { translates("2 parameters: $k2ParametersKey$",                       to: "2 parameters: Sabes %{perc} por cento %{name}") }
-    it { translates("2 parameters: $k2ParametersKey{perc:%2$d, name:%1$s}$", to: "2 parameters: Sabes %2$d por cento %1$s") }
-    it { translates("2 parameters: $k2ParametersKey{name:%1$s, perc:%2$d}$", to: "2 parameters: Sabes %2$d por cento %1$s") }
-
-    it { translates("$kNewLineSingle$",   to: "Não sabes nada\\nJoão das Neves") }
-    it { translates("$kNewLineMultiple$", to: "Não sabes nada\\nJoão das Neves") }
-
-    # type dependent translations
-
-    it { translates("$kDoubleQuoted$", to: expected[:double_quoted]) }
-    it { translates("$kSingleQuoted$", to: expected[:single_quoted]) }
-    it { translates("$kEllipsis$", to: expected[:ellipsis]) }
-    it { translates("$kAmpersand$", to: expected[:ampersand]) }
-    it { translates("$kAtSign$", to: expected[:at_sign]) }
-    it { translates("$kPercentage$", to: expected[:percentage]) }
-    it { translates("$kPercentage//formatted-string$", to: expected[:percentage_formatted]) }
-
-    # error handling
-
-    it "throws a warnings when key has no translation" do
-      expect {
-        localizer.localize("$kUnknownKey$", language, locale)
-      }.to change { Bisu::Logger.summary[:warn] }.by(1)
-       .and not_change { Bisu::Logger.summary[:error] }
-    end
-
-    it "does not throw a warning when key is found" do
-      expect {
-        localizer.localize("$kTranslationKey$", language, locale)
-      }.to not_change { Bisu::Logger.summary[:warn] }
-       .and not_change { Bisu::Logger.summary[:error] }
-    end
-
-    it "throws a error when missing key parameters (expect on ruby on rails)" do
-      if type == :ror
-        expect {
-          localizer.localize("$k1ParameterKey$", language, locale)
-        }.to not_change { Bisu::Logger.summary[:warn] }
-         .and not_change { Bisu::Logger.summary[:error] }
-      else
-        expect {
-          localizer.localize("$k1ParameterKey$", language, locale)
-        }.to not_change { Bisu::Logger.summary[:warn] }
-         .and change { Bisu::Logger.summary[:error] }.by(1)
-       end
-    end
-
-    it "does not throw an error when key parameters where given" do
-      expect {
-        localizer.localize("$k1ParameterKey{name:%1$s}$", language, locale)
-      }.to not_change { Bisu::Logger.summary[:warn] }
-       .and not_change { Bisu::Logger.summary[:error] }
-    end
-
-    it "throws an error when given parameters for parameterless key" do
-      expect {
-        localizer.localize("$kTranslationKey{param:%s}$", language, locale)
-      }.to not_change { Bisu::Logger.summary[:warn] }
-       .and change { Bisu::Logger.summary[:error] }.by(1)
-    end
-
-    # non localizable text with params
-
-    it "does not try to translate params outside $$" do
-      translates("%{some_text}", to: "%{some_text}")
-
-      expect {
-        localizer.localize("%{some_text}", language, locale)
-      }.to not_change { Bisu::Logger.summary[:warn] }
-       .and not_change { Bisu::Logger.summary[:error] }
-    end
-  end
-
-  let(:type_dependent_defaults) { {
-    double_quoted: keys[language]["kDoubleQuoted"],
-    single_quoted: keys[language]["kSingleQuoted"],
-    ellipsis: keys[language]["kEllipsis"],
-    ampersand: keys[language]["kAmpersand"],
-    at_sign: keys[language]["kAtSign"],
-    percentage: keys[language]["kPercentage"],
-    percentage_formatted: keys[language]["kPercentage"],
-  } }
-
-  describe "of type iOS" do
-    let(:type) { :ios }
-
-    let(:expected) { type_dependent_defaults.merge(
-      double_quoted: "Não sabes nada \\\"João das Neves\\\"",
-      percentage: "Sabes 0% João das Neves.",
-      percentage_formatted: "Sabes 0%% João das Neves.",
-    ) }
-
-    it_behaves_like "a localizer"
-
-    context "when a parameter replacemnt was not defined" do
-      let(:line) { "1 parameter: $k1ParameterKey$" }
-      let(:expected) { "1 parameter: Não sabes nada %{name}" }
-
-      it { translates(line, to: expected) }
-
-      it "returns an error" do
-        expect {
-          localizer.localize(line, language, locale)
-        }.to not_change { Bisu::Logger.summary[:warn] }
-         .and change { Bisu::Logger.summary[:error] }.by(1)
-      end
-
-      context "when passing //ignore-params" do
-        let(:line) { "1 parameter: $k1ParameterKey//ignore-params$" }
-
-        it { translates(line, to: expected) }
-
-        it "does not return an error" do
-          expect {
-            localizer.localize(line, language, locale)
-          }.to not_change { Bisu::Logger.summary[:warn] }
-           .and not_change { Bisu::Logger.summary[:error] }
-        end
-      end
-    end
-  end
-
-  describe "of type Android" do
-    let(:type) { :android }
-
-    let(:expected) { type_dependent_defaults.merge(
-      single_quoted: "Não sabes nada \\'João das Neves\\'",
-      double_quoted: "Não sabes nada \\\"João das Neves\\\"",
-      ellipsis: "Não sabes nada João das Neves…",
-      ampersand: "Não sabes nada João das Neves T&C",
-      at_sign: "\\@johnsnow sabes alguma coisa?",
-      percentage: "Sabes 0\\%% João das Neves.",
-      percentage_formatted: "Sabes 0\\%% João das Neves.",
-    ) }
-
-    it_behaves_like "a localizer"
-  end
-
-  describe "of type Ruby on Rails" do
-    let(:type) { :ror }
-
-    let(:expected) { type_dependent_defaults.merge(
-      double_quoted: "Não sabes nada \\\"João das Neves\\\"",
-    ) }
-
-    it_behaves_like "a localizer"
-  end
-
-  describe "of an unkown type" do
-    let(:type) { :dunno }
-    it do
-      expect { localizer }.to raise_error /Unknown type/
-    end
-  end
-end

data/spec/lib/bisu/logger_spec.rb

@@ -1,36 +0,0 @@
-describe Bisu::Logger do
-  let(:summary) { Bisu::Logger.summary }
-  let(:info)    { summary[:info] }
-  let(:warn)    { summary[:warn] }
-  let(:error)   { summary[:error] }
-
-  context "when logging to info" do
-    before { Bisu::Logger.info "msg" }
-
-    it "returns the expected totals" do
-      expect(info).to  eq 1
-      expect(warn).to  eq 0
-      expect(error).to eq 0
-    end
-  end
-
-  context "when logging to warn" do
-    before { Bisu::Logger.warn "msg" }
-
-    it "returns the expected totals" do
-      expect(info).to  eq 0
-      expect(warn).to  eq 1
-      expect(error).to eq 0
-    end
-  end
-
-  context "when logging to error" do
-    before { Bisu::Logger.error "msg" }
-
-    it "returns the expected totals" do
-      expect(info).to  eq 0
-      expect(warn).to  eq 0
-      expect(error).to eq 1
-    end
-  end
-end

data/spec/lib/bisu/object_extension_spec.rb

@@ -1,100 +0,0 @@
-describe Object do
-
-  describe "#deep_symbolize" do
-    subject { obj.deep_symbolize }
-
-    context "when object is an Hash" do
-      let(:obj) { { "key1" => "value1", key2: "value2" } }
-      it { should eq({ key1: "value1", key2: "value2" }) }
-
-      context "with inner Hashes" do
-        before { obj["key2"] = { "key3" => { "key4" => "value4" } } }
-        it { should eq({ key1: "value1", key2: { key3: { key4: "value4" } }}) }
-      end
-    end
-
-    context "when object is an Array" do
-      let(:obj) { ["value1"] }
-      it { should eq obj }
-
-      context "with inner Hashes" do
-        let(:obj) { [{ "key1" => "value1" }, { "key2" => "value2" }] }
-        it { should eq([{ key1: "value1" }, { key2: "value2" }]) }
-      end
-    end
-
-    context "when object is something else" do
-      let(:obj) { "value1" }
-      it { should eq obj }
-    end
-  end
-
-  describe "#validate_structure!" do
-    subject { obj.validate_structure!(structure) }
-
-    context "when object type differs of the structure type" do
-      let(:obj) { "a string" }
-      let(:structure) { { type: Integer } }
-      it { expect { subject }.to raise_error /expected Integer, got String/i }
-    end
-
-    context "when object is a Nil" do
-      let(:obj) { nil }
-      let(:structure) { { type: Integer } }
-      it { expect { subject }.to raise_error /expected Integer, got NilClass/i }
-
-      context "but is also optional" do
-        before { structure[:optional] = true }
-        it { expect { subject }.not_to raise_error }
-      end
-    end
-
-    context "when object is an Array" do
-      let(:obj) { ["elem1", "elem2"] }
-      let(:structure) { { type: Array } }
-      it { expect { subject }.not_to raise_error }
-
-      context "given an element structure" do
-        before { structure[:elements] = { type: String } }
-        it { expect { subject }.not_to raise_error }
-
-        context "which is not respected" do
-          before { structure[:elements] = { type: Integer } }
-          it { expect { subject }.to raise_error /expected Integer, got String/i }
-        end
-      end
-    end
-
-    context "when object is an Hash" do
-      let(:obj) { { key1: "value1", key2: "value2", key3: "value3" } }
-      let(:structure) { { type: Hash } }
-      it { expect { subject }.not_to raise_error }
-
-      context "when given an element structure" do
-        let(:structure) { { type: Hash, elements: { key1: { type: String }, key2: { type: String }, key3: { type: String } } } }
-        it { expect { subject }.not_to raise_error }
-
-        context "which is not respected" do
-          before { obj[:key2] = {} }
-          it { expect { subject }.to raise_error /expected String, got Hash/i }
-        end
-
-        context "when missing keys" do
-          before do
-            obj.delete(:key1)
-            obj.delete(:key3)
-          end
-          it { expect { subject }.to raise_error /missing keys: key1, key3/i }
-
-          context "which are optional" do
-            before do
-              structure[:elements][:key1][:optional] = true
-              structure[:elements][:key3][:optional] = true
-            end
-            it { expect { subject }.not_to raise_error }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/bisu/source/google_sheet_spec.rb

@@ -1,43 +0,0 @@
-describe Bisu::Source::GoogleSheet do
-  subject(:to_i18) { Bisu::Source::GoogleSheet.new(url, "key name").to_i18 }
-
-  let(:url) { "https://docs.google.com/spreadsheets/d/e/2PACX-1vTm6yu_zfbxKizC-PvUE1HVFCsplmiyz0s0qLSIGeokA7KtS3BgtqaA79CsfYfPsXH6xzUaP8HDTcj8/pub?gid=0&single=true&output=csv" }
-  let(:response) { File.read("spec/fixtures/sample_google_response.csv") }
-
-  def stub_url(status:, response:)
-    stub_request(:get, url).
-      to_return(:status => status, :body => response, :headers => {})
-  end
-
-  before { stub_url(status: 200, response: response) }
-
-  it do
-    expect { to_i18 }.not_to raise_error
-  end
-
-  it "returns an hash in i18 format" do
-    expect(to_i18).to eq({
-      "en" => { "kConnectFacebook" => "Connect with Facebook", "kNoNoNoMr" => "No, no, no. Mr %{name} not here" },
-      "ja" => { "kConnectFacebook" => "フェイスブックへ接続" },
-      "fr" => { "kConnectFacebook" => "Connexion par Facebook" },
-      "de" => { "kConnectFacebook" => "Mit Facebook verbinden" },
-      "ko" => { "kConnectFacebook" => "페이스북으로 접속", "kTwitterServer" => "트위터 서버연결 실패. \\n잠시 후 재시도." }
-   })
-  end
-
-  context "when given an inexistent sheet" do
-    before { stub_url(status: 400, response: "Not Found") }
-
-    it do
-      expect { to_i18 }.to raise_error /Http Error/
-    end
-  end
-
-  context "when url content is not CSV" do
-    before { stub_url(status: 200, response: "{\"asdsa\": \"This is a json\"}") }
-
-    it do
-      expect { to_i18 }.to raise_error /Cannot parse. Expected CSV/
-    end
-  end
-end

data/spec/lib/bisu/source/one_sky_spec.rb

@@ -1,53 +0,0 @@
-describe Bisu::Source::OneSky do
-  subject(:to_i18) { Bisu::Source::OneSky.new(api_key, api_secret, project_id, file_name).to_i18 }
-
-  let(:api_key)    { "a123" }
-  let(:api_secret) { "b123" }
-  let(:project_id) { 98765 }
-  let(:file_name)  { "file456.json" }
-
-  let(:os_response) { File.read("spec/fixtures/sample_one_sky_response.json") }
-
-  def stub_multilingual(status:, response:)
-    stub_request(:get, "https://platform.api.onesky.io/1/projects/#{project_id}/translations/multilingual").
-      with(query: hash_including(api_key: api_key, file_format: "I18NEXT_MULTILINGUAL_JSON", source_file_name: file_name)).
-      to_return(:status => status, :body => response, :headers => {})
-  end
-
-  before { stub_multilingual(status: 200, response: os_response) }
-
-  it { expect { to_i18 }.not_to raise_error }
-
-  it "returns an hash in i18 format" do
-    expect(to_i18).to eq({
-      "en" => { "kConnectFacebook" => "Connect with Facebook", "kNoNoNoMr" => "No, no, no. Mr %{name} not here" },
-      "ja" => { "kConnectFacebook" => "フェイスブックへ接続" },
-      "fr" => { "kConnectFacebook" => "Connexion par Facebook" },
-      "de" => { "kConnectFacebook" => "Mit Facebook verbinden" },
-      "ko" => { "kConnectFacebook" => "페이스북으로 접속", "kTwitterServer" => "트위터 서버연결 실패. \\n잠시 후 재시도." }
-    })
-  end
-
-  context "when OneSky raises an error" do
-    before { stub_multilingual(status: 400, response: { error: "ups... not allowed!" }.to_json) }
-
-    it "raises that same error" do
-      expect { to_i18 }.to raise_error /not allowed/
-    end
-  end
-
-  context "when OneSky returns the newline bug" do
-    let(:os_response) { File.read("spec/fixtures/sample_one_sky_response_with_bug.json") }
-
-    it { expect { to_i18 }.not_to raise_error }
-
-    it "returns an hash in i18 format with the newline bug fixed" do
-      expect(to_i18).to eq({
-        "en" => {
-          "kRegularNewLine" => "This is the first line\\nthis is the second line",
-          "kErrorNewLine"   => "This is the first line\\nthis is the second line"
-        }
-      })
-    end
-  end
-end

data/spec/lib/bisu/source/tolgee_spec.rb

@@ -1,45 +0,0 @@
-describe Bisu::Source::Tolgee do
-  subject(:to_i18) { Bisu::Source::Tolgee.new(api_key).to_i18 }
-
-  let(:api_key)    { "a123" }
-  let(:os_response) { File.read("spec/fixtures/sample_tolgee_response.zip") }
-
-  def stub_url(status:, response:, host: "app.tolgee.io")
-    stub_request(:get, "https://#{host}/v2/projects/export?format=JSON&structureDelimiter=").
-      to_return(:status => status, :body => response, :headers => {})
-  end
-
-  before { stub_url(status: 200, response: os_response) }
-
-  it { expect { to_i18 }.not_to raise_error }
-
-  it "returns an hash in i18 format" do
-    expect(to_i18).to eq({
-      "en" => { "kConnectFacebook" => "Connect with Facebook", "kNoNoNoMr" => "No, no, no. Mr %{name} not here" },
-      "ja" => { "kConnectFacebook" => "フェイスブックへ接続" },
-      "fr" => { "kConnectFacebook" => "Connexion par Facebook" },
-      "de" => { "kConnectFacebook" => "Mit Facebook verbinden" },
-      "ko" => { "kConnectFacebook" => "페이스북으로 접속", "kTwitterServer" => "트위터 서버연결 실패. \\n잠시 후 재시도." }
-    })
-  end
-
-  context "when get request to that URL raises an error" do
-    before { stub_url(status: 400, response: { error: "ups... not allowed!" }.to_json) }
-
-    it "raises that same error" do
-      expect { to_i18 }.to raise_error /not allowed/
-    end
-  end
-
-  context "with a custom host" do
-    let(:host) { "translations.example.com" }
-    subject(:to_i18) { Bisu::Source::Tolgee.new(api_key, host).to_i18 }
-
-    before { stub_url(status: 200, response: os_response, host: host) }
-
-    it "uses that host" do
-      to_i18
-      expect(WebMock).to have_requested(:get, "https://translations.example.com/v2/projects/export?format=JSON&structureDelimiter=")
-    end
-  end
-end

data/spec/lib/bisu/source/url_spec.rb

@@ -1,33 +0,0 @@
-describe Bisu::Source::Url do
-  subject(:to_i18) { Bisu::Source::Url.new(url).to_i18 }
-
-  let(:url) { "https://in17n-08c12b370aeb6c66.herokuapp.com/documents/1/json?api_key=0320cd5d-1a51-4785-a832-a5bed8e62ed6" }
-  let(:os_response) { File.read("spec/fixtures/sample_json_response.json") }
-
-  def stub_url(status:, response:)
-    stub_request(:get, url).
-      to_return(:status => status, :body => response, :headers => {})
-  end
-
-  before { stub_url(status: 200, response: os_response) }
-
-  it { expect { to_i18 }.not_to raise_error }
-
-  it "returns an hash in i18 format" do
-    expect(to_i18).to eq({
-      "en" => { "kConnectFacebook" => "Connect with Facebook", "kNoNoNoMr" => "No, no, no. Mr %{name} not here" },
-      "ja" => { "kConnectFacebook" => "フェイスブックへ接続" },
-      "fr" => { "kConnectFacebook" => "Connexion par Facebook" },
-      "de" => { "kConnectFacebook" => "Mit Facebook verbinden" },
-      "ko" => { "kConnectFacebook" => "페이스북으로 접속", "kTwitterServer" => "트위터 서버연결 실패. \\n잠시 후 재시도." }
-    })
-  end
-
-  context "when get request to that URL raises an error" do
-    before { stub_url(status: 400, response: { error: "ups... not allowed!" }.to_json) }
-
-    it "raises that same error" do
-      expect { to_i18 }.to raise_error /not allowed/
-    end
-  end
-end

data/spec/lib/bisu_spec.rb

@@ -1,36 +0,0 @@
-describe Bisu do
-  subject(:run) { Bisu.run([]) }
-
-  context "when there is a translatable.yml" do
-    let(:file) { File.open("spec/fixtures/sample.translatable.yml") }
-
-    before do
-      allow(Bisu).to receive(:open_file).and_return(file)
-      allow_any_instance_of(Bisu::Source::GoogleSheet).to receive(:to_i18).and_return({
-        "english" => { "kKey" => "Value" },
-        "english-us" => { "kKey" => "Value" }
-      })
-      allow(Bisu).to receive(:localize_file)
-    end
-
-    it { expect { run }.not_to raise_error }
-
-    it "logs an error" do
-      expect {
-        run
-      }.to not_change { Bisu::Logger.summary[:warn] }
-       .and not_change { Bisu::Logger.summary[:error] }
-    end
-  end
-
-  context "when translatable.yml does not exist locally" do
-    it { expect { run }.not_to raise_error }
-
-    it "logs an error" do
-      expect {
-        run
-      }.to not_change { Bisu::Logger.summary[:warn] }
-       .and change { Bisu::Logger.summary[:error] }.by(1)
-    end
-  end
-end