deepl-rb 3.7.0 → 3.8.0

data/spec/requests/style_rule/destroy_spec.rb

@@ -24,31 +24,4 @@ describe DeepL::Requests::StyleRule::Destroy do
       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

@@ -26,31 +26,4 @@ describe DeepL::Requests::StyleRule::FindCustomInstruction do
       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

@@ -25,32 +25,4 @@ describe DeepL::Requests::StyleRule::Find do
       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

@@ -24,35 +24,4 @@ describe DeepL::Requests::StyleRule::List do
       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

@@ -28,25 +28,4 @@ describe DeepL::Requests::StyleRule::UpdateConfiguredRules do
       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

data/spec/requests/style_rule/update_custom_instruction_spec.rb

@@ -29,30 +29,4 @@ describe DeepL::Requests::StyleRule::UpdateCustomInstruction do
       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_instruction) do
-        described_class.new(api, new_rule.style_id, new_instruction.id, label, prompt)
-      end
-
-      let(:new_rule) do
-        DeepL::Requests::StyleRule::Create.new(api, 'Update Instruction Test', 'en').request
-      end
-      let(:new_instruction) do
-        DeepL::Requests::StyleRule::CreateCustomInstruction.new(
-          api, new_rule.style_id, 'Original', 'Original prompt'
-        ).request
-      end
-
-      it 'returns a custom instruction object' do
-        instruction = update_instruction.request
-        expect(instruction).to be_a(DeepL::Resources::CustomInstruction)
-      end
-    end
-  end
 end

data/spec/requests/style_rule/update_spec.rb

@@ -26,23 +26,4 @@ describe DeepL::Requests::StyleRule::Update do
       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) { described_class.new(api, new_rule.style_id, 'Updated Name') }
-
-      let(:new_rule) do
-        DeepL::Requests::StyleRule::Create.new(api, 'Update Test', 'en').request
-      end
-
-      it 'returns a style rule object' do
-        style_rule = update.request
-        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
-      end
-    end
-  end
 end

data/spec/requests/translate_spec.rb

@@ -266,226 +266,17 @@ describe DeepL::Requests::Translate do
         expect(request.options[:custom_instructions]).to eq(['Use informal language', 'Be concise'])
       end
     end
-  end
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('translate_texts') { example.call }
-    end
-
-    context 'when performing a valid request with one text' do
-      it 'returns a text object' do
-        text = translate.request
-
-        expect(text).to be_a(DeepL::Resources::Text)
-        expect(text.text).to eq('Texto de muestra')
-        expect(text.detected_source_language).to eq('EN')
-      end
-    end
-
-    context 'when performing a valid request with multiple texts' do
-      let(:text) { %w[Sample Word] }
-
-      it 'returns a text object' do
-        texts = translate.request
-
-        expect(texts).to be_a(Array)
-        expect(texts.first.text).to eq('Muestra')
-        expect(texts.first.detected_source_language).to eq('EN')
-
-        expect(texts.last.text).to eq('Palabra')
-        expect(texts.last.detected_source_language).to eq('EN')
-      end
-    end
-
-    context 'when performing a valid request with tag handling' do
-      let(:text) { '<p>Sample text</p>' }
-      let(:options) { { tag_handling: 'xml' } }
-
-      it 'returns a text object' do
-        text = translate.request
-
-        expect(text).to be_a(DeepL::Resources::Text)
-        expect(text.text).to eq('<p>Texto de muestra</p>')
-        expect(text.detected_source_language).to eq('EN')
-      end
-    end
-
-    context 'when performing a valid request and passing a variable' do
-      let(:text) { 'Welcome and <code>Hello great World</code> Good Morning!' }
-      let(:options) { { tag_handling: 'xml', ignore_tags: %w[code span] } }
-
-      it 'returns a text object' do
-        text = translate.request
-
-        expect(text).to be_a(DeepL::Resources::Text)
-        expect(text.text).to eq('Bienvenido y <code>Hello great World</code> ¡Buenos días!')
-        expect(text.detected_source_language).to eq('EN')
-      end
-    end
-
-    context 'when performing a valid request with an HTML document' do
-      let(:text) do
-        <<~XML
-          <document>
-            <meta>
-              <title>A document's title</title>
-            </meta>
-            <content>
-              <par>This is the first sentence. Followed by a second one.</par>
-              <par>This is the third sentence.</par>
-            </content>
-          </document>
-        XML
-      end
-      let(:options) do
-        {
-          tag_handling: 'xml',
-          split_sentences: 'nonewlines',
-          outline_detection: false,
-          splitting_tags: %w[title par]
-        }
-      end
-
-      it 'returns a text object' do
-        text = translate.request
-
-        expect(text).to be_a(DeepL::Resources::Text)
-        expect(text.text).to eq(
-          <<~XML
-            <document>
-              <meta>
-                <title>Título de un documento</title>
-              </meta>
-              <content>
-                <par>Es la primera frase. Seguido de una segunda.</par>
-                <par>Esta es la tercera frase.</par>
-              </content>
-            </document>
-          XML
-        )
-        expect(text.detected_source_language).to eq('EN')
-      end
-    end
-
-    context 'when performing a valid request with context' do
-      let(:text) { 'That is hot!' }
-
-      context 'when context is empty' do
-        let(:options) { { context: '' } }
-
-        it 'translates correctly with empty context' do
-          res = translate.request
-          expect(res).to be_a(DeepL::Resources::Text)
-          expect(res.text).to eq('¡Eso está caliente!')
-        end
-      end
 
