ruby-lokalise-api 6.0.0 → 6.1.0

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

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:key_id) { 15_571_976 }
-  let(:task_id) { 4387 }
-
-  describe '#tasks' do
-    it 'returns all tasks' do
-      tasks = VCR.use_cassette('all_tasks') do
-        test_client.tasks project_id
-      end.collection
-
-      expect(tasks.count).to eq(3)
-    end
-
-    it 'supports pagination' do
-      tasks = VCR.use_cassette('all_tasks_pagination') do
-        test_client.tasks project_id, limit: 2, page: 2
-      end
-
-      expect(tasks.collection.count).to eq(1)
-      expect(tasks.total_results).to eq(3)
-      expect(tasks.total_pages).to eq(2)
-      expect(tasks.results_per_page).to eq(2)
-      expect(tasks.current_page).to eq(2)
-    end
-  end
-
-  specify '#task' do
-    task = VCR.use_cassette('task') do
-      test_client.task project_id, '11925'
-    end
-
-    expect(task.task_id).to eq(11_925)
-    expect(task.title).to eq('node updated')
-    expect(task.description).to eq('')
-    expect(task.status).to eq('completed')
-    expect(task.progress).to eq(0)
-    expect(task.due_date).to be_nil
-    expect(task.due_date_timestamp).to be_nil
-    expect(task.keys_count).to eq(16)
-    expect(task.words_count).to eq(275)
-    expect(task.created_at).to eq('2019-05-13 16:15:26 (Etc/UTC)')
-    expect(task.created_at_timestamp).to eq(1_557_764_126)
-    expect(task.created_by).to eq(20_181)
-    expect(task.created_by_email).to eq('bodrovis@protonmail.com')
-    expect(task.can_be_parent).to be(false)
-    expect(task.task_type).to eq('review')
-    expect(task.parent_task_id).to be_nil
-    expect(task.closing_tags).to eq([])
-    expect(task.languages.first['language_iso']).to eq('sq')
-    expect(task.auto_close_languages).to be(true)
-    expect(task.auto_close_task).to be(true)
-    expect(task.auto_close_items).to be(true)
-    expect(task.completed_by).to eq(20_181)
-    expect(task.completed_by_email).to eq('bodrovis@protonmail.com')
-    expect(task.completed_at).to eq('2019-10-01 11:09:12 (Etc/UTC)')
-    expect(task.completed_at_timestamp).to eq(1_569_928_152)
-    expect(task.do_lock_translations).to be(false)
-    expect(task.custom_translation_status_ids).to eq([])
-  end
-
-  specify '#reload_data' do
-    task = VCR.use_cassette('task') do
-      test_client.task project_id, '11925'
-    end
-
-    reloaded_task = VCR.use_cassette('task') do
-      task.reload_data
-    end
-
-    expect(reloaded_task.task_id).to eq(task.task_id)
-  end
-
-  specify '#create_task' do
-    task = VCR.use_cassette('create_task') do
-      test_client.create_task project_id, title: 'another rspec key',
-                                          keys: [key_id],
-                                          languages: [
-                                            {
-                                              language_iso: 'ru',
-                                              users: ['20181']
-                                            }
-                                          ]
-    end
-
-    expect(task.title).to eq('another rspec key')
-    expect(task.languages.first['language_iso']).to eq('ru')
-  end
-
-  specify '#update_task' do
-    task = VCR.use_cassette('update_task') do
-      test_client.update_task project_id, task_id, description: 'desc here', auto_close_task: true
-    end
-
-    expect(task.task_id).to eq(task_id)
-    expect(task.description).to eq('desc here')
-    expect(task.auto_close_task).to be(true)
-  end
-
-  specify '#destroy_task' do
-    response = VCR.use_cassette('delete_task') do
-      test_client.destroy_task project_id, task_id
-    end
-    expect(response['project_id']).to eq(project_id)
-    expect(response['task_deleted']).to be(true)
-  end
-
-  context 'when task methods are chained' do
-    it 'supports update and destroy' do
-      task = VCR.use_cassette('create_another_task') do
-        test_client.create_task project_id, title: 'chained',
-                                            keys: [key_id],
-                                            languages: [
-                                              {
-                                                language_iso: 'ru',
-                                                users: ['20181']
-                                              }
-                                            ]
-      end
-
-      expect(task.client.token).to eq(test_client.token)
-      expect(task.title).to eq('chained')
-
-      path = task.path
-
-      updated_task = VCR.use_cassette('update_task_chained') do
-        task.update title: 'updated!'
-      end
-
-      expect(updated_task.client.token).to eq(test_client.token)
-      expect(updated_task.title).to eq('updated!')
-      expect(updated_task.task_id).to eq(task.task_id)
-      expect(updated_task.path).to eq(path)
-
-      delete_response = VCR.use_cassette('delete_task_chained') do
-        updated_task.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['task_deleted']).to be(true)
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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/client/team_user_groups_spec.rb

@@ -1,278 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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 be(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 be(true)
-    expect(group.permissions['is_reviewer']).to be(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 be(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 be(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 be(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/client/team_users_spec.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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 be(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 be(true)
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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/client/translation_providers_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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 be(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