ruby-lokalise-api 1.1.0 → 2.0.0

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

@@ -81,11 +81,40 @@ RSpec.describe Lokalise::Client do
     expect(language.plural_forms).to eq(%w[one])
   end
 
-  specify '#delete_language' do
+  specify '#destroy_language' do
     response = VCR.use_cassette('delete_language') do
-      test_client.delete_language project_id, new_language_id
+      test_client.destroy_language project_id, new_language_id
     end
     expect(response['project_id']).to eq(project_id)
     expect(response['language_deleted']).to eq(true)
   end
+
+  context 'project language chained methods' do
+    it 'should support update and destroy' do
+      language = VCR.use_cassette('create_another_language') do
+        test_client.create_languages project_id, lang_iso: 'ab', custom_name: 'chained lang'
+      end.collection.first
+
+      expect(language.client).to eq(test_client)
+      expect(language.lang_name).to eq('chained lang')
+
+      path = language.path
+
+      updated_language = VCR.use_cassette('update_language_chained') do
+        language.update lang_name: 'updated!'
+      end
+
+      expect(updated_language.client).to eq(test_client)
+      expect(updated_language.lang_name).to eq('updated!')
+      expect(updated_language.lang_id).to eq(language.lang_id)
+      expect(updated_language.path).to eq(path)
+
+      delete_response = VCR.use_cassette('delete_language_chained') do
+        updated_language.destroy
+      end
+
+      expect(delete_response['project_id']).to eq(project_id)
+      expect(delete_response['language_deleted']).to eq(true)
+    end
+  end
 end

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

@@ -74,11 +74,45 @@ RSpec.describe Lokalise::Client do
     expect(response['keys_deleted']).to eq(true)
   end
 
-  specify '#delete_project' do
+  specify '#destroy_project' do
     response = VCR.use_cassette('delete_project') do
-      test_client.delete_project new_project_id
+      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 'project chained methods' do
+    it 'should support 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).to eq(test_client)
+      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/screenshots_spec.rb

@@ -40,18 +40,13 @@ RSpec.describe Lokalise::Client do
   end
 
   specify '#create_screenshots' do
-    file = File.open File.expand_path('spec/fixtures/screenshot_base64.txt')
-    begin
+    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')
-    rescue StandardError => e
-      puts e
-    ensure
-      file.close
     end
   end
 
@@ -66,11 +61,53 @@ RSpec.describe Lokalise::Client do
     expect(screenshot.description).to eq('demo desc')
   end
 
-  specify '#delete_screenshot' do
+  specify '#destroy_screenshot' do
     response = VCR.use_cassette('delete_screenshot') do
-      test_client.delete_screenshot project_id, screenshot_id
+      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 'screenshot chained methods' do
+    it 'should support 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).to eq(test_client)
+      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).to eq(test_client)
+      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/snapshots_spec.rb

@@ -55,12 +55,35 @@ RSpec.describe Lokalise::Client do
     expect(project.project_id).not_to eq(project_id)
   end
 
-  specify '#delete_snapshot' do
+  specify '#destroy_snapshot' do
     response = VCR.use_cassette('delete_snapshot') do
-      test_client.delete_snapshot project_id, snapshot_id
+      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 'snapshot chained methods' do
+    it 'should support 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

@@ -79,11 +79,47 @@ RSpec.describe Lokalise::Client do
     expect(task.auto_close_task).to eq(true)
   end
 
-  specify '#delete_task' do
+  specify '#destroy_task' do
     response = VCR.use_cassette('delete_task') do
-      test_client.delete_task project_id, task_id
+      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 'task chained methods' do
+    it 'should support 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).to eq(test_client)
+      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).to eq(test_client)
+      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

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

@@ -1,6 +1,7 @@
 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 'should return all team_users' do
@@ -46,11 +47,33 @@ RSpec.describe Lokalise::Client do
     expect(team_user.role).to eq('admin')
   end
 
-  specify '#delete_team_user' do
+  specify '#destroy_team_user' do
     response = VCR.use_cassette('delete_team_user') do
-      test_client.delete_team_user team_id, team_user_id
+      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 'team user chained methods' do
+    it 'should support 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).to eq(test_client)
+      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/translations_spec.rb

@@ -1,6 +1,7 @@
 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 'should return all translations' do
@@ -23,7 +24,6 @@ RSpec.describe Lokalise::Client do
       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.ids).to eq([project_id])
 
       next_page_trans = VCR.use_cassette('translations_next_page') do
         translations.next_page
@@ -35,7 +35,6 @@ RSpec.describe Lokalise::Client do
       expect(next_page_trans.request_params[:disable_references]).to eq(0)
       expect(next_page_trans.total_results).to eq(9)
       expect(next_page_trans.current_page).to eq(3)
-      expect(next_page_trans.ids).to eq([project_id])
       expect(next_page_trans.next_page?).to eq(false)
       expect(next_page_trans.prev_page?).to eq(true)
 
@@ -51,7 +50,6 @@ RSpec.describe Lokalise::Client do
       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)
-      expect(prev_page_trans.ids).to eq([project_id])
     end
   end
 
@@ -82,4 +80,20 @@ RSpec.describe Lokalise::Client do
     expect(translation.translation).to eq('rspec trans')
     expect(translation.is_reviewed).to eq(true)
   end
+
+  context 'translation chained methods' do
+    it 'should support 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).to eq(test_client)
+      expect(updated_translation.translation).to eq('chained updated')
+      expect(updated_translation.translation_id).to eq(translation.translation_id)
+    end
+  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lokalise-api
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Ilya Bodrov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-11 00:00:00.000000000 Z
+date: 2018-12-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -189,6 +203,7 @@ files:
 - lib/ruby-lokalise-api/rest/teams.rb
 - lib/ruby-lokalise-api/rest/translations.rb
 - lib/ruby-lokalise-api/utils/attribute_helpers.rb
+- lib/ruby-lokalise-api/utils/endpoint_helpers.rb
 - lib/ruby-lokalise-api/utils/string_utils.rb
 - lib/ruby-lokalise-api/version.rb
 - ruby-lokalise-api.gemspec