deepl-rb 3.6.0 → 3.7.0

data/spec/integration_tests/style_rule_api_spec.rb

@@ -0,0 +1,135 @@
+# 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 do
+  before do
+    VCR.turn_off!
+    WebMock.allow_net_connect!
+  end
+
+  after do
+    VCR.turn_on!
+    WebMock.disable_net_connect!
+  end
+
+  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!'
+      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
+      skip 'Only runs on mock server' if real_server?
+
+      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
+      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)
+      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
+      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)
+      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
+      skip 'Only runs on mock server' if real_server?
+
+      # 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/translation_memory_api_spec.rb

@@ -0,0 +1,70 @@
+# 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::TranslationMemoryApi do
+  before do
+    VCR.turn_off!
+    WebMock.allow_net_connect!
+  end
+
+  after do
+    VCR.turn_on!
+    WebMock.disable_net_connect!
+  end
+
+  describe '#translate_with_translation_memory' do
+    it 'when performing a request with translation_memory_id' do
+      skip 'Only runs on mock server' if real_server?
+
+      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 })
+      expect(result).to be_a(DeepL::Resources::Text)
+    end
+
+    it 'when performing a request with translation_memory resource object' do
+      skip 'Only runs on mock server' if real_server?
+
+      source_lang = 'DE'
+      target_lang = 'EN'
+      text = 'Protonenstrahl'
+      translation_memory = build_test_translation_memory
+
+      result = DeepL.translate(text, source_lang, target_lang,
+                               { translation_memory: translation_memory })
+      expect(result).to be_a(DeepL::Resources::Text)
+    end
+  end
+
+  describe '#list_translation_memories' do
+    it 'when requesting a list of all translation memories' do
+      skip 'Only runs on mock server' if real_server?
+
+      translation_memories = DeepL.translation_memories.list
+      expect(translation_memories).to be_an(Array)
+      expect(translation_memories).not_to be_empty
+      expect(translation_memories.first).to be_a(DeepL::Resources::TranslationMemory)
+      expect(translation_memories.first.translation_memory_id).not_to be_nil
+      expect(translation_memories.first.name).not_to be_nil
+    end
+  end
+
+  def build_test_translation_memory
+    tm_data = {
+      'translation_memory_id' => 'a74d88fb-ed2a-4943-a664-a4512398b994',
+      'name' => 'Default Translation Memory',
+      'source_language' => 'DE',
+      'target_languages' => %w[EN ES FR],
+      'segment_count' => 3542
+    }
+    DeepL::Resources::TranslationMemory.new(tm_data, nil, nil)
+  end
+end

data/spec/requests/extra_body_parameters_types_spec.rb

@@ -0,0 +1,82 @@
+# 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.md file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'DeepL::Requests::Base extra_body_parameters type preservation' do
+  let(:api) { build_deepl_api }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  describe 'apply_extra_body_parameters_to_json' do
+    it 'preserves boolean true' do
+      request = DeepL::Requests::Translate.new(
+        api, 'test', 'EN', 'ES',
+        extra_body_parameters: { enable_beta_languages: true }
+      )
+
+      payload = {}
+      request.send(:apply_extra_body_parameters_to_json, payload)
+
+      expect(payload[:enable_beta_languages]).to be(true)
+      expect(payload[:enable_beta_languages]).to be_a(TrueClass)
+    end
+
+    it 'preserves boolean false' do
+      request = DeepL::Requests::Translate.new(
+        api, 'test', 'EN', 'ES',
+        extra_body_parameters: { some_flag: false }
+      )
+
+      payload = {}
+      request.send(:apply_extra_body_parameters_to_json, payload)
+
+      expect(payload[:some_flag]).to be(false)
+      expect(payload[:some_flag]).to be_a(FalseClass)
+    end
+
+    it 'preserves integers' do
+      request = DeepL::Requests::Translate.new(
+        api, 'test', 'EN', 'ES',
+        extra_body_parameters: { some_number: 42 }
+      )
+
+      payload = {}
+      request.send(:apply_extra_body_parameters_to_json, payload)
+
+      expect(payload[:some_number]).to eq(42)
+      expect(payload[:some_number]).to be_a(Integer)
+    end
+
+    it 'preserves strings' do
+      request = DeepL::Requests::Translate.new(
+        api, 'test', 'EN', 'ES',
+        extra_body_parameters: { some_string: 'hello' }
+      )
+
+      payload = {}
+      request.send(:apply_extra_body_parameters_to_json, payload)
+
+      expect(payload[:some_string]).to eq('hello')
+      expect(payload[:some_string]).to be_a(String)
+    end
+
+    it 'allows overriding standard parameters' do
+      request = DeepL::Requests::Translate.new(
+        api, 'test', 'EN', 'ES',
+        extra_body_parameters: { target_lang: 'FR' }
+      )
+
+      payload = { target_lang: 'ES' }
+      request.send(:apply_extra_body_parameters_to_json, payload)
+
+      expect(payload[:target_lang]).to eq('FR')
+    end
+  end
+end

data/spec/requests/glossary/create_spec.rb