-      context 'when context is set' do
-        let(:options) { { context: 'He did not like the jalapenos in his meal.' } }
-
-        it 'translates correctly with context taken into account' do
-          res = translate.request
-          expect(res).to be_a(DeepL::Resources::Text)
-          expect(res.text).to eq('¡Eso es picante!')
-        end
-      end
-    end
-
-    context 'when performing a request with a model type' do
-      let(:target_lang) { 'DE' }
-
-      %w[quality_optimized latency_optimized prefer_quality_optimized].each do |model_type_str|
-        it "translates correctly with #{model_type_str} models" do
-          options = { model_type: model_type_str }
-          translate = described_class.new(api, text, source_lang, target_lang, options)
-          res = translate.request
-          expect(res).to be_a(DeepL::Resources::Text)
-          expect(res.model_type_used).not_to be_nil
-        end
-      end
-    end
-
-    context 'when performing a request with extra_body_parameters' do
-      it 'allows extra parameters to override standard parameters' do
-        extra_options = { extra_body_parameters: { target_lang: 'FR', debug: '1' } }
-        translate = described_class.new(api, text, source_lang, target_lang, extra_options)
-        res = translate.request
-
-        expect(res).to be_a(DeepL::Resources::Text)
-        expect(res.text).to eq('Texte modèle')
-        expect(res.detected_source_language).to eq('EN')
-      end
-    end
-
-    context 'when performing a request with custom_instructions' do
-      let(:text) { 'Hello world' }
-      let(:target_lang) { 'DE' }
-
-      it 'includes custom_instructions in the payload' do
-        options = { custom_instructions: ['Use formal language', 'Be concise'] }
-        translate = described_class.new(api, text, source_lang, target_lang, options)
-
-        # Verify the options are properly stored
-        expect(translate.options[:custom_instructions]).to eq(['Use formal language', 'Be concise'])
+    context 'when passing additional headers' do
+      it 'merges the headers into the request headers' do
+        request = described_class.new(api, nil, nil, nil, {},
+                                      { 'X-DeepL-Reporting-Tag' => 'my-tag' })
+        expect(request.send(:headers)).to include('X-DeepL-Reporting-Tag' => 'my-tag')
       end
