lokalise_manager 2.1.0 → 3.1.0

data/spec/lib/lokalise_manager/task_definitions/base_spec.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::TaskDefinitions::Base do
-  let(:described_object) { described_class.new }
-
-  describe '.new' do
-    it 'allows to override config' do
-      obj = described_class.new token: 'fake'
-      expect(obj.config.token).to eq('fake')
-    end
-  end
-
-  describe '#config' do
-    it 'allows to update config after initialization' do
-      obj = described_class.new token: 'fake', project_id: '123'
-
-      obj.config.project_id = '345'
-
-      expect(obj.config.project_id).to eq('345')
-      expect(obj.config.token).to eq('fake')
-    end
-  end
-
-  specify '.reset_client!' do
-    expect(described_object.api_client).to be_an_instance_of(Lokalise::Client)
-    described_object.reset_api_client!
-    current_client = described_object.instance_variable_get :@api_client
-    expect(current_client).to be_nil
-  end
-
-  specify '.project_id_with_branch!' do
-    result = described_object.send :project_id_with_branch
-    expect(result).to be_an_instance_of(String)
-    expect(result).not_to include(':master')
-
-    described_object.config.branch = 'develop'
-    result = described_object.send :project_id_with_branch
-    expect(result).to be_an_instance_of(String)
-    expect(result).to include(':develop')
-  end
-
-  describe '.subdir_and_filename_for' do
-    it 'works properly for longer paths' do
-      path = 'my_path/is/here/file.yml'
-      result = described_object.send(:subdir_and_filename_for, path)
-      expect(result.length).to eq(2)
-      expect(result[0]).to be_an_instance_of(Pathname)
-      expect(result[0].to_s).to eq('my_path/is/here')
-      expect(result[1].to_s).to eq('file.yml')
-    end
-
-    it 'works properly for shorter paths' do
-      path = 'file.yml'
-      result = described_object.send(:subdir_and_filename_for, path)
-      expect(result.length).to eq(2)
-      expect(result[1]).to be_an_instance_of(Pathname)
-      expect(result[0].to_s).to eq('.')
-      expect(result[1].to_s).to eq('file.yml')
-    end
-  end
-
-  describe '.check_options_errors!' do
-    it 'raises an error when the API key is not set' do
-      allow(LokaliseManager::GlobalConfig).to receive(:api_token).and_return(nil)
-
-      expect(-> { described_object.send(:check_options_errors!) }).to raise_error(LokaliseManager::Error, /API token is not set/i)
-
-      expect(LokaliseManager::GlobalConfig).to have_received(:api_token)
-    end
-
-    it 'returns an error when the project_id is not set' do
-      allow_project_id described_object, nil do
-        expect(-> { described_object.send(:check_options_errors!) }).to raise_error(LokaliseManager::Error, /ID is not set/i)
-      end
-    end
-  end
-
-  describe '.proper_ext?' do
-    it 'works properly with path represented as a string' do
-      path = 'my_path/here/file.yml'
-      expect(described_object.send(:proper_ext?, path)).to be true
-    end
-
-    it 'works properly with path represented as a pathname' do
-      path = Pathname.new 'my_path/here/file.json'
-      expect(described_object.send(:proper_ext?, path)).to be false
-    end
-  end
-
-  describe '.api_client' do
-    it 'is possible to set timeouts' do
-      allow(described_object.config).to receive(:timeouts).and_return({
-                                                                        open_timeout: 100,
-                                                                        timeout: 500
-                                                                      })
-
-      client = described_object.api_client
-      expect(client).to be_an_instance_of(Lokalise::Client)
-      expect(client).not_to be_an_instance_of(Lokalise::OAuthClient)
-      expect(client.open_timeout).to eq(100)
-      expect(client.timeout).to eq(500)
-    end
-
-    it 'uses .oauth_client when the use_oauth2_token is true' do
-      allow(described_object.config).to receive(:use_oauth2_token).and_return(true)
-
-      client = described_object.api_client
-
-      expect(client).to be_an_instance_of(Lokalise::OAuthClient)
-      expect(client).not_to be_an_instance_of(Lokalise::Client)
-    end
-  end
-end

