lokalise_rails 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ac898ae13038db9d3426f367e3cba3b54c41e35797dfb56dd5da5595959e728
-  data.tar.gz: 2bf9f24929b226b8994b3f4648f67b5da59aa0b68687cb7f597f531ac2d7bb99
+  metadata.gz: 3dc5e8a5807db8316b7b60606b5e32274d669504f12917022e0fbaba3f0969db
+  data.tar.gz: 2c54267a133e24cef62019185d2063b09b3c57bd26bca4ee28364ab2c05f6c21
 SHA512:
-  metadata.gz: 93be5d1f8379908fbf6e3ac7a1f44534373779d8aa3e375f456ef7a83454a07babe3971aa364afe374759e54571d036c60c68e16f14c81397128770573058a9a
-  data.tar.gz: 84c42e122da897f7103a16d11e9a5e066cee28c2b6413c44ec3e459868dfe89d8c5005f3fa644024bea7dfd7c49233de5fecc67746016485f467febe91b3fa52
+  metadata.gz: 21a740e73e2d2bdef702ed8ebf719b60b70474a3503428b05131ddfe0443cc21bf0750203ee9aee9c0b47b1d75ebaa200db7b47a934204d9fe800d3f2c66e1d3
+  data.tar.gz: 44288cec4fc4a95c95780bfe4e00f7efc23d23a07e94dd3c2bc885ef8ee4de309ade9555291aa6a8ae56a8bb99487c2a9982f026f54794e50e08acea3c93e038

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 3.0.0 (14-Oct-21)
+
+This is a major re-write of this gem. The actual import/export functionality was extracted to a separate gem called [lokalise_manager](https://github.com/bodrovis/lokalise_manager) that you can use to run your tasks programmatically from *any* Ruby scripts (powered or not powered by Rails). LokaliseRails now has only the Rails-related logic (even though it should probably work with other frameworks as well).
+
+* **Breaking change:** the global config class is renamed therefore update your `config/lokalise_rails.rb` file to look like this:
+
+```ruby
+LokaliseRails::GlobalConfig.config do |c|
+  # ...your configuration options provided as before...
+end
+```
+
+* **Breaking change**: the `branch` config option now has `""` set as default value (it was `"master"` previously). Therefore, you might need to explicitly state which branch to use now:
+
+```ruby
+LokaliseRails::GlobalConfig.config do |c|
+  c.branch = "master"
+end
+```
+
+* **Breaking change**: to run your task prommatically, use a new approach:
+
+```ruby
+LokaliseManager.importer(optional_config, global_config_object).import!
+
+LokaliseManager.exporter(optional_config, global_config_object).export!
+```
+
+* Please check [this document section](https://github.com/bodrovis/lokalise_rails#running-tasks-programmatically) to learn more about running tasks programmatically. This change doesn't have any effect on you if you're using only Rake tasks to import/export files.
+* No need to say `require 'lokalise_rails` in your `lokalise_rails.rb` config file anymore.
+
 ## 2.0.0 (19-Aug-21)
 
 * Add exponential backoff mechanism for file imports to comply with the upcoming API changes ("rate limiting"), see below for more details.

data/README.md

@@ -5,7 +5,7 @@
 [![Test Coverage](https://codecov.io/gh/bodrovis/lokalise_rails/graph/badge.svg)](https://codecov.io/gh/bodrovis/lokalise_rails)
 ![Downloads total](https://img.shields.io/gem/dt/lokalise_rails)
 
-This gem provides [Lokalise](http://lokalise.com) integration for Ruby on Rails and allows to exchange translation files easily. It relies on [ruby-lokalise-api](https://lokalise.github.io/ruby-lokalise-api) to send APIv2 requests.
+This gem provides [Lokalise](http://lokalise.com) integration for Ruby on Rails and allows to exchange translation files easily. It relies on [lokalise_manager](https://github.com/bodrovis/lokalise_manager) which perform the actual import/export and can be used to run this task in any Ruby script.
 
 *If you would like to know how this gem was built, check out the ["How to create a Ruby gem" series at Lokalise blog](https://lokalise.com/blog/create-a-ruby-gem-basics/).*
 
@@ -33,9 +33,7 @@ rails g lokalise_rails:install
 The latter command will generate a new config file `config/lokalise_rails.rb` looking like this:
 
 ```ruby
-require 'lokalise_rails'
-
-LokaliseRails.config do |c|
+LokaliseRails::GlobalConfig.config do |c|
   c.api_token = ENV['LOKALISE_API_TOKEN']
   c.project_id = ENV['LOKALISE_PROJECT_ID']
 
@@ -45,7 +43,7 @@ end
 
 You have to provide `api_token` and `project_id` to proceed. `project_id` can be found in your Lokalise project settings.
 
-[Other options can be customized as well (see below)](https://github.com/bodrovis/lokalise_rails#import-settings) but they have sensible defaults.
+Other options can be customized as well but they have sensible defaults. To learn about all the available options please check [lokalise_manager docs](https://github.com/bodrovis/lokalise_manager#configuration). The generated config file also contains some examples to help you get started.
 
 ## Importing translations from Lokalise
 
@@ -55,7 +53,7 @@ To import translations from the specified Lokalise project to your Rails app, ru
 rails lokalise_rails:import
 ```
 
-Please note that any duplicating files inside the `locales` directory (or any other directory that you've specified in the options) will be overwritten! You may enable [safe mode](https://github.com/bodrovis/lokalise_rails#import-settings) to check whether the folder is empty or not.
+Please note that any duplicating files inside the `locales` directory (or any other directory that you've specified in the options) will be overwritten! You can enable [safe mode](https://github.com/bodrovis/lokalise_manager#import-config) to check whether the folder is empty or not.
 
 ## Exporting translations to Lokalise
 
@@ -67,84 +65,101 @@ rails lokalise_rails:export
 
 ## Running tasks programmatically
 
-You can also run the import and export tasks from the Rails app:
+You can also run the import and export tasks programmatically from your code. To achieve that, please check the [`lokalise_manager`](https://github.com/bodrovis/lokalise_manager) gem which `lokalise_rails` relies on.
+
+For example, you can use the following approach:
 
 ```ruby
+# This line is actually not required. Include it if you would like to use your global settings:
 require "#{Rails.root}/config/lokalise_rails.rb"
 
-# Import the files:
-result = LokaliseRails::TaskDefinition::Importer.import!
+importer = LokaliseManager.importer({api_token: '1234abc', project_id: '123.abc'}, LokaliseRails::GlobalConfig)
+
+# OR
+
+exporter = LokaliseManager.exporter({api_token: '1234abc', project_id: '123.abc'}, LokaliseRails::GlobalConfig)
 ```
-`result` contains a boolean value with the result of the operation
+
+The first argument passed to `importer` or `exporter` is the hash containing per-client options. This is an optional argument and you can simply pass an empty hash if you don't want to override any global settings.
+
+The second argument is the name of your global config which is usually stored inside the `lokalise_rails.rb` file (however, you can subclass this global config and even adjust the defaults [as explained here](https://github.com/bodrovis/lokalise_manager#overriding-defaults)). If you would like to use `LokaliseRails` global defaults, then you must pass this class to the clients. If you don't do this, then `LokaliseManager` defaults will be used instead. The only difference is the location where translation files are stored. For `LokaliseManager` we use `./locales` directory, whereas for `LokaliseRails` the directory is `./config/locales`.
+
+However, you can also provide the translation files folder on per-client basis, for instance:
 
 ```ruby
-# Export the files:
-processes = LokaliseRails::TaskDefinition::Exporter.export!
+importer = LokaliseManager.importer api_token: '1234abc', project_id: '123.abc', locales_path: "#{Rails.root}/config/locales"
 ```
 
-`processes` contains a list of [queued background processes](https://lokalise.github.io/ruby-lokalise-api/api/queued-processes).
+After the client is instantiated, you can run the corresponding task:
 
-## Configuration
+```ruby
+importer.import!
 
-Options are specified in the `config/lokalise_rails.rb` file.
+# OR 
 
-### Global settings
+exporter.export!
+```
 
-* `api_token` (`string`, required) - Lokalise API token with read/write permissions.
-* `project_id` (`string`, required) - Lokalise project ID. You must have import/export permissions in the specified project.
-* `locales_path` (`string`) - path to the directory with your translation files. Defaults to `"#{Rails.root}/config/locales"`.
-* `branch` (`string`) - Lokalise project branch to use. Defaults to `"master"`.
-* `timeouts` (`hash`) - set [request timeouts for the Lokalise API client](https://lokalise.github.io/ruby-lokalise-api/additional_info/customization#setting-timeouts). By default, requests have no timeouts: `{open_timeout: nil, timeout: nil}`. Both values are in seconds.
+## Configuration
 
-### Import settings
+Options are specified in the `config/lokalise_rails.rb` file.
 
-* `import_opts` (`hash`) - options that will be passed to Lokalise API when downloading translations to your app. Here are the default options:
+Here's an example:
 
 ```ruby
-{
-  format: 'yaml',
-  placeholder_format: :icu,
-  yaml_include_root: true,
-  original_filenames: true,
-  directory_prefix: '',
-  indentation: '2sp'
-}
-```
+LokaliseRails::GlobalConfig.config do |c|
+  # These are mandatory options that you must set before running rake tasks:
+  c.api_token = ENV['LOKALISE_API_TOKEN']
+  c.project_id = ENV['LOKALISE_PROJECT_ID']
 
-Full list of available import options [can be found in the official API documentation](https://app.lokalise.com/api2docs/curl/#transition-download-files-post).
-* `import_safe_mode` (`boolean`) - default to `false`. When this option is enabled, the import task will check whether the directory set with `locales_path` is empty or not. If it is not empty, you will be prompted to continue.
-* `max_retries_import` (`integer`) - this option is introduced to properly handle Lokalise API rate limiting. If the HTTP status code 429 (too many requests) has been received, LokaliseRails will apply an exponential backoff mechanism with a very simple formula: `2 ** retries`. If the maximum number of retries has been reached, a `Lokalise::Error::TooManyRequests` exception will be raised and the export operation will be halted.
+  # Provide a custom path to the directory with your translation files:
+  # c.locales_path = "#{Rails.root}/config/locales"
 
-### Export settings
+  # Provide a Lokalise project branch to use:
+  c.branch = 'develop'
 
-* `export_opts` (`hash`) - options that will be passed to Lokalise API when uploading translations. Full list of available export options [can be found in the official documentation](https://app.lokalise.com/api2docs/curl/#transition-download-files-post). By default, the following options are provided:
-  + `data` (`string`, required) - base64-encoded contents of the translation file.
-  + `filename` (`string`, required) - translation file name. If the file is stored under a subdirectory (for example, `nested/en.yml` inside the `locales/` directory), the whole path acts as a name. Later when importing files with such names, they will be placed into the proper subdirectories.
-  + `lang_iso` (`string`, required) - language ISO code which is determined using the root key inside your YAML file. For example, in this case the `lang_iso` is `en_US`:
+  # Provide request timeouts for the Lokalise API client:
+  c.timeouts = {open_timeout: 5, timeout: 5}
 
-```yaml
-en_US:
-  my_key: "my value"
-```
+  # Provide maximum number of retries for file exporting:
+  c.max_retries_export = 5
 
-**Please note** that if your Lokalise project does not have a language with the specified `lang_iso` code, the export will fail.
+  # Provide maximum number of retries for file importing:
+  c.max_retries_import = 5
 
-* `skip_file_export` (`lambda` or `proc`) - specify additional exclusion criteria for the exported files. By default, the rake task will ignore all non-file entries and all files with improper extensions (the latter is controlled by the `file_ext_regexp`). Lambda passed to this option should accept a single argument which is full path to the file (instance of the [`Pathname` class](https://ruby-doc.org/stdlib-2.7.1/libdoc/pathname/rdoc/Pathname.html)). For example, to exclude all files that have `fr` part in their names, add the following config:
+  # Import options have the following defaults:
+  # c.import_opts = {
+  #   format: 'yaml',
+  #   placeholder_format: :icu,
+  #   yaml_include_root: true,
+  #   original_filenames: true,
+  #   directory_prefix: '',
+  #   indentation: '2sp'
+  # }
 
-```ruby
-c.skip_file_export = ->(file) { f.split[1].to_s.include?('fr') }
-```
+  # Safe mode for imports is disabled by default:
+  # c.import_safe_mode = false
+
+  # Additional export options (only filename, contents, and lang_iso params are provided by default)
+  # c.export_opts = {}
+
+  # Provide additional file exclusion criteria for exports (by default, any file with the proper extension will be exported)
+  # c.skip_file_export = ->(file) { file.split[1].to_s.include?('fr') }
 
-* `max_retries_export` (`integer`) - this option is introduced to properly handle Lokalise API rate limiting. If the HTTP status code 429 (too many requests) has been received, LokaliseRails will apply an exponential backoff mechanism with a very simple formula: `2 ** retries` (initially `retries` is `0`). If the maximum number of retries has been reached, a `Lokalise::Error::TooManyRequests` exception will be raised and the export operation will be halted. By default, LokaliseRails will make up to `5` retries which potentially means `1 + 2 + 4 + 8 + 16 + 32 = 63` seconds of waiting time. If the `max_retries_export` is less than `1`, LokaliseRails will not perform any retries and give up immediately after receiving error 429.
+  # Set the options below if you would like to work with format other than YAML
+  ## Regular expression to use when choosing the files to extract from the downloaded archive and upload to Lokalise
+  ## c.file_ext_regexp = /\.ya?ml\z/i
 
-### Settings to work with formats other than YAML
+  ## Load translations data and make sure they are valid:
+  ## c.translations_loader = ->(raw_data) { YAML.safe_load raw_data }
 
-If your translation files are not in YAML format, you will need to adjust the following options:
+  ## Convert translations data to a proper format:
+  ## c.translations_converter = ->(raw_data) { raw_data.to_yaml }
 
-* `file_ext_regexp` (`regexp`) - regular expression applied to file extensions to determine which files should be imported and exported. Defaults to `/\.ya?ml\z/i` (YAML files).
-* `translations_loader` (`lambda` or `proc`) - loads translations data and makes sure they are valid before saving them to a translation file. Defaults to `->(raw_data) { YAML.safe_load raw_data }`. In the simplest case you may just return the data back, for example `-> (raw_data) { raw_data }`.
-* `translations_converter` (`lambda` or `proc`) - converts translations data to a proper format before saving them to a translation file. Defaults to `->(raw_data) { raw_data.to_yaml }`. In the simplest case you may just return the data back, for example `-> (raw_data) { raw_data }`.
-* `lang_iso_inferer` (`lambda` or `proc`) - infers language ISO code based on the translation file data before uploading it to Lokalise. Defaults to `->(data) { YAML.safe_load(data)&.keys&.first }`.
+  ## Infer language ISO code for the translation file:
+  ## c.lang_iso_inferer = ->(data) { YAML.safe_load(data)&.keys&.first }
+end
+```
 
 ## Running tests
 

data/lib/generators/templates/lokalise_rails_config.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'lokalise_rails'
-
-LokaliseRails.config do |c|
+LokaliseRails::GlobalConfig.config do |c|
   # These are mandatory options that you must set before running rake tasks:
   # c.api_token = ENV['LOKALISE_API_TOKEN']
   # c.project_id = ENV['LOKALISE_PROJECT_ID']
@@ -11,7 +9,7 @@ LokaliseRails.config do |c|
   # c.locales_path = "#{Rails.root}/config/locales"
 
   # Provide a Lokalise project branch to use:
-  # c.branch = 'master'
+  # c.branch = ''
 
   # Provide request timeouts for the Lokalise API client:
   # c.timeouts = {open_timeout: nil, timeout: nil}

data/lib/lokalise_rails/global_config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LokaliseRails
+  class GlobalConfig < LokaliseManager::GlobalConfig
+    class << self
+      def locales_path
+        @locales_path || "#{LokaliseRails::Utils.root}/config/locales"
+      end
+    end
+  end
+end

data/lib/lokalise_rails/utils.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module LokaliseRails
+  module Utils
+    class << self
+      def root
+        Pathname.new(rails_root || Dir.getwd)
+      end
+
+      def rails_root
+        return ::Rails.root.to_s if defined?(::Rails.root) && ::Rails.root
+        return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
+
+        nil
+      end
+    end
+  end
+end

data/lib/lokalise_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LokaliseRails
-  VERSION = '2.0.0'
+  VERSION = '3.0.0'
 end

data/lib/lokalise_rails.rb

@@ -1,94 +1,11 @@
 # frozen_string_literal: true
 
-require 'lokalise_rails/error'
-require 'lokalise_rails/task_definition/base'
-require 'lokalise_rails/task_definition/importer'
-require 'lokalise_rails/task_definition/exporter'
+require 'lokalise_manager'
 
-module LokaliseRails
-  class << self
-    attr_accessor :api_token, :project_id
-    attr_writer :import_opts, :import_safe_mode, :export_opts, :locales_path,
-                :file_ext_regexp, :skip_file_export, :branch, :timeouts,
-                :translations_loader, :translations_converter, :lang_iso_inferer,
-                :max_retries_export, :max_retries_import
-
-    # Main interface to provide configuration options for rake tasks
-    def config
-      yield self
-    end
-
-    # Full path to directory with translation files
-    def locales_path
-      @locales_path || "#{Rails.root}/config/locales"
-    end
-
-    # Project branch to use
-    def branch
-      @branch || 'master'
-    end
-
-    # Set request timeouts for the Lokalise API client
-    def timeouts
-      @timeouts || {}
-    end
-
-    # Maximum number of retries for file exporting
-    def max_retries_export
-      @max_retries_export || 5
-    end
-
-    # Maximum number of retries for file importing
-    def max_retries_import
-      @max_retries_import || 5
-    end
-
-    # Regular expression used to select translation files with proper extensions
-    def file_ext_regexp
-      @file_ext_regexp || /\.ya?ml\z/i
-    end
+require 'lokalise_rails/utils'
+require 'lokalise_rails/global_config'
 
-    # Options for import rake task
-    def import_opts
-      @import_opts || {
-        format: 'yaml',
-        placeholder_format: :icu,
-        yaml_include_root: true,
-        original_filenames: true,
-        directory_prefix: '',
-        indentation: '2sp'
-      }
-    end
-
-    # Options for export rake task
-    def export_opts
-      @export_opts || {}
-    end
-
-    # Enables safe mode for import. When enabled, will check whether the target folder is empty or not
-    def import_safe_mode
-      @import_safe_mode.nil? ? false : @import_safe_mode
-    end
-
-    # Additional file skip criteria to apply when performing export
-    def skip_file_export
-      @skip_file_export || ->(_) { false }
-    end
-
-    def translations_loader
-      @translations_loader || ->(raw_data) { YAML.safe_load raw_data }
-    end
-
-    # Converts translations data to the proper format
-    def translations_converter
-      @translations_converter || ->(raw_data) { raw_data.to_yaml }
-    end
-
-    # Infers lang ISO for the given translation file
-    def lang_iso_inferer
-      @lang_iso_inferer || ->(data) { YAML.safe_load(data)&.keys&.first }
-    end
-  end
+module LokaliseRails
 end
 
 require 'lokalise_rails/railtie' if defined?(Rails)

data/lib/tasks/lokalise_rails_tasks.rake

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 require 'rake'
-require "#{Rails.root}/config/lokalise_rails"
+require 'lokalise_rails'
+require "#{LokaliseRails::Utils.root}/config/lokalise_rails"
 
 namespace :lokalise_rails do
   task :import do
-    LokaliseRails::TaskDefinition::Importer.import!
+    importer = LokaliseManager.importer({}, LokaliseRails::GlobalConfig)
+    importer.import!
   rescue StandardError => e
     abort e.inspect
   end
 
   task :export do
-    LokaliseRails::TaskDefinition::Exporter.export!
+    exporter = LokaliseManager.exporter({}, LokaliseRails::GlobalConfig)
+    exporter.export!
   rescue StandardError => e
     abort e.inspect
   end

data/lokalise_rails.gemspec

@@ -23,13 +23,12 @@ Gem::Specification.new do |spec|
   spec.extra_rdoc_files = ['README.md']
   spec.require_paths    = ['lib']
 
-  spec.add_dependency 'ruby-lokalise-api', '~> 4.0'
-  spec.add_dependency 'rubyzip', '~> 2.3'
+  spec.add_dependency 'lokalise_manager', '~> 1.0'
 
   spec.add_development_dependency 'codecov', '~> 0.2'
   spec.add_development_dependency 'dotenv', '~> 2.5'
   if ENV['TEST_RAILS_VERSION'].nil?
-    spec.add_development_dependency 'rails', '~> 6.1.0'
+    spec.add_development_dependency 'rails', '~> 6.1.4'
   else
     spec.add_development_dependency 'rails', ENV['TEST_RAILS_VERSION'].to_s
   end
@@ -37,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.6'
   spec.add_development_dependency 'rubocop', '~> 1.0'
   spec.add_development_dependency 'rubocop-performance', '~> 1.5'
-  spec.add_development_dependency 'rubocop-rspec', '~> 2.4.0'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.5.0'
   spec.add_development_dependency 'simplecov', '~> 0.16'
   spec.add_development_dependency 'vcr', '~> 6.0'
 end

data/spec/dummy/config/lokalise_rails.rb

@@ -1,5 +1,5 @@
-require 'lokalise_rails'
-LokaliseRails.config do |c|
+LokaliseRails::GlobalConfig.config do |c|
   c.api_token = ENV['LOKALISE_API_TOKEN']
   c.project_id = ENV['LOKALISE_PROJECT_ID']
-end
+
+end

data/spec/lib/lokalise_rails/global_config_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+describe LokaliseRails::GlobalConfig do
+  let(:child_config) { Class.new(described_class) }
+
+  it 'is possible to provide config options' do
+    described_class.config do |c|
+      expect(c).to eq(described_class)
+    end
+  end
+
+  it 'can be redefined' do
+    child_config.config do |c|
+      c.api_token = ENV['LOKALISE_API_TOKEN']
+      c.project_id = ENV['LOKALISE_PROJECT_ID']
+
+      c.branch = 'develop'
+    end
+
+    expect(child_config.branch).to eq('develop')
+    importer = LokaliseManager::TaskDefinitions::Importer.new({}, child_config)
+    expect(importer.config.branch).to eq('develop')
+    expect(importer.config.api_token).to eq(ENV['LOKALISE_API_TOKEN'])
+  end
+
+  describe 'parameters' do
+    let(:fake_class) { class_double(described_class) }
+
+    it 'is possible to set project_id' do
+      allow(fake_class).to receive(:project_id=).with('123.abc')
+      fake_class.project_id = '123.abc'
+    end
+
+    it 'is possible to set file_ext_regexp' do
+      allow(fake_class).to receive(:file_ext_regexp=).with(Regexp.new('.*'))
+      fake_class.file_ext_regexp = Regexp.new('.*')
+    end
+
+    it 'is possible to set import_opts' do
+      allow(fake_class).to receive(:import_opts=).with(duck_type(:each))
+      fake_class.import_opts = {
+        format: 'json',
+        indentation: '8sp'
+      }
+    end
+
+    it 'is possible to set export_opts' do
+      allow(fake_class).to receive(:export_opts=).with(duck_type(:each))
+      fake_class.export_opts = {
+        convert_placeholders: true,
+        detect_icu_plurals: true
+      }
+    end
+
+    it 'is possible to set branch' do
+      allow(fake_class).to receive(:branch=).with('custom')
+      fake_class.branch = 'custom'
+    end
+
+    it 'is possible to set timeouts' do
+      allow(fake_class).to receive(:timeouts=).with(duck_type(:each))
+      fake_class.timeouts = {
+        open_timeout: 100,
+        timeout: 500
+      }
+    end
+
+    it 'is possible to set import_safe_mode' do
+      allow(fake_class).to receive(:import_safe_mode=).with(true)
+      fake_class.import_safe_mode = true
+    end
+
+    it 'is possible to set max_retries_export' do
+      allow(fake_class).to receive(:max_retries_export=).with(10)
+      fake_class.max_retries_export = 10
+    end
+
+    it 'is possible to set max_retries_import' do
+      allow(fake_class).to receive(:max_retries_import=).with(10)
+      fake_class.max_retries_import = 10
+    end
+
+    it 'is possible to set api_token' do
+      allow(fake_class).to receive(:api_token=).with('abc')
+      fake_class.api_token = 'abc'
+    end
+
+    it 'is possible to override locales_path' do
+      allow(fake_class).to receive(:locales_path=).with('/demo/path')
+      fake_class.locales_path = '/demo/path'
+    end
+
+    it 'is possible to set skip_file_export' do
+      cond = ->(f) { f.nil? }
+      allow(fake_class).to receive(:skip_file_export=).with(cond)
+      fake_class.skip_file_export = cond
+    end
+
+    it 'is possible to set translations_loader' do
+      runner = ->(f) { f.to_json }
+      allow(fake_class).to receive(:translations_loader=).with(runner)
+      fake_class.translations_loader = runner
+    end
+
+    it 'is possible to set translations_converter' do
+      runner = ->(f) { f.to_json }
+      allow(fake_class).to receive(:translations_converter=).with(runner)
+      fake_class.translations_converter = runner
+    end
+
+    it 'is possible to set lang_iso_inferer' do
+      runner = ->(f) { f.to_json }
+      allow(fake_class).to receive(:lang_iso_inferer=).with(runner)
+      fake_class.lang_iso_inferer = runner
+    end
+  end
+end