ruby-lokalise-api 4.5.1 → 6.1.0

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:team_id) { 176_692 }
-  let(:team_id2) { 273_879 }
-
-  specify '#team_user_billing_details' do
-    details = VCR.use_cassette('team_user_billing_details') do
-      test_client.team_user_billing_details team_id
-    end
-
-    expect(details.billing_email).to eq('hello@example.com')
-    expect(details.country_code).to eq('LV')
-    expect(details.zip).to eq('LV-6543')
-    expect(details.state_code).to eq('')
-    expect(details.address1).to eq('Sample line 1')
-    expect(details.address2).to eq('Sample line 2')
-    expect(details.city).to eq('Riga')
-    expect(details.phone).to eq('+371123456')
-    expect(details.company).to eq('Self-employed')
-    expect(details.vatnumber).to eq('123')
-  end
-
-  specify '#create_team_user_billing_details' do
-    details = VCR.use_cassette('create_team_user_billing_details') do
-      test_client.create_team_user_billing_details team_id2, billing_email: 'ruby@example.com',
-                                                             country_code: 'LV',
-                                                             zip: 'LV-1111'
-    end
-
-    expect(details.billing_email).to eq('ruby@example.com')
-    expect(details.country_code).to eq('LV')
-    expect(details.address1).to eq('')
-  end
-
-  specify '#update_team_user_billing_details' do
-    details = VCR.use_cassette('update_team_user_billing_details') do
-      test_client.update_team_user_billing_details team_id2, billing_email: 'ruby_rspec@example.com',
-                                                             country_code: 'LV',
-                                                             zip: 'LV-1111',
-                                                             address1: 'Addr line 1'
-    end
-
-    expect(details.billing_email).to eq('ruby_rspec@example.com')
-    expect(details.country_code).to eq('LV')
-    expect(details.address1).to eq('Addr line 1')
-  end
-end

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