data/spec/lib/lokalise_manager/task_definitions/exporter_spec.rb

@@ -1,240 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-describe LokaliseManager::TaskDefinitions::Exporter do
-  let(:filename) { 'en.yml' }
-  let(:path) { "#{Dir.getwd}/locales/nested/#{filename}" }
-  let(:relative_name) { "nested/#{filename}" }
-  let(:project_id) { ENV['LOKALISE_PROJECT_ID'] }
-  let(:described_object) do
-    described_class.new project_id: project_id,
-                        api_token: ENV['LOKALISE_API_TOKEN'],
-                        max_retries_export: 2
-  end
-
-  context 'with many translation files' do
-    before :all do
-      add_translation_files! with_ru: true, additional: 5
-    end
-
-    after :all do
-      rm_translation_files
-    end
-
-    describe '.export!' do
-      it 'sends a proper API request and handles rate limiting' do
-        process = nil
-
-        VCR.use_cassette('upload_files_multiple') do
-          expect(-> { process = described_object.export!.first.process }).to output(/complete!/).to_stdout
-        end
-
-        expect(process.project_id).to eq(project_id)
-        expect(process.status).to eq('queued')
-      end
-
-      it 'handles too many requests' do
-        allow(described_object.config).to receive(:max_retries_export).and_return(1)
-        allow(described_object).to receive(:sleep).and_return(0)
-
-        fake_client = instance_double('Lokalise::Client')
-        allow(fake_client).to receive(:token).with(any_args).and_return('fake_token')
-        allow(fake_client).to receive(:upload_file).with(any_args).and_raise(Lokalise::Error::TooManyRequests)
-        allow(described_object).to receive(:api_client).and_return(fake_client)
-
-        expect(-> { described_object.export! }).to raise_error(Lokalise::Error::TooManyRequests, /Gave up after 1 retries/i)
-
-        expect(described_object).to have_received(:sleep).exactly(6).times
-        expect(described_object).to have_received(:api_client).at_least(12).times
-        expect(fake_client).to have_received(:upload_file).exactly(12).times
-      end
-
-      it 'handles too many requests but does not re-raise anything when raise_on_export_fail is false' do
-        allow(described_object.config).to receive(:max_retries_export).and_return(1)
-        allow(described_object.config).to receive(:raise_on_export_fail).and_return(false)
-        allow(described_object).to receive(:sleep).and_return(0)
-
-        fake_client = instance_double('Lokalise::Client')
-        allow(fake_client).to receive(:token).with(any_args).and_return('fake_token')
-        allow(fake_client).to receive(:upload_file).with(any_args).and_raise(Lokalise::Error::TooManyRequests)
-        allow(described_object).to receive(:api_client).and_return(fake_client)
-        processes = []
-        expect(-> { processes = described_object.export! }).not_to raise_error
-
-        expect(processes[0].path.to_s).to include('en_0')
-        expect(processes[0].success).to be false
-        expect(processes[1].error.class).to eq(Lokalise::Error::TooManyRequests)
-        expect(processes.count).to eq(7)
-
-        expect(described_object).to have_received(:sleep).exactly(7).times
-        expect(described_object).to have_received(:api_client).at_least(14).times
-        expect(fake_client).to have_received(:upload_file).exactly(14).times
-      end
-    end
-  end
-
-  context 'with one translation file' do
-    before :all do
-      add_translation_files!
-    end
-
-    after :all do
-      rm_translation_files
-    end
-
-    describe '.export!' do
-      it 'sends a proper API request but does not output anything when silent_mode is enabled' do
-        allow(described_object.config).to receive(:silent_mode).and_return(true)
-
-        process = nil
-
-        VCR.use_cassette('upload_files') do
-          expect(-> { process = described_object.export!.first.process }).not_to output(/complete!/).to_stdout
-        end
-
-        expect(process.status).to eq('queued')
-        expect(described_object.config).to have_received(:silent_mode).at_most(1).times
-      end
-
-      it 'sends a proper API request' do
-        process = VCR.use_cassette('upload_files') do
-          described_object.export!
-        end.first.process
-
-        expect(process.project_id).to eq(project_id)
-        expect(process.status).to eq('queued')
-      end
-
-      it 'sends a proper API request when a different branch is provided' do
-        allow(described_object.config).to receive(:branch).and_return('develop')
-
-        process_data = VCR.use_cassette('upload_files_branch') do
-          described_object.export!
-        end.first
-
-        expect(described_object.config).to have_received(:branch).at_most(2).times
-        expect(process_data.success).to be true
-        expect(process_data.path.to_s).to include('en.yml')
-
-        process = process_data.process
-        expect(process).to be_an_instance_of(Lokalise::Resources::QueuedProcess)
-        expect(process.project_id).to eq(project_id)
-        expect(process.status).to eq('queued')
-      end
-
-      it 'halts when the API key is not set' do
-        allow(described_object.config).to receive(:api_token).and_return(nil)
-
-        expect(-> { described_object.export! }).to raise_error(LokaliseManager::Error, /API token is not set/i)
-        expect(described_object.config).to have_received(:api_token)
-      end
-
-      it 'halts when the project_id is not set' do
-        allow_project_id described_object, nil do
-          expect(-> { described_object.export! }).to raise_error(LokaliseManager::Error, /ID is not set/i)
-        end
-      end
-    end
-
-    describe '#all_files' do
-      it 'yield proper arguments' do
-        expect(described_object.send(:all_files).first).to include(
-          Pathname.new(path),
-          Pathname.new(relative_name)
-        )
-      end
-    end
-
-    describe '.opts' do
-      let(:base64content) { Base64.strict_encode64(File.read(path).strip) }
-
-      it 'generates proper options' do
-        resulting_opts = described_object.send(:opts, path, relative_name)
-
-        expect(resulting_opts[:data]).to eq(base64content)
-        expect(resulting_opts[:filename]).to eq(relative_name)
-        expect(resulting_opts[:lang_iso]).to eq('en')
-      end
-
-      it 'allows to redefine options' do
-        allow(described_object.config).to receive(:export_opts).and_return({
-                                                                             detect_icu_plurals: true,
-                                                                             convert_placeholders: true
-                                                                           })
-
-        resulting_opts = described_object.send(:opts, path, relative_name)
-
-        expect(described_object.config).to have_received(:export_opts)
-        expect(resulting_opts[:data]).to eq(base64content)
-        expect(resulting_opts[:filename]).to eq(relative_name)
-        expect(resulting_opts[:lang_iso]).to eq('en')
-        expect(resulting_opts[:detect_icu_plurals]).to be true
-        expect(resulting_opts[:convert_placeholders]).to be true
-      end
-    end
-  end
-
-  context 'with two translation files' do
-    let(:filename_ru) { 'ru.yml' }
-    let(:path_ru) { "#{Dir.getwd}/locales/#{filename_ru}" }
-
-    before :all do
-      add_translation_files! with_ru: true
-    end
-
-    after :all do
-      rm_translation_files
-    end
-
-    describe '.export!' do
-      it 're-raises export errors' do
-        allow_project_id described_object, '542886116159f798720dc4.94769464'
-
-        VCR.use_cassette('upload_files_error') do
-          expect { described_object.export! }.to raise_error(Lokalise::Error::BadRequest, /Unknown `lang_iso`/)
-        end
-      end
-    end
-
-    describe '.opts' do
-      let(:base64content_ru) { Base64.strict_encode64(File.read(path_ru).strip) }
-
-      it 'generates proper options' do
-        resulting_opts = described_object.send(:opts, path_ru, filename_ru)
-
-        expect(resulting_opts[:data]).to eq(base64content_ru)
-        expect(resulting_opts[:filename]).to eq(filename_ru)
-        expect(resulting_opts[:lang_iso]).to eq('ru_RU')
-      end
-    end
-
-    describe '#each_file' do
-      it 'returns all files' do
-        files = described_object.send(:all_files)
-        expect(files[0]).to include(
-          Pathname.new(path),
-          Pathname.new(relative_name)
-        )
-        expect(files[1]).to include(
-          Pathname.new(path_ru),
-          Pathname.new(filename_ru)
-        )
-      end
-
-      it 'does not return files that have to be skipped' do
-        allow(described_object.config).to receive(:skip_file_export).twice.and_return(
-          ->(f) { f.split[1].to_s.include?('ru') }
-        )
-        files = described_object.send(:all_files)
-        expect(files[0]).to include(
-          Pathname.new(path),
-          Pathname.new(relative_name)
-        )
-        expect(files.count).to eq(1)
-
-        expect(described_object.config).to have_received(:skip_file_export).twice
-      end
-    end
-  end
-end

