ruby-lokalise-api 6.0.0 → 6.1.0

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

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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 be(false)
-      expect(cards.last_page?).to be(true)
-      expect(cards.prev_page?).to be(false)
-      expect(cards.first_page?).to be(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 be(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 be(true)
-    expect(result['card_id']).to eq(card_id)
-  end
-end

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

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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 be(true)
-      expect(projects.last_page?).to be(false)
-      expect(projects.prev_page?).to be(true)
-      expect(projects.first_page?).to be(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 be(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
-
-  context 'with OAuth 2 token' do
-    it 'creates a project' do
-      name = 'OAuth 2 project'
-      description = 'Via OAuth 2'
-      project = VCR.use_cassette('oauth2/new_project') do
-        test_oauth2_client.create_project name: name, description: description
-      end
-
-      expect(project.name).to eq(name)
-      expect(project.description).to eq(description)
-    end
-  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 be(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 be(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 be(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 be(true)
-    end
-  end
-end

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

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

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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 be(false)
-      expect(segment.is_reviewed).to be(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 be(true)
-      expect(updated_segment.value).to eq('Chain Updated')
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RubyLokaliseApi::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 be(false)
-      expect(snapshots.last_page?).to be(true)
-      expect(snapshots.prev_page?).to be(true)
-      expect(snapshots.first_page?).to be(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 be(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 be(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 be(true)
-    end
-  end
-end