ruby-lokalise-api 6.0.0 → 6.1.0

data/spec/lib/ruby_lokalise_api/client/translations_spec.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:translation_id) { 80_015_147 }
-  let(:another_translation_id) { 82_070_312 }
-
-  describe '#translations' do
-    it 'returns all translations' do
-      translations = VCR.use_cassette('translations') do
-        test_client.translations project_id
-      end.collection
-
-      expect(translations.count).to eq(9)
-    end
-
-    it 'supports pagination' do
-      translations = VCR.use_cassette('all_translations_pagination') do
-        test_client.translations project_id, limit: 4, page: 2, disable_references: 0,
-                                             filter_is_reviewed: 0
-      end
-
-      expect(translations.collection.count).to eq(4)
-      expect(translations.total_results).to eq(187)
-      expect(translations.total_pages).to eq(47)
-      expect(translations.results_per_page).to eq(4)
-      expect(translations.current_page).to eq(2)
-      expect(translations.request_params[:page]).to eq(2)
-      expect(translations.request_params[:disable_references]).to eq(0)
-      expect(translations.request_params[:filter_is_reviewed]).to eq(0)
-
-      next_page_trans = VCR.use_cassette('translations_next_page') do
-        translations.next_page
-      end
-
-      expect(next_page_trans).to be_an_instance_of(RubyLokaliseApi::Collections::Translation)
-      expect(next_page_trans.client).to be_an_instance_of(described_class)
-      expect(next_page_trans.request_params[:page]).to eq(3)
-      expect(next_page_trans.request_params[:disable_references]).to eq(0)
-      expect(next_page_trans.total_results).to eq(187)
-      expect(next_page_trans.current_page).to eq(3)
-      expect(next_page_trans.next_page?).to be(true)
-      expect(next_page_trans.prev_page?).to be(true)
-
-      prev_page_trans = VCR.use_cassette('translations_prev_page') do
-        translations.prev_page
-      end
-
-      expect(prev_page_trans).to be_an_instance_of(RubyLokaliseApi::Collections::Translation)
-      expect(prev_page_trans.client).to be_an_instance_of(described_class)
-      expect(prev_page_trans.request_params[:page]).to eq(1)
-      expect(next_page_trans.request_params[:disable_references]).to eq(0)
-      expect(prev_page_trans.total_results).to eq(187)
-      expect(prev_page_trans.current_page).to eq(1)
-      expect(prev_page_trans.next_page?).to be(true)
-      expect(prev_page_trans.prev_page?).to be(false)
-    end
-  end
-
-  specify '#translation' do
-    translation = VCR.use_cassette('translation') do
-      test_client.translation project_id, 304_581_218
-    end
-
-    expect(translation.translation_id).to eq(304_581_218)
-    expect(translation.key_id).to eq(44_596_059)
-    expect(translation.language_iso).to eq('ru')
-    expect(translation.modified_at).to eq('2020-05-15 10:44:42 (Etc/UTC)')
-    expect(translation.modified_at_timestamp).to eq(1_589_539_482)
-    expect(translation.modified_by).to eq(20_181)
-    expect(translation.modified_by_email).to eq('bodrovis@protonmail.com')
-    expect(translation.translation).to eq('Сообщение')
-    expect(translation.is_fuzzy).to be(false)
-    expect(translation.is_reviewed).to be(false)
-    expect(translation.words).to eq(1)
-    expect(translation.custom_translation_statuses).to eq([])
-    expect(translation.task_id).to be_nil
-  end
-
-  specify '#reload_data' do
-    translation = VCR.use_cassette('translation') do
-      test_client.translation project_id, 304_581_218
-    end
-
-    reloaded_translation = VCR.use_cassette('translation') do
-      translation.reload_data
-    end
-
-    expect(reloaded_translation.translation_id).to eq(translation.translation_id)
-  end
-
-  specify '#update_translation' do
-    translation = VCR.use_cassette('update_translation') do
-      test_client.update_translation project_id, translation_id, translation: 'rspec trans',
-                                                                 is_reviewed: true
-    end
-
-    expect(translation.translation_id).to eq(translation_id)
-    expect(translation.translation).to eq('rspec trans')
-    expect(translation.is_reviewed).to be(true)
-  end
-
-  context 'when translation chained methods are used' do
-    it 'supports update' do
-      translation = VCR.use_cassette('another_translation') do
-        test_client.translation project_id, another_translation_id
-      end
-
-      updated_translation = VCR.use_cassette('update_translation_chained') do
-        translation.update translation: 'chained updated'
-      end
-
-      expect(updated_translation.client.token).to eq(test_client.token)
-      expect(updated_translation.translation).to eq('chained updated')
-      expect(updated_translation.translation_id).to eq(translation.translation_id)
-    end
-  end
-end