data/spec/lib/lokalise_manager/task_definitions/importer_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::TaskDefinitions::Importer do
-  let(:described_object) do
-    described_class.new project_id: project_id,
-                        api_token: ENV['LOKALISE_API_TOKEN'],
-                        max_retries_import: 2
-  end
-  let(:loc_path) { described_object.config.locales_path }
-  let(:project_id) { ENV['LOKALISE_PROJECT_ID'] }
-  let(:local_trans) { "#{Dir.getwd}/spec/fixtures/trans.zip" }
-
-  describe '#open_and_process_zip' do
-    it 're-raises errors during file processing' do
-      entry = double
-      allow(entry).to receive(:name).and_return('fail.yml')
-      allow(described_object).to receive(:data_from).with(entry).and_raise(EncodingError)
-      expect(-> { described_object.send(:process!, entry) }).
-        to raise_error(EncodingError, /Error when trying to process fail\.yml/)
-
-      expect(described_object).to have_received(:data_from)
-    end
-
-    it 're-raises errors during file opening' do
-      expect(-> { described_object.send(:open_and_process_zip, 'http://fake.url/wrong/path.zip') }).
-        to raise_error(SocketError, /Failed to open TCP connection/)
-    end
-  end
-
-  describe '#download_files' do
-    it 'returns a proper download URL' do
-      response = VCR.use_cassette('download_files') do
-        described_object.send :download_files
-      end
-
-      expect(response['project_id']).to eq('672198945b7d72fc048021.15940510')
-      expect(response['bundle_url']).to include('s3-eu-west-1.amazonaws.com')
-      expect(described_object.api_client.enable_compression).to eq(true)
-    end
-
-    it 're-raises errors during file download' do
-      allow_project_id described_object, 'invalid'
-
-      VCR.use_cassette('download_files_error') do
-        expect(-> { described_object.send :download_files }).
-          to raise_error(Lokalise::Error::BadRequest, /Invalid `project_id` parameter/)
-      end
-    end
-  end
-
-  describe '.import!' do
-    context 'with errors' do
-      it 'handles too many requests' do
-        allow(described_object).to receive(:sleep).and_return(0)
-
-        fake_client = instance_double('Lokalise::Client')
-        allow(fake_client).to receive(:download_files).and_raise(Lokalise::Error::TooManyRequests)
-        allow(described_object).to receive(:api_client).and_return(fake_client)
-
-        expect(-> { described_object.import! }).to raise_error(Lokalise::Error::TooManyRequests, /Gave up after 2 retries/i)
-
-        expect(described_object).to have_received(:sleep).exactly(2).times
-        expect(described_object).to have_received(:api_client).exactly(3).times
-        expect(fake_client).to have_received(:download_files).exactly(3).times
-      end
-
-      it 'halts when the API key is not set' do
-        allow(described_object.config).to receive(:api_token).and_return(nil)
-        expect(-> { described_object.import! }).to raise_error(LokaliseManager::Error, /API token is not set/i)
-        expect(described_object.config).to have_received(:api_token)
-        expect(count_translations).to eq(0)
-      end
-
-      it 'halts when the project_id is not set' do
-        allow_project_id described_object, nil do
-          expect(-> { described_object.import! }).to raise_error(LokaliseManager::Error, /ID is not set/i)
-          expect(count_translations).to eq(0)
-        end
-      end
-    end
-
-    context 'when directory is empty' do
-      before do
-        mkdir_locales
-        rm_translation_files
-      end
-
-      after :all do
-        rm_translation_files
-      end
-
-      it 'runs import successfully for local files' do
-        allow(described_object).to receive(:download_files).and_return(
-          {
-            'project_id' => '123.abc',
-            'bundle_url' => local_trans
-          }
-        )
-
-        expect(described_object.import!).to be true
-
-        expect(count_translations).to eq(4)
-        expect(described_object).to have_received(:download_files)
-        expect_file_exist loc_path, 'en/nested/main_en.yml'
-        expect_file_exist loc_path, 'en/nested/deep/secondary_en.yml'
-        expect_file_exist loc_path, 'ru/main_ru.yml'
-      end
-
-      it 'runs import successfully' do
-        result = nil
-
-        VCR.use_cassette('import') do
-          expect(-> { result = described_object.import! }).to output(/complete!/).to_stdout
-        end
-
-        expect(result).to be true
-
-        expect(count_translations).to eq(24)
-        expect_file_exist loc_path, 'en_1.yml'
-        expect_file_exist loc_path, 'ru_2.yml'
-      end
-
-      it 'runs import successfully but does not provide any output when silent_mode is enabled' do
-        allow(described_object.config).to receive(:silent_mode).and_return(true)
-        result = nil
-
-        VCR.use_cassette('import') do
-          expect(-> { result = described_object.import! }).not_to output(/complete!/).to_stdout
-        end
-
-        expect(result).to be true
-        expect_file_exist loc_path, 'en_1.yml'
-        expect_file_exist loc_path, 'ru_2.yml'
-        expect(described_object.config).to have_received(:silent_mode).at_most(1).times
-      end
-    end
-
-    context 'when directory is not empty and safe mode enabled' do
-      let(:safe_mode_obj) do
-        described_class.new project_id: project_id,
-                            api_token: ENV['LOKALISE_API_TOKEN'],
-                            import_safe_mode: true
-      end
-
-      before :all do
-        mkdir_locales
-      end
-
-      before do
-        rm_translation_files
-        add_translation_files!
-      end
-
-      after :all do
-        rm_translation_files
-      end
-
-      it 'import proceeds when the user agrees' do
-        allow(safe_mode_obj).to receive(:download_files).and_return(
-          {
-            'project_id' => '123.abc',
-            'bundle_url' => local_trans
-          }
-        )
-
-        allow($stdin).to receive(:gets).and_return('Y')
-        expect(-> { safe_mode_obj.import! }).to output(/is not empty/).to_stdout
-
-        expect(count_translations).to eq(5)
-        expect($stdin).to have_received(:gets)
-        expect(safe_mode_obj).to have_received(:download_files)
-        expect_file_exist loc_path, 'en/nested/main_en.yml'
-        expect_file_exist loc_path, 'en/nested/deep/secondary_en.yml'
-        expect_file_exist loc_path, 'ru/main_ru.yml'
-      end
-
-      it 'import halts when a user chooses not to proceed' do
-        allow(safe_mode_obj).to receive(:download_files).at_most(0).times
-        allow($stdin).to receive(:gets).and_return('N')
-        expect(-> { safe_mode_obj.import! }).to output(/cancelled/).to_stdout
-
-        expect(safe_mode_obj).not_to have_received(:download_files)
-        expect($stdin).to have_received(:gets)
-        expect(count_translations).to eq(1)
-      end
-
-      it 'import halts when a user chooses not to proceed and debug info is not printed out when silent_mode is enabled' do
-        allow(safe_mode_obj.config).to receive(:silent_mode).and_return(true)
-        allow(safe_mode_obj).to receive(:download_files).at_most(0).times
-        allow($stdin).to receive(:gets).and_return('N')
-        expect(-> { safe_mode_obj.import! }).not_to output(/cancelled/).to_stdout
-
-        expect(safe_mode_obj).not_to have_received(:download_files)
-        expect(safe_mode_obj.config).to have_received(:silent_mode)
-        expect($stdin).to have_received(:gets)
-        expect(count_translations).to eq(1)
-      end
-    end
-  end
-end

