deepl-rb 3.7.0 → 3.8.0

data/spec/integration_tests/translate_error_paths_spec.rb

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

data/spec/integration_tests/translation_memory_api_spec.rb

@@ -5,21 +5,9 @@
 
 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 DeepL::TranslationMemoryApi, :mock_server_only do
   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'
@@ -31,8 +19,6 @@ describe DeepL::TranslationMemoryApi do
     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'
@@ -46,8 +32,6 @@ describe DeepL::TranslationMemoryApi do
 
   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

data/spec/integration_tests/translation_memory_error_paths_spec.rb

@@ -0,0 +1,19 @@
+# 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, :mock_server_only do # rubocop:disable RSpec/SpecFilePathFormat
+  include_context 'with a live mock server'
+
+  describe 'authorization failures' do
+    let(:unauthorized_translation_memories) { described_class.new(unauthorized_api) }
+
+    it 'raises AuthorizationFailed when listing with an invalid auth key' do
+      expect { unauthorized_translation_memories.list }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+  end
+end

data/spec/integration_tests/usage_api_spec.rb

@@ -0,0 +1,29 @@
+# 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.usage' do # rubocop:disable RSpec/DescribeClass
+  describe 'happy path' do
+    it 'returns a Usage resource with integer counters where count does not exceed limit' do
+      usage = DeepL.usage
+
+      expect(usage).to be_a(DeepL::Resources::Usage)
+      expect(usage).to respond_to(:character_count, :character_limit)
+      expect(usage.character_count).to be_an(Integer)
+      expect(usage.character_limit).to be_an(Integer)
+      expect(usage.character_count).to be <= usage.character_limit
+    end
+  end
+
+  describe 'resource shape' do
+    it 'exposes quota_exceeded? consistent with character_count vs character_limit' do
+      usage = DeepL.usage
+
+      expect(usage).to respond_to(:quota_exceeded?)
+      expect(usage.quota_exceeded?).to eq(usage.character_count >= usage.character_limit)
+    end
+  end
+end

data/spec/integration_tests/usage_error_paths_spec.rb

@@ -0,0 +1,18 @@
+# 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.usage 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::Usage.new(unauthorized_api)
+
+      expect { request.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+  end
+end

data/spec/requests/glossary/create_spec.rb

@@ -26,7 +26,6 @@ describe DeepL::Requests::Glossary::Create do
       %w[World Mundo]
     ]
   end
-  let(:entries_format) { 'tsv' }
   let(:options) { {} }
 
   describe '#initialize' do
@@ -42,24 +41,4 @@ describe DeepL::Requests::Glossary::Create do
       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

@@ -24,43 +24,4 @@ describe DeepL::Requests::Glossary::Destroy do
       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

@@ -24,39 +24,4 @@ describe DeepL::Requests::Glossary::Entries do
       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

@@ -25,44 +25,4 @@ describe DeepL::Requests::Glossary::Find do
       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

@@ -24,17 +24,4 @@ describe DeepL::Requests::Glossary::LanguagePairs do
       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

@@ -24,31 +24,4 @@ describe DeepL::Requests::Glossary::List do
       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

data/spec/requests/languages_spec.rb

@@ -24,45 +24,4 @@ describe DeepL::Requests::Languages do
       end
     end
   end
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('languages') { example.call }
-    end
-
-    context 'when requesting source languages' do
-      it 'returns a valid list of source languages' do
-        languages = languages_obj.request
-
-        expect(languages).to be_an(Array)
-        expect(languages.size).to eq(29)
-        expect(languages).to(be_any { |l| l.code == 'EN' && l.name == 'English' })
-        expect(languages).to(be_any { |l| l.code == 'ES' && l.name == 'Spanish' })
-      end
-    end
-
-    context 'when requesting target languages' do
-      let(:options) { { type: :target } }
-
-      it 'returns a valid list of target languages' do
-        languages = languages_obj.request
-
-        expect(languages).to be_an(Array)
-        expect(languages.size).to eq(31)
-        expect(languages).not_to(be_any { |l| l.code == 'EN' && l.name == 'English' })
-        expect(languages).to(be_any { |l| l.code == 'ES' && l.name == 'Spanish' })
-        expect(languages)
-          .to(be_any { |l| l.code == 'EN-US' && l.name == 'English (American)' })
-      end
-    end
-
-    context 'when using an invalid type' do
-      let(:options) { { type: :invalid } }
-
-      it 'returns an usage object' do
-        message = "Parameter 'type' is invalid. 'source' and 'target' are valid values."
-        expect { languages_obj.request }.to raise_error(DeepL::Exceptions::BadRequest, message)
-      end
-    end
-  end
 end

