ruby-lokalise-api 4.5.1 → 6.1.0

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:new_project_id) { '572222075c0953fd70d492.30502628' }
-
-  describe '#projects' do
-    it 'returns all projects' do
-      projects = VCR.use_cassette('all_projects') do
-        test_client.projects
-      end.collection
-      project = projects.first
-
-      expect(projects.count).to eq(5)
-      expect(project.name).to eq('demo phoenix')
-    end
-
-    it 'supports pagination' do
-      projects = VCR.use_cassette('all_projects_pagination') do
-        test_client.projects limit: 1, page: 2
-      end
-
-      expect(projects.collection.count).to eq(1)
-      expect(projects.total_results).to eq(5)
-      expect(projects.total_pages).to eq(5)
-      expect(projects.results_per_page).to eq(1)
-      expect(projects.current_page).to eq(2)
-
-      expect(projects.next_page?).to eq(true)
-      expect(projects.last_page?).to eq(false)
-      expect(projects.prev_page?).to eq(true)
-      expect(projects.first_page?).to eq(false)
-    end
-  end
-
-  specify '#project' do
-    project = VCR.use_cassette('project') do
-      test_client.project '803826145ba90b42d5d860.46800099'
-    end
-
-    expect(project.project_id).to eq('803826145ba90b42d5d860.46800099')
-    expect(project.name).to eq('demo phoenix')
-    expect(project.team_id).to eq(176_692)
-    expect(project.description).to eq('')
-    expect(project.created_at).to eq('2018-09-24 16:05:22 (Etc/UTC)')
-    expect(project.created_by).to eq(20_181)
-    expect(project.created_by_email).to eq('bodrovis@protonmail.com')
-    expect(project.created_at_timestamp).to eq(1_537_805_122)
-    expect(project.base_language_id).to eq(640)
-    expect(project.base_language_iso).to eq('en')
-    expect(project.settings['per_platform_key_names']).to eq(false)
-    expect(project.statistics['progress_total']).to eq(18)
-  end
-
-  specify '#reload_data' do
-    project = VCR.use_cassette('project') do
-      test_client.project '803826145ba90b42d5d860.46800099'
-    end
-
-    reloaded_project = VCR.use_cassette('project') do
-      project.reload_data
-    end
-
-    expect(reloaded_project.project_id).to eq(project.project_id)
-  end
-
-  specify '#create_project' do
-    project = VCR.use_cassette('new_project') do
-      test_client.create_project name: 'rspec proj', description: 'demo project for rspec'
-    end
-
-    expect(project.name).to eq('rspec proj')
-    expect(project.description).to eq('demo project for rspec')
-    expect(project.team_id).to eq(176_692)
-  end
-
-  specify '#update_project' do
-    project = VCR.use_cassette('update_project') do
-      test_client.update_project new_project_id,
-                                 name: 'rspec proj updated', description: 'updated project for rspec'
-    end
-
-    expect(project.name).to eq('rspec proj updated')
-    expect(project.description).to eq('updated project for rspec')
-    expect(project.team_id).to eq(176_692)
-  end
-
-  specify '#empty_project' do
-    response = VCR.use_cassette('empty_project') do
-      test_client.empty_project new_project_id
-    end
-
-    expect(response['project_id']).to eq(new_project_id)
-    expect(response['keys_deleted']).to eq(true)
-  end
-
-  specify '#destroy_project' do
-    response = VCR.use_cassette('delete_project') do
-      test_client.destroy_project new_project_id
-    end
-    expect(response['project_id']).to eq(new_project_id)
-    expect(response['project_deleted']).to eq(true)
-  end
-
-  context 'when project methods are chained' do
-    it 'supports update, empty, and destroy' do
-      project = VCR.use_cassette('create_another_project') do
-        test_client.create_project name: 'chained proj'
-      end
-
-      expect(project.name).to eq('chained proj')
-
-      path = project.path
-
-      updated_project = VCR.use_cassette('update_project_chained') do
-        project.update name: 'updated!'
-      end
-
-      expect(updated_project.client.token).to eq(test_client.token)
-      expect(updated_project.name).to eq('updated!')
-      expect(updated_project.path).to eq(path)
-
-      empty_response = VCR.use_cassette('empty_project_chained') do
-        updated_project.empty
-      end
-
-      expect(empty_response['project_id']).to eq(updated_project.project_id)
-      expect(empty_response['keys_deleted']).to eq(true)
-
-      delete_response = VCR.use_cassette('delete_project_chained') do
-        updated_project.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(updated_project.project_id)
-      expect(delete_response['project_deleted']).to eq(true)
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:process_id) { '3b943469e6b3e324b5bdad639b122a623e6e7a1a' }
-  let(:queued_process_id) { '85c42bf5eff44648ca2f01f9db67b7d306a2f282' }
-
-  describe '#queued_processes' do
-    it 'returns all queued processes' do
-      processes = VCR.use_cassette('all_queued_processes') do
-        test_client.queued_processes project_id
-      end
-
-      expect(processes.branch).to eq('master')
-      processes = processes.collection
-      expect(processes.count).to eq(8)
-      expect(processes.first.process_id).to eq(process_id)
-    end
-  end
-
-  specify '#queued_process' do
-    process = VCR.use_cassette('queued_process') do
-      test_client.queued_process project_id, process_id
-    end
-
-    expect(process.branch).to eq('master')
-    expect(process.process_id).to eq(process_id)
-    expect(process.type).to eq('file-import')
-    expect(process.status).to eq('finished')
-    expect(process.message).to eq('')
-    expect(process.created_by).to eq(20_181)
-    expect(process.created_by_email).to eq('bodrovis@protonmail.com')
-    expect(process.created_at).to eq('2020-05-13 11:24:37 (Etc/UTC)')
-    expect(process.created_at_timestamp).to eq(1_589_369_077)
-    files = process.details['files']
-    expect(files.count).to eq(1)
-    expect(files[0]['status']).to eq('finished')
-    expect(files[0]['name_original']).to eq('test_async.json')
-  end
-
-  describe 'process status check' do
-    specify '#reload_data' do
-      queued_process = VCR.use_cassette('upload_file_status') do
-        test_client.queued_process project_id, queued_process_id
-      end
-
-      expect(queued_process.status).to eq('finished')
-
-      reloaded_process = VCR.use_cassette('upload_file_queued_reload') do
-        queued_process.reload_data
-      end
-
-      expect(reloaded_process.process_id).to eq(queued_process.process_id)
-      expect(reloaded_process.status).to eq('finished')
-    end
-  end
-end

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

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:screenshot_id) { 115_185 }
-
-  describe '#screenshots' do
-    it 'returns all screenshots' do
-      screenshots = VCR.use_cassette('all_screenshots') do
-        test_client.screenshots project_id
-      end.collection
-
-      expect(screenshots.count).to eq(1)
-    end
-
-    it 'supports pagination' do
-      screenshots = VCR.use_cassette('all_screenshots_pagination') do
-        test_client.screenshots project_id, limit: 1, page: 1
-      end
-
-      expect(screenshots.collection.count).to eq(1)
-      expect(screenshots.total_results).to eq(1)
-      expect(screenshots.total_pages).to eq(1)
-      expect(screenshots.results_per_page).to eq(1)
-      expect(screenshots.current_page).to eq(1)
-    end
-  end
-
-  specify '#screenshot' do
-    screenshot = VCR.use_cassette('screenshot') do
-      test_client.screenshot project_id, screenshot_id
-    end
-
-    expect(screenshot.screenshot_id).to eq(screenshot_id)
-    expect(screenshot.key_ids).to eq([])
-    expect(screenshot.url).to include('amazonaws.com')
-    expect(screenshot.title).to eq('rspec screen')
-    expect(screenshot.description).to eq('')
-    expect(screenshot.screenshot_tags).to eq([])
-    expect(screenshot.width).to eq(125)
-    expect(screenshot.height).to eq(32)
-  end
-
-  specify '#reload_data' do
-    screenshot = VCR.use_cassette('screenshot') do
-      test_client.screenshot project_id, screenshot_id
-    end
-
-    reloaded_screenshot = VCR.use_cassette('screenshot') do
-      screenshot.reload_data
-    end
-
-    expect(reloaded_screenshot.screenshot_id).to eq(screenshot.screenshot_id)
-  end
-
-  specify '#create_screenshots' do
-    screenshot_from_file do |file|
-      screenshot = VCR.use_cassette('create_screenshots') do
-        test_client.create_screenshots project_id, data: file.read, title: 'rspec screen'
-      end.collection.first
-
-      expect(screenshot.title).to eq('rspec screen')
-      expect(screenshot.url).to include('amazonaws.com')
-    end
-  end
-
-  specify '#update_screenshot' do
-    screenshot = VCR.use_cassette('update_screenshot') do
-      test_client.update_screenshot project_id, screenshot_id, tags: %w[demo rspec],
-                                                               description: 'demo desc'
-    end
-
-    expect(screenshot.screenshot_id).to eq(screenshot_id)
-    expect(screenshot.screenshot_tags).to eq(%w[demo rspec])
-    expect(screenshot.description).to eq('demo desc')
-  end
-
-  specify '#destroy_screenshot' do
-    response = VCR.use_cassette('delete_screenshot') do
-      test_client.destroy_screenshot project_id, screenshot_id
-    end
-    expect(response['project_id']).to eq(project_id)
-    expect(response['screenshot_deleted']).to eq(true)
-  end
-
-  context 'when screenshot methods are chained' do
-    it 'supports update and destroy' do
-      screenshot = screenshot_from_file do |file|
-        VCR.use_cassette('create_another_screenshot') do
-          test_client.create_screenshots project_id, data: file.read, title: 'chained screen'
-        end.collection.first
-      end
-
-      expect(screenshot.client.token).to eq(test_client.token)
-      expect(screenshot.title).to eq('chained screen')
-
-      path = screenshot.path
-
-      updated_screenshot = VCR.use_cassette('update_screenshot_chained') do
-        screenshot.update title: 'updated!'
-      end
-
-      expect(updated_screenshot.client.token).to eq(test_client.token)
-      expect(updated_screenshot.title).to eq('updated!')
-      expect(updated_screenshot.screenshot_id).to eq(screenshot.screenshot_id)
-      expect(updated_screenshot.path).to eq(path)
-
-      delete_response = VCR.use_cassette('delete_screenshot_chained') do
-        updated_screenshot.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['screenshot_deleted']).to eq(true)
-    end
-  end
-end
-
-def screenshot_from_file
-  file = File.open File.expand_path('spec/fixtures/screenshot_base64.txt')
-  begin
-    yield file
-  rescue StandardError => e
-    puts e
-  ensure
-    file.close
-  end
-end

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:project_id) { '39066161618d4ecb9fdc12.00274309' }
-  let(:key_id) { 129_358_815 }
-
-  describe '#segments' do
-    it 'returns all segments for a key under lang_iso' do
-      segments = VCR.use_cassette('all_key_segments') do
-        test_client.segments project_id, key_id, 'en'
-      end.collection
-
-      expect(segments.count).to eq(4)
-      expect(segments.first.value).to eq('Hello!')
-    end
-  end
-
-  describe '#segment' do
-    it 'returns a single segment' do
-      lang_iso = 'en'
-      segment_number = 2
-
-      segment = VCR.use_cassette('key_segment') do
-        test_client.segment project_id, key_id, lang_iso, segment_number
-      end
-
-      expect(segment.key_id).to eq(key_id)
-      expect(segment.segment_number).to eq(segment_number)
-      expect(segment.language_iso).to eq(lang_iso)
-      expect(segment.modified_at).to eq('2021-11-22 16:46:50 (Etc/UTC)')
-      expect(segment.modified_at_timestamp).to eq(1_637_599_610)
-      expect(segment.modified_by).to eq(20_181)
-      expect(segment.modified_by_email).to eq('bodrovis@protonmail.com')
-      expect(segment.value).to eq('This is just a simple text.')
-      expect(segment.is_fuzzy).to eq(false)
-      expect(segment.is_reviewed).to eq(false)
-      expect(segment.reviewed_by).to eq(0)
-      expect(segment.words).to eq(6)
-      expect(segment.custom_translation_statuses.first['color']).to eq('#61bd4f')
-    end
-
-    it 'allows to pass params' do
-      lang_iso = 'en'
-      segment_number = 2
-
-      segment = VCR.use_cassette('key_segment_params') do
-        test_client.segment project_id, key_id, lang_iso, segment_number, disable_references: '1'
-      end
-
-      expect(segment.segment_number).to eq(segment_number)
-      expect(segment.value).to eq('This is just a simple text.')
-      expect(segment.language_iso).to eq(lang_iso)
-    end
-  end
-
-  specify '#update_segment' do
-    lang_iso = 'en'
-    segment_number = 3
-
-    segment = VCR.use_cassette('update_key_segment') do
-      test_client.update_segment project_id, key_id, lang_iso, segment_number,
-                                 value: 'Updated via API',
-                                 is_reviewed: true
-    end
-
-    expect(segment.segment_number).to eq(segment_number)
-    expect(segment.value).to eq('Updated via API')
-    expect(segment.language_iso).to eq(lang_iso)
-  end
-
-  context 'when segment methods are chained' do
-    specify '#reload_data' do
-      lang_iso = 'en'
-      segment_number = 2
-
-      segment = VCR.use_cassette('key_segment') do
-        test_client.segment project_id, key_id, lang_iso, segment_number
-      end
-
-      reloaded_segment = VCR.use_cassette('reload_key_segment') do
-        segment.reload_data
-      end
-
-      expect(reloaded_segment.segment_number).to eq(segment_number)
-      expect(reloaded_segment.key_id).to eq(key_id)
-    end
-
-    specify '#update' do
-      lang_iso = 'en'
-      segment_number = 4
-
-      segment = VCR.use_cassette('another_key_segment') do
-        test_client.segment project_id, key_id, lang_iso, segment_number
-      end
-
-      updated_segment = VCR.use_cassette('update_key_segment_chained') do
-        segment.update value: 'Chain Updated',
-                       is_fuzzy: true
-      end
-
-      expect(updated_segment.segment_number).to eq(segment_number)
-      expect(updated_segment.is_fuzzy).to eq(true)
-      expect(updated_segment.value).to eq('Chain Updated')
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::Client do
-  let(:project_id) { '803826145ba90b42d5d860.46800099' }
-  let(:snapshot_id) { 27_881 }
-
-  describe '#snapshots' do
-    it 'returns all snapshots' do
-      snapshots = VCR.use_cassette('all_snapshots') do
-        test_client.snapshots project_id
-      end.collection
-
-      snapshot = snapshots.first
-
-      expect(snapshots.count).to eq(1)
-      expect(snapshot.title).to eq('test rspec')
-      expect(snapshot.snapshot_id).to eq(27_882)
-      expect(snapshot.created_at).to eq('2018-12-10 17:02:04 (Etc/UTC)')
-      expect(snapshot.created_by).to eq(20_181)
-      expect(snapshot.created_by_email).to eq('bodrovis@protonmail.com')
-      expect(snapshot.created_at_timestamp).to eq(1_544_461_324)
-    end
-
-    it 'supports pagination' do
-      snapshots = VCR.use_cassette('all_snapshots_pagination') do
-        test_client.snapshots project_id, limit: 1, page: 2
-      end
-
-      expect(snapshots.collection.count).to eq(1)
-      expect(snapshots.total_results).to eq(2)
-      expect(snapshots.total_pages).to eq(2)
-      expect(snapshots.results_per_page).to eq(1)
-      expect(snapshots.current_page).to eq(2)
-
-      expect(snapshots.next_page?).to eq(false)
-      expect(snapshots.last_page?).to eq(true)
-      expect(snapshots.prev_page?).to eq(true)
-      expect(snapshots.first_page?).to eq(false)
-    end
-  end
-
-  specify '#create_snapshot' do
-    snapshot = VCR.use_cassette('create_snapshot') do
-      test_client.create_snapshot project_id, title: 'test rspec'
-    end
-
-    expect(snapshot.title).to eq('test rspec')
-  end
-
-  specify '#restore_snapshot' do
-    project = VCR.use_cassette('restore_snapshot') do
-      test_client.restore_snapshot project_id, snapshot_id
-    end
-
-    expect(project.name).to eq('demo phoenix copy')
-    expect(project.created_by_email).to eq('bodrovis@protonmail.com')
-    # Restore creates a new copy of the project!
-    expect(project.project_id).not_to eq(project_id)
-  end
-
-  specify '#destroy_snapshot' do
-    response = VCR.use_cassette('delete_snapshot') do
-      test_client.destroy_snapshot project_id, snapshot_id
-    end
-
-    expect(response['project_id']).to eq(project_id)
-    expect(response['snapshot_deleted']).to eq(true)
-  end
-
-  context 'when snapshot methods are chained' do
-    it 'allows restored project to receive chained methods' do
-      snapshot = VCR.use_cassette('create_snapshot_for_chained') do
-        test_client.create_snapshot project_id, title: 'chained rspec snap'
-      end
-
-      new_project = VCR.use_cassette('restore_snapshot_for_chained') do
-        snapshot.restore
-      end
-
-      updated_project = VCR.use_cassette('restored_updated_project') do
-        new_project.update name: 'Restored and updated'
-      end
-
-      expect(updated_project.client.token).to eq(test_client.token)
-      expect(updated_project.name).to eq('Restored and updated')
-      expect(updated_project.project_id).to eq(new_project.project_id)
-
-      response = VCR.use_cassette('delete_restored_project') do
-        updated_project.destroy
-      end
-
-      expect(response['project_id']).to eq(updated_project.project_id)
-      expect(response['project_deleted']).to eq(true)
-    end
-
-    it 'supports destroy and restore' do
-      snapshot = VCR.use_cassette('create_another_snapshot') do
-        test_client.create_snapshot project_id, title: 'chained'
-      end
-
-      expect(snapshot.title).to eq('chained')
-
-      restored_project = VCR.use_cassette('restore_snapshot_chained') do
-        snapshot.restore
-      end
-
-      expect(restored_project.name).to eq('demo phoenix copy')
-
-      delete_response = VCR.use_cassette('delete_snapshot_chained') do
-        snapshot.destroy
-      end
-
-      expect(delete_response['project_id']).to eq(project_id)
-      expect(delete_response['snapshot_deleted']).to eq(true)
-    end
-  end
-end

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

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lokalise::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 eq(nil)
-    expect(task.due_date_timestamp).to eq(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 eq(false)
-    expect(task.task_type).to eq('review')
-    expect(task.parent_task_id).to eq(nil)
-    expect(task.closing_tags).to eq([])
-    expect(task.languages.first['language_iso']).to eq('sq')
-    expect(task.auto_close_languages).to eq(true)
-    expect(task.auto_close_task).to eq(true)
-    expect(task.auto_close_items).to eq(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 eq(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 eq(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 eq(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 eq(true)
-    end
-  end
-end