deepl-rb 3.6.1 → 3.8.0

data/spec/requests/translate_spec.rb

@@ -266,227 +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)
-          expected_model_type = model_type_str.sub(/^prefer_/, '')
-          expect(res.model_type_used).to eq(expected_model_type)
-        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

@@ -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::TranslationMemory::List do
+  subject(:translation_memory_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(translation_memory_list).to be_a(described_class)
+      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

data/spec/resources/translation_memory_spec.rb

@@ -0,0 +1,35 @@
+# 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::TranslationMemory do
+  subject(:translation_memory) do
+    described_class.new({
+                          'translation_memory_id' => 'a74d88fb-ed2a-4943-a664-a4512398b994',
+                          'name' => 'Legal',
+                          'source_language' => 'en',
+                          'target_languages' => %w[es de],
+                          'segment_count' => 3542
+                        }, nil, nil)
+  end
+
+  describe '#initialize' do
+    context 'when building a basic object' do
+      it 'creates a resource' do
+        expect(translation_memory).to be_a(described_class)
+      end
+
+      it 'assigns the attributes' do
+        expect(translation_memory.translation_memory_id)
+          .to eq('a74d88fb-ed2a-4943-a664-a4512398b994')
+        expect(translation_memory.name).to eq('Legal')
+        expect(translation_memory.source_language).to eq('en')
+        expect(translation_memory.target_languages).to eq(%w[es de])
+        expect(translation_memory.segment_count).to eq(3542)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -14,59 +14,29 @@ SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
 require_relative '../lib/deepl'
 require_relative 'integration_tests/integration_test_utils'
 
+# Auto-load test helpers under spec/support
+Dir[File.expand_path('support/**/*.rb', __dir__)].sort.each { |f| require f }
+
 # Lib config
 ENV['DEEPL_AUTH_KEY'] ||= 'TEST-TOKEN'
 
-# General helpers
-def build_deepl_api
-  DeepL::API.new(DeepL::Configuration.new)
-end
+RSpec.configure do |config|
+  config.include ManagedGlossary
+  config.include ManagedStyleRule
+  config.include ManagedTranslationMemory
 
-uri_ignoring_deepl_api_subdomain = lambda do |request1, request2|
-  deepl_api_regexp = %r{https?://api.*\.deepl\.com/}
-  uri1 = request1.uri
-  uri2 = request2.uri
-  uri1_match = uri1.match(deepl_api_regexp)
-  uri2_match = uri2.match(deepl_api_regexp)
-  if uri1_match && uri2_match
-    uri1_without_deepl_domain = uri1.gsub(uri1_match[0], '')
-    uri2_without_deepl_domain = uri2.gsub(uri2_match[0], '')
-    uri1_without_deepl_domain == uri2_without_deepl_domain
-  else
-    uri1 == uri2
+  config.before(:each, :mock_server_only) do
+    skip 'Only runs on mock server' unless ENV.key?('DEEPL_MOCK_SERVER_PORT')
   end
-end
-
-headers_ignoring_user_agent = lambda do |request1, request2|
-  user_agent_key = 'User-Agent'
-  # Pass by reference, so we need to use a copy of the headers
-  headers1 = request1.headers.dup
-  headers2 = request2.headers.dup
-  headers1_has_user_agent = headers1.key?(user_agent_key)
-  headers2_has_user_agent = headers2.key?(user_agent_key)
-  return false if headers1_has_user_agent != headers2_has_user_agent
 
-  headers1.delete(user_agent_key)
-  headers2.delete(user_agent_key)
-  headers1 == headers2
+  config.before(:each, :real_server_only) do
+    skip 'Only runs on real server' if ENV.key?('DEEPL_MOCK_SERVER_PORT')
+  end
 end
 
-# VCR tapes configuration
-require 'vcr'
-VCR.configure do |config|
-  config.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
-  config.hook_into :webmock
-  config.filter_sensitive_data('VALID_TOKEN') { ENV.fetch('DEEPL_AUTH_KEY', nil) }
-
-  # to record new or missing VCR cassettes, call rspec like this:
-  # $ VCR_RECORD_MODE=new_episodes bundle exec rspec
-
-  record_mode = ENV['VCR_RECORD_MODE'] ? ENV['VCR_RECORD_MODE'].to_sym : :none
-  config.default_cassette_options = {
-    record: record_mode,
-    match_requests_on: [:method, uri_ignoring_deepl_api_subdomain, :body,
-                        headers_ignoring_user_agent]
-  }
+# General helpers
+def build_deepl_api
+  DeepL::API.new(DeepL::Configuration.new)
 end
 
 # Test helpers

data/spec/support/live_mock_server.rb

@@ -0,0 +1,12 @@
+# 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 file.
+# frozen_string_literal: true
+
+# Shared setup for integration specs that hit the live mock server: expose an
+# API the server rejects as unauthorized without mutating global DeepL state.
+RSpec.shared_context 'with a live mock server' do
+  let(:unauthorized_api) do
+    DeepL::API.new(DeepL::Configuration.new(auth_key: 'invalid'))
+  end
+end

data/spec/support/managed_glossary.rb

@@ -0,0 +1,17 @@
+# 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 file.
+# frozen_string_literal: true
+
+module ManagedGlossary
+  def with_managed_glossary(name:, source_lang:, target_lang:, entries:, options: {})
+    glossary = DeepL.glossaries.create(name, source_lang, target_lang, entries, options)
+    yield glossary
+  ensure
+    begin
+      DeepL.glossaries.destroy(glossary.id) if glossary
+    rescue StandardError
+      nil
+    end
+  end
+end

data/spec/support/managed_style_rule.rb

@@ -0,0 +1,17 @@
+# 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 file.
+# frozen_string_literal: true
+
+module ManagedStyleRule
+  def with_managed_style_rule(name:, language:, options: {})
+    style_rule = DeepL.style_rules.create(name, language, options)
+    yield style_rule
+  ensure
+    begin
+      DeepL.style_rules.destroy(style_rule.style_id) if style_rule
+    rescue StandardError
+      nil
+    end
+  end
+end

data/spec/support/managed_translation_memory.rb

@@ -0,0 +1,7 @@
+# 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 file.
+# frozen_string_literal: true
+
+module ManagedTranslationMemory
+end