@@ -1,278 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:team_id) { 176_692 }
-  let(:group_id) { 515 }
-  let(:second_group_id) { 690 }
-  let(:third_group_id) { 689 }
-  let(:project_id) { '605317925c13e4ecb36a79.94825279' }
-  let(:another_project_id) { '446952185c01a12b4d0b45.76217122' }
-  let(:user_id) { 35_554 }
-
-  describe '#team_user_groups' do
-    it 'returns all team_user_groups' do
-      team_user_groups = VCR.use_cassette('team_user_groups') do
-        test_client.team_user_groups team_id
-      end
-
-      expect(team_user_groups.collection.count).to eq(2)
-      expect(team_user_groups.team_id).to eq(team_id)
-    end
-
-    it 'supports pagination' do
-      team_users = VCR.use_cassette('team_user_groups_pagination') do
-        test_client.team_user_groups team_id, limit: 1, page: 2
-      end
-
-      expect(team_users.collection.count).to eq(1)
-      expect(team_users.total_results).to eq(2)
-      expect(team_users.total_pages).to eq(2)
-      expect(team_users.results_per_page).to eq(1)
-      expect(team_users.current_page).to eq(2)
-    end
-  end
-
-  specify '#team_user_group' do
-    group = VCR.use_cassette('team_user_group') do
-      test_client.team_user_group team_id, group_id
-    end
-
-    expect(group.group_id).to eq(group_id)
-    expect(group.name).to eq('Demo')
-    expect(group.permissions['is_admin']).to eq(true)
-    expect(group.created_at).to eq('2019-03-19 19:53:04 (Etc/UTC)')
-    expect(group.created_at_timestamp).to eq(1_553_025_184)
-    expect(group.team_id).to eq(team_id)
-    expect(group.projects.first).to eq('803826145ba90b42d5d860.46800099')
-    expect(group.members[1]).to eq(25_753)
-
-    reloaded_group = VCR.use_cassette('team_user_group') do
-      group.reload_data
-    end
-    expect(reloaded_group.group_id).to eq(group.group_id)
-  end
-
-  specify '#create_team_user_group' do
-    group = VCR.use_cassette('create_team_user_group') do
-      test_client.create_team_user_group team_id, name: 'RSpec group',
-                                                  is_reviewer: false,
-                                                  is_admin: false,
-                                                  languages: {
-                                                    reference: [],
-                                                    contributable: [640]
-                                                  }
-    end
-
-    expect(group.name).to eq('RSpec group')
-    expect(group.team_id).to eq(team_id)
-
-    reloaded_group = VCR.use_cassette('created_team_user_group') do
-      group.reload_data
-    end
-    expect(reloaded_group.group_id).to eq(group.group_id)
-  end
-
-  specify '#update_team_user_group' do
-    group = VCR.use_cassette('update_team_user_group') do
-      test_client.update_team_user_group team_id, second_group_id,
-                                         name: 'updated rspec', is_admin: true,
-                                         is_reviewer: true
-    end
-
-    expect(group.name).to eq('updated rspec')
-    expect(group.team_id).to eq(team_id)
-    expect(group.permissions['is_admin']).to eq(true)
-    expect(group.permissions['is_reviewer']).to eq(true)
-  end
-
-  specify '#destroy_team_user_group' do
-    response = VCR.use_cassette('destroy_team_user_group') do
-      test_client.destroy_team_user_group team_id, second_group_id
-    end
-    expect(response['team_id']).to eq(team_id)
-    expect(response['group_deleted']).to eq(true)
-  end
-
-  specify '#add_projects_to_group' do
-    group = VCR.use_cassette('add_projects_to_group') do
-      test_client.add_projects_to_group team_id, third_group_id, project_id
-    end
-
-    expect(group.team_id).to eq(team_id)
-    expect(group.group_id).to eq(third_group_id)
-    expect(group.projects).to include(project_id)
-
-    reloaded_group = VCR.use_cassette('another_team_user_group') do
-      group.reload_data
-    end
-    expect(reloaded_group.group_id).to eq(group.group_id)
-
-    group = VCR.use_cassette('add_projects_to_group') do
-      group.add_projects projects: [project_id]
-    end
-    expect(group.group_id).to eq(third_group_id)
-  end
-
-  specify '#remove_projects_from_group' do
-    group = VCR.use_cassette('remove_projects_from_group') do
-      test_client.remove_projects_from_group team_id, third_group_id, another_project_id
-    end
-
-    expect(group.group_id).to eq(third_group_id)
-    expect(group.team_id).to eq(team_id)
-    expect(group.projects).to be_empty
-
-    reloaded_group = VCR.use_cassette('another_team_user_group') do
-      group.reload_data
-    end
-    expect(reloaded_group.group_id).to eq(group.group_id)
-
-    group = VCR.use_cassette('remove_projects_from_group') do
-      group.remove_projects projects: [project_id]
-    end
-    expect(group.group_id).to eq(third_group_id)
-  end
-
-  specify '#add_users_to_group' do
-    group = VCR.use_cassette('add_users_to_group') do
-      test_client.add_users_to_group team_id, third_group_id, user_id
-    end
-
-    expect(group.team_id).to eq(team_id)
-    expect(group.group_id).to eq(third_group_id)
-    expect(group.members).to include(user_id)
-
-    reloaded_group = VCR.use_cassette('another_team_user_group') do
-      group.reload_data
-    end
-    expect(reloaded_group.group_id).to eq(group.group_id)
-
-    group = VCR.use_cassette('add_users_to_group') do
-      group.add_users users: [user_id]
-    end
-  end
-
-  specify '#remove_users_from_group' do
-    group = VCR.use_cassette('remove_users_from_group') do
-      test_client.remove_users_from_group team_id, third_group_id, user_id
-    end
-
-    expect(group.group_id).to eq(third_group_id)
-    expect(group.team_id).to eq(team_id)
-    expect(group.members).to be_empty
-
-    reloaded_group = VCR.use_cassette('another_team_user_group') do
-      group.reload_data
-    end
-    expect(reloaded_group.group_id).to eq(group.group_id)
-
-    group = VCR.use_cassette('remove_users_from_group') do
-      group.remove_users users: [user_id]
-    end
-  end
-
-  context 'when team user group methods are chained' do
-    it 'supports update and destroy' do
-      group = VCR.use_cassette('another_team_user_group') do
-        test_client.team_user_group team_id, third_group_id
-      end
-
-      expect(group.group_id).to eq(third_group_id)
-
-      group = VCR.use_cassette('update_another_team_user_group') do
-        group.update name: 'another group updated', is_admin: true, is_reviewer: true
-      end
-
-      expect(group.group_id).to eq(third_group_id)
-      expect(group.permissions['is_admin']).to eq(true)
-      expect(group.name).to eq('another group updated')
-
-      response = VCR.use_cassette('destroy_another_team_user_group') do
-        group.destroy
-      end
-
-      expect(response['team_id']).to eq(team_id)
-      expect(response['group_deleted']).to eq(true)
-    end
-
-    it 'supports project management' do
-      group = VCR.use_cassette('team_user_group') do
-        test_client.team_user_group team_id, group_id
-      end
-
-      group = VCR.use_cassette('add_project_to_group_chained') do
-        group.add_projects(projects: [another_project_id])
-      end
-
-      expect(group.team_id).to eq(team_id)
-      expect(group.group_id).to eq(group_id)
-      expect(group.projects).to include(another_project_id)
-
-      group = VCR.use_cassette('add_project_to_group_chained') do
-        group.add_projects(projects: [another_project_id])
-      end
-
-      reloaded_group = VCR.use_cassette('team_user_group') do
-        group.reload_data
-      end
-      expect(reloaded_group.group_id).to eq(group.group_id)
-
-      group = VCR.use_cassette('remove_project_from_group_chained') do
-        group.remove_projects(projects: [another_project_id])
-      end
-
-      expect(group.team_id).to eq(team_id)
-      expect(group.group_id).to eq(group_id)
-      expect(group.projects).not_to include(another_project_id)
-
-      group = VCR.use_cassette('remove_project_from_group_chained') do
-        group.remove_projects(projects: [another_project_id])
-      end
-
-      reloaded_group = VCR.use_cassette('team_user_group') do
-        group.reload_data
-      end
-      expect(reloaded_group.group_id).to eq(group.group_id)
-    end
-
-    it 'supports users management' do
-      group = VCR.use_cassette('team_user_group') do
-        test_client.team_user_group team_id, group_id
-      end
-
-      group = VCR.use_cassette('add_user_to_group_chained') do
-        group.add_users(users: [user_id])
-      end
-
-      expect(group.team_id).to eq(team_id)
-      expect(group.group_id).to eq(group_id)
-      expect(group.members).to include(user_id)
-
-      group = VCR.use_cassette('add_user_to_group_chained') do
-        group.add_users(users: [user_id])
-      end
-
-      reloaded_group = VCR.use_cassette('team_user_group') do
-        group.reload_data
-      end
-      expect(reloaded_group.group_id).to eq(group.group_id)
-
-      group = VCR.use_cassette('remove_user_from_group_chained') do
-        group.remove_users(users: [user_id])
-      end
-
-      expect(group.team_id).to eq(team_id)
-      expect(group.group_id).to eq(group_id)
-      expect(group.members).not_to include(user_id)
-
-      group = VCR.use_cassette('remove_user_from_group_chained') do
-        group.remove_users(users: [user_id])
-      end
-
-      reloaded_group = VCR.use_cassette('team_user_group') do
-        group.reload_data
-      end
-      expect(reloaded_group.group_id).to eq(group.group_id)
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:team_id) { 176_692 }
-  let(:team_user_id) { 25_953 }
-  let(:another_user_id) { 26_265 }
-
-  describe '#team_users' do
-    it 'returns all team_users' do
-      team_users = VCR.use_cassette('team_users') do
-        test_client.team_users team_id
-      end
-
-      expect(team_users.collection.count).to eq(4)
-      expect(team_users.team_id).to eq(team_id)
-    end
-
-    it 'supports pagination' do
-      team_users = VCR.use_cassette('all_team_users_pagination') do
-        test_client.team_users team_id, limit: 1, page: 3
-      end
-
-      expect(team_users.collection.count).to eq(1)
-      expect(team_users.total_results).to eq(4)
-      expect(team_users.total_pages).to eq(4)
-      expect(team_users.results_per_page).to eq(1)
-      expect(team_users.current_page).to eq(3)
-    end
-  end
-
-  specify '#team_user' do
-    team_user = VCR.use_cassette('team_user') do
-      test_client.team_user team_id, '20181'
-    end
-
-    expect(team_user.team_id).to eq(team_id)
-    expect(team_user.user_id).to eq(20_181)
-    expect(team_user.email).to eq('bodrovis@protonmail.com')
-    expect(team_user.fullname).to eq('Ilya B')
-    expect(team_user.created_at).to eq('2018-08-21 15:35:25 (Etc/UTC)')
-    expect(team_user.created_at_timestamp).to eq(1_534_865_725)
-    expect(team_user.role).to eq('owner')
-  end
-
-  specify '#reload_data' do
-    team_user = VCR.use_cassette('team_user') do
-      test_client.team_user team_id, '20181'
-    end
-
-    reloaded_team_user = VCR.use_cassette('team_user') do
-      team_user.reload_data
-    end
-
-    expect(reloaded_team_user.user_id).to eq(team_user.user_id)
-  end
-
-  specify '#update_team_user' do
-    team_user = VCR.use_cassette('update_team_user') do
-      test_client.update_team_user team_id, team_user_id, role: 'admin'
-    end
-
-    expect(team_user.user_id).to eq(team_user_id)
-    expect(team_user.role).to eq('admin')
-  end
-
-  specify '#destroy_team_user' do
-    response = VCR.use_cassette('delete_team_user') do
-      test_client.destroy_team_user team_id, team_user_id
-    end
-    expect(response['team_id']).to eq(team_id)
-    expect(response['team_user_deleted']).to eq(true)
-  end
-
-  context 'when team user methods are chained' do
-    it 'supports update and destroy' do
-      team_user = VCR.use_cassette('another_team_user') do
-        test_client.team_user team_id, another_user_id
-      end
-
-      updated_team_user = VCR.use_cassette('update_team_user_chained') do
-        team_user.update role: 'admin'
-      end
-
-      expect(updated_team_user.client.token).to eq(test_client.token)
-      expect(updated_team_user.role).to eq('admin')
-
-      delete_response = VCR.use_cassette('delete_team_user_chained') do
-        updated_team_user.destroy
-      end
-
-      expect(delete_response['team_id']).to eq(team_id)
-      expect(delete_response['team_user_deleted']).to eq(true)
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  specify '#teams' do
-    teams = VCR.use_cassette('teams') do
-      test_client.teams page: 2, limit: 1
-    end
-
-    team = teams.collection.first
-
-    expect(teams.collection.length).to eq(1)
-    expect(teams.total_results).to eq(2)
-    expect(teams.total_pages).to eq(2)
-    expect(teams.results_per_page).to eq(1)
-    expect(teams.current_page).to eq(2)
-
-    expect(team.team_id).to eq(176_692)
-    expect(team.name).to eq('Ilya\'s Team')
-    expect(team.created_at).to eq('2018-08-21 15:35:25 (Etc/UTC)')
-    expect(team.created_at_timestamp).to eq(1_534_865_725)
-    expect(team.plan).to eq('Trial')
-    expect(team.quota_usage['users']).to eq(9)
-    expect(team.quota_allowed['keys']).to eq(999_999_999)
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:team_id) { 176_692 }
-
-  describe '#translation_providers' do
-    it 'returns all providers' do
-      providers = VCR.use_cassette('all_translation_providers') do
-        test_client.translation_providers team_id
-      end.collection
-
-      expect(providers.count).to eq(2)
-      expect(providers.first.slug).to eq('gengo')
-    end
-
-    it 'supports pagination' do
-      providers = VCR.use_cassette('all_translation_providers_pagination') do
-        test_client.translation_providers team_id, limit: 1, page: 2
-      end
-
-      expect(providers.collection.count).to eq(1)
-      expect(providers.total_results).to eq(2)
-      expect(providers.total_pages).to eq(2)
-      expect(providers.results_per_page).to eq(1)
-      expect(providers.current_page).to eq(2)
-    end
-  end
-
-  specify '#translation_provider' do
-    provider = VCR.use_cassette('translation_provider') do
-      test_client.translation_provider team_id, 1
-    end
-
-    expect(provider.provider_id).to eq(1)
-    expect(provider.name).to eq('Gengo')
-    expect(provider.slug).to eq('gengo')
-    expect(provider.price_pair_min).to eq('0.00')
-    expect(provider.website_url).to eq('https://gengo.com')
-    expect(provider.description.start_with?('At')).to eq(true)
-    expect(provider.tiers.first['title']).to eq('Native speaker')
-    expect(provider.pairs.first['price_per_word']).to eq('0.05')
-
-    reloaded_provider = VCR.use_cassette('translation_provider') do
-      provider.reload_data
-    end
-    expect(reloaded_provider.provider_id).to eq(provider.provider_id)
-  end
-end

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::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(Lokalise::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 eq(true)
-      expect(next_page_trans.prev_page?).to eq(true)
-
-      prev_page_trans = VCR.use_cassette('translations_prev_page') do
-        translations.prev_page
-      end
-
-      expect(prev_page_trans).to be_an_instance_of(Lokalise::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 eq(true)
-      expect(prev_page_trans.prev_page?).to eq(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 eq(false)
-    expect(translation.is_reviewed).to eq(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 eq(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