data/spec/lib/ruby_lokalise_api/client/webhooks_spec.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:webhook_id) { 'c7eb7e6e3c2fb2b26d0b64d0de083a5a71675b3d' }
-  let(:new_webhook_id) { 'b345ccc6499920c490e8f4fe9487b1378dbf1dbf' }
-  let(:serious_webhook_id) { '795565582e5ab15a59bb68156c7e2e9eaa1e8d1a' }
-
-  describe '#webhooks' do
-    it 'returns all webhooks' do
-      webhooks = VCR.use_cassette('webhooks') do
-        test_client.webhooks project_id
-      end.collection
-
-      expect(webhooks.count).to eq(3)
-      expect(webhooks.first.url).to eq('https://serios.webhook')
-    end
-
-    it 'supports pagination' do
-      webhooks = VCR.use_cassette('all_webhooks_pagination') do
-        test_client.webhooks project_id, limit: 1, page: 2
-      end
-
-      expect(webhooks.collection.count).to eq(1)
-      expect(webhooks.total_results).to eq(3)
-      expect(webhooks.total_pages).to eq(3)
-      expect(webhooks.results_per_page).to eq(1)
-      expect(webhooks.current_page).to eq(2)
-    end
-  end
-
-  specify '#webhook' do
-    webhook = VCR.use_cassette('webhook') do
-      test_client.webhook project_id, webhook_id
-    end
-
-    expect(webhook.webhook_id).to eq(webhook_id)
-    expect(webhook.url).to eq('https://canihaz.hook')
-    expect(webhook.secret).to eq('a62450cd9eeca8dfc84f3c0cf9b7a6a370267d6f')
-    expect(webhook.events).to include('project.snapshot')
-    expect(webhook.event_lang_map.first['event']).to eq('project.translation.updated')
-  end
-
-  specify '#reload_data' do
-    webhook = VCR.use_cassette('webhook') do
-      test_client.webhook project_id, webhook_id
-    end
-
-    reloaded_webhook = VCR.use_cassette('webhook') do
-      webhook.reload_data
-    end
-
-    expect(reloaded_webhook.webhook_id).to eq(webhook.webhook_id)
-  end
-
-  specify '#create_webhook' do
-    webhook = VCR.use_cassette('create_webhook') do
-      test_client.create_webhook project_id,
-                                 url: 'http://thatz.ahook',
-                                 events: ['project.imported', 'project.exported']
-    end
-
-    expect(webhook.webhook_id).to eq(new_webhook_id)
-    expect(webhook.url).to eq('http://thatz.ahook')
-    expect(webhook.events).to include('project.imported', 'project.exported')
-  end
-
-  specify '#update_webhook' do
-    webhook = VCR.use_cassette('update_webhook') do
-      test_client.update_webhook project_id,
-                                 new_webhook_id,
-                                 url: 'http://ihaz.cheezburger'
-    end
-
-    expect(webhook.webhook_id).to eq(new_webhook_id)
-    expect(webhook.url).to eq('http://ihaz.cheezburger')
-    expect(webhook.events).to include('project.imported', 'project.exported')
-  end
-
-  specify '#destroy_webhook' do
-    response = VCR.use_cassette('destroy_webhook') do
-      test_client.destroy_webhook project_id,
-                                  new_webhook_id
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['webhook_deleted']).to be(true)
-  end
-
-  specify '#regenerate_webhook_secret' do
-    response = VCR.use_cassette('regenerate_webhook_secret') do
-      test_client.regenerate_webhook_secret project_id,
-                                            serious_webhook_id
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['secret']).not_to be_nil
-  end
-
-  context 'when webhook chained methods are used' do
-    it 'supports regenerate_webhook_secret' do
-      webhook = VCR.use_cassette('webhook_2') do
-        test_client.webhook project_id, serious_webhook_id
-      end
-
-      expect(webhook.branch).to eq('master')
-      expect(webhook.webhook_id).to eq(serious_webhook_id)
-
-      response = VCR.use_cassette('regenerate_webhook_secret_2') do
-        webhook.regenerate_secret
-      end
-
-      expect(response['project_id']).to eq(project_id)
-      expect(response['secret']).not_to be_nil
-    end
-
-    it 'supports update and destroy' do
-      webhook = VCR.use_cassette('webhook_2') do
-        test_client.webhook project_id, serious_webhook_id
-      end
-
-      expect(webhook).to respond_to(:update)
-      expect(webhook).to respond_to(:destroy)
-    end
-  end
-end

