deepl-rb 3.9.0 → 3.10.0

data/spec/requests/translate_spec.rb

@@ -1,338 +0,0 @@
-# Copyright 2018 Daniel Herzog
-# 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::Translate do
-  subject(:translate) { described_class.new(api, text, source_lang, target_lang, options) }
-
-  around do |tests|
-    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
-    tests.call
-    ENV.replace(tmp_env)
-  end
-
-  let(:tags_str) { 'p,strong,span' }
-  let(:tags_array) { %w[p strong span] }
-
-  let(:api) { build_deepl_api }
-  let(:text) { 'Sample text' }
-  let(:source_lang) { 'EN' }
-  let(:target_lang) { 'ES' }
-  let(:options) { {} }
-
-  describe '#initialize' do
-    context 'when building a request' do
-      it 'creates a request object' do
-        expect(translate).to be_a(described_class)
-      end
-    end
-
-    context 'when using `splitting_tags` options' do
-      it 'works with a nil values' do
-        request = described_class.new(api, nil, nil, nil, splitting_tags: nil)
-        expect(request.options[:splitting_tags]).to be_nil
-      end
-
-      it 'works with a blank list' do
-        request = described_class.new(api, nil, nil, nil, splitting_tags: '')
-        expect(request.options[:splitting_tags]).to eq([])
-      end
-
-      it 'works with a comma-separated list and converts strings to an array' do
-        request = described_class.new(api, nil, nil, nil, splitting_tags: tags_str)
-        expect(request.options[:splitting_tags]).to eq(tags_array)
-      end
-
-      it 'works with an array of tags and leaves it as is' do
-        request = described_class.new(api, nil, nil, nil, splitting_tags: tags_array)
-        expect(request.options[:splitting_tags]).to eq(tags_array)
-      end
-    end
-
-    context 'when using `non_splitting_tags` options' do
-      it 'works with a nil values' do
-        request = described_class.new(api, nil, nil, nil, non_splitting_tags: nil)
-        expect(request.options[:non_splitting_tags]).to be_nil
-      end
-
-      it 'works with a blank list' do
-        request = described_class.new(api, nil, nil, nil, non_splitting_tags: '')
-        expect(request.options[:non_splitting_tags]).to eq([])
-      end
-
-      it 'works with a comma-separated list and converts strings to an array' do
-        request = described_class.new(api, nil, nil, nil, non_splitting_tags: tags_str)
-        expect(request.options[:non_splitting_tags]).to eq(tags_array)
-      end
-
-      it 'works with an array and leaves it as it is' do
-        request = described_class.new(api, nil, nil, nil, non_splitting_tags: tags_array)
-        expect(request.options[:non_splitting_tags]).to eq(tags_array)
-      end
-    end
-
-    context 'when using `ignore_tags` options' do
-      it 'works with a nil values' do
-        request = described_class.new(api, nil, nil, nil, ignore_tags: nil)
-        expect(request.options[:ignore_tags]).to be_nil
-      end
-
-      it 'works with a blank list' do
-        request = described_class.new(api, nil, nil, nil, ignore_tags: '')
-        expect(request.options[:ignore_tags]).to eq([])
-      end
-
-      it 'works with a comma-separated list and converts a string to an array' do
-        request = described_class.new(api, nil, nil, nil, ignore_tags: tags_str)
-        expect(request.options[:ignore_tags]).to eq(tags_array)
-      end
-
-      it 'works with an array and leaves it as it is' do
-        request = described_class.new(api, nil, nil, nil, ignore_tags: tags_array)
-        expect(request.options[:ignore_tags]).to eq(tags_array)
-      end
-    end
-
-    context 'when using `split_sentences` options' do
-      it 'converts `true` to `1`' do
-        request = described_class.new(api, nil, nil, nil, split_sentences: true)
-        expect(request.options[:split_sentences]).to eq('1')
-      end
-
-      it 'converts `false` to `0`' do
-        request = described_class.new(api, nil, nil, nil, split_sentences: false)
-        expect(request.options[:split_sentences]).to eq('0')
-      end
-
-      it 'leaves `0` as is' do
-        request = described_class.new(api, nil, nil, nil, split_sentences: '0')
-        expect(request.options[:split_sentences]).to eq('0')
-      end
-
-      it 'leaves `nonewlines` as is' do
-        request = described_class.new(api, nil, nil, nil, split_sentences: 'nonewlines')
-        expect(request.options[:split_sentences]).to eq('nonewlines')
-      end
-
-      it 'leaves `1` as is' do
-        request = described_class.new(api, nil, nil, nil, split_sentences: '1')
-        expect(request.options[:split_sentences]).to eq('1')
-      end
-
-      it 'works with provided constants' do
-        request = described_class.new(
-          api,
-          nil,
-          nil,
-          nil,
-          split_sentences: DeepL::Constants::SplitSentences::SPLIT_ON_PUNCTUATION_AND_NEWLINES
-        )
-        expect(request.options[:split_sentences]).to eq('1')
-      end
-    end
-
-    context 'when using `preserve_formatting` options' do
-      it 'leaves `true` as is' do
-        request = described_class.new(api, nil, nil, nil, preserve_formatting: true)
-        expect(request.options[:preserve_formatting]).to be(true)
-      end
-
-      it 'leaves `false` as is' do
-        request = described_class.new(api, nil, nil, nil, preserve_formatting: false)
-        expect(request.options[:preserve_formatting]).to be(false)
-      end
-
-      it 'converts `0` to `false`' do
-        request = described_class.new(api, nil, nil, nil, preserve_formatting: '0')
-        expect(request.options[:preserve_formatting]).to be(false)
-      end
-
-      it 'converts `1` to `true`' do
-        request = described_class.new(api, nil, nil, nil, preserve_formatting: '1')
-        expect(request.options[:preserve_formatting]).to be(true)
-      end
-    end
-
-    context 'when using `outline_detection` options' do
-      it 'leaves `true` as is' do
-        request = described_class.new(api, nil, nil, nil, outline_detection: true)
-        expect(request.options[:outline_detection]).to be(true)
-      end
-
-      it 'leaves `false` as is' do
-        request = described_class.new(api, nil, nil, nil, outline_detection: false)
-        expect(request.options[:outline_detection]).to be(false)
-      end
-
-      it 'converts `0` to `false`' do
-        request = described_class.new(api, nil, nil, nil, outline_detection: '0')
-        expect(request.options[:outline_detection]).to be(false)
-      end
-
-      it 'converts `1` to `true`' do
-        request = described_class.new(api, nil, nil, nil, outline_detection: '1')
-        expect(request.options[:outline_detection]).to be(true)
-      end
-    end
-
-    context 'when using `glossary_id` options' do
-      it 'works with a nil values' do
-        request = described_class.new(api, nil, nil, nil, glossary_id: nil)
-        expect(request.options[:glossary_id]).to be_nil
-      end
-
-      it 'works with a string' do
-        request = described_class.new(api, nil, nil, nil, glossary_id: 'sample_id')
-        expect(request.options[:glossary_id]).to eq('sample_id')
-      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)
-        expect(request.options[:formality]).to be_nil
-      end
-
-      it 'works with a string' do
-        request = described_class.new(api, nil, nil, nil, formality: 'more')
-        expect(request.options[:formality]).to eq('more')
-      end
-
-      it 'works with provided constants' do
-        request = described_class.new(api, nil, nil, nil,
-                                      formality: DeepL::Constants::Formality::MORE)
-        expect(request.options[:formality]).to eq('more')
-      end
-    end
-
-    context 'when using `tag_handling_version` options' do
-      it 'works with a nil value' do
-        request = described_class.new(api, nil, nil, nil, tag_handling_version: nil)
-        expect(request.options[:tag_handling_version]).to be_nil
-      end
-
-      it 'works with v1' do
-        request = described_class.new(api, nil, nil, nil, tag_handling_version: 'v1')
-        expect(request.options[:tag_handling_version]).to eq('v1')
-      end
-
-      it 'works with v2' do
-        request = described_class.new(api, nil, nil, nil, tag_handling_version: 'v2')
-        expect(request.options[:tag_handling_version]).to eq('v2')
-      end
-    end
-
-    context 'when using `model_type` options' do
-      it 'works with a nil value' do
-        request = described_class.new(api, nil, nil, nil, model_type: nil)
-        expect(request.options[:model_type]).to be_nil
-      end
-
-      it 'works with a string' do
-        request = described_class.new(api, nil, nil, nil, model_type: 'latency_optimized')
-        expect(request.options[:model_type]).to eq('latency_optimized')
-      end
-
-      it 'works with provided constants' do
-        request = described_class.new(api, nil, nil, nil,
-                                      model_type: DeepL::Constants::ModelType::LATENCY_OPTIMIZED)
-        expect(request.options[:model_type]).to eq('latency_optimized')
-      end
-    end
-
-    context 'when using `custom_instructions` options' do
-      it 'works with a nil value' do
-        request = described_class.new(api, nil, nil, nil, custom_instructions: nil)
-        expect(request.options[:custom_instructions]).to be_nil
-      end
-
-      it 'works with an array of strings' do
-        instructions = ['Use informal language', 'Be concise']
-        request = described_class.new(api, nil, nil, nil, custom_instructions: instructions)
-        expect(request.options[:custom_instructions]).to eq(instructions)
-      end
-
-      it 'works with a single string' do
-        request = described_class.new(api, nil, nil, nil, custom_instructions: ['Be concise'])
-        expect(request.options[:custom_instructions]).to eq(['Be concise'])
-      end
-
-      it 'works with a single string and converts it to an array' do
-        instructions = 'Use informal language,Be concise'
-        request = described_class.new(api, nil, nil, nil, custom_instructions: instructions)
-        expect(request.options[:custom_instructions]).to eq(['Use informal language', 'Be concise'])
-      end
-    end
-
-    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
-
-      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
-end

