deepl-rb 3.6.1 → 3.8.0

data/spec/requests/rephrase_spec.rb

@@ -6,8 +6,6 @@
 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
@@ -19,153 +17,29 @@ describe DeepL::Requests::Rephrase 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
+  describe '#initialize' do
+    context 'when passing additional headers' do
+      it 'merges the headers into the request headers' do
+        request = described_class.new(api, text, target_lang, nil, nil, {},
+                                      { 'X-DeepL-Reporting-Tag' => 'my-tag' })
+        expect(request.send(:headers)).to include('X-DeepL-Reporting-Tag' => 'my-tag')
       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
+      it 'defaults to no additional headers' do
+        request = described_class.new(api, text, target_lang)
+        expect(request.send(:headers).keys).to contain_exactly('Authorization', 'User-Agent')
       end
     end
 
-    context 'with a writing style or tone from the provided constants applied' do
+    context 'with a writing style and 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
+        request = described_class.new(api, text, target_lang, writing_style, tone)
+        expect(request.writing_style).to eq('business')
+        expect(request.tone).to eq('friendly')
       end
     end
   end

data/spec/requests/style_rule/create_custom_instruction_spec.rb

@@ -0,0 +1,30 @@
+# 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
+end

data/spec/requests/style_rule/create_spec.rb

@@ -0,0 +1,29 @@
+# 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
+end

data/spec/requests/style_rule/destroy_custom_instruction_spec.rb

@@ -0,0 +1,28 @@
+# 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
+end

data/spec/requests/style_rule/destroy_spec.rb

@@ -0,0 +1,27 @@
+# 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
+end

data/spec/requests/style_rule/find_custom_instruction_spec.rb

@@ -0,0 +1,29 @@
+# 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
+end

data/spec/requests/style_rule/find_spec.rb

@@ -0,0 +1,28 @@
+# 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
+end

data/spec/requests/style_rule/list_spec.rb

@@ -0,0 +1,27 @@
+# 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
+end

data/spec/requests/style_rule/update_configured_rules_spec.rb

@@ -0,0 +1,31 @@
+# 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
+end

data/spec/requests/style_rule/update_custom_instruction_spec.rb

@@ -0,0 +1,32 @@
+# 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::UpdateCustomInstruction do
+  subject(:update_instruction) do
+    described_class.new(api, style_id, instruction_id, label, prompt, nil, {})
+  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(:instruction_id) { 'test-instruction-id' }
+  let(:label) { 'Updated Label' }
+  let(:prompt) { 'Use casual language' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(update_instruction).to be_a(described_class)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/update_spec.rb

@@ -0,0 +1,29 @@
+# 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::Update do
+  subject(:update) { described_class.new(api, style_id, name, 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(:name) { 'Updated Name' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(update).to be_a(described_class)
+      end
+    end
+  end
+end