data/spec/lib/ruby_lokalise_api/connection_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Connection do
-  let(:dummy) { Class.new { include RubyLokaliseApi::Connection }.new }
-
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:key_id) { 44_596_059 }
-
-  before { RubyLokaliseApi.reset_client! }
-
-  after { RubyLokaliseApi.reset_client! }
-
-  it 'Authorization header must be present for OAuth2 client' do
-    conn = dummy.connection test_oauth2_client
-    expect(conn.headers['Authorization']).to eq(test_oauth2_client.token)
-    expect(conn.headers['X-api-token']).to be_nil
-  end
-
-  it 'timeouts are not be set by default but the token must be present' do
-    conn = dummy.connection test_client
-    expect(conn.options.timeout).to be_nil
-    expect(conn.options.open_timeout).to be_nil
-    expect(conn.headers['X-api-token']).to eq(test_client.token)
-  end
-
-  it 'allows to customize timeouts' do
-    custom_client = RubyLokaliseApi.client(ENV['LOKALISE_API_TOKEN'],
-                                           open_timeout: 100, timeout: 500)
-    conn = dummy.connection custom_client
-    expect(conn.options.timeout).to eq(500)
-    expect(conn.options.open_timeout).to eq(100)
-    expect(conn.headers['X-api-token']).to eq(custom_client.token)
-
-    custom_client.timeout = 300
-    custom_client.open_timeout = 200
-    another_conn = dummy.connection custom_client
-    expect(another_conn.options.timeout).to eq(300)
-    expect(another_conn.options.open_timeout).to eq(200)
-  end
-
-  it 'works with gzip compression' do
-    gzip_client = RubyLokaliseApi.client(ENV['LOKALISE_API_TOKEN'])
-    keys = VCR.use_cassette('all_keys_gzip') do
-      gzip_client.keys project_id, limit: 30
-    end.collection
-
-    expect(keys.first.key_id).to eq(key_id)
-  end
-
-  it 'gzip compression is on by default' do
-    custom_client = RubyLokaliseApi.client(ENV['LOKALISE_API_TOKEN'])
-    conn = dummy.connection custom_client
-    expect(conn.headers['X-api-token']).to eq(custom_client.token)
-    expect(conn.builder.handlers).to include(Faraday::Gzip::Middleware)
-  end
-
-  it 'is possible to customize adapter' do
-    conn = dummy.connection test_client
-    expect(conn.builder.adapter).to eq(Faraday::Adapter::NetHttp)
-
-    Faraday.default_adapter = :test
-
-    another_conn = dummy.connection test_client
-
-    expect(another_conn.builder.adapter).to eq(Faraday::Adapter::Test)
-    expect(conn.builder.adapter).to eq(Faraday::Adapter::NetHttp)
-  end
-end

data/spec/lib/ruby_lokalise_api/custom_json_parser_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'oj'
-
-RSpec.describe RubyLokaliseApi::JsonHandler do
-  let(:loaded_json) do
-    {'projects' => [{'project_id' => '547879415c01a0e6e0b855.29978928',
-                     'name' => 'demo phoenix copy',
-                     'description' => '',
-                     'created_at' => '2018-11-30 20:43:18 (Etc/UTC)',
-                     'created_by' => 20_181,
-                     'created_by_email' => 'bodrovis@protonmail.com',
-                     'team_id' => 176_692,
-                     'statistics' =>
-           {'progress' => 0,
-            'keys' => 1,
-            'team' => 1,
-            'base_words' => 0,
-            'qa_issues' => 1,
-            'languages' =>
-              [{'language_id' => 640, 'language_iso' => 'en', 'progress' => 0, 'words_to_do' => 0},
-               {'language_id' => 597, 'language_iso' => 'ru', 'progress' => 0, 'words_to_do' => 0},
-               {'language_id' => 673, 'language_iso' => 'f_over', 'progress' => 0, 'words_to_do' => 0}]}}]}
-  end
-
-  let(:dumped_json) do
-    '{":name":"rspec proj",":description":"demo project for rspec"}'
-  end
-
-  # rubocop:disable RSpec/LeakyConstantDeclaration, Lint/ConstantDefinitionInBlock
-  before do
-    module RubyLokaliseApi
-      module JsonHandler
-        def custom_dump(obj)
-          Oj.dump obj
-        end
-
-        def custom_load(obj)
-          Oj.load obj
-        end
-      end
-    end
-  end
-
-  after do
-    module RubyLokaliseApi
-      module JsonHandler
-        def custom_dump(obj)
-          JSON.dump obj
-        end
-
-        def custom_load(obj)
-          JSON.parse obj
-        end
-      end
-    end
-  end
-  # rubocop:enable RSpec/LeakyConstantDeclaration, Lint/ConstantDefinitionInBlock
-
-  it 'allows to customize #load' do
-    allow(Oj).to receive(:load).and_return(loaded_json)
-    expect(JSON).not_to receive(:parse)
-    projects = VCR.use_cassette('all_projects_pagination') do
-      test_client.projects limit: 1, page: 2
-    end
-
-    expect(projects.collection.count).to eq(1)
-    expect(projects.total_results).to eq(5)
-    expect(projects.collection.first.name).to eq('demo phoenix copy')
-  end
-
-  it 'allows to customize #dump' do
-    allow(Oj).to receive(:dump).and_return(dumped_json)
-    expect(JSON).not_to receive(:dump)
-    project = VCR.use_cassette('new_project') do
-      test_client.create_project name: 'rspec proj', description: 'demo project for rspec'
-    end
-
-    expect(project.name).to eq('rspec proj')
-  end
-end