data/spec/requests/rephrase_spec.rb

@@ -6,8 +6,6 @@
 require 'spec_helper'
 
 describe DeepL::Requests::Rephrase do
-  subject(:rephrase) { described_class.new(api, text, target_lang, writing_style, tone, options) }
-
   around do |tests|
     tmp_env = replace_env_preserving_deepl_vars_except_mock_server
     tests.call
@@ -19,153 +17,29 @@ describe DeepL::Requests::Rephrase do
     'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.'
   end
   let(:target_lang) { 'EN' }
-  let(:writing_style) { nil }
-  let(:tone) { nil }
-  let(:options) { {} }
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('rephrase_texts') { example.call }
-    end
-
-    context 'without a style or tone applied' do
-      context 'with a string as input' do
-        it 'returns a valid response as a DeepL Text resource' do
-          original_length = text.length
-          response_text = rephrase.request
-
-          expect(response_text).to be_a(DeepL::Resources::Text)
-          expect(response_text.text.length).not_to eq(original_length)
-          expect(response_text.detected_source_language.upcase).to eq('EN')
-        end
-      end
-
-      context 'with an array of texts as input' do
-        let(:text) do
-          [
-            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
-            'He lay on his armour-like back, and if he lifted his head a little'
-          ]
-        end
-
-        it 'returns a valid response as an array of DeepL Text resources' do
-          response_texts = rephrase.request
-
-          expect(response_texts).to all(be_a(DeepL::Resources::Text))
-          response_texts.each_with_index do |response_text, index|
-            expect(response_text.text.length).not_to eq(text[index].length)
-            expect(response_text.detected_source_language.upcase).to eq('EN')
-          end
-        end
-      end
-    end
-
-    context 'with a valid tone applied' do
-      let(:tone) { 'friendly' }
-
-      context 'with a string as input' do
-        it 'returns a valid response with a string as text input' do
-          original_length = text.length
-          response_text = rephrase.request
-
-          expect(response_text).to be_a(DeepL::Resources::Text)
-          expect(response_text.text.length).not_to eq(original_length)
-          expect(response_text.detected_source_language.upcase).to eq('EN')
-        end
-      end
-
-      context 'with an array of texts as input' do
-        let(:text) do
-          [
-            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
-            'He lay on his armour-like back, and if he lifted his head a little'
-          ]
-        end
-
-        it 'returns an array of valid text objects' do
-          response_texts = rephrase.request
-
-          expect(response_texts).to all(be_a(DeepL::Resources::Text))
-          response_texts.each_with_index do |response_text, index|
-            expect(response_text.text.length).not_to eq(text[index].length)
-            expect(response_text.detected_source_language.upcase).to eq('EN')
-          end
-        end
-      end
-    end
-
-    context 'with a valid writing style applied' do
-      let(:writing_style) { 'business' }
 
-      context 'with a string as input' do
-        it 'returns a valid response with a string as text input' do
-          original_length = text.length
-          response_text = rephrase.request
-
-          expect(response_text).to be_a(DeepL::Resources::Text)
-          expect(response_text.text.length).not_to eq(original_length)
-          expect(response_text.detected_source_language.upcase).to eq('EN')
-        end
+  describe '#initialize' do
+    context 'when passing additional headers' do
+      it 'merges the headers into the request headers' do
+        request = described_class.new(api, text, target_lang, nil, nil, {},
+                                      { 'X-DeepL-Reporting-Tag' => 'my-tag' })
+        expect(request.send(:headers)).to include('X-DeepL-Reporting-Tag' => 'my-tag')
       end
 
