deepl-rb 3.6.1 → 3.8.0

data/spec/integration_tests/glossary_api_spec.rb

@@ -0,0 +1,114 @@
+# 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::GlossaryApi do
+  let(:default_glossary_args) do
+    {
+      name: 'Integration Test Glossary',
+      source_lang: 'en',
+      target_lang: 'de',
+      entries: [%w[Hello Hallo], %w[World Welt]]
+    }
+  end
+
+  describe 'happy path lifecycle' do
+    it 'creates, lists, and finds a glossary' do # rubocop:disable RSpec/ExampleLength,RSpec/MultipleExpectations
+      with_managed_glossary(**default_glossary_args) do |glossary|
+        expect(glossary).to be_a(DeepL::Resources::Glossary)
+        expect(glossary.id).to be_a(String)
+        expect(glossary.name).to eq(default_glossary_args[:name])
+        expect(glossary.entry_count).to eq(2)
+        expect(glossary.source_lang).to eq(default_glossary_args[:source_lang])
+        expect(glossary.target_lang).to eq(default_glossary_args[:target_lang])
+        expect(glossary.ready).to be(true).or be(false)
+        expect { Time.iso8601(glossary.creation_time) }.not_to raise_error
+
+        listed = DeepL.glossaries.list
+        expect(listed).to be_an(Array)
+        expect(listed.map(&:id)).to include(glossary.id)
+
+        found = DeepL.glossaries.find(glossary.id)
+        expect(found).to be_a(DeepL::Resources::Glossary)
+        expect(found.id).to eq(glossary.id)
+        expect(found.name).to eq(glossary.name)
+      end
+    end
+  end
+
+  describe '#language_pairs' do
+    it 'returns a non-empty list of supported source/target combos' do
+      pairs = DeepL.glossaries.language_pairs
+      expect(pairs).to be_an(Array)
+      expect(pairs).not_to be_empty
+      expect(pairs.first).to be_a(DeepL::Resources::LanguagePair)
+      expect(pairs.first.source_lang).to be_a(String)
+      expect(pairs.first.target_lang).to be_a(String)
+    end
+  end
+
+  describe 'error handling' do
+    it 'raises when creating a glossary with an invalid source language code' do
+      expect do
+        DeepL.glossaries.create(
+          'Invalid Lang Glossary',
+          'zz',
+          'de',
+          [%w[Hello Hallo]]
+        )
+      end.to raise_error(DeepL::Exceptions::RequestError)
+    end
+  end
+
+  describe '#destroy' do
+    it 'returns the id of the destroyed glossary' do
+      glossary = DeepL.glossaries.create(
+        default_glossary_args[:name],
+        default_glossary_args[:source_lang],
+        default_glossary_args[:target_lang],
+        default_glossary_args[:entries]
+      )
+
+      expect(DeepL.glossaries.destroy(glossary.id)).to eq(glossary.id)
+    end
+  end
+
+  describe '#entries' do
+    it 'returns the glossary entries as an array of [source, target] pairs' do # rubocop:disable RSpec/ExampleLength
+      with_managed_glossary(**default_glossary_args) do |glossary|
+        entries = DeepL.glossaries.entries(glossary.id)
+
+        expect(entries).to be_an(Array)
+        expect(entries).to all(be_an(Array))
+        expect(entries.size).to eq(default_glossary_args[:entries].size)
+        entries.each do |entry|
+          expect(entry.size).to eq(2)
+          expect(entry.first).to be_a(String)
+          expect(entry.last).to be_a(String)
+        end
+      end
+    end
+  end
+
+  describe 'edge cases' do
+    it 'accepts Unicode keys and values in glossary entries' do # rubocop:disable RSpec/ExampleLength
+      unicode_entries = [
+        ['Schöne Grüße', 'Best regards'],
+        ['🚀 rocket', '🚀 fusée'],
+        ['日本語', 'Japanese'],
+        ['café', 'kafē']
+      ]
+      args = default_glossary_args.merge(
+        name: 'Unicode Glossary',
+        entries: unicode_entries
+      )
+
+      with_managed_glossary(**args) do |glossary|
+        expect(glossary.entry_count).to eq(unicode_entries.length)
+      end
+    end
+  end
+end

data/spec/integration_tests/glossary_error_paths_spec.rb