data/spec/lib/ruby_lokalise_api/error_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Error do
-  include RubyLokaliseApi::Request
-
-  before { RubyLokaliseApi.reset_client! }
-
-  after { RubyLokaliseApi.reset_client! }
-
-  it 'raises a generic error when the code is unknown' do
-    expect do
-      VCR.use_cassette('error_unknown_code') do
-        get 'projects', RubyLokaliseApi.client('invalid')
-      end
-    end.to raise_error(described_class)
-  end
-
-  it 'handles an exception when the response does not contain an error key' do
-    expect do
-      VCR.use_cassette('error_no_error_key') do
-        get 'projects', RubyLokaliseApi.client('invalid')
-      end
-    end.to raise_error(RubyLokaliseApi::Error::BadRequest)
-  end
-
-  it 'raises BadRequest when API token is invalid' do
-    expect do
-      VCR.use_cassette('error_invalid_token') do
-        get 'projects', RubyLokaliseApi.client('invalid')
-      end
-    end.to raise_error(RubyLokaliseApi::Error::BadRequest)
-  end
-
-  it 'raises NotFound when the provided path cannot be found' do
-    expect do
-      VCR.use_cassette('error_not_found') do
-        get 'invalid_path', test_client
-      end
-    end.to raise_error(RubyLokaliseApi::Error::NotFound)
-  end
-end

data/spec/lib/ruby_lokalise_api/oauth2/auth_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::OAuth2::Auth do
-  describe '#auth' do
-    it 'returns auth code' do
-      uri = auth_client.auth scope: 'read_projects'
-      expect(uri).to include(described_class::BASE_URL.to_s)
-      expect(uri).to include('auth?client_id=')
-      expect(uri).to include('&scope=read_projects')
-    end
-
-    it 'allows to pass an array of scopes' do
-      scopes = %w[write_projects write_team_groups write_tasks]
-      uri = auth_client.auth scope: scopes
-      expect(uri).to include(described_class::BASE_URL.to_s)
-      expect(uri).to include('auth?client_id=')
-      expect(uri).to include("&scope=#{scopes.join('+')}")
-    end
-
-    it 'allows to set redirect_uri' do
-      uri = auth_client.auth scope: 'read_projects', redirect_uri: 'http://example.com/callback'
-      expect(uri).to include(described_class::BASE_URL.to_s)
-      expect(uri).to include('example.com%2Fcallback')
-    end
-
-    it 'allows to set state' do
-      state = '123abc'
-      uri = auth_client.auth scope: 'read_projects', state: state
-      expect(uri).to include(described_class::BASE_URL.to_s)
-      expect(uri).to include(state)
-    end
-  end
-
-  describe '#token' do
-    it 'returns an OAuth2 token' do
-      resp = VCR.use_cassette('oauth2/token') do
-        auth_client.token ENV['OAUTH2_CODE']
-      end
-      expect(resp['access_token']).not_to be_nil
-      expect(resp['refresh_token']).not_to be_nil
-      expect(resp['expires_in']).to eq(3600)
-      expect(resp['token_type']).to eq('Bearer')
-    end
-
-    it 'raises an error when the code is invalid' do
-      expect do
-        VCR.use_cassette('oauth2/token_error') do
-          auth_client.token 'incorrect_code'
-        end
-      end.to raise_error(RubyLokaliseApi::Error::BadRequest)
-    end
-  end
-
-  describe '#refresh' do
-    it 'returns a refreshed OAuth2 token' do
-      resp = VCR.use_cassette('oauth2/refresh') do
-        auth_client.refresh ENV['OAUTH2_REFRESH_TOKEN']
-      end
-      expect(resp['access_token']).not_to be_nil
-      expect(resp['refresh_token']).to be_nil
-      expect(resp['expires_in']).to eq(3600)
-      expect(resp['token_type']).to eq('Bearer')
-    end
-
-    it 'raises an error when the token is invalid' do
-      expect do
-        VCR.use_cassette('oauth2/refresh_error') do
-          auth_client.refresh 'incorrect_token'
-        end
-      end.to raise_error(RubyLokaliseApi::Error::BadRequest)
-    end
-  end
-end

