deepl-rb 3.7.0 → 3.9.0

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

@@ -190,6 +190,61 @@ describe DeepL::Requests::Translate do
       end
     end
 
+    context 'when using `glossary_ids` options' do
+      it 'works with a nil value' do
+        request = described_class.new(api, nil, nil, nil, glossary_ids: nil)
+        expect(request.options[:glossary_ids]).to be_nil
+      end
+
+      it 'works with an array of strings' do
+        request = described_class.new(api, nil, nil, nil, glossary_ids: %w[id1 id2])
+        expect(request.options[:glossary_ids]).to eq(%w[id1 id2])
+      end
+    end
+
+    context 'when building the `glossary_ids` request parameter' do
+      def glossary_ids_param(source_lang, options)
+        described_class.new(api, text, source_lang, target_lang, options)
+                       .send(:build_glossary_ids_param, source_lang)
+      end
+
+      it 'returns nil when `glossary_ids` is not provided' do
+        expect(glossary_ids_param('EN', {})).to be_nil
+      end
+
+      it 'returns nil when `glossary_ids` is nil' do
+        expect(glossary_ids_param('EN', { glossary_ids: nil })).to be_nil
+      end
+
+      it 'returns nil when `glossary_ids` is an empty array' do
+        expect(glossary_ids_param('EN', { glossary_ids: [] })).to be_nil
+      end
+
+      it 'resolves an array of IDs to an array of strings' do
+        expect(glossary_ids_param('EN', { glossary_ids: %w[id1 id2 id3] })).to eq(%w[id1 id2 id3])
+      end
+
+      it 'resolves glossary objects to their IDs' do
+        glossary = DeepL::Resources::Glossary.new({ 'glossary_id' => 'obj_id' }, nil, nil)
+        expect(glossary_ids_param('EN', { glossary_ids: [glossary, 'id2'] })).to eq(%w[obj_id id2])
+      end
+
+      it 'raises when `source_lang` is not set' do
+        expect { glossary_ids_param(nil, { glossary_ids: %w[id1] }) }
+          .to raise_error(ArgumentError, /requires `source_lang`/)
+      end
+
+      it 'raises when combined with the singular `glossary_id` option' do
+        expect { glossary_ids_param('EN', { glossary_id: 'single', glossary_ids: %w[id1] }) }
+          .to raise_error(ArgumentError, /cannot be used together with the `glossary_id`/)
+      end
+
+      it 'raises when more than 5 IDs are provided' do
+        expect { glossary_ids_param('EN', { glossary_ids: %w[id1 id2 id3 id4 id5 id6] }) }
+          .to raise_error(ArgumentError, /maximum of 5 glossary IDs/)
+      end
+    end
+
     context 'when using `formality` options' do
       it 'works with a nil values' do
         request = described_class.new(api, nil, nil, nil, formality: nil)
@@ -266,226 +321,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')
+    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 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'])
-      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/create_export_spec.rb

@@ -0,0 +1,37 @@
+# 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::CreateExport do
+  subject(:translation_memory_create_export) { described_class.new(api, 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(:id) { 'a74d88fb-ed2a-4943-a664-a4512398b994' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(translation_memory_create_export).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'when building a request' do
+      it 'posts to the export endpoint below the v3 prefix' do
+        expect(translation_memory_create_export.to_s)
+          .to eq("POST /v3/translation_memories/#{id}/export")
+      end
+    end
+  end
+end

data/spec/requests/translation_memory/create_import_spec.rb

@@ -0,0 +1,61 @@
+# 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::CreateImport do
+  subject(:translation_memory_create_import) do
+    described_class.new(api, file_name, content_length, 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(:file_name) { 'legal.tmx' }
+  let(:content_length) { 128 }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(translation_memory_create_import).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'when building a request' do
+      it 'posts to the import endpoint below the v3 prefix' do
+        expect(translation_memory_create_import.to_s)
+          .to eq('POST /v3/translation_memories/import')
+      end
+    end
+  end
+
+  describe '#details' do
+    context 'when only the required parameters are given' do
+      it 'declares the source file without the optional fields' do
+        expect(translation_memory_create_import.details).to include('legal.tmx', '128')
+        expect(translation_memory_create_import.details).not_to include('content_type')
+        expect(translation_memory_create_import.details).not_to include('parameters')
+      end
+    end
+
+    context 'when the optional parameters are given' do
+      let(:options) { { content_type: 'text/xml', display_name: 'Legal' } }
+
+      it 'declares the content type and the display name' do
+        expect(translation_memory_create_import.details)
+          .to include('content_type', 'text/xml')
+        expect(translation_memory_create_import.details)
+          .to include('parameters', 'display_name', 'Legal')
+      end
+    end
+  end
+end

data/spec/requests/translation_memory/destroy_spec.rb

@@ -0,0 +1,36 @@
+# 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::Destroy do
+  subject(:translation_memory_destroy) { described_class.new(api, 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(:id) { 'a74d88fb-ed2a-4943-a664-a4512398b994' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(translation_memory_destroy).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'when building a request' do
+      it 'deletes the translation memory below the v3 prefix' do
+        expect(translation_memory_destroy.to_s).to eq("DELETE /v3/translation_memories/#{id}")
+      end
+    end
+  end
+end

data/spec/requests/translation_memory/download_export_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::TranslationMemory::DownloadExport do
+  subject(:download_export) { described_class.new(api, download_url, output_path) }
+
+  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(:download_url) { 'https://storage.example.com/download/tm?signature=abc' }
+  let(:output_path) { '/tmp/export.tmx' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(download_export).to be_a(described_class)
+      end
+    end
+
+    context 'when no download URL is given' do
+      let(:download_url) { nil }
+
+      it 'raises an error' do
+        expect { download_export }.to raise_error(DeepL::Exceptions::Error, /must not be empty/)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'when building a request' do
+      it 'gets from the pre-signed storage URL' do
+        expect(download_export.to_s).to eq('GET /download/tm?signature=abc')
+      end
+    end
+  end
+
+  describe '#details' do
+    context 'when building a request' do
+      # The download URL points outside of the DeepL API, so the auth key must not be sent there.
+      it 'does not send the DeepL authorization header' do
+        expect(download_export.details).not_to include('Authorization')
+        expect(download_export.details).to include('User-Agent')
+      end
+    end
+  end
+end

data/spec/requests/translation_memory/find_job_spec.rb

@@ -0,0 +1,37 @@
+# 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::FindJob do
+  subject(:translation_memory_find_job) { described_class.new(api, job_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(:job_id) { '5b1a0a52-1f3b-4b7f-9f6b-9d4d3f5b6c7d' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(translation_memory_find_job).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'when building a request' do
+      it 'requests the job below the v3 prefix' do
+        expect(translation_memory_find_job.to_s)
+          .to eq("GET /v3/translation_memories/jobs/#{job_id}")
+      end
+    end
+  end
+end

data/spec/requests/translation_memory/find_spec.rb

@@ -0,0 +1,36 @@
+# 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::Find do
+  subject(:translation_memory_find) { described_class.new(api, 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(:id) { 'a74d88fb-ed2a-4943-a664-a4512398b994' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(translation_memory_find).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    context 'when building a request' do
+      it 'requests the translation memory below the v3 prefix' do
+        expect(translation_memory_find.to_s).to eq("GET /v3/translation_memories/#{id}")
+      end
+    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