data/spec/requests/translation_memory/create_export_spec.rb

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

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

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

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

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

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

@@ -1,27 +0,0 @@
-# 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/translation_memory/segments_spec.rb

@@ -1,58 +0,0 @@
-# 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::Segments do
-  subject(:translation_memory_segments) { 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_segments).to be_a(described_class)
-      end
-    end
-  end
-
-  describe '#to_s' do
-    context 'when no options are given' do
-      it 'requests the segments below the v3 prefix without a query string' do
-        expect(translation_memory_segments.to_s)
-          .to eq("GET /v3/translation_memories/#{id}/segments")
-      end
-    end
-
-    context 'when the supported options are given' do
-      let(:options) { { page_size: 10, page_cursor: 'NQ', filter_case_sensitive: true } }
-
-      it 'adds the options to the query string' do
-        expect(translation_memory_segments.to_s)
-          .to eq("GET /v3/translation_memories/#{id}/segments" \
-                 '?page_size=10&page_cursor=NQ&filter_case_sensitive=true')
-      end
-    end
-
-    context 'when the text filter contains characters that must be escaped' do
-      let(:options) { { filter_text: 'a b+c' } }
-
-      # A space must be percent-encoded in a URI query string; `+` only means a space in a form
-      # body, and a literal `+` has to survive as %2B.
-      it 'percent-encodes the spaces instead of writing them as a plus' do
-        expect(translation_memory_segments.to_s)
-          .to eq("GET /v3/translation_memories/#{id}/segments?filter_text=a%20b%2Bc")
-      end
-    end
-  end
-end