data/spec/lib/ruby_lokalise_api_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi do
-  specify '.client' do
-    expect(test_client).to be_an_instance_of(RubyLokaliseApi::Client)
-    expect(test_client.token).to eq(ENV['LOKALISE_API_TOKEN'])
-    expect(test_client.timeout).to be_nil
-    expect(test_client.open_timeout).to be_nil
-  end
-
-  specify '.reset_client!' do
-    expect(test_client).to be_an_instance_of(RubyLokaliseApi::Client)
-    described_class.reset_client!
-    current_client = described_class.instance_variable_get :@client
-    expect(current_client).to be_nil
-  end
-
-  specify '.oauth2_client' do
-    expect(test_oauth2_client).to be_an_instance_of(RubyLokaliseApi::OAuth2Client)
-    expect(test_oauth2_client.token).to eq("Bearer #{ENV['OAUTH2_TOKEN']}")
-    expect(test_oauth2_client.timeout).to be_nil
-    expect(test_oauth2_client.open_timeout).to be_nil
-  end
-
-  specify '.reset_oauth2_client!' do
-    expect(test_oauth2_client).to be_an_instance_of(RubyLokaliseApi::OAuth2Client)
-    described_class.reset_oauth2_client!
-    current_oauth_client = described_class.instance_variable_get :@oauth2_client
-    expect(current_oauth_client).to be_nil
-  end
-
-  context 'with client params' do
-    before { described_class.reset_client! }
-
-    after { described_class.reset_client! }
-
-    it 'is possible to customize timeout' do
-      custom_client = described_class.client(ENV['LOKALISE_API_TOKEN'], timeout: 600)
-      expect(custom_client.timeout).to eq(600)
-    end
-
-    it 'is possible to customize open timeout' do
-      custom_client = described_class.client(ENV['LOKALISE_API_TOKEN'], open_timeout: 100)
-      expect(custom_client.open_timeout).to eq(100)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,22 +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 'ruby_lokalise_api'
-
-# Support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.include TestClient
-end

data/spec/support/test_client.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module TestClient
-  def test_client(token = nil, params = {})
-    RubyLokaliseApi.client(token || ENV['LOKALISE_API_TOKEN'], params)
-  end
-
-  def test_oauth2_client(token = nil, params = {})
-    RubyLokaliseApi.oauth2_client(token || ENV['OAUTH2_TOKEN'], params)
-  end
-
-  def auth_client
-    RubyLokaliseApi.auth_client(ENV['OAUTH2_CLIENT_ID'], ENV['OAUTH2_CLIENT_SECRET'])
-  end
-end

data/spec/support/vcr.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'vcr'
-
-VCR.configure do |c|
-  c.ignore_hosts 'codeclimate.com'
-  c.hook_into :faraday
-  c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes')
-  c.filter_sensitive_data('<LOKALISE_TOKEN>') { ENV.fetch('LOKALISE_API_TOKEN') }
-  c.filter_sensitive_data('<OAUTH2_CLIENT_ID>') { ENV.fetch('OAUTH2_CLIENT_ID') }
-  c.filter_sensitive_data('<OAUTH2_CLIENT_SECRET>') { ENV.fetch('OAUTH2_CLIENT_SECRET') }
-  c.filter_sensitive_data('<OAUTH2_TOKEN>') { ENV.fetch('OAUTH2_TOKEN') }
-  c.filter_sensitive_data('<OAUTH2_CODE>') { ENV.fetch('OAUTH2_CODE') }
-  c.filter_sensitive_data('<OAUTH2_REFRESH_TOKEN>') { ENV.fetch('OAUTH2_REFRESH_TOKEN') }
-end