data/spec/lib/lokalise_manager_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager do
-  it 'returns a proper version' do
-    expect(described_class::VERSION).to be_a(String)
-  end
-
-  specify '.importer' do
-    expect(described_class.importer).to be_a(LokaliseManager::TaskDefinitions::Importer)
-  end
-
-  specify '.exporter' do
-    expect(described_class.exporter).to be_a(LokaliseManager::TaskDefinitions::Exporter)
-  end
-end

data/spec/lib/utils/array_utils_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::Utils::ArrayUtils do
-  using described_class
-  let(:arr) { (1..8).to_a }
-
-  describe '#in_groups_of' do
-    it 'raises an exception when the number is less than 1' do
-      expect(-> { arr.in_groups_of(-1) }).to raise_error(ArgumentError)
-    end
-
-    it 'uses collection itself if fill_with is false' do
-      enum = arr.in_groups_of(5, false)
-      enum.next
-      expect(enum.next.count).to eq(3)
-    end
-  end
-end

data/spec/lib/utils/hash_utils_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::Utils::HashUtils do
-  using described_class
-  let(:h1) { {a: 100, b: 200, c: {c1: 100}} }
-  let(:h2) { {b: 250, c: {c1: 200}} }
-
-  specify '#deep_merge' do
-    result = h1.deep_merge(h2) { |_key, this_val, other_val| this_val + other_val }
-    expect(result[:b]).to eq(450)
-    expect(result[:c][:c1]).to eq(300)
-  end
-end

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'dotenv/load'
-require 'simplecov'
-
-SimpleCov.start do
-  add_filter 'spec/'
-  add_filter '.github/'
-end
-
-if ENV['CI'] == 'true'
-  require 'codecov'
-  SimpleCov.formatter = SimpleCov::Formatter::Codecov
-end
-
-require 'lokalise_manager'
-
-# Support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.include FileManager
-  config.include SpecAddons
-end

