deepl-rb 3.9.0 → 3.10.0

data/spec/integration_tests/languages_api_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 file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# Covers GET /v2/languages; the SDK has no v3 languages endpoint.
-describe 'DeepL.languages' do # rubocop:disable RSpec/DescribeClass
-  describe 'source languages' do
-    it 'returns a non-empty array of Language resources with common codes' do
-      languages = DeepL.languages
-
-      expect(languages).to be_an(Array)
-      expect(languages).not_to be_empty
-      expect(languages).to all(be_a(DeepL::Resources::Language))
-      expect(languages.first).to respond_to(:code, :name)
-
-      codes = languages.map(&:code)
-      expect(codes).to include('EN', 'DE')
-    end
-  end
-
-  describe 'target languages' do
-    it 'returns target entries that include both formality-supporting and non-supporting members' do
-      languages = DeepL.languages(type: :target)
-
-      expect(languages).to be_an(Array)
-      expect(languages).not_to be_empty
-      expect(languages).to all(be_a(DeepL::Resources::Language))
-
-      formalities = languages.map(&:supports_formality?)
-      expect(formalities).to include(true)
-      expect(formalities).to include(false)
-    end
-
-    it 'raises NotSupported when supports_formality? is called on a source-language entry' do
-      source_languages = DeepL.languages
-
-      expect { source_languages.first.supports_formality? }
-        .to raise_error(DeepL::Exceptions::NotSupported)
-    end
-  end
-
-  describe 'source vs target counts' do
-    it 'returns sensible (>20) counts for both source and target listings' do
-      source_languages = DeepL.languages
-      target_languages = DeepL.languages(type: :target)
-
-      expect(source_languages.size).to be > 20
-      expect(target_languages.size).to be > 20
-    end
-  end
-end

data/spec/integration_tests/languages_error_paths_spec.rb

