ruby-lokalise-api 6.0.0 → 6.1.0

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

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:status_id) { 128 }
-  let(:new_status_id) { 126 }
-
-  describe '#translation_statuses' do
-    it 'returns all statuses' do
-      statuses = VCR.use_cassette('all_translation_statuses') do
-        test_client.translation_statuses project_id
-      end.collection
-
-      expect(statuses.count).to eq(3)
-      expect(statuses.first.status_id).to eq(status_id)
-    end
-
-    it 'supports pagination' do
-      statuses = VCR.use_cassette('all_translation_statuses_pagination') do
-        test_client.translation_statuses project_id, limit: 1, page: 2
-      end
-
-      expect(statuses.collection.count).to eq(1)
-      expect(statuses.total_results).to eq(3)
-      expect(statuses.total_pages).to eq(3)
-      expect(statuses.results_per_page).to eq(1)
-      expect(statuses.current_page).to eq(2)
-
-      expect(statuses.next_page?).to be(true)
-      expect(statuses.last_page?).to be(false)
-      expect(statuses.prev_page?).to be(true)
-      expect(statuses.first_page?).to be(false)
-    end
-  end
-
-  specify '#translation_status' do
-    status = VCR.use_cassette('translation_status') do
-      test_client.translation_status project_id, status_id
-    end
-
-    expect(status.status_id).to eq(status_id)
-    expect(status.title).to eq('random')
-    expect(status.color).to eq('#0079bf')
-  end
-
-  specify '#reload_data' do
-    status = VCR.use_cassette('translation_status') do
-      test_client.translation_status project_id, status_id
-    end
-
-    reloaded_status = VCR.use_cassette('translation_status') do
-      status.reload_data
-    end
-
-    expect(reloaded_status.status_id).to eq(status.status_id)
-  end
-
-  specify '#create_translation_status' do
-    title = 'Reviewed by doctors'
-    color = '#f2d600'
-    status = VCR.use_cassette('create_translation_status') do
-      test_client.create_translation_status project_id,
-                                            title: title,
-                                            color: color
-    end
-
-    expect(status.title).to eq(title)
-    expect(status.color).to eq(color)
-  end
-
-  specify '#update_translation_status' do
-    title = 'Reviewed by rubyists'
-    color = '#c377e0'
-    status = VCR.use_cassette('update_translation_status') do
-      test_client.update_translation_status project_id, new_status_id,
-                                            title: title,
-                                            color: color
-    end
-
-    expect(status.title).to eq(title)
-    expect(status.color).to eq(color)
-  end
-
-  specify '#destroy_translation_status' do
-    response = VCR.use_cassette('destroy_translation_status') do
-      test_client.destroy_translation_status project_id, new_status_id
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['custom_translation_status_deleted']).to be(true)
-  end
-
-  specify '#translation_status_colors' do
-    response = VCR.use_cassette('translation_status_colors') do
-      test_client.translation_status_colors project_id
-    end
-
-    expect(response).to be_an(Array)
-    expect(response).to include('#f2d600')
-  end
-
-  context 'when translation status methods are chained' do
-    it 'supports update and destroy' do
-      status = VCR.use_cassette('create_another_translation_status') do
-        test_client.create_translation_status project_id,
-                                              title: 'rspec',
-                                              color: '#c377e0'
-      end
-
-      expect(status.title).to eq('rspec')
-      expect(status.color).to eq('#c377e0')
-
-      status = VCR.use_cassette('update_another_translation_status') do
-        status.update(
-          title: 'updated rspec',
-          color: '#0079bf'
-        )
-      end
-
-      expect(status.title).to eq('updated rspec')
-      expect(status.color).to eq('#0079bf')
-
-      response = VCR.use_cassette('delete_another_translation_status') do
-        status.destroy
-      end
-
-      expect(response['project_id']).to eq(project_id)
-      expect(response['custom_translation_status_deleted']).to be(true)
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-
-  describe '#files' do
-    it 'returns all files' do
-      files = VCR.use_cassette('files') do
-        test_client.files project_id
-      end.collection
-
-      file = files.first
-
-      expect(files.count).to eq(1)
-      expect(file.filename).to eq('__unassigned__')
-      expect(file.key_count).to eq(1)
-    end
-
-    it 'supports pagination' do
-      files = VCR.use_cassette('all_files_pagination') do
-        test_client.files project_id, limit: 1, page: 1
-      end
-
-      expect(files.collection.count).to eq(1)
-      expect(files.total_results).to eq(1)
-      expect(files.total_pages).to eq(1)
-      expect(files.results_per_page).to eq(1)
-      expect(files.current_page).to eq(1)
-
-      expect(files.next_page).to be_nil
-      expect(files.prev_page).to be_nil
-    end
-  end
-
-  specify '#download_files' do
-    response = VCR.use_cassette('download_files') do
-      test_client.download_files project_id,
-                                 format: 'po',
-                                 original_filenames: true
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['bundle_url']).to include('amazonaws.com')
-  end
-
-  specify '#upload_file' do
-    process = VCR.use_cassette('upload_file') do
-      test_client.upload_file project_id,
-                              data: 'ZnI6DQogIHRlc3Q6IHRyYW5zbGF0aW9u',
-                              filename: 'rspec_async.yml',
-                              lang_iso: 'ru'
-    end
-
-    expect(process).to be_an_instance_of(RubyLokaliseApi::Resources::QueuedProcess)
-    expect(process.process_id).to eq('85c42bf5eff44648ca2f01f9db67b7d306a2f282')
-    expect(process.status).to eq('queued')
-
-    reloaded_process = VCR.use_cassette('upload_file_queued_reload') do
-      process.reload_data
-    end
-
-    expect(reloaded_process.process_id).to eq(process.process_id)
-    expect(reloaded_process.status).to eq('finished')
-    expect(reloaded_process.details['files'][0]['status']).to eq('finished')
-  end
-end

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

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:key_id) { 15_305_182 }
-  let(:new_key_id) { 15_519_770 }
-
-  describe '#keys' do
-    it 'returns all keys' do
-      keys = VCR.use_cassette('all_keys') do
-        test_client.keys project_id
-      end.collection
-
-      expect(keys.count).to eq(8)
-    end
-
-    it 'supports pagination' do
-      keys = VCR.use_cassette('all_keys_pagination') do
-        test_client.keys project_id, limit: 2, page: 3
-      end
-
-      expect(keys.collection.count).to eq(2)
-      expect(keys.total_results).to eq(8)
-      expect(keys.total_pages).to eq(4)
-      expect(keys.results_per_page).to eq(2)
-      expect(keys.current_page).to eq(3)
-
-      expect(keys.next_page?).to be(true)
-      expect(keys.last_page?).to be(false)
-      expect(keys.prev_page?).to be(true)
-      expect(keys.first_page?).to be(false)
-    end
-  end
-
-  specify '#key' do
-    key = VCR.use_cassette('key') do
-      test_client.key project_id, 44_596_066, disable_references: 0
-    end
-
-    expect(key.key_id).to eq(44_596_066)
-    expect(key.project_id).to eq(project_id)
-    expect(key.branch).to eq('master')
-    expect(key.created_at).to eq('2020-05-11 11:20:33 (Etc/UTC)')
-    expect(key.created_at_timestamp).to eq(1_589_196_033)
-    expect(key.key_name['ios']).to eq('static_pages:index:welcome')
-    expect(key.filenames['web']).to eq('%LANG_ISO%.yml')
-    expect(key.description).to eq('')
-    expect(key.platforms).to eq(%w[web])
-    expect(key.tags).to eq([])
-    expect(key.comments).to eq([])
-    expect(key.screenshots).to eq([])
-    expect(key.translations.first['modified_by_email']).to eq('bodrovis@protonmail.com')
-    expect(key.is_plural).to be(false)
-    expect(key.plural_name).to eq('')
-    expect(key.is_hidden).to be(true)
-    expect(key.is_archived).to be(false)
-    expect(key.context).to eq('')
-    expect(key.base_words).to eq(1)
-    expect(key.char_limit).to eq(0)
-    expect(key.custom_attributes).to eq('')
-    expect(key.modified_at).to eq('2020-05-11 11:20:33 (Etc/UTC)')
-    expect(key.modified_at_timestamp).to eq(1_589_196_033)
-    expect(key.translations_modified_at).to eq('2020-05-15 10:44:42 (Etc/UTC)')
-    expect(key.translations_modified_at_timestamp).to eq(1_589_539_482)
-  end
-
-  specify '#reload_data' do
-    key = VCR.use_cassette('key') do
-      test_client.key project_id, 44_596_066, disable_references: 0
-    end
-
-    reloaded_key = VCR.use_cassette('key') do
-      key.reload_data disable_references: 0
-    end
-
-    expect(reloaded_key.key_id).to eq(key.key_id)
-  end
-
-  specify '#create_keys' do
-    keys = VCR.use_cassette('create_keys') do
-      test_client.create_keys project_id, key_name: 'rspec_k', platforms: %w[ios]
-    end
-
-    key = keys.collection.first
-
-    expect(keys.project_id).to eq(project_id)
-    expect(key.key_name['ios']).to eq('rspec_k')
-    expect(key.platforms).to eq(%w[ios])
-  end
-
-  specify '#update_key' do
-    key = VCR.use_cassette('update_key') do
-      test_client.update_key project_id, new_key_id, key_name: 'updated_rspec_k', description: 'desc here'
-    end
-
-    expect(key.key_name['ios']).to eq('updated_rspec_k')
-    expect(key.platforms).to eq(%w[ios])
-    expect(key.description).to eq('desc here')
-  end
-
-  specify '#update_keys' do
-    keys = VCR.use_cassette('update_keys') do
-      test_client.update_keys project_id, [
-        {
-          key_id: new_key_id,
-          description: 'bulk updated'
-        },
-        {
-          key_id: key_id,
-          tags: %w[bulk upd]
-        }
-      ]
-    end
-
-    # `update_keys` returns a collection but it should not be paginated
-    expect(keys.next_page?).to be(false)
-    expect(keys.prev_page?).to be(false)
-
-    first_key = keys.collection.first
-    second_key = keys.collection[1]
-
-    expect(first_key.key_id).to eq(key_id)
-    expect(first_key.key_name['ios']).to eq('test')
-    expect(first_key.tags).to eq(%w[bulk upd])
-
-    expect(second_key.key_id).to eq(new_key_id)
-    expect(second_key.key_name['web']).to eq('updated_rspec_k')
-    expect(second_key.description).to eq('bulk updated')
-  end
-
-  specify '#destroy_key' do
-    response = VCR.use_cassette('delete_key') do
-      test_client.destroy_key project_id, '15519771'
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['key_removed']).to be(true)
-  end
-
-  specify '#destroy_keys' do
-    response = VCR.use_cassette('delete_keys') do
-      test_client.destroy_keys project_id, [new_key_id, key_id]
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['keys_removed']).to be(true)
-  end
-
-  context 'when key methods are chained' do
-    it 'supports update and destroy' do
-      key = VCR.use_cassette('create_another_key') do
-        test_client.create_keys project_id, key_name: 'chained_k', platforms: %w[ios]
-      end.collection.first
-
-      expect(key.key_name['ios']).to eq('chained_k')
-
-      path = key.path
-
-      updated_key = VCR.use_cassette('update_key_chained') do
-        key.update key_name: 'updated!'
-      end
-
-      expect(updated_key.client.token).to eq(test_client.token)
-      expect(updated_key.key_name['ios']).to eq('updated!')
-      expect(updated_key.path).to eq(path)
-
-      delete_response = VCR.use_cassette('delete_key_chained') do
-        updated_key.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['key_removed']).to be(true)
-    end
-  end
-
-  context 'when keys collection methods are chained' do
-    it 'supports destroy_all' do
-      keys = VCR.use_cassette('create_keys_collection') do
-        test_client.create_keys project_id, [
-          {
-            key_name: 'key_collect1', platforms: %w[ios]
-          },
-          {
-            key_name: 'key_collect2', platforms: %w[ios]
-          }
-        ]
-      end
-
-      expect(keys.collection.length).to eq(2)
-
-      delete_response = VCR.use_cassette('delete_all_keys_chained') do
-        keys.destroy_all
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['keys_removed']).to be(true)
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:language_id) { 640 }
-  let(:new_language_id) { 894 }
-
-  describe '#system_languages' do
-    it 'returns all system languages' do
-      languages = VCR.use_cassette('all_system_languages') do
-        test_client.system_languages
-      end.collection
-
-      expect(languages.count).to eq(100)
-      expect(languages.first.lang_iso).to eq('ab')
-    end
-
-    it 'supports pagination' do
-      languages = VCR.use_cassette('all_system_languages_pagination') do
-        test_client.system_languages limit: 10, page: 3
-      end
-
-      expect(languages.collection.count).to eq(10)
-      expect(languages.total_results).to eq(618)
-      expect(languages.total_pages).to eq(62)
-      expect(languages.results_per_page).to eq(10)
-      expect(languages.current_page).to eq(3)
-    end
-  end
-
-  describe '#project_languages' do
-    it 'returns all project languages' do
-      languages = VCR.use_cassette('all_project_languages') do
-        test_client.project_languages project_id
-      end.collection
-
-      expect(languages.count).to eq(3)
-      expect(languages.first.lang_iso).to eq('en')
-    end
-
-    it 'supports pagination' do
-      languages = VCR.use_cassette('all_project_languages_pagination') do
-        test_client.project_languages project_id, limit: 1, page: 2
-      end
-
-      expect(languages.collection.count).to eq(1)
-      expect(languages.total_results).to eq(3)
-      expect(languages.total_pages).to eq(3)
-      expect(languages.results_per_page).to eq(1)
-      expect(languages.current_page).to eq(2)
-    end
-  end
-
-  specify '#language' do
-    language = VCR.use_cassette('language') do
-      test_client.language project_id, language_id
-    end
-
-    expect(language.lang_id).to eq(language_id)
-    expect(language.lang_iso).to eq('en')
-    expect(language.lang_name).to eq('English')
-    expect(language.is_rtl).to be(false)
-    expect(language.plural_forms).to eq(%w[one other])
-  end
-
-  specify '#reload_data' do
-    language = VCR.use_cassette('language') do
-      test_client.language project_id, language_id
-    end
-
-    reloaded_language = VCR.use_cassette('language') do
-      language.reload_data
-    end
-
-    expect(reloaded_language.lang_id).to eq(language.lang_id)
-  end
-
-  specify '#create_languages' do
-    language = VCR.use_cassette('create_languages') do
-      test_client.create_languages project_id, lang_iso: 'ab', custom_name: 'rspec lang'
-    end.collection.first
-
-    expect(language.lang_name).to eq('rspec lang')
-    expect(language.lang_iso).to eq('ab')
-  end
-
-  specify '#update_language' do
-    language = VCR.use_cassette('update_language') do
-      test_client.update_language project_id, new_language_id, lang_name: 'updated lang',
-                                                               plural_forms: %w[one]
-    end
-
-    expect(language.lang_name).to eq('updated lang')
-    expect(language.lang_iso).to eq('ab')
-    expect(language.plural_forms).to eq(%w[one])
-  end
-
-  specify '#destroy_language' do
-    response = VCR.use_cassette('delete_language') do
-      test_client.destroy_language project_id, new_language_id
-    end
-    expect(response['project_id']).to eq(project_id)
-    expect(response['language_deleted']).to be(true)
-  end
-
-  context 'when project language methods are chained' do
-    it 'supports update and destroy' do
-      language = VCR.use_cassette('create_another_language') do
-        test_client.create_languages project_id, lang_iso: 'ab', custom_name: 'chained lang'
-      end.collection.first
-
-      expect(language.client.token).to eq(test_client.token)
-      expect(language.lang_name).to eq('chained lang')
-
-      path = language.path
-
-      updated_language = VCR.use_cassette('update_language_chained') do
-        language.update lang_name: 'updated!'
-      end
-
-      expect(updated_language.client.token).to eq(test_client.token)
-      expect(updated_language.lang_name).to eq('updated!')
-      expect(updated_language.lang_id).to eq(language.lang_id)
-      expect(updated_language.path).to eq(path)
-
-      delete_response = VCR.use_cassette('delete_language_chained') do
-        updated_language.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['language_deleted']).to be(true)
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:team_id) { 176_692 }
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:key_id) { 15_519_786 }
-  let(:order_id) { '201903198B2' }
-  let(:card_id) { 1774 }
-
-  describe '#orders' do
-    it 'returns all orders' do
-      orders = VCR.use_cassette('all_orders') do
-        test_client.orders team_id
-      end.collection
-
-      expect(orders.count).to eq(1)
-      expect(orders.first.order_id).to eq(order_id)
-    end
-
-    it 'supports pagination' do
-      orders = VCR.use_cassette('all_orders_pagination') do
-        test_client.orders team_id, limit: 1, page: 1
-      end
-
-      expect(orders.collection.count).to eq(1)
-      expect(orders.total_results).to eq(1)
-      expect(orders.total_pages).to eq(1)
-      expect(orders.results_per_page).to eq(1)
-      expect(orders.current_page).to eq(1)
-    end
-  end
-
-  specify '#order' do
-    order = VCR.use_cassette('order') do
-      test_client.order team_id, order_id
-    end
-
-    expect(order.order_id).to eq(order_id)
-    expect(order.project_id).to eq(project_id)
-    expect(order.card_id).to eq(card_id)
-    expect(order.status).to eq('completed')
-    expect(order.created_at).to eq('2019-03-19 18:18:21 (Etc/UTC)')
-    expect(order.created_by).to eq(20_181)
-    expect(order.created_by_email).to eq('bodrovis@protonmail.com')
-    expect(order.source_language_iso).to eq('en')
-    expect(order.target_language_isos).to eq(%w[ru])
-    expect(order.keys).to eq([key_id])
-    expect(order.source_words['ru']).to eq(1)
-    expect(order.provider_slug).to eq('gengo')
-    expect(order.translation_style).to eq('friendly')
-    expect(order.translation_tier).to eq(1)
-    expect(order.translation_tier_name).to eq('Professional translator')
-    expect(order.briefing).to eq('Some briefing')
-    expect(order.total).to eq(0.07)
-    expect(order.payment_method).to be_nil
-  end
-
-  specify '#reload_data' do
-    order = VCR.use_cassette('order') do
-      test_client.order team_id, order_id
-    end
-
-    reloaded_order = VCR.use_cassette('order') do
-      order.reload_data
-    end
-
-    expect(reloaded_order.order_id).to eq(order.order_id)
-  end
-
-  specify '#create_order' do
-    order = VCR.use_cassette('create_order') do
-      test_client.create_order team_id,
-                               project_id: project_id,
-                               card_id: card_id,
-                               briefing: 'Some briefing',
-                               source_language_iso: 'en',
-                               target_language_isos: [
-                                 'ru'
-                               ],
-                               keys: [
-                                 key_id
-                               ],
-                               provider_slug: 'gengo',
-                               translation_tier: '1'
-    end
-
-    expect(order.order_id).to eq(order_id)
-    expect(order.status).to eq('in progress')
-  end
-
-  it 'creates an order with dry run' do
-    order = VCR.use_cassette('create_order_dry_run') do
-      test_client.create_order team_id,
-                               project_id: project_id,
-                               card_id: card_id,
-                               briefing: 'Some briefing',
-                               source_language_iso: 'en',
-                               target_language_isos: [
-                                 'ru'
-                               ],
-                               keys: [
-                                 74_189_435
-                               ],
-                               provider_slug: 'gengo',
-                               translation_tier: '1',
-                               dry_run: true
-    end
-
-    expect(order.order_id).to be_nil
-    expect(order.status).to eq('draft')
-    expect(order.dry_run).to be true
-  end
-end