data/spec/support/file_manager.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-
-module FileManager
-  def mkdir_locales
-    FileUtils.mkdir_p(LokaliseManager::GlobalConfig.locales_path) unless File.directory?(LokaliseManager::GlobalConfig.locales_path)
-  end
-
-  def rm_translation_files
-    FileUtils.rm_rf locales_dir
-  end
-
-  def locales_dir
-    Dir["#{LokaliseManager::GlobalConfig.locales_path}/**/*"]
-  end
-
-  def count_translations
-    locales_dir.count { |file| File.file?(file) }
-  end
-
-  def add_translation_files!(with_ru: false, additional: nil)
-    FileUtils.mkdir_p "#{Dir.getwd}/locales/nested"
-    open_and_write('locales/nested/en.yml') { |f| f.write en_data }
-
-    return unless with_ru
-
-    open_and_write('locales/ru.yml') { |f| f.write ru_data }
-
-    return unless additional
-
-    additional.times do |i|
-      data = {'en' => {"key_#{i}" => "value #{i}"}}
-
-      open_and_write("locales/en_#{i}.yml") { |f| f.write data.to_yaml }
-    end
-  end
-
-  def open_and_write(rel_path, &block)
-    return unless block
-
-    File.open("#{Dir.getwd}/#{rel_path}", 'w+:UTF-8', &block)
-  end
-
-  private
-
-  def en_data
-    <<~DATA
-      en:
-        my_key: "My value"
-        nested:
-          key: "Value 2"
-    DATA
-  end
-
-  def ru_data
-    <<~DATA
-      ru_RU:
-        my_key: "Моё значение"
-        nested:
-          key: "Значение 2"
-    DATA
-  end
-end