ruby-lokalise-api 4.5.1 → 6.1.0

data/spec/lib/ruby-lokalise-api/rest/files_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::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(Lokalise::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/rest/keys_spec.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::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 eq(true)
-      expect(keys.last_page?).to eq(false)
-      expect(keys.prev_page?).to eq(true)
-      expect(keys.first_page?).to eq(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 eq(false)
-    expect(key.plural_name).to eq('')
-    expect(key.is_hidden).to eq(true)
-    expect(key.is_archived).to eq(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 eq(false)
-    expect(keys.prev_page?).to eq(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 eq(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 eq(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 eq(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 eq(true)
-    end
-  end
-end

data/spec/lib/ruby-lokalise-api/rest/languages_spec.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::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 eq(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 eq(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 eq(true)
-    end
-  end
-end

data/spec/lib/ruby-lokalise-api/rest/orders_spec.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::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

data/spec/lib/ruby-lokalise-api/rest/payment_cards_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:card_id) { 1773 }
-
-  describe '#payment_cards' do
-    it 'returns all payment cards' do
-      cards = VCR.use_cassette('all_payment_cards') do
-        test_client.payment_cards
-      end
-
-      expect(cards.user_id).to eq(20_181)
-      card = cards.collection.first
-      expect(card.card_id).to eq(1774)
-      expect(card.last4).to eq('0358')
-    end
-
-    it 'supports pagination' do
-      cards = VCR.use_cassette('all_payment_cards_pagination') do
-        test_client.payment_cards limit: 1, page: 1
-      end
-
-      expect(cards.collection.count).to eq(1)
-      expect(cards.total_results).to eq(1)
-      expect(cards.total_pages).to eq(1)
-      expect(cards.results_per_page).to eq(1)
-      expect(cards.current_page).to eq(1)
-
-      expect(cards.next_page?).to eq(false)
-      expect(cards.last_page?).to eq(true)
-      expect(cards.prev_page?).to eq(false)
-      expect(cards.first_page?).to eq(true)
-    end
-  end
-
-  specify '#create_payment_card' do
-    card = VCR.use_cassette('new_payment_card') do
-      test_client.create_payment_card number: '4242424242424242',
-                                      cvc: '123',
-                                      exp_month: 1,
-                                      exp_year: 2030
-    end
-
-    expect(card.card_id).to eq(card_id)
-    expect(card.last4).to eq('4242')
-  end
-
-  specify '#payment_card' do
-    card = VCR.use_cassette('payment_card') do
-      test_client.payment_card card_id
-    end
-
-    expect(card.user_id).to eq(20_181)
-    expect(card.card_id).to eq(card_id)
-    expect(card.brand).to eq('Visa')
-    expect(card.last4).to eq('4242')
-    expect(card.created_at).to eq('2019-03-19 17:01:22 (Etc/UTC)')
-  end
-
-  specify '#reload_data' do
-    card = VCR.use_cassette('payment_card') do
-      test_client.payment_card card_id
-    end
-
-    reloaded_card = VCR.use_cassette('payment_card') do
-      card.reload_data
-    end
-
-    expect(reloaded_card.card_id).to eq(card.card_id)
-  end
-
-  specify '#destroy_payment_card' do
-    result = VCR.use_cassette('destroy_payment_card') do
-      test_client.destroy_payment_card card_id
-    end
-
-    expect(result['card_deleted']).to eq(true)
-    expect(result['card_id']).to eq(card_id)
-  end
-
-  it 'supports chained destroy' do
-    card = VCR.use_cassette('payment_card') do
-      test_client.payment_card card_id
-    end
-    result = VCR.use_cassette('destroy_payment_card') do
-      card.destroy
-    end
-
-    expect(result['card_deleted']).to eq(true)
-    expect(result['card_id']).to eq(card_id)
-  end
-end