-      context 'with an array of texts as input' do
-        let(:text) do
-          [
-            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
-            'He lay on his armour-like back, and if he lifted his head a little'
-          ]
-        end
-
-        it 'returns an array of valid text objects' do
-          response_texts = rephrase.request
-
-          expect(response_texts).to all(be_a(DeepL::Resources::Text))
-          response_texts.each_with_index do |response_text, index|
-            expect(response_text.text.length).not_to eq(text[index].length)
-            expect(response_text.detected_source_language.upcase).to eq('EN')
-          end
-        end
+      it 'defaults to no additional headers' do
+        request = described_class.new(api, text, target_lang)
+        expect(request.send(:headers).keys).to contain_exactly('Authorization', 'User-Agent')
       end
     end
 
-    context 'with a writing style or tone from the provided constants applied' do
+    context 'with a writing style and tone from the provided constants applied' do
       let(:writing_style) { DeepL::Constants::WritingStyle::BUSINESS }
       let(:tone) { DeepL::Constants::Tone::FRIENDLY }
 
       it 'has the correct writing style and tone applied' do
-        expect(rephrase.writing_style).to eq('business')
-        expect(rephrase.tone).to eq('friendly')
-      end
-    end
-
-    context 'with an invalid writing style applied' do
-      let(:writing_style) { 'angry' }
-
-      it 'raises a bad request error' do
-        expect { rephrase.request }.to raise_error(DeepL::Exceptions::BadRequest)
-      end
-    end
-
-    context 'when both writing style and tone are applied' do
-      let(:writing_style) { 'business' }
-      let(:tone) { 'friendly' }
-
-      it 'raises a bad request error' do
-        expect { rephrase.request }.to raise_error(DeepL::Exceptions::BadRequest)
-      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 { rephrase.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-        end
+        request = described_class.new(api, text, target_lang, writing_style, tone)
+        expect(request.writing_style).to eq('business')
+        expect(request.tone).to eq('friendly')
       end
     end
   end

data/spec/requests/style_rule/create_custom_instruction_spec.rb

@@ -27,28 +27,4 @@ describe DeepL::Requests::StyleRule::CreateCustomInstruction do
       end
     end
   end
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('style_rules_crud') { example.call }
-    end
-
-    context 'when performing a valid request' do
-      subject(:create_instruction) do
-        described_class.new(api, new_rule.style_id, label, prompt)
-      end
-
-      let(:new_rule) do
-        DeepL::Requests::StyleRule::Create.new(api, 'Instruction Test', 'en').request
-      end
-
-      it 'returns a custom instruction object' do
-        instruction = create_instruction.request
-        expect(instruction).to be_a(DeepL::Resources::CustomInstruction)
-        expect(instruction.id).to be_a(String)
-        expect(instruction.label).to eq('Test Instruction')
-        expect(instruction.prompt).to eq('Always use formal language')
-      end
-    end
-  end
 end

data/spec/requests/style_rule/create_spec.rb

@@ -26,20 +26,4 @@ describe DeepL::Requests::StyleRule::Create do
       end
     end
   end
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('style_rules_crud') { example.call }
-    end
-
-    context 'when performing a valid request' do
-      it 'returns a style rule object' do
-        style_rule = create.request
-        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
-        expect(style_rule.style_id).to be_a(String)
-        expect(style_rule.name).to eq('Test Style Rule')
-        expect(style_rule.language).to eq('en')
-      end
-    end
-  end
 end

data/spec/requests/style_rule/destroy_custom_instruction_spec.rb

@@ -25,30 +25,4 @@ describe DeepL::Requests::StyleRule::DestroyCustomInstruction do
       end
     end
   end
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('style_rules_crud') { example.call }
-    end
-
-    context 'when performing a valid request' do
-      subject(:destroy_instruction) do
-        described_class.new(api, new_rule.style_id, new_instruction.id)
-      end
-
-      let(:new_rule) do
-        DeepL::Requests::StyleRule::Create.new(api, 'Destroy Instruction Test', 'en').request
-      end
-      let(:new_instruction) do
-        DeepL::Requests::StyleRule::CreateCustomInstruction.new(
-          api, new_rule.style_id, 'To Delete', 'Delete me'
-        ).request
-      end
-
-      it 'returns the deleted instruction id' do
-        response = destroy_instruction.request
-        expect(response).to eq(new_instruction.id)
-      end
-    end
-  end
 end