-    end
-
-    context 'when performing a request with tag_handling_version' do
-      let(:text) { '<p>Hello world</p>' }
-      let(:target_lang) { 'DE' }
-
-      %w[v1 v2].each do |version|
-        it "translates correctly with tag_handling_version #{version}" do
-          options = { tag_handling: 'html', tag_handling_version: version }
-          translate = described_class.new(api, text, source_lang, target_lang, options)
-          res = translate.request
-
-          expect(res).to be_a(DeepL::Resources::Text)
-          expect(res.text).not_to be_nil
-          expect(res.text).not_to be_empty
-        end
-      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 { translate.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-        end
-      end
-
-      context 'when using an invalid text' do
-        let(:text) { nil }
-
-        it 'raises a bad request error' do
-          message = "Invalid request: Expected 'text' parameter to be an array of strings"
-          expect { translate.request }.to raise_error(DeepL::Exceptions::BadRequest, message)
-        end
-      end
-
-      context 'when using an invalid target language' do
-        let(:target_lang) { nil }
-
-        it 'raises a bad request error' do
-          message = "Value for 'target_lang' not supported."
-          expect { translate.request }.to raise_error(DeepL::Exceptions::BadRequest, message)
-        end
-      end
-    end
-
-    context 'when performing a request with too many texts' do
-      let(:text) { Array.new(10_000) { |i| "This is the sentence number #{i}" } }
 
-      it 'raises a request entity too large error' do
-        expect { translate.request }.to raise_error(DeepL::Exceptions::RequestEntityTooLarge,
-                                                    /request size has reached the supported limit/)
+      it 'defaults to no additional headers' do
+        request = described_class.new(api, nil, nil, nil)
+        expect(request.send(:headers).keys).to contain_exactly('Authorization', 'User-Agent')
       end
     end
   end

data/spec/requests/translation_memory/list_spec.rb

@@ -24,38 +24,4 @@ describe DeepL::Requests::TranslationMemory::List do
       end
     end
   end
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('translation_memories') { example.call }
-    end
-
-    context 'when requesting a list of all translation memories' do
-      it 'returns an array of translation memories' do
-        translation_memories = translation_memory_list.request
-        expect(translation_memories).to be_an(Array)
-        expect(translation_memories).not_to be_empty
-        expect(translation_memories.first).to be_a(DeepL::Resources::TranslationMemory)
-        expect(translation_memories.first.translation_memory_id).to be_a(String)
-        expect(translation_memories.first.name).to be_a(String)
-        expect(translation_memories.first.source_language).to be_a(String)
-        expect(translation_memories.first.target_languages).to be_an(Array)
-        expect(translation_memories.first.segment_count).to be_an(Integer)
-      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 { translation_memory_list.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-        end
-      end
-    end
-  end
 end

data/spec/requests/usage_spec.rb

@@ -24,20 +24,4 @@ describe DeepL::Requests::Usage do
       end
     end
   end
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('usage') { example.call }
-    end
-
-    context 'when performing a valid request' do
-      it 'returns an usage object' do
-        usage = usage_req.request
-
-        expect(usage).to be_a(DeepL::Resources::Usage)
-        expect(usage.character_count).to be_a(Numeric)
-        expect(usage.character_limit).to be_a(Numeric)
-      end
-    end
-  end
 end

data/spec/resources/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::Resources::CustomInstruction do
+  subject(:custom_instruction) do
+    described_class.new({
+                          'id' => 'ci-1',
+                          'label' => 'Formal',
+                          'prompt' => 'Always use formal language',
+                          'source_language' => 'en'
+                        })
+  end
+
+  describe '#initialize' do
+    context 'when building a basic object' do
+      it 'creates a resource' do
+        expect(custom_instruction).to be_a(described_class)
+      end
+
+      it 'assigns the attributes' do
+        expect(custom_instruction.id).to eq('ci-1')
+        expect(custom_instruction.label).to eq('Formal')
+        expect(custom_instruction.prompt).to eq('Always use formal language')
+        expect(custom_instruction.source_language).to eq('en')
+      end
+    end
+  end
+end

data/spec/resources/style_rule_spec.rb

@@ -0,0 +1,68 @@
+# 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::Resources::StyleRule do
+  subject(:style_rule) do
+    described_class.new({
+                          'style_id' => 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4',
+                          'name' => 'Default Style Rule',
+                          'creation_time' => '2025-01-01T00:00:00Z',
+                          'updated_time' => '2025-01-02T00:00:00Z',
+                          'language' => 'en',
+                          'version' => 1
+                        }, nil, nil)
+  end
+
+  describe '#initialize' do
+    context 'when building a basic object' do
+      it 'creates a resource' do
+        expect(style_rule).to be_a(described_class)
+      end
+
+      it 'assigns the attributes' do
+        expect(style_rule.style_id).to eq('dca2e053-8ae5-45e6-a0d2-881156e7f4e4')
+        expect(style_rule.name).to eq('Default Style Rule')
+        expect(style_rule.language).to eq('en')
+        expect(style_rule.version).to eq(1)
+        expect(style_rule.creation_time).to eq(Time.parse('2025-01-01T00:00:00Z'))
+        expect(style_rule.updated_time).to eq(Time.parse('2025-01-02T00:00:00Z'))
+        expect(style_rule.configured_rules).to be_nil
+        expect(style_rule.custom_instructions).to be_nil
+      end
+    end
+
+    context 'when building an object with configured rules and custom instructions' do
+      subject(:style_rule) do
+        described_class.new({
+                              'style_id' => 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4',
+                              'name' => 'Detailed Style Rule',
+                              'language' => 'en',
+                              'version' => 1,
+                              'configured_rules' => {
+                                'dates_and_times' => { 'calendar_era' => 'use_bc_and_ad' }
+                              },
+                              'custom_instructions' => [
+                                { 'id' => 'ci-1', 'label' => 'Test', 'prompt' => 'Be formal' }
+                              ]
+                            }, nil, nil)
+      end
+
+      it 'maps configured_rules into a ConfiguredRules resource' do
+        expect(style_rule.configured_rules).to be_a(DeepL::Resources::ConfiguredRules)
+        expect(style_rule.configured_rules.dates_and_times)
+          .to eq({ 'calendar_era' => 'use_bc_and_ad' })
+      end
+
+      it 'maps custom_instructions into an array of CustomInstruction resources' do
+        expect(style_rule.custom_instructions).to all(be_a(DeepL::Resources::CustomInstruction))
+        expect(style_rule.custom_instructions.first.id).to eq('ci-1')
+        expect(style_rule.custom_instructions.first.label).to eq('Test')
+        expect(style_rule.custom_instructions.first.prompt).to eq('Be formal')
+      end
+    end
+  end
+end