deepl-rb 3.6.0 → 3.7.0

data/spec/requests/languages_spec.rb

@@ -0,0 +1,68 @@
+# Copyright 2021 Daniel Herzog
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Languages do
+  subject(:languages_obj) { described_class.new(api, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(languages_obj).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('languages') { example.call }
+    end
+
+    context 'when requesting source languages' do
+      it 'returns a valid list of source languages' do
+        languages = languages_obj.request
+
+        expect(languages).to be_an(Array)
+        expect(languages.size).to eq(29)
+        expect(languages).to(be_any { |l| l.code == 'EN' && l.name == 'English' })
+        expect(languages).to(be_any { |l| l.code == 'ES' && l.name == 'Spanish' })
+      end
+    end
+
+    context 'when requesting target languages' do
+      let(:options) { { type: :target } }
+
+      it 'returns a valid list of target languages' do
+        languages = languages_obj.request
+
+        expect(languages).to be_an(Array)
+        expect(languages.size).to eq(31)
+        expect(languages).not_to(be_any { |l| l.code == 'EN' && l.name == 'English' })
+        expect(languages).to(be_any { |l| l.code == 'ES' && l.name == 'Spanish' })
+        expect(languages)
+          .to(be_any { |l| l.code == 'EN-US' && l.name == 'English (American)' })
+      end
+    end
+
+    context 'when using an invalid type' do
+      let(:options) { { type: :invalid } }
+
+      it 'returns an usage object' do
+        message = "Parameter 'type' is invalid. 'source' and 'target' are valid values."
+        expect { languages_obj.request }.to raise_error(DeepL::Exceptions::BadRequest, message)
+      end
+    end
+  end
+end

data/spec/requests/rephrase_spec.rb

@@ -0,0 +1,172 @@
+# Copyright 2025 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Rephrase do
+  subject(:rephrase) { described_class.new(api, text, target_lang, writing_style, tone, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:text) do
+    'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.'
+  end
+  let(:target_lang) { 'EN' }
+  let(:writing_style) { nil }
+  let(:tone) { nil }
+  let(:options) { {} }
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('rephrase_texts') { example.call }
+    end
+
+    context 'without a style or tone applied' do
+      context 'with a string as input' do
+        it 'returns a valid response as a DeepL Text resource' do
+          original_length = text.length
+          response_text = rephrase.request
+
+          expect(response_text).to be_a(DeepL::Resources::Text)
+          expect(response_text.text.length).not_to eq(original_length)
+          expect(response_text.detected_source_language.upcase).to eq('EN')
+        end
+      end
+
+      context 'with an array of texts as input' do
+        let(:text) do
+          [
+            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
+            'He lay on his armour-like back, and if he lifted his head a little'
+          ]
+        end
+
+        it 'returns a valid response as an array of DeepL Text resources' do
+          response_texts = rephrase.request
+
+          expect(response_texts).to all(be_a(DeepL::Resources::Text))
+          response_texts.each_with_index do |response_text, index|
+            expect(response_text.text.length).not_to eq(text[index].length)
+            expect(response_text.detected_source_language.upcase).to eq('EN')
+          end
+        end
+      end
+    end
+
+    context 'with a valid tone applied' do
+      let(:tone) { 'friendly' }
+
+      context 'with a string as input' do
+        it 'returns a valid response with a string as text input' do
+          original_length = text.length
+          response_text = rephrase.request
+
+          expect(response_text).to be_a(DeepL::Resources::Text)
+          expect(response_text.text.length).not_to eq(original_length)
+          expect(response_text.detected_source_language.upcase).to eq('EN')
+        end
+      end
+
+      context 'with an array of texts as input' do
+        let(:text) do
+          [
+            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
+            'He lay on his armour-like back, and if he lifted his head a little'
+          ]
+        end
+
+        it 'returns an array of valid text objects' do
+          response_texts = rephrase.request
+
+          expect(response_texts).to all(be_a(DeepL::Resources::Text))
+          response_texts.each_with_index do |response_text, index|
+            expect(response_text.text.length).not_to eq(text[index].length)
+            expect(response_text.detected_source_language.upcase).to eq('EN')
+          end
+        end
+      end
+    end
+
+    context 'with a valid writing style applied' do
+      let(:writing_style) { 'business' }
+
+      context 'with a string as input' do
+        it 'returns a valid response with a string as text input' do
+          original_length = text.length
+          response_text = rephrase.request
+
+          expect(response_text).to be_a(DeepL::Resources::Text)
+          expect(response_text.text.length).not_to eq(original_length)
+          expect(response_text.detected_source_language.upcase).to eq('EN')
+        end
+      end
+
+      context 'with an array of texts as input' do
+        let(:text) do
+          [
+            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
+            'He lay on his armour-like back, and if he lifted his head a little'
+          ]
+        end
+
+        it 'returns an array of valid text objects' do
+          response_texts = rephrase.request
+
+          expect(response_texts).to all(be_a(DeepL::Resources::Text))
+          response_texts.each_with_index do |response_text, index|
+            expect(response_text.text.length).not_to eq(text[index].length)
+            expect(response_text.detected_source_language.upcase).to eq('EN')
+          end
+        end
+      end
+    end
+
+    context 'with a writing style or tone from the provided constants applied' do
+      let(:writing_style) { DeepL::Constants::WritingStyle::BUSINESS }
+      let(:tone) { DeepL::Constants::Tone::FRIENDLY }
+
+      it 'has the correct writing style and tone applied' do
+        expect(rephrase.writing_style).to eq('business')
+        expect(rephrase.tone).to eq('friendly')
+      end
+    end
+
+    context 'with an invalid writing style applied' do
+      let(:writing_style) { 'angry' }
+
+      it 'raises a bad request error' do
+        expect { rephrase.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+
+    context 'when both writing style and tone are applied' do
+      let(:writing_style) { 'business' }
+      let(:tone) { 'friendly' }
+
+      it 'raises a bad request error' do
+        expect { rephrase.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+
+    context 'when performing a bad request' do
+      context 'when using an invalid token' do
+        let(:api) do
+          api = build_deepl_api
+          api.configuration.auth_key = 'invalid'
+          api
+        end
+
+        it 'raises an unauthorized error' do
+          expect { rephrase.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+        end
+      end
+    end
+  end
+end

data/spec/requests/style_rule/create_custom_instruction_spec.rb

@@ -0,0 +1,54 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::CreateCustomInstruction do
+  subject(:create_instruction) { described_class.new(api, style_id, label, prompt, nil, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:label) { 'Test Instruction' }
+  let(:prompt) { 'Always use formal language' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(create_instruction).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:create_instruction) do
+        described_class.new(api, new_rule.style_id, label, prompt)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Instruction Test', 'en').request
+      end
+
+      it 'returns a custom instruction object' do
+        instruction = create_instruction.request
+        expect(instruction).to be_a(DeepL::Resources::CustomInstruction)
+        expect(instruction.id).to be_a(String)
+        expect(instruction.label).to eq('Test Instruction')
+        expect(instruction.prompt).to eq('Always use formal language')
+      end
+    end
+  end
+end

data/spec/requests/style_rule/create_spec.rb

@@ -0,0 +1,45 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::Create do
+  subject(:create) { described_class.new(api, name, language, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:name) { 'Test Style Rule' }
+  let(:language) { 'en' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(create).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      it 'returns a style rule object' do
+        style_rule = create.request
+        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
+        expect(style_rule.style_id).to be_a(String)
+        expect(style_rule.name).to eq('Test Style Rule')
+        expect(style_rule.language).to eq('en')
+      end
+    end
+  end
+end

data/spec/requests/style_rule/destroy_custom_instruction_spec.rb

@@ -0,0 +1,54 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::DestroyCustomInstruction do
+  subject(:destroy_instruction) { described_class.new(api, style_id, instruction_id) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:instruction_id) { 'test-instruction-id' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(destroy_instruction).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:destroy_instruction) do
+        described_class.new(api, new_rule.style_id, new_instruction.id)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Destroy Instruction Test', 'en').request
+      end
+      let(:new_instruction) do
+        DeepL::Requests::StyleRule::CreateCustomInstruction.new(
+          api, new_rule.style_id, 'To Delete', 'Delete me'
+        ).request
+      end
+
+      it 'returns the deleted instruction id' do
+        response = destroy_instruction.request
+        expect(response).to eq(new_instruction.id)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/destroy_spec.rb

@@ -0,0 +1,54 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::Destroy do
+  subject(:destroy) { described_class.new(api, style_id) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(destroy).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:destroy) { described_class.new(api, new_rule.style_id) }
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Destroy Test', 'en').request
+      end
+
+      it 'returns the deleted style rule id' do
+        response = destroy.request
+        expect(response).to eq(new_rule.style_id)
+      end
+    end
+
+    context 'when deleting a non existing style rule with an invalid id' do
+      let(:style_id) { 'invalid-uuid' }
+
+      it 'raises an error' do
+        expect { destroy.request }.to raise_error(DeepL::Exceptions::Error)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/find_custom_instruction_spec.rb

@@ -0,0 +1,56 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::FindCustomInstruction do
+  subject(:find_instruction) { described_class.new(api, style_id, instruction_id, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:instruction_id) { 'test-instruction-id' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(find_instruction).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:find_instruction) do
+        described_class.new(api, new_rule.style_id, new_instruction.id)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Find Instruction Test', 'en').request
+      end
+      let(:new_instruction) do
+        DeepL::Requests::StyleRule::CreateCustomInstruction.new(
+          api, new_rule.style_id, 'Test', 'Test prompt'
+        ).request
+      end
+
+      it 'returns a custom instruction object' do
+        instruction = find_instruction.request
+        expect(instruction).to be_a(DeepL::Resources::CustomInstruction)
+        expect(instruction.id).to eq(new_instruction.id)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/find_spec.rb

@@ -0,0 +1,56 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::Find do
+  subject(:style_rule_find) { described_class.new(api, style_id, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(style_rule_find).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:style_rule_find) do
+        new_rule = DeepL::Requests::StyleRule::Create.new(api, 'Find Test', 'en').request
+        described_class.new(api, new_rule.style_id, options)
+      end
+
+      it 'returns a style rule object' do
+        style_rule = style_rule_find.request
+        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
+        expect(style_rule.style_id).to be_a(String)
+        expect(style_rule.name).to be_a(String)
+      end
+    end
+
+    context 'when requesting a non existing style rule with an invalid id' do
+      let(:style_id) { 'invalid-uuid' }
+
+      it 'raises an error' do
+        expect { style_rule_find.request }.to raise_error(DeepL::Exceptions::Error)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/list_spec.rb

@@ -0,0 +1,58 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::List do
+  subject(:style_rule_list) { described_class.new(api, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(style_rule_list).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules') { example.call }
+    end
+
+    context 'when requesting a list of all style rules' do
+      it 'returns an array of style rules' do
+        style_rules = style_rule_list.request
+        expect(style_rules).to be_an(Array)
+        expect(style_rules).not_to be_empty
+        expect(style_rules.first).to be_a(DeepL::Resources::StyleRule)
+        expect(style_rules.first.style_id).to be_a(String)
+        expect(style_rules.first.name).to be_a(String)
+      end
+    end
+
+    context 'when performing a bad request' do
+      context 'when using an invalid token' do
+        let(:api) do
+          api = build_deepl_api
+          api.configuration.auth_key = 'invalid'
+          api
+        end
+
+        it 'raises an authorization failed error' do
+          expect { style_rule_list.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+        end
+      end
+    end
+  end
+end

data/spec/requests/style_rule/update_configured_rules_spec.rb

@@ -0,0 +1,52 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::UpdateConfiguredRules do
+  subject(:update_configured_rules) do
+    described_class.new(api, style_id, configured_rules, options)
+  end
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:configured_rules) { { 'dates_and_times' => { 'calendar_era' => 'use_bc_and_ad' } } }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(update_configured_rules).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:update_configured_rules) do
+        described_class.new(api, new_rule.style_id, configured_rules)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Configured Rules Test', 'en').request
+      end
+
+      it 'returns a style rule object' do
+        style_rule = update_configured_rules.request
+        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
+      end
+    end
+  end
+end