@@ -1,25 +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 file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'DeepL.languages error paths' do # rubocop:disable RSpec/DescribeClass
-  include_context 'with a live mock server'
-
-  describe 'authorization failures' do
-    it 'raises AuthorizationFailed when the auth key is invalid' do
-      request = DeepL::Requests::Languages.new(unauthorized_api)
-
-      expect { request.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-    end
-  end
-
-  describe 'bad request errors' do
-    it 'raises BadRequest for an unsupported languages type' do
-      expect { DeepL.languages(type: :invalid) }
-        .to raise_error(DeepL::Exceptions::BadRequest)
-    end
-  end
-end

data/spec/integration_tests/rephrase_api_spec.rb

@@ -1,90 +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 file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'DeepL.rephrase' do # rubocop:disable RSpec/DescribeClass
-  describe 'happy path' do
-    it 'rephrases an English sentence into English and returns a Text resource' do
-      result = DeepL.rephrase('As Gregor Samsa awoke one morning he found himself transformed.',
-                              'en')
-
-      expect(result).to be_a(DeepL::Resources::Text)
-      expect(result.text).to be_a(String)
-      expect(result.text).not_to be_empty
-    end
-  end
-
-  describe 'error path' do
-    it 'raises a bad request error for an invalid writing_style value' do
-      expect do
-        DeepL.rephrase('As Gregor Samsa awoke one morning he found himself transformed.',
-                       'en', 'totally_invalid_style')
-      end.to raise_error(DeepL::Exceptions::BadRequest)
-    end
-  end
-
-  describe 'edge case' do
-    it 'rephrases with a writing_style option applied' do
-      result = DeepL.rephrase('As Gregor Samsa awoke one morning he found himself transformed.',
-                              'en', 'business')
-
-      expect(result).to be_a(DeepL::Resources::Text)
-      expect(result.text).to be_a(String)
-      expect(result.text).not_to be_empty
-    end
-
-    it 'rephrases with a tone option applied' do
-      result = DeepL.rephrase('As Gregor Samsa awoke one morning he found himself transformed.',
-                              'en', nil, 'friendly')
-
-      expect(result).to be_a(DeepL::Resources::Text)
-      expect(result.text).to be_a(String)
-      expect(result.text).not_to be_empty
-    end
-
-    it 'rephrases an array of texts with a tone applied' do
-      texts = [
-        'As Gregor Samsa awoke one morning he found himself transformed.',
-        'He lay on his armour-like back, and if he lifted his head a little.'
-      ]
-
-      results = DeepL.rephrase(texts, 'en', nil, 'friendly')
-
-      expect(results).to be_an(Array)
-      expect(results.size).to eq(2)
-      expect(results).to all(be_a(DeepL::Resources::Text))
-      expect(results.map(&:text)).to all(be_a(String).and(satisfy { |t| !t.empty? }))
-    end
-
-    it 'rephrases an array of texts with a writing_style applied' do
-      texts = [
-        'As Gregor Samsa awoke one morning he found himself transformed.',
-        'He lay on his armour-like back, and if he lifted his head a little.'
-      ]
-
-      results = DeepL.rephrase(texts, 'en', 'business')
-
-      expect(results).to be_an(Array)
-      expect(results.size).to eq(2)
-      expect(results).to all(be_a(DeepL::Resources::Text))
-      expect(results.map(&:text)).to all(be_a(String).and(satisfy { |t| !t.empty? }))
-    end
-
-    it 'rephrases an array of texts and returns an array of Text resources' do
-      texts = [
-        'As Gregor Samsa awoke one morning he found himself transformed.',
-        'He lay on his armour-like back, and if he lifted his head a little.'
-      ]
-
-      results = DeepL.rephrase(texts, 'en')
-
-      expect(results).to be_an(Array)
-      expect(results.size).to eq(2)
-      expect(results).to all(be_a(DeepL::Resources::Text))
-      expect(results.map(&:text)).to all(be_a(String).and(satisfy { |t| !t.empty? }))
-    end
-  end
-end

data/spec/integration_tests/rephrase_error_paths_spec.rb

@@ -1,53 +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 file.
-# frozen_string_literal: true
-
-require 'securerandom'
-require 'spec_helper'
-
-describe 'DeepL.rephrase error paths' do # rubocop:disable RSpec/DescribeClass
-  include IntegrationTestUtils
-
-  include_context 'with a live mock server'
-
-  let(:sample_text) { 'As Gregor Samsa awoke one morning he found himself transformed.' }
-
-  def rephrase_with_fresh_user(headers)
-    fresh_auth_key = "rephrase-err-#{SecureRandom.uuid}"
-    config = DeepL::Configuration.new(auth_key: fresh_auth_key)
-    config.max_network_retries = 0
-    api = DeepL::API.new(config)
-    DeepL::Requests::Rephrase.new(api, sample_text, 'en', nil, nil, {}, headers).request
-  end
-
-  describe 'authorization failures' do
-    it 'raises AuthorizationFailed when called with an invalid auth_key' do
-      request = DeepL::Requests::Rephrase.new(unauthorized_api, sample_text, 'en')
-
-      expect { request.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-    end
-  end
-
-  describe 'bad request errors' do
-    it 'raises BadRequest for an unsupported target_lang code' do
-      expect do
-        DeepL.rephrase(sample_text, 'zzz')
-      end.to raise_error(DeepL::Exceptions::BadRequest)
-    end
-
-    it 'raises BadRequest when both writing_style and tone are provided' do
-      expect do
-        DeepL.rephrase(sample_text, 'en', 'business', 'friendly')
-      end.to raise_error(DeepL::Exceptions::BadRequest)
-    end
-  end
-
-  describe 'rate limiting' do
-    it 'raises LimitExceeded when the server responds with 429', :mock_server_only do
-      expect do
-        rephrase_with_fresh_user(respond_with_429_header(1))
-      end.to raise_error(DeepL::Exceptions::LimitExceeded)
-    end
-  end
-end

data/spec/integration_tests/smoke_test_spec.rb

@@ -1,24 +0,0 @@
-# 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
-
-require 'spec_helper'
-
-describe 'SDK smoke test', :integration do # rubocop:disable RSpec/DescribeClass
-  it 'exercises translate, glossaries.list, and usage end-to-end' do # rubocop:disable RSpec/ExampleLength
-    source_text = 'Hello, world!'
-    result = DeepL.translate(source_text, 'EN', 'DE')
-    expect(result).to be_a(DeepL::Resources::Text)
-    expect(result.text).to be_a(String)
-    expect(result.text).not_to be_empty
-    expect(result.text).not_to eq(source_text)
-
-    glossaries = DeepL.glossaries.list
-    expect(glossaries).to be_an(Array)
-
-    usage = DeepL.usage
-    expect(usage).to be_a(DeepL::Resources::Usage)
-    expect(usage).to respond_to(:character_count, :character_limit)
-  end
-end

data/spec/integration_tests/style_rule_api_spec.rb

@@ -1,117 +0,0 @@
-# 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
-
-require 'spec_helper'
-
-describe DeepL::StyleRuleApi, :mock_server_only do
-  describe '#translate_with_style_rules' do
-    it 'when performing a request with style_id' do
-      source_lang = 'DE'
-      target_lang = 'EN-US'
-      text = 'Hallo, Welt!'
-      style_id = 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4'
-
-      result = DeepL.translate(text, source_lang, target_lang, { style_rule: style_id })
-      expect(result).to be_a(DeepL::Resources::Text)
-    end
-
-    it 'when performing a request with style_rule object' do
-      source_lang = 'DE'
-      target_lang = 'EN-US'
-      text = 'Hallo, Welt!'
-      style_rule = build_test_style_rule
-
-      result = DeepL.translate(text, source_lang, target_lang, { style_rule: style_rule })
-      expect(result).to be_a(DeepL::Resources::Text)
-    end
-  end
-
-  describe '#list_style_rules' do
-    it 'when requesting a list of all style rules' do
-      style_rules = DeepL.style_rules.list(page: 0, page_size: 10, detailed: true)
-      expect(style_rules).to be_an(Array)
-      expect(style_rules.length).to eq(1)
-      expect(style_rules[0].style_id).to eq('dca2e053-8ae5-45e6-a0d2-881156e7f4e4')
-      expect(style_rules[0].name).to eq('Default Style Rule')
-      expect(style_rules[0].configured_rules).to be_a(DeepL::Resources::ConfiguredRules)
-      expect(style_rules[0].custom_instructions).to be_an(Array)
-    end
-
-    it 'when requesting a list of all style rules without detailed' do
-      style_rules = DeepL.style_rules.list
-      expect(style_rules).to be_an(Array)
-      expect(style_rules.length).to eq(1)
-      expect(style_rules[0].style_id).to eq('dca2e053-8ae5-45e6-a0d2-881156e7f4e4')
-      expect(style_rules[0].configured_rules).to be_nil
-      expect(style_rules[0].custom_instructions).to be_nil
-    end
-  end
-
-  describe 'style rule management operations' do
-    it 'when performing all management operations on style rules' do # rubocop:disable RSpec/ExampleLength,RSpec/MultipleExpectations
-      # Create a style rule
-      style_rule = DeepL.style_rules.create('Test Style Rule', 'en')
-      expect(style_rule).to be_a(DeepL::Resources::StyleRule)
-      expect(style_rule.style_id).not_to be_nil
-      style_id = style_rule.style_id
-
-      # Find the style rule
-      found_rule = DeepL.style_rules.find(style_id)
-      expect(found_rule).to be_a(DeepL::Resources::StyleRule)
-      expect(found_rule.style_id).to eq(style_id)
-
-      # Update the style rule name
-      updated_rule = DeepL.style_rules.update_name(style_id, 'Updated Style Rule')
-      expect(updated_rule).to be_a(DeepL::Resources::StyleRule)
-
-      # Update configured rules
-      configured_rules = {
-        'dates_and_times' => { 'calendar_era' => 'use_bc_and_ad' }
-      }
-      updated_rule = DeepL.style_rules.update_configured_rules(style_id, configured_rules)
-      expect(updated_rule).to be_a(DeepL::Resources::StyleRule)
-
-      # Create a custom instruction
-      custom_instruction = DeepL.style_rules.create_custom_instruction(
-        style_id, 'Test Instruction', 'Always use formal language'
-      )
-      expect(custom_instruction).to be_a(DeepL::Resources::CustomInstruction)
-      expect(custom_instruction.id).not_to be_nil
-      instruction_id = custom_instruction.id
-
-      # Find a custom instruction
-      fetched_instruction = DeepL.style_rules.find_custom_instruction(style_id, instruction_id)
-      expect(fetched_instruction).to be_a(DeepL::Resources::CustomInstruction)
-      expect(fetched_instruction.id).to eq(instruction_id)
-
-      # Update a custom instruction
-      updated_instruction = DeepL.style_rules.update_custom_instruction(
-        style_id, instruction_id, 'Updated Instruction', 'Use casual language'
-      )
-      expect(updated_instruction).to be_a(DeepL::Resources::CustomInstruction)
-
-      # Destroy the custom instruction
-      deleted_instruction_id = DeepL.style_rules.destroy_custom_instruction(style_id,
-                                                                            instruction_id)
-      expect(deleted_instruction_id).to eq(instruction_id)
-
-      # Destroy the style rule
-      deleted_style_id = DeepL.style_rules.destroy(style_id)
-      expect(deleted_style_id).to eq(style_id)
-    end
-  end
-
-  def build_test_style_rule
-    style_rule_data = {
-      'style_id' => 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4',
-      'name' => 'Default Style Rule',
-      'creation_time' => '2025-01-01T00:00:00Z',
-      'updated_time' => '2025-01-01T00:00:00Z',
-      'language' => 'en',
-      'version' => 1
-    }
-    DeepL::Resources::StyleRule.new(style_rule_data, nil, nil)
-  end
-end

data/spec/integration_tests/style_rule_error_paths_spec.rb

@@ -1,45 +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::StyleRuleApi, :mock_server_only do # rubocop:disable RSpec/SpecFilePathFormat
-  include_context 'with a live mock server'
-
-  let(:missing_uuid) { '00000000-0000-0000-0000-000000000000' }
-
-  describe 'authorization failures' do
-    let(:unauthorized_style_rules) { described_class.new(unauthorized_api) }
-
-    it 'raises AuthorizationFailed on a read operation (list)' do
-      expect { unauthorized_style_rules.list }
-        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
-    end
-
-    it 'raises AuthorizationFailed on a write operation (create)' do
-      expect { unauthorized_style_rules.create('Auth Failure Test', 'en') }
-        .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.style_rules.find(missing_uuid) }
-        .to raise_error(DeepL::Exceptions::NotFound)
-    end
-  end
-
-  describe 'bad-request failures' do
-    it 'raises BadRequest when create is called with a nil language' do
-      expect { DeepL.style_rules.create('Nil Lang', nil) }
-        .to raise_error(DeepL::Exceptions::BadRequest)
-    end
-
-    it 'raises an error when #destroy is called with a malformed UUID' do
-      expect { DeepL.style_rules.destroy('invalid-uuid') }
-        .to raise_error(DeepL::Exceptions::Error)
-    end
-  end
-end

data/spec/integration_tests/translate_api_spec.rb

@@ -1,117 +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 file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'DeepL.translate' do # rubocop:disable RSpec/DescribeClass
-  include_context 'with a live mock server'
-
-  let(:text) { 'proton beam' }
-
-  describe 'happy path' do
-    it 'translates a single string into a Text resource' do
-      result = DeepL.translate(text, 'EN', 'DE')
-
-      expect(result).to be_a(DeepL::Resources::Text)
-      expect(result.text).to be_a(String)
-      expect(result.text).not_to be_empty
-    end
-
-    it 'translates an array of strings into an array of Text resources' do
-      results = DeepL.translate(%w[Sample Word], 'EN', 'ES')
-
-      expect(results).to be_an(Array)
-      expect(results.size).to eq(2)
-      expect(results).to all(be_a(DeepL::Resources::Text))
-    end
-  end
-
-  describe 'options' do
-    it 'accepts a formality setting' do
-      result = DeepL.translate('How are you?', 'EN', 'DE', { formality: 'more' })
-
-      expect(result).to be_a(DeepL::Resources::Text)
-    end
-
-    it 'translates with XML tag handling and ignored tags' do
-      result = DeepL.translate('<p>Sample <code>x</code></p>', 'EN', 'ES',
-                               { tag_handling: 'xml', ignore_tags: %w[code] })
-
-      expect(result.text).to be_a(String)
-      expect(result.text).not_to be_empty
-    end
-
-    it 'accepts a context option' do
-      result = DeepL.translate('That is hot!', 'EN', 'ES', { context: 'about the weather' })
-
-      expect(result).to be_a(DeepL::Resources::Text)
-    end
-
-    it 'accepts an empty context option' do
-      result = DeepL.translate('That is hot!', 'EN', 'ES', { context: '' })
-
-      expect(result).to be_a(DeepL::Resources::Text)
-    end
-
-    it 'translates an HTML document with split_sentences, outline_detection and splitting_tags' do
-      document = '<document><meta><title>Title</title></meta>' \
-                 '<content><par>First sentence. Second one.</par></content></document>'
-      result = DeepL.translate(document, 'EN', 'ES',
-                               { tag_handling: 'xml', split_sentences: 'nonewlines',
-                                 outline_detection: false, splitting_tags: %w[title par] })
-
-      expect(result).to be_a(DeepL::Resources::Text)
-      expect(result.text).not_to be_empty
-    end
-
-    it 'translates using a glossary' do
-      with_managed_glossary(name: 'Translate Glossary', source_lang: 'en', target_lang: 'de',
-                            entries: [%w[Hello Hallo]]) do |glossary|
-        result = DeepL.translate('Hello', 'EN', 'DE', { glossary_id: glossary.id })
-
-        expect(result).to be_a(DeepL::Resources::Text)
-        expect(result.text).not_to be_empty
-      end
-    end
-
-    it 'translates using multiple glossaries via glossary_ids' do # rubocop:disable RSpec/ExampleLength
-      with_managed_glossary(name: 'Translate Glossary IDs 1', source_lang: 'en', target_lang: 'de',
-                            entries: [%w[Hello Hallo]]) do |glossary1|
-        with_managed_glossary(name: 'Translate Glossary IDs 2', source_lang: 'en',
-                              target_lang: 'de', entries: [%w[World Welt]]) do |glossary2|
-          # Newly created glossaries can lag behind (eventual consistency), so
-          # ensure they are resolvable before translating and tolerate a
-          # transient "not found" on the translate call itself.
-          wait_until_glossaries_ready(glossary1, glossary2)
-          result = translate_retrying_missing_glossary(
-            'Hello', 'EN', 'DE', { glossary_ids: [glossary1.id, glossary2.id] }
-          )
-
-          expect(result).to be_a(DeepL::Resources::Text)
-          expect(result.text).not_to be_empty
-        end
-      end
-    end
-
-    %w[quality_optimized latency_optimized prefer_quality_optimized].each do |model_type|
-      it "returns model_type_used for #{model_type}" do
-        result = DeepL.translate(text, 'EN', 'DE', { model_type: model_type })
-
-        expect(result).to be_a(DeepL::Resources::Text)
-        expect(result.model_type_used).not_to be_nil
-      end
-    end
-
-    %w[v1 v2].each do |version|
-      it "translates with tag_handling_version #{version}" do
-        result = DeepL.translate('<p>Hello world</p>', 'EN', 'DE',
-                                 { tag_handling: 'html', tag_handling_version: version })
-
-        expect(result).to be_a(DeepL::Resources::Text)
-        expect(result.text).not_to be_empty
-      end
-    end
-  end
-end

data/spec/integration_tests/translate_error_paths_spec.rb

@@ -1,48 +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 file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'DeepL.translate error paths' do # rubocop:disable RSpec/DescribeClass
-  include_context 'with a live mock server'
-
-  let(:text) { 'proton beam' }
-
-  describe 'authorization failures' do
-    it 'raises AuthorizationFailed when the auth key is invalid' do
-      request = DeepL::Requests::Translate.new(unauthorized_api, text, 'EN', 'DE')
-
-      expect { request.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-    end
-  end
-
-  describe 'bad request errors' do
-    it 'raises BadRequest for an unsupported target language' do
-      expect { DeepL.translate(text, 'EN', 'ZZ') }
-        .to raise_error(DeepL::Exceptions::BadRequest)
-    end
-
-    it 'raises BadRequest when no target language is given' do
-      expect { DeepL.translate(text, 'EN', nil) }
-        .to raise_error(DeepL::Exceptions::BadRequest)
-    end
-
-    # Real-server only: the mock coerces text:[null] to text:[""] and accepts it,
-    # so it cannot reproduce this; prod rejects [null] with 400.
-    it 'raises BadRequest when the text is nil', :real_server_only do
-      expect { DeepL.translate(nil, 'EN', 'DE') }
-        .to raise_error(DeepL::Exceptions::BadRequest)
-    end
-  end
-
-  describe 'request entity too large errors' do
-    it 'raises RequestEntityTooLarge when too many texts are sent in a single request' do
-      texts = Array.new(10_000) { |i| "This is the sentence number #{i}" }
-
-      expect { DeepL.translate(texts, 'EN', 'DE') }
-        .to raise_error(DeepL::Exceptions::RequestEntityTooLarge)
-    end
-  end
-end