ruby-lokalise-api 5.0.0 → 6.2.0

data/spec/lib/ruby-lokalise-api/error_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Error do
-  include Lokalise::Request
-
-  before { Lokalise.reset_client! }
-
-  after { Lokalise.reset_client! }
-
-  it 'raises a generic error when the code is unknown' do
-    expect do
-      VCR.use_cassette('error_unknown_code') do
-        get 'projects', Lokalise.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', Lokalise.client('invalid')
-      end
-    end.to raise_error(Lokalise::Error::BadRequest)
-  end
-
-  it 'raises BadRequest when API token is invalid' do
-    expect do
-      VCR.use_cassette('error_invalid_token') do
-        get 'projects', Lokalise.client('invalid')
-      end
-    end.to raise_error(Lokalise::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(Lokalise::Error::NotFound)
-  end
-end

data/spec/lib/ruby-lokalise-api/oauth2/auth_spec.rb

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

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

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:branch_id) { 41_302 }
-
-  describe '#branches' do
-    it 'returns all branches' do
-      branches = VCR.use_cassette('all_branches') do
-        test_client.branches project_id
-      end.collection
-
-      expect(branches.count).to eq(4)
-    end
-
-    it 'supports pagination' do
-      branches = VCR.use_cassette('all_branches_pagination') do
-        test_client.branches project_id, limit: 2, page: 2
-      end
-
-      expect(branches.collection.count).to eq(2)
-      expect(branches.total_results).to eq(4)
-      expect(branches.total_pages).to eq(2)
-      expect(branches.results_per_page).to eq(2)
-      expect(branches.current_page).to eq(2)
-      expect(branches.collection.first.name).to eq('merge-me')
-    end
-  end
-
-  specify '#branch' do
-    branch = VCR.use_cassette('branch') do
-      test_client.branch project_id, branch_id
-    end
-
-    expect(branch.branch_id).to eq(branch_id)
-    expect(branch.name).to eq('ruby-branch')
-    expect(branch.created_at).to eq('2019-10-30 14:24:41 (Etc/UTC)')
-    expect(branch.created_at_timestamp).to eq(1_572_445_481)
-    expect(branch.created_by).to eq(20_181)
-    expect(branch.created_by_email).to eq('bodrovis@protonmail.com')
-  end
-
-  specify '#reload_data' do
-    branch = VCR.use_cassette('branch') do
-      test_client.branch project_id, branch_id
-    end
-
-    reloaded_branch = VCR.use_cassette('branch') do
-      branch.reload_data
-    end
-
-    expect(reloaded_branch.branch_id).to eq(branch.branch_id)
-  end
-
-  specify '#create_branch' do
-    branch = VCR.use_cassette('create_branch') do
-      test_client.create_branch project_id, name: 'ruby-branch'
-    end
-
-    expect(branch.name).to eq('ruby-branch')
-  end
-
-  specify '#update_branch' do
-    branch = VCR.use_cassette('update_branch') do
-      test_client.update_branch project_id, branch_id, name: 'updated-ruby-branch'
-    end
-
-    expect(branch.name).to eq('updated-ruby-branch')
-  end
-
-  specify '#destroy_branch' do
-    response = VCR.use_cassette('destroy_branch') do
-      test_client.destroy_branch project_id, branch_id
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['branch_deleted']).to eq(true)
-  end
-
-  specify '#merge_branch' do
-    branch = VCR.use_cassette('create_branch_to_merge') do
-      test_client.create_branch project_id, name: 'merge-me'
-    end
-
-    expect(branch.name).to eq('merge-me')
-
-    branch_id = branch.branch_id
-
-    response = VCR.use_cassette('merge_branch') do
-      test_client.merge_branch project_id, branch_id, force_conflict_resolve_using: 'master'
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['branch_merged']).to eq(true)
-    expect(response['branch']['branch_id']).to eq(branch_id)
-    expect(response['branch']['name']).to eq(branch.name)
-  end
-
-  context 'when branch methods are chained' do
-    it 'supports merge' do
-      branch = VCR.use_cassette('create_branch_to_merge2') do
-        test_client.create_branch project_id, name: 'merge-me-plz'
-      end
-
-      expect(branch.name).to eq('merge-me-plz')
-
-      branch_id = branch.branch_id
-
-      response = VCR.use_cassette('merge_branch_chained') do
-        branch.merge force_conflict_resolve_using: 'master'
-      end
-
-      expect(response['project_id']).to eq(project_id)
-      expect(response['branch_merged']).to eq(true)
-      expect(response['branch']['branch_id']).to eq(branch_id)
-      expect(response['branch']['name']).to eq(branch.name)
-    end
-
-    it 'supports update and destroy' do
-      branch = VCR.use_cassette('create_another_branch') do
-        test_client.create_branch project_id, name: 'ruby-second-branch'
-      end
-
-      expect(branch.name).to eq('ruby-second-branch')
-
-      branch = VCR.use_cassette('update_another_branch') do
-        branch.update name: 'updated-ruby-second-branch'
-      end
-
-      expect(branch.name).to eq('updated-ruby-second-branch')
-
-      response = VCR.use_cassette('destroy_another_branch') do
-        branch.destroy
-      end
-
-      expect(response['project_id']).to eq(project_id)
-      expect(response['branch_deleted']).to eq(true)
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:key_id) { 15_305_182 }
-  let(:another_key_id) { 15_519_786 }
-
-  describe '#comments' do
-    it 'returns all comments' do
-      comments = VCR.use_cassette('all_comments') do
-        test_client.comments project_id, key_id
-      end.collection
-
-      expect(comments.count).to eq(3)
-    end
-
-    it 'supports pagination' do
-      comments = VCR.use_cassette('all_comments_pagination') do
-        test_client.comments project_id, key_id, limit: 1, page: 2
-      end
-
-      expect(comments.collection.count).to eq(1)
-      expect(comments.total_results).to eq(3)
-      expect(comments.total_pages).to eq(3)
-      expect(comments.results_per_page).to eq(1)
-      expect(comments.current_page).to eq(2)
-      expect(comments.collection.first.comment).to eq('demo comment')
-
-      expect(comments.next_page?).to eq(true)
-      expect(comments.last_page?).to eq(false)
-      expect(comments.prev_page?).to eq(true)
-      expect(comments.first_page?).to eq(false)
-
-      expect(comments.client).to be_an_instance_of(described_class)
-    end
-  end
-
-  specify '#comment' do
-    comment = VCR.use_cassette('comment') do
-      test_client.comment project_id, another_key_id, '800746'
-    end
-
-    expect(comment.comment).to eq('rspec comment')
-    expect(comment.comment_id).to eq(800_746)
-    expect(comment.key_id).to eq(another_key_id)
-    expect(comment.added_by).to eq(20_181)
-    expect(comment.added_by_email).to eq('bodrovis@protonmail.com')
-    expect(comment.added_at).to eq('2018-12-09 18:41:44 (Etc/UTC)')
-    expect(comment.added_at_timestamp).to eq(1_544_380_904)
-  end
-
-  specify '#reload_data' do
-    comment = VCR.use_cassette('comment') do
-      test_client.comment project_id, another_key_id, '800746'
-    end
-
-    reloaded_comment = VCR.use_cassette('comment') do
-      comment.reload_data
-    end
-
-    expect(reloaded_comment.key_id).to eq(comment.key_id)
-  end
-
-  specify '#create_comments' do
-    comments = VCR.use_cassette('create_comments') do
-      test_client.create_comments project_id, key_id, [
-        {comment: 'demo comment'},
-        {comment: 'from rspec'}
-      ]
-    end
-
-    first_comment = comments.collection.first
-    second_comment = comments.collection[1]
-
-    expect(comments.project_id).to eq(project_id)
-    expect(first_comment.comment).to eq('demo comment')
-    expect(first_comment.key_id).to eq(key_id)
-    expect(second_comment.comment).to eq('from rspec')
-    expect(second_comment.key_id).to eq(key_id)
-  end
-
-  specify '#project_comments' do
-    comments = VCR.use_cassette('project_comments') do
-      test_client.project_comments project_id
-    end
-
-    comment = comments.collection.first
-
-    expect(comments.total_results).to eq(3)
-    expect(comment.comment).to eq('test')
-    expect(comment.comment_id).to eq(767_938)
-  end
-
-  specify '#destroy_comment' do
-    response = VCR.use_cassette('delete_comment') do
-      test_client.destroy_comment project_id, key_id, 767_938
-    end
-    expect(response['project_id']).to eq(project_id)
-    expect(response['comment_deleted']).to eq(true)
-  end
-
-  context 'when comment methods are chained' do
-    it 'supports destroy' do
-      comment = VCR.use_cassette('create_another_comment') do
-        test_client.create_comments project_id, another_key_id, comment: 'chained comment'
-      end.collection.first
-
-      expect(comment.comment).to eq('chained comment')
-
-      delete_response = VCR.use_cassette('delete_comment_chained') do
-        comment.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['comment_deleted']).to eq(true)
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:contributor_id) { 25_953 }
-
-  describe '#contributors' do
-    it 'returns all contributors' do
-      contributors = VCR.use_cassette('all_contributors') do
-        test_client.contributors project_id
-      end.collection
-
-      expect(contributors.count).to eq(2)
-      expect(contributors.first.fullname).to eq('John Doe')
-    end
-
-    it 'supports pagination' do
-      contributors = VCR.use_cassette('all_contributors_pagination') do
-        test_client.contributors project_id, limit: 1, page: 2
-      end
-
-      expect(contributors.collection.count).to eq(1)
-      expect(contributors.total_results).to eq(2)
-      expect(contributors.total_pages).to eq(2)
-      expect(contributors.results_per_page).to eq(1)
-      expect(contributors.current_page).to eq(2)
-
-      expect(contributors.next_page?).to eq(false)
-      expect(contributors.last_page?).to eq(true)
-      expect(contributors.prev_page?).to eq(true)
-      expect(contributors.first_page?).to eq(false)
-    end
-  end
-
-  specify '#contributor' do
-    contributor = VCR.use_cassette('contributor') do
-      test_client.contributor project_id, '20181'
-    end
-
-    expect(contributor.user_id).to eq(20_181)
-    expect(contributor.email).to eq('bodrovis@protonmail.com')
-    expect(contributor.fullname).to eq('Ilya B')
-    expect(contributor.created_at).to eq('2018-08-21 15:35:25 (Etc/UTC)')
-    expect(contributor.is_admin).to eq(true)
-    expect(contributor.is_reviewer).to eq(true)
-    expect(contributor.languages.first['lang_id']).to eq(803)
-    expect(contributor.admin_rights.first).to eq('upload')
-    expect(contributor.created_at_timestamp).to eq(1_534_865_725)
-  end
-
-  specify '#reload_data' do
-    contributor = VCR.use_cassette('contributor') do
-      test_client.contributor project_id, '20181'
-    end
-
-    reloaded_contributor = VCR.use_cassette('contributor') do
-      contributor.reload_data
-    end
-
-    expect(reloaded_contributor.user_id).to eq(contributor.user_id)
-  end
-
-  specify '#create_contributors' do
-    contributor = VCR.use_cassette('create_contributors') do
-      test_client.create_contributors project_id,
-                                      email: 'rspec@test.com',
-                                      fullname: 'Rspec test',
-                                      languages: [{
-                                        lang_iso: 'en'
-                                      },
-                                                  {
-                                                    lang_iso: 'ru'
-                                                  }]
-    end.collection.first
-
-    expect(contributor.fullname).to eq('Rspec test')
-    expect(contributor.email).to eq('rspec@test.com')
-    expect(contributor.languages[1]['lang_iso']).to eq('ru')
-  end
-
-  specify '#update_contributor' do
-    contributor = VCR.use_cassette('update_contributor') do
-      test_client.update_contributor project_id, contributor_id,
-                                     languages: [{lang_iso: 'en'}]
-    end
-
-    expect(contributor.user_id).to eq(contributor_id)
-    expect(contributor.languages[0]['lang_iso']).to eq('en')
-    expect(contributor.languages.length).to eq(1)
-  end
-
-  specify '#destroy_contributor' do
-    response = VCR.use_cassette('delete_contributor') do
-      test_client.destroy_contributor project_id, contributor_id
-    end
-    expect(response['project_id']).to eq(project_id)
-    expect(response['contributor_deleted']).to eq(true)
-  end
-
-  context 'when contributor methods are chained' do
-    it 'supports update and destroy' do
-      contributor = VCR.use_cassette('create_another_contributor') do
-        test_client.create_contributors project_id,
-                                        email: 'demo@test.com',
-                                        fullname: 'chained',
-                                        languages: [{lang_iso: 'en'}]
-      end.collection.first
-
-      expect(contributor.client.token).to eq(test_client.token)
-      expect(contributor.fullname).to eq('chained')
-
-      id = contributor.user_id
-      path = contributor.path
-
-      updated_contributor = VCR.use_cassette('update_contributor_chained') do
-        contributor.update fullname: 'updated!'
-      end
-
-      expect(updated_contributor.client.token).to eq(test_client.token)
-      expect(updated_contributor.fullname).to eq('updated!')
-      expect(updated_contributor.user_id).to eq(id)
-      expect(updated_contributor.path).to eq(path)
-
-      delete_response = VCR.use_cassette('delete_contributor_chained') do
-        updated_contributor.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['contributor_deleted']).to eq(true)
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::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 eq(true)
-      expect(statuses.last_page?).to eq(false)
-      expect(statuses.prev_page?).to eq(true)
-      expect(statuses.first_page?).to eq(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 eq(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 eq(true)
-    end
-  end
-end