deepl-rb 3.8.0 → 3.9.0

data/spec/integration_tests/translation_memory_api_spec.rb

@@ -6,15 +6,20 @@
 require 'spec_helper'
 
 describe DeepL::TranslationMemoryApi, :mock_server_only do
+  include_context 'with temp dir'
+
+  let(:default_tm_id) { 'a74d88fb-ed2a-4943-a664-a4512398b994' }
+  let(:tmx_file_path) { write_example_tmx(File.join(temp_dir, 'example.tmx')) }
+  let(:translation_memories) { DeepL.translation_memories }
+
   describe '#translate_with_translation_memory' do
     it 'when performing a request with translation_memory_id' do
       source_lang = 'DE'
       target_lang = 'EN'
       text = 'Protonenstrahl'
-      translation_memory_id = 'a74d88fb-ed2a-4943-a664-a4512398b994'
 
       result = DeepL.translate(text, source_lang, target_lang,
-                               { translation_memory: translation_memory_id })
+                               { translation_memory: default_tm_id })
       expect(result).to be_a(DeepL::Resources::Text)
     end
 
@@ -41,6 +46,191 @@ describe DeepL::TranslationMemoryApi, :mock_server_only do
     end
   end
 
+  describe '#find' do
+    it 'when requesting a single translation memory by ID' do
+      translation_memory = DeepL.translation_memories.find(default_tm_id)
+      expect(translation_memory).to be_a(DeepL::Resources::TranslationMemory)
+      expect(translation_memory.translation_memory_id).to eq(default_tm_id)
+      expect(translation_memory.name).to eq('Default Translation Memory')
+      expect(translation_memory.source_language).to eq('de')
+      expect(translation_memory.target_languages).to eq(%w[en es fr])
+      expect(translation_memory.segment_count).to eq(12)
+    end
+
+    it 'when requesting a single translation memory by resource object' do
+      translation_memory = DeepL.translation_memories.find(build_test_translation_memory)
+      expect(translation_memory.translation_memory_id).to eq(default_tm_id)
+      expect(translation_memory.creation_time).to be_a(Time)
+      expect(translation_memory.updated_time).to be_a(Time)
+    end
+  end
+
+  describe '#segments' do
+    it 'when requesting the segments of a translation memory' do
+      page = DeepL.translation_memories.segments(default_tm_id)
+      expect(page).to be_a(DeepL::Resources::TranslationMemorySegments)
+      expect(page.segments.length).to eq(12)
+      expect(page.segment_count).to eq(12)
+      expect(page.next_page?).to be(false)
+      expect(page.segments.first.source_text).to eq('Quelltext Nummer 0')
+    end
+
+    it 'when reading segment timestamps' do
+      # The API does not return creation_time/updated_time on segments at all, and returns
+      # last_used_time only for segments that have been used.
+      page = DeepL.translation_memories.segments(default_tm_id)
+      expect(page.segments.first.creation_time).to be_nil
+      expect(page.segments.first.updated_time).to be_nil
+      expect(page.segments.first.last_used_time).to be_a(Time)
+      expect(page.segments[1].last_used_time).to be_nil
+    end
+
+    it 'when reading the target segments of a source segment' do
+      page = DeepL.translation_memories.segments(default_tm_id, page_size: 1)
+      segment = page.segments.first
+      expect(segment.targets.map(&:target_language)).to eq(%w[en es fr])
+      expect(segment.targets.first.target_text).to eq('Target text number 0 (de->en)')
+      expect(segment.targets.first.target_segment_id).not_to be_nil
+      expect(segment.targets.first.last_used_time).to be_a(Time)
+    end
+
+    it 'when paginating through the segments with the page cursor' do
+      first_page = DeepL.translation_memories.segments(default_tm_id, page_size: 5)
+      second_page = next_segments_page(first_page)
+      last_page = next_segments_page(second_page)
+
+      expect(first_page.segments.length).to eq(5)
+      expect(first_page.next_page?).to be(true)
+      expect(second_page.segments.first.source_text).to eq('Quelltext Nummer 5')
+      expect(last_page.segments.length).to eq(2)
+      expect(last_page.next_page?).to be(false)
+    end
+
+    it 'when filtering the segments by a text containing a space' do
+      page = DeepL.translation_memories.segments(default_tm_id, filter_text: 'Nummer 1')
+      expect(page.segments.map(&:source_text))
+        .to eq(['Quelltext Nummer 1', 'Quelltext Nummer 10', 'Quelltext Nummer 11'])
+      # segment_count is the number of segments stored in the translation memory, a text filter
+      # does not reduce it.
+      expect(page.segment_count).to eq(12)
+    end
+
+    it 'when filtering the segments case-sensitively' do
+      page = DeepL.translation_memories.segments(default_tm_id, filter_text: 'quelltext',
+                                                                filter_case_sensitive: true)
+      expect(page.segments).to be_empty
+      expect(page.segment_count).to eq(12)
+    end
+  end
+
+  describe '#import_from_filepath' do
+    it 'when importing a translation memory from a TMX file' do
+      with_managed_translation_memory(tmx_file_path, display_name: 'Imported TM') do |job|
+        expect(job).to be_a(DeepL::Resources::TranslationMemoryJob)
+        expect(job.operation).to eq('import')
+        expect(job.display_name).to eq('Imported TM')
+        expect(job.status).to eq('completed')
+        expect(job.finished?).to be(true)
+        expect(job.result.translation_memory_id).not_to be_nil
+        expect(job.result.skipped_segment_count).to eq(0)
+      end
+    end
+
+    it 'when the imported translation memory can be retrieved afterwards' do
+      with_managed_translation_memory(tmx_file_path) do |job|
+        translation_memory = DeepL.translation_memories.find(job.result.translation_memory_id)
+        expect(translation_memory.name).to eq('example.tmx')
+        expect(translation_memory.source_language).to eq('de')
+        expect(job.source_content_type).to eq('application/xml')
+        expect(job.source_content_length).to eq(File.size(tmx_file_path))
+      end
+    end
+  end
+
+  describe '#create_import' do
+    it 'when the import job is still awaiting the file upload' do
+      created = DeepL.translation_memories.create_import('awaiting.tmx', 128,
+                                                         display_name: 'Awaiting Upload')
+      expect(created).to be_a(DeepL::Resources::TranslationMemoryImport)
+      expect(created.upload_url).to start_with('http')
+      expect(created.expires_at).to be_a(Time)
+
+      job = DeepL.translation_memories.find_job(created.job_id)
+      expect(job.awaiting_input?).to be(true)
+      expect(job.status).to eq('awaiting_input')
+      expect(job.result.required_action).not_to be_nil
+    end
+
+    # The API detects the upload asynchronously, so an uploaded job keeps reporting
+    # `awaiting_input` for a while. The wait loop must poll through that status.
+    it 'when waiting on an uploaded job it polls through the awaiting_input status' do
+      created = create_uploaded_import(translation_memories, tmx_file_path, processing_polls: 1)
+      polled_statuses = []
+      allow(translation_memories).to receive(:find_job).and_wrap_original do |original, *args|
+        original.call(*args).tap { |status| polled_statuses << status.status }
+      end
+      expect(translation_memories).to receive(:sleep).once
+
+      job = translation_memories.wait_until_job_done(created.job_id)
+
+      expect(polled_statuses).to eq(%w[awaiting_input completed])
+      expect(job.status).to eq('completed')
+      DeepL.translation_memories.destroy(job.result.translation_memory_id)
+    end
+
+    it 'when the file is never uploaded it waits until the timeout of the caller' do
+      created = translation_memories.create_import('never-uploaded.tmx', 128)
+      # Such a job does not finish on its own, only the timeout ends the wait.
+      expect(translation_memories).not_to receive(:sleep)
+
+      expect { translation_memories.wait_until_job_done(created.job_id, timeout_s: 0) }
+        .to raise_error(DeepL::Exceptions::Error, /Manual timeout of 0s exceeded/)
+    end
+  end
+
+  describe '#export_to_filepath' do
+    let(:output_path) { File.join(temp_dir, 'export.tmx') }
+
+    it 'when exporting a translation memory to a TMX file' do
+      job = DeepL.translation_memories.export_to_filepath(default_tm_id, output_path)
+      expect(job).to be_a(DeepL::Resources::TranslationMemoryJob)
+      expect(job.operation).to eq('export')
+      expect(job.status).to eq('completed')
+      expect(job.result.download_url).to start_with('http')
+
+      contents = File.read(output_path)
+      expect(contents).to include('<tmx version="1.4">')
+      expect(contents).to include('<seg>Quelltext Nummer 0</seg>')
+      expect(contents).to include('<tuv xml:lang="en"><seg>Target text number 0 (de->en)</seg>')
+    end
+
+    it 'when re-exporting an unchanged translation memory it reuses the completed job' do
+      job = DeepL.translation_memories.export_to_filepath(default_tm_id, output_path)
+      reused = DeepL.translation_memories.create_export(default_tm_id)
+      expect(reused).to be_a(DeepL::Resources::TranslationMemoryExport)
+      expect(reused.reused_existing?).to be(true)
+      expect(reused.job_id).to eq(job.job_id)
+      expect(reused.translation_memory_id).to eq(default_tm_id)
+    end
+  end
+
+  describe '#destroy' do
+    it 'when deleting a translation memory it can no longer be found' do
+      job = DeepL.translation_memories.import_from_filepath(tmx_file_path)
+      translation_memory_id = job.result.translation_memory_id
+
+      expect(DeepL.translation_memories.destroy(translation_memory_id))
+        .to eq(translation_memory_id)
+      expect { DeepL.translation_memories.find(translation_memory_id) }
+        .to raise_error(DeepL::Exceptions::NotFound)
+    end
+  end
+
+  def next_segments_page(page)
+    DeepL.translation_memories.segments(default_tm_id, page_size: 5,
+                                                       page_cursor: page.next_page_cursor)
+  end
+
   def build_test_translation_memory
     tm_data = {
       'translation_memory_id' => 'a74d88fb-ed2a-4943-a664-a4512398b994',

data/spec/integration_tests/translation_memory_error_paths_spec.rb

@@ -8,6 +8,9 @@ require 'spec_helper'
 describe DeepL::TranslationMemoryApi, :mock_server_only do # rubocop:disable RSpec/SpecFilePathFormat
   include_context 'with a live mock server'
 
+  let(:default_tm_id) { 'a74d88fb-ed2a-4943-a664-a4512398b994' }
+  let(:missing_uuid) { '00000000-0000-0000-0000-000000000000' }
+
   describe 'authorization failures' do
     let(:unauthorized_translation_memories) { described_class.new(unauthorized_api) }
 
@@ -15,5 +18,70 @@ describe DeepL::TranslationMemoryApi, :mock_server_only do # rubocop:disable RSp
       expect { unauthorized_translation_memories.list }
         .to raise_error(DeepL::Exceptions::AuthorizationFailed)
     end
+
+    it 'raises AuthorizationFailed on a read operation (find)' do
+      expect { unauthorized_translation_memories.find(default_tm_id) }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+
+    it 'raises AuthorizationFailed on a write operation (create_export)' do
+      expect { unauthorized_translation_memories.create_export(default_tm_id) }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+  end
+
+  describe 'not-found failures' do
+    it 'raises NotFound when #find is called with a missing UUID' do
+      expect { DeepL.translation_memories.find(missing_uuid) }
+        .to raise_error(DeepL::Exceptions::NotFound)
+    end
+
+    it 'raises NotFound when #segments is called with a missing UUID' do
+      expect { DeepL.translation_memories.segments(missing_uuid) }
+        .to raise_error(DeepL::Exceptions::NotFound)
+    end
+
+    it 'raises NotFound when #find_job is called with a missing UUID' do
+      expect { DeepL.translation_memories.find_job(missing_uuid) }
+        .to raise_error(DeepL::Exceptions::NotFound)
+    end
+  end
+
+  describe 'bad-request failures' do
+    it 'raises BadRequest when #segments is called with a too short text filter' do
+      expect { DeepL.translation_memories.segments(default_tm_id, filter_text: 'a') }
+        .to raise_error(DeepL::Exceptions::BadRequest)
+    end
+
+    it 'raises an error when #destroy is called with a malformed UUID' do
+      expect { DeepL.translation_memories.destroy('invalid-uuid') }
+        .to raise_error(DeepL::Exceptions::Error)
+    end
+  end
+
+  describe 'client-side validation failures' do
+    it 'raises an error when #find is called with an empty ID' do
+      expect { DeepL.translation_memories.find('') }
+        .to raise_error(DeepL::Exceptions::Error, /must not be empty/)
+    end
+
+    it 'raises an error when #find_job is called with an empty job ID' do
+      expect { DeepL.translation_memories.find_job(nil) }
+        .to raise_error(DeepL::Exceptions::Error, /must not be empty/)
+    end
+
+    it 'raises an error when #import_from_filepath is given a missing file' do
+      expect { DeepL.translation_memories.import_from_filepath('/no/such/file.tmx') }
+        .to raise_error(DeepL::Exceptions::Error, /No file found/)
+    end
+
+    it 'raises an error when #download_export is given an unfinished job' do
+      created = DeepL.translation_memories.create_export(default_tm_id)
+      job = DeepL::Resources::TranslationMemoryJob.new(
+        { 'job_id' => created.job_id, 'results' => [{ 'status' => 'processing' }] }, nil, nil
+      )
+      expect { DeepL.translation_memories.download_export(job, '/tmp/unused.tmx') }
+        .to raise_error(DeepL::Exceptions::Error, /no download URL/)
+    end
   end
 end

data/spec/requests/document/upload_spec.rb

@@ -0,0 +1,130 @@
+# 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::Document::Upload do
+  subject(:upload) do
+    described_class.new(api, input_file_path, source_lang, target_lang, filename, 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(:input_file_path) { '/tmp/example.txt' }
+  let(:source_lang) { 'EN' }
+  let(:target_lang) { 'DE' }
+  let(:filename) { 'example.txt' }
+  let(:options) { {} }
+  let(:input_file) { instance_double(File) }
+
+  # Builds the multipart form data without performing any network or filesystem IO.
+  def form_data
+    upload.send(:build_base_form_data, input_file)
+  end
+
+  def form_value(form, key)
+    field = form.find { |name, _| name == key }
+    field&.last
+  end
+
+  describe '#initialize' do
+    it 'creates a request object' do
+      expect(upload).to be_a(described_class)
+    end
+  end
+
+  describe 'building the upload form data' do
+    context 'when using the `style_rule` option' do
+      it 'does not append a `style_id` field when not provided' do
+        expect(form_value(form_data, 'style_id')).to be_nil
+      end
+
+      it 'appends a `style_id` field from a style rule ID string' do
+        options[:style_rule] = 'style-123'
+        expect(form_value(form_data, 'style_id')).to eq('style-123')
+      end
+
+      it 'appends a `style_id` field from a StyleRule object' do
+        options[:style_rule] =
+          DeepL::Resources::StyleRule.new({ 'style_id' => 'style-obj' }, nil, nil)
+        expect(form_value(form_data, 'style_id')).to eq('style-obj')
+      end
+    end
+
+    context 'when using the `translation_memory` option' do
+      it 'does not append a `translation_memory_id` field when not provided' do
+        expect(form_value(form_data, 'translation_memory_id')).to be_nil
+      end
+
+      it 'appends a `translation_memory_id` field from a translation memory ID string' do
+        options[:translation_memory] = 'tm-123'
+        expect(form_value(form_data, 'translation_memory_id')).to eq('tm-123')
+      end
+
+      it 'appends a `translation_memory_id` field from a TranslationMemory object' do
+        options[:translation_memory] =
+          DeepL::Resources::TranslationMemory.new({ 'translation_memory_id' => 'tm-obj' }, nil, nil)
+        expect(form_value(form_data, 'translation_memory_id')).to eq('tm-obj')
+      end
+
+      it 'appends a `translation_memory_threshold` field serialized to a string' do
+        options[:translation_memory] = 'tm-123'
+        options[:translation_memory_threshold] = 80
+        form = form_data
+        expect(form_value(form, 'translation_memory_id')).to eq('tm-123')
+        expect(form_value(form, 'translation_memory_threshold')).to eq('80')
+      end
+
+      it 'does not append a `translation_memory_threshold` field when not provided' do
+        options[:translation_memory] = 'tm-123'
+        expect(form_value(form_data, 'translation_memory_threshold')).to be_nil
+      end
+    end
+
+    context 'when using the `glossary_ids` option' do
+      it 'does not append a `glossary_ids` field when not provided' do
+        expect(form_value(form_data, 'glossary_ids')).to be_nil
+      end
+
+      it 'appends a comma-separated `glossary_ids` field from an array of IDs' do
+        options[:glossary_ids] = %w[gid1 gid2 gid3]
+        expect(form_value(form_data, 'glossary_ids')).to eq('gid1,gid2,gid3')
+      end
+
+      it 'appends `glossary_ids` from Glossary objects using their IDs' do
+        options[:glossary_ids] = [
+          DeepL::Resources::Glossary.new({ 'glossary_id' => 'gid-obj' }, nil, nil),
+          'gid-str'
+        ]
+        expect(form_value(form_data, 'glossary_ids')).to eq('gid-obj,gid-str')
+      end
+
+      it 'raises when combined with the singular `glossary_id` option' do
+        options[:glossary_id] = 'single'
+        options[:glossary_ids] = %w[gid1]
+        expect { form_data }.to raise_error(ArgumentError, /cannot be used together/)
+      end
+
+      it 'raises when more than 5 glossary IDs are provided' do
+        options[:glossary_ids] = %w[a b c d e f]
+        expect { form_data }.to raise_error(ArgumentError, /maximum of 5 glossary IDs/)
+      end
+
+      context 'when `source_lang` is not set' do
+        let(:source_lang) { nil }
+
+        it 'raises because `glossary_ids` requires `source_lang`' do
+          options[:glossary_ids] = %w[gid1]
+          expect { form_data }.to raise_error(ArgumentError, /requires `source_lang`/)
+        end
+      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)

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