@@ -0,0 +1,65 @@
+# Copyright 2022 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::Glossary::Create do
+  subject(:create) do
+    described_class.new(api, name, source_lang, target_lang, entries, 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(:name) { 'Mi Glosario' }
+  let(:source_lang) { 'EN' }
+  let(:target_lang) { 'ES' }
+  let(:entries) do
+    [
+      %w[Hello Hola],
+      %w[World Mundo]
+    ]
+  end
+  let(:entries_format) { 'tsv' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(create).to be_a(described_class)
+      end
+
+      it 'sets the default value for the entries format if not specified' do
+        request = described_class.new(api, name, source_lang, target_lang,
+                                      entries, options)
+        expect(request.entries_format).to eq('tsv')
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'when performing a valid request with two glossary entries' do
+      it 'returns a glossaries object' do
+        glossary = create.request
+        expect(glossary).to be_a(DeepL::Resources::Glossary)
+        expect(glossary.id).to be_a(String)
+        expect(glossary.name).to eq('Mi Glosario')
+        expect(glossary.ready).to be(true).or be(false)
+        expect(glossary.source_lang).to eq('en')
+        expect(glossary.target_lang).to eq('es')
+        expect { Time.iso8601(glossary.creation_time) }.not_to raise_error
+        expect(glossary.entry_count).to eq(2)
+      end
+    end
+  end
+end

data/spec/requests/glossary/destroy_spec.rb

@@ -0,0 +1,66 @@
+# Copyright 2022 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::Glossary::Destroy do
+  subject(:destroy) { described_class.new(api, id) }
+
+  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) { '9ab5dac2-b7b2-4b4a-808a-e8e305df5ecb' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(destroy).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:destroy) { described_class.new(api, new_glossary.id) }
+
+      let(:new_glossary) do
+        DeepL::Requests::Glossary::Create.new(api, 'fixture', 'EN', 'ES', [%w[Hello Hola]]).request
+      end
+
+      it 'returns an empty object' do
+        response = destroy.request
+        expect(response).to eq(new_glossary.id)
+      end
+    end
+
+    context 'when deleting a non existing glossary with a valid id' do
+      subject(:destroy) { described_class.new(api, id) }
+
+      let(:id) { '00000000-0000-0000-0000-000000000000' }
+
+      it 'raises a not found error' do
+        expect { destroy.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'when deleting a non existing glossary with an invalid id' do
+      subject(:destroy) { described_class.new(api, id) }
+
+      let(:id) { 'invalid-uuid' }
+
+      it 'raises a bad request error' do
+        expect { destroy.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/entries_spec.rb

@@ -0,0 +1,62 @@
+# Copyright 2022 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::Glossary::Entries do
+  subject(:entries_obj) { described_class.new(api, id) }
+
+  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) { '9ab5dac2-b7b2-4b4a-808a-e8e305df5ecb' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(entries_obj).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      it 'returns a list of entries in TSV format' do
+        entries = entries_obj.request
+        expect(entries).to be_a(Array)
+        expect(entries).to all(be_a(Array))
+        expect(entries.size).to eq(2)
+      end
+    end
+
+    context 'when requesting entries with a valid but non existing glossary id' do
+      subject(:entries_obj) { described_class.new(api, id) }
+
+      let(:id) { '00000000-0000-0000-0000-000000000000' }
+
+      it 'raises a not found error' do
+        expect { entries_obj.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'when requesting entries with an invalid glossary id' do
+      subject(:entries_obj) { described_class.new(api, id) }
+
+      let(:id) { 'invalid-uuid' }
+
+      it 'raises a bad request error' do
+        expect { entries_obj.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/find_spec.rb

@@ -0,0 +1,68 @@
+# Copyright 2022 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::Glossary::Find do
+  subject(:glossary_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) { '9ab5dac2-b7b2-4b4a-808a-e8e305df5ecb' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(glossary_find).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      it 'returns a glossary object' do
+        glossary = glossary_find.request
+        expect(glossary).to be_a(DeepL::Resources::Glossary)
+        expect(glossary.id).to eq('9ab5dac2-b7b2-4b4a-808a-e8e305df5ecb')
+        expect(glossary.name).to eq('Mi Glosario')
+        expect(glossary.ready).to be(true).or be(false)
+        expect(glossary.source_lang).to eq('en')
+        expect(glossary.target_lang).to eq('es')
+        expect { Time.iso8601(glossary.creation_time) }.not_to raise_error
+        expect(glossary.entry_count).to eq(2)
+      end
+    end
+
+    context 'when requesting a non existing glossary with a valid id' do
+      subject(:glossary_find) { described_class.new(api, id, options) }
+
+      let(:id) { 'a0af40e1-d81b-4aab-a95c-7cafbcfd1eb1' }
+
+      it 'raises a not found error' do
+        expect { glossary_find.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'when requesting a non existing glossary with an invalid id' do
+      subject(:glossary_find) { described_class.new(api, id, options) }
+
+      let(:id) { 'invalid-uuid' }
+
+      it 'raises a bad request error' do
+        expect { glossary_find.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/language_pairs_spec.rb

@@ -0,0 +1,40 @@
+# Copyright 2022 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::Glossary::LanguagePairs do
+  subject(:language_pairs_obj) { 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(language_pairs_obj).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'when requesting a list of all language pairs supported by glossaries' do
+      it 'returns a language pairs object' do
+        language_pairs = language_pairs_obj.request
+        expect(language_pairs).to be_an(Array)
+      end
+    end
+  end
+end

data/spec/requests/glossary/list_spec.rb

@@ -0,0 +1,54 @@
+# Copyright 2022 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::Glossary::List do
+  subject(:glossary_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(glossary_list).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'when requesting a list of all glossaries' do
+      it 'returns a glossaries object' do
+        glossaries = glossary_list.request
+        expect(glossaries).to be_an(Array)
+      end
+    end
+
+    context 'when performing a bad request' do
+      context 'when using an invalid token' do
+        let(:api) do
+          api = build_deepl_api
+          api.configuration.auth_key = 'invalid'
+          api
+        end
+
+        it 'raises an unauthorized error' do
+          expect { glossary_list.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+        end
+      end
+    end
+  end
+end