@@ -0,0 +1,107 @@
+# 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::GlossaryApi do # rubocop:disable RSpec/SpecFilePathFormat
+  include_context 'with a live mock server'
+
+  let(:nonexistent_glossary_id) { '00000000-0000-0000-0000-000000000000' }
+
+  let(:valid_glossary_args) do
+    {
+      name: 'Error Path Test Glossary',
+      source_lang: 'en',
+      target_lang: 'de',
+      entries: [%w[Hello Hallo]]
+    }
+  end
+
+  describe 'AuthorizationFailed (401/403)' do
+    let(:unauthorized_glossaries) { described_class.new(unauthorized_api) }
+
+    it 'is raised by #list when the auth key is invalid' do
+      expect { unauthorized_glossaries.list }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+
+    it 'is raised by #language_pairs when the auth key is invalid' do
+      expect { unauthorized_glossaries.language_pairs }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+
+    it 'is raised by #create when the auth key is invalid' do
+      expect do
+        unauthorized_glossaries.create(
+          valid_glossary_args[:name],
+          valid_glossary_args[:source_lang],
+          valid_glossary_args[:target_lang],
+          valid_glossary_args[:entries]
+        )
+      end.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+
+    it 'is raised by #find when the auth key is invalid' do
+      expect { unauthorized_glossaries.find(nonexistent_glossary_id) }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+
+    it 'is raised by #destroy when the auth key is invalid' do
+      expect { unauthorized_glossaries.destroy(nonexistent_glossary_id) }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+  end
+
+  describe 'NotFound (404)' do
+    it 'is raised by #find for a well-formed but unknown glossary id' do
+      expect { DeepL.glossaries.find(nonexistent_glossary_id) }
+        .to raise_error(DeepL::Exceptions::NotFound)
+    end
+
+    it 'is raised by #destroy for a well-formed but unknown glossary id' do
+      expect { DeepL.glossaries.destroy(nonexistent_glossary_id) }
+        .to raise_error(DeepL::Exceptions::NotFound)
+    end
+  end
+
+  describe 'BadRequest (400) from #create' do
+    it 'is raised for an invalid source language code' do
+      expect do
+        DeepL.glossaries.create(
+          valid_glossary_args[:name],
+          'zz',
+          valid_glossary_args[:target_lang],
+          valid_glossary_args[:entries]
+        )
+      end.to raise_error(DeepL::Exceptions::BadRequest)
+    end
+  end
+
+  describe 'BadRequest (400) from a malformed glossary id' do
+    let(:malformed_uuid) { 'invalid-uuid' }
+
+    it 'is raised by #find for a malformed glossary id' do
+      expect { DeepL.glossaries.find(malformed_uuid) }
+        .to raise_error(DeepL::Exceptions::BadRequest)
+    end
+
+    it 'is raised by #destroy for a malformed glossary id' do
+      expect { DeepL.glossaries.destroy(malformed_uuid) }
+        .to raise_error(DeepL::Exceptions::BadRequest)
+    end
+
+    it 'is raised by #entries for a malformed glossary id' do
+      expect { DeepL.glossaries.entries(malformed_uuid) }
+        .to raise_error(DeepL::Exceptions::BadRequest)
+    end
+  end
+
+  describe 'NotFound (404) from #entries' do
+    it 'is raised for a well-formed but unknown glossary id' do
+      expect { DeepL.glossaries.entries(nonexistent_glossary_id) }
+        .to raise_error(DeepL::Exceptions::NotFound)
+    end
+  end
+end

data/spec/integration_tests/languages_api_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 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

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

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

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

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

@@ -5,21 +5,9 @@
 
 require 'spec_helper'
 
-describe DeepL::StyleRuleApi do
-  before do
-    VCR.turn_off!
-    WebMock.allow_net_connect!
-  end
-
-  after do
-    VCR.turn_on!
-    WebMock.disable_net_connect!
-  end
-
+describe DeepL::StyleRuleApi, :mock_server_only do
   describe '#translate_with_style_rules' do
     it 'when performing a request with style_id' do
-      skip 'Only runs on mock server' if real_server?
-
       source_lang = 'DE'
       target_lang = 'EN-US'
       text = 'Hallo, Welt!'
@@ -30,8 +18,6 @@ describe DeepL::StyleRuleApi do
     end
 
     it 'when performing a request with style_rule object' do
-      skip 'Only runs on mock server' if real_server?
-
       source_lang = 'DE'
       target_lang = 'EN-US'
       text = 'Hallo, Welt!'
@@ -44,7 +30,6 @@ describe DeepL::StyleRuleApi do
 
   describe '#list_style_rules' do
     it 'when requesting a list of all style rules' do
-      skip 'Only runs on mock server' if real_server?
       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)
@@ -55,7 +40,6 @@ describe DeepL::StyleRuleApi do
     end
 
     it 'when requesting a list of all style rules without detailed' do
-      skip 'Only runs on mock server' if real_server?
       style_rules = DeepL.style_rules.list
       expect(style_rules).to be_an(Array)
       expect(style_rules.length).to eq(1)
@@ -65,6 +49,60 @@ describe DeepL::StyleRuleApi do
     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',

data/spec/integration_tests/style_rule_error_paths_spec.rb

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