deepl-rb 3.6.1 → 3.8.0

data/lib/version.rb

@@ -4,5 +4,5 @@
 # frozen_string_literal: true
 
 module DeepL
-  VERSION = '3.6.1'
+  VERSION = '3.8.0'
 end

data/spec/api/deepl_spec.rb

@@ -4,9 +4,9 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'tempfile'
 
-describe DeepL do
+# rubocop:disable RSpec/StubbedMock
+describe DeepL do # rubocop:disable RSpec/SpecFilePathFormat
   subject(:deepl) { described_class.dup }
 
   around do |tests|
@@ -56,405 +56,207 @@ describe DeepL do
   end
 
   describe '#translate' do
-    let(:input) { 'Sample' }
-    let(:source_lang) { 'EN' }
-    let(:target_lang) { 'ES' }
-    let(:options) { { param: 'fake' } }
-
-    around do |example|
-      deepl.configure
-      VCR.use_cassette('deepl_translate') { example.call }
-    end
-
-    context 'when translating a text' do
-      it 'creates and call a request object' do
-        expect(DeepL::Requests::Translate).to receive(:new)
-          .with(deepl.api, input, source_lang, target_lang, options).and_call_original
-
-        text = deepl.translate(input, source_lang, target_lang, options)
-        expect(text).to be_a(DeepL::Resources::Text)
-      end
-    end
-
-    context 'when translating a text using a glossary' do
-      before do
-        @glossary = deepl.glossaries.create('fixture', 'EN', 'ES', [%w[car auto]])
-      end
-
-      let(:input) { 'I wish we had a car.' }
-      # rubocop:disable RSpec/InstanceVariable
-      let(:options) { { glossary_id: @glossary.id } }
+    let(:request) { instance_double(DeepL::Requests::Translate, request: 'result') }
 
-      after do
-        deepl.glossaries.destroy(@glossary.id)
-      end
-      # rubocop:enable RSpec/InstanceVariable
-
-      it 'creates and call a request object' do
-        expect(DeepL::Requests::Translate).to receive(:new)
-          .with(deepl.api, input, source_lang, target_lang, options).and_call_original
-        text = deepl.translate(input, source_lang, target_lang, options)
-        expect(text).to be_a(DeepL::Resources::Text)
-        expect(text.text).to eq('Ojalá tuviéramos auto.')
-      end
-    end
-  end
+    before { deepl.configure }
 
-  describe '#usage' do
-    let(:options) { {} }
+    it 'delegates to DeepL::Requests::Translate with the given arguments' do
+      options = { formality: 'more' }
+      additional_headers = { 'X-DeepL-Reporting-Tag' => 'tag' }
+      expect(DeepL::Requests::Translate).to receive(:new)
+        .with(deepl.api, 'Sample', 'EN', 'ES', options, additional_headers)
+        .and_return(request)
 
-    around do |example|
-      deepl.configure
-      VCR.use_cassette('deepl_usage') { example.call }
+      expect(deepl.translate('Sample', 'EN', 'ES', options, additional_headers)).to eq('result')
     end
 
-    context 'when checking usage' do
-      it 'creates and call a request object' do
-        expect(DeepL::Requests::Usage).to receive(:new)
-          .with(deepl.api, options).and_call_original
+    it 'defaults options and additional_headers to empty hashes' do
+      expect(DeepL::Requests::Translate).to receive(:new)
+        .with(deepl.api, 'Sample', 'EN', 'ES', {}, {})
+        .and_return(request)
 
-        usage = deepl.usage(options)
-        expect(usage).to be_a(DeepL::Resources::Usage)
-      end
+      deepl.translate('Sample', 'EN', 'ES')
     end
   end
 
-  # rubocop:disable RSpec/InstanceVariable
-  describe '#document' do
-    describe '#document.upload' do
-      before do
-        @tmpfile = Tempfile.new('foo')
-        @tmpfile.write("Geology for Beginners Report
-          A test report for the DeepL API
-          It is with great pleasure, that I, Urna Semper, write this fake document on geology.
-          Geology is an excellent field that deals with how to extract oil from the earth.")
-        @tmpfile.close
-      end
-
-      after do
-        @tmpfile.unlink
-      end
+  describe '#rephrase' do
+    let(:request) { instance_double(DeepL::Requests::Rephrase, request: 'result') }
 
-      let(:input_file) { @tmpfile.path }
-      let(:source_lang) { 'EN' }
-      let(:target_lang) { 'ES' }
-      let(:output_file) { 'test_translated_doc.txt' }
-      let(:options) { { param: 'fake' } }
-      let(:additional_headers) { { 'Fake-Header': 'fake_value' } }
+    before { deepl.configure }
 
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_document') { example.call }
-      end
+    it 'delegates to DeepL::Requests::Rephrase with the given arguments' do
+      options = { foo: 'bar' }
+      additional_headers = { 'X-DeepL-Reporting-Tag' => 'tag' }
+      expect(DeepL::Requests::Rephrase).to receive(:new)
+        .with(deepl.api, 'Sample', 'DE', 'business', 'friendly', options, additional_headers)
+        .and_return(request)
 
-      context 'when uploading a document' do
-        it 'creates an upload object' do
-          expect(DeepL::Requests::Document::Upload).to receive(:new)
-            .with(deepl.api, input_file, source_lang, target_lang,
-                  "#{File.basename(@tmpfile.path)}.txt", options,
-                  additional_headers).and_call_original
-          doc_handle = deepl.document.upload(input_file, source_lang, target_lang,
-                                             "#{File.basename(@tmpfile.path)}.txt", options,
-                                             additional_headers)
-          expect(doc_handle).to be_a(DeepL::Resources::DocumentHandle)
-        end
-      end
+      result = deepl.rephrase('Sample', 'DE', 'business', 'friendly', options, additional_headers)
+      expect(result).to eq('result')
     end
-    # rubocop:enable RSpec/InstanceVariable
-
-    describe '#document.get_status' do
-      let(:document_handle) do
-        DeepL::Resources::DocumentHandle.new('9B7CB9418DCDEBF2C4C519F65A32B99F',
-                                             'EA637EA43BB3F8A52A2A25B76EF3E0C72CE9CD00C881148D1236CB584CB34815', # rubocop:disable Layout/LineLength
-                                             nil,
-                                             nil)
-      end
-      let(:options) { { param: 'fake' } }
-      let(:additional_headers) { { 'Fake-Header': 'fake_value' } }
 
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_document') { example.call }
-      end
+    it 'defaults the optional arguments' do
+      expect(DeepL::Requests::Rephrase).to receive(:new)
+        .with(deepl.api, 'Sample', nil, nil, nil, {}, {})
+        .and_return(request)
 
-      context 'when querying the status of a document' do
-        it 'creates a GetStatus object' do
-          expect(DeepL::Requests::Document::GetStatus).to receive(:new)
-            .with(
-              deepl.api,
-              document_handle.document_id,
-              document_handle.document_key,
-              options,
-              additional_headers
-            ).and_call_original
-          status = deepl.document.get_status(document_handle, options, additional_headers)
-          expect(status).to be_a(DeepL::Resources::DocumentTranslationStatus)
-        end
-      end
+      deepl.rephrase('Sample')
     end
+  end
 
-    # rubocop:disable RSpec/InstanceVariable
-    describe '#document.download' do
-      before do
-        @tmpfile = Tempfile.new('bar')
-      end
+  describe '#usage' do
+    let(:request) { instance_double(DeepL::Requests::Usage, request: 'result') }
 
-      after do
-        @tmpfile.close
-        @tmpfile.unlink
-      end
+    before { deepl.configure }
 
-      let(:document_handle) do
-        DeepL::Resources::DocumentHandle.new('9B7CB9418DCDEBF2C4C519F65A32B99F',
-                                             'EA637EA43BB3F8A52A2A25B76EF3E0C72CE9CD00C881148D1236CB584CB34815', # rubocop:disable Layout/LineLength
-                                             nil,
-                                             nil)
-      end
-      let(:output_file_path) { @tmpfile.path }
-      let(:options) { { param: 'fake' } }
+    it 'delegates to DeepL::Requests::Usage with the given options' do
+      options = { foo: 'bar' }
+      expect(DeepL::Requests::Usage).to receive(:new).with(deepl.api, options).and_return(request)
 
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_document_download', preserve_exact_body_bytes: true) do
-          example.call
-        end
-      end
+      expect(deepl.usage(options)).to eq('result')
+    end
 
-      context 'when downloading a document' do
-        it 'creates an downloading object and writes to the output file' do # rubocop:disable RSpec/ExampleLength
-          expect(DeepL::Requests::Document::Download).to receive(:new)
-            .with(
-              deepl.api,
-              document_handle.document_id,
-              document_handle.document_key,
-              output_file_path
-            ).and_call_original
-          deepl.document.download(document_handle, output_file_path)
-          file_contents = File.read(output_file_path)
-          expect(file_contents).to be_a(String)
-          expect(file_contents.length).to be > 200
-        end
-      end
+    it 'defaults options to an empty hash' do
+      expect(DeepL::Requests::Usage).to receive(:new).with(deepl.api, {}).and_return(request)
+
+      deepl.usage
     end
   end
-  # rubocop:enable RSpec/InstanceVariable
 
   describe '#languages' do
-    let(:options) { { type: :target } }
+    let(:request) { instance_double(DeepL::Requests::Languages, request: 'result') }
+
+    before { deepl.configure }
+
+    it 'delegates to DeepL::Requests::Languages with the given options' do
+      options = { type: :target }
+      expect(DeepL::Requests::Languages).to receive(:new).with(deepl.api, options)
+                                                         .and_return(request)
 
-    around do |example|
-      deepl.configure
-      VCR.use_cassette('deepl_languages') { example.call }
+      expect(deepl.languages(options)).to eq('result')
     end
 
-    context 'when checking languages' do
-      it 'creates and call a request object' do
-        expect(DeepL::Requests::Languages).to receive(:new)
-          .with(deepl.api, options).and_call_original
+    it 'defaults options to an empty hash' do
+      expect(DeepL::Requests::Languages).to receive(:new).with(deepl.api, {}).and_return(request)
 
-        languages = deepl.languages(options)
-        expect(languages).to be_an(Array)
-        expect(languages).to(be_all { |l| l.is_a?(DeepL::Resources::Language) })
-      end
+      deepl.languages
     end
   end
 
   describe '#glossaries' do
-    describe '#glossaries.create' do
-      let(:name) { 'Mi Glosario' }
-      let(:source_lang) { 'EN' }
-      let(:target_lang) { 'ES' }
-      let(:entries) do
-        [
-          %w[Hello Hola],
-          %w[World Mundo]
-        ]
-      end
-      let(:options) { { param: 'fake', entries_format: 'tsv' } }
+    before { deepl.configure }
 
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_glossaries') { example.call }
-      end
-
-      context 'when creating a glossary' do
-        it 'creates and call a request object' do
-          expect(DeepL::Requests::Glossary::Create).to receive(:new)
-            .with(deepl.api, name, source_lang, target_lang, entries, options).and_call_original
-
-          glossary = deepl.glossaries.create(name, source_lang, target_lang, entries, options)
-          expect(glossary).to be_a(DeepL::Resources::Glossary)
-        end
-      end
+    it 'returns a GlossaryApi instance built with the configured api' do
+      expect(deepl.glossaries).to be_a(DeepL::GlossaryApi)
     end
 
-    describe '#glossaries.find' do
-      let(:id) { 'e7a62637-7ef4-4959-a355-09ba61dd0126' }
-      let(:options) { {} }
-
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_glossaries') { example.call }
-      end
-
-      context 'when fetching a glossary' do
-        it 'creates and call a request object' do
-          expect(DeepL::Requests::Glossary::Find).to receive(:new)
-            .with(deepl.api, id, options).and_call_original
-
-          glossary = deepl.glossaries.find(id, options)
-          expect(glossary).to be_a(DeepL::Resources::Glossary)
-        end
-      end
-
-      context 'when fetching a non existing glossary' do
-        let(:id) { '00000000-0000-0000-0000-000000000000' }
+    describe 'GlossaryApi#create' do
+      it 'delegates to DeepL::Requests::Glossary::Create' do
+        request = instance_double(DeepL::Requests::Glossary::Create, request: 'result')
+        entries = [%w[Hello Hola]]
+        expect(DeepL::Requests::Glossary::Create).to receive(:new)
+          .with(deepl.api, 'Mi Glosario', 'EN', 'ES', entries, {})
+          .and_return(request)
 
-        it 'raises an exception when the glossary does not exist' do
-          expect(DeepL::Requests::Glossary::Find).to receive(:new)
-            .with(deepl.api, id, options).and_call_original
-          expect { deepl.glossaries.find(id, options) }
-            .to raise_error(DeepL::Exceptions::NotFound)
-        end
+        deepl.glossaries.create('Mi Glosario', 'EN', 'ES', entries)
       end
     end
 
-    describe '#glossaries.list' do
-      let(:options) { {} }
-
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_glossaries') { example.call }
-      end
-
-      context 'when fetching glossaries' do
-        it 'creates and call a request object' do
-          expect(DeepL::Requests::Glossary::List).to receive(:new)
-            .with(deepl.api, options).and_call_original
+    describe 'GlossaryApi#find' do
+      it 'delegates to DeepL::Requests::Glossary::Find' do
+        request = instance_double(DeepL::Requests::Glossary::Find, request: 'result')
+        expect(DeepL::Requests::Glossary::Find).to receive(:new)
+          .with(deepl.api, 'glossary-id', {})
+          .and_return(request)
 
-          glossaries = deepl.glossaries.list(options)
-          expect(glossaries).to all(be_a(DeepL::Resources::Glossary))
-        end
+        deepl.glossaries.find('glossary-id')
       end
     end
 
-    describe '#glossaries.destroy' do
-      let(:id) { 'e7a62637-7ef4-4959-a355-09ba61dd0126' }
-      let(:options) { {} }
+    describe 'GlossaryApi#list' do
+      it 'delegates to DeepL::Requests::Glossary::List' do
+        request = instance_double(DeepL::Requests::Glossary::List, request: 'result')
+        expect(DeepL::Requests::Glossary::List).to receive(:new).with(deepl.api, {})
+                                                                .and_return(request)
 
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_glossaries') { example.call }
-      end
-
-      context 'when destroy a glossary' do
-        let(:new_glossary) do
-          deepl.glossaries.create('fixture', 'EN', 'ES', [%w[Hello Hola]])
-        end
-
-        it 'creates and call a request object' do
-          expect(DeepL::Requests::Glossary::Destroy).to receive(:new)
-            .with(deepl.api, new_glossary.id, options).and_call_original
-
-          glossary_id = deepl.glossaries.destroy(new_glossary.id, options)
-          expect(glossary_id).to eq(new_glossary.id)
-        end
+        deepl.glossaries.list
       end
+    end
 
-      context 'when destroying a non existing glossary' do
-        let(:id) { '00000000-0000-0000-0000-000000000000' }
+    describe 'GlossaryApi#destroy' do
+      it 'delegates to DeepL::Requests::Glossary::Destroy' do
+        request = instance_double(DeepL::Requests::Glossary::Destroy, request: 'result')
+        expect(DeepL::Requests::Glossary::Destroy).to receive(:new)
+          .with(deepl.api, 'glossary-id', {})
+          .and_return(request)
 
-        it 'raises an exception when the glossary does not exist' do
-          expect(DeepL::Requests::Glossary::Destroy).to receive(:new)
-            .with(deepl.api, id, options).and_call_original
-          expect { deepl.glossaries.destroy(id, options) }
-            .to raise_error(DeepL::Exceptions::NotFound)
-        end
+        deepl.glossaries.destroy('glossary-id')
       end
     end
 
-    describe '#glossaries.entries' do
-      let(:id) { 'e7a62637-7ef4-4959-a355-09ba61dd0126' }
-      let(:options) { {} }
-
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_glossaries') { example.call }
-      end
+    describe 'GlossaryApi#entries' do
+      it 'delegates to DeepL::Requests::Glossary::Entries' do
+        request = instance_double(DeepL::Requests::Glossary::Entries, request: 'result')
+        expect(DeepL::Requests::Glossary::Entries).to receive(:new)
+          .with(deepl.api, 'glossary-id', {})
+          .and_return(request)
 
-      context 'when listing glossary entries' do
-        it 'creates and call a request object' do
-          expect(DeepL::Requests::Glossary::Entries).to receive(:new)
-            .with(deepl.api, id, options).and_call_original
-
-          entries = deepl.glossaries.entries(id, options)
-          expect(entries).to all(be_a(Array))
-          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
-
-      context 'when listing entries of a non existing glossary' do
-        let(:id) { '00000000-0000-0000-0000-000000000000' }
-
-        it 'raises an exception when the glossary does not exist' do
-          expect(DeepL::Requests::Glossary::Entries).to receive(:new)
-            .with(deepl.api, id, options).and_call_original
-          expect { deepl.glossaries.entries(id, options) }
-            .to raise_error(DeepL::Exceptions::NotFound)
-        end
+        deepl.glossaries.entries('glossary-id')
       end
     end
 
-    describe '#glossaries.language_pairs' do
-      let(:options) { {} }
+    describe 'GlossaryApi#language_pairs' do
+      it 'delegates to DeepL::Requests::Glossary::LanguagePairs' do
+        request = instance_double(DeepL::Requests::Glossary::LanguagePairs, request: 'result')
+        expect(DeepL::Requests::Glossary::LanguagePairs).to receive(:new).with(deepl.api, {})
+                                                                         .and_return(request)
 
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_glossaries') { example.call }
+        deepl.glossaries.language_pairs
       end
+    end
+  end
 
-      context 'when fetching language pairs supported by glossaries' do
-        it 'creates and call a request object' do
-          expect(DeepL::Requests::Glossary::LanguagePairs).to receive(:new)
-            .with(deepl.api, options).and_call_original
+  describe '#document' do
+    before { deepl.configure }
 
-          language_pairs = deepl.glossaries.language_pairs(options)
-          expect(language_pairs).to all(be_a(DeepL::Resources::LanguagePair))
-        end
-      end
+    it 'returns a DocumentApi instance built with the configured api' do
+      expect(deepl.document).to be_a(DeepL::DocumentApi)
     end
-  end
 
-  describe '#rephrase' do
-    let(:text) { 'Ih bin ei beispielsatz.' }
-    let(:target_lang) { 'DE' }
-    let(:options) { {} }
+    describe 'DocumentApi#upload' do
+      it 'delegates to DeepL::Requests::Document::Upload' do
+        request = instance_double(DeepL::Requests::Document::Upload, request: 'result')
+        expect(DeepL::Requests::Document::Upload).to receive(:new)
+          .with(deepl.api, 'path', 'EN', 'ES', 'file.txt', {}, {})
+          .and_return(request)
 
-    around do |example|
-      deepl.configure
-      VCR.use_cassette('deepl_rephrase') { example.call }
+        deepl.document.upload('path', 'EN', 'ES', 'file.txt')
+      end
     end
 
-    context 'when rephrasing text' do
-      it 'creates and call a request object' do
-        expect(DeepL::Requests::Rephrase).to receive(:new)
-          .with(deepl.api, text, nil, nil, nil, {}).and_call_original
+    describe 'DocumentApi#get_status' do
+      it 'delegates to DeepL::Requests::Document::GetStatus' do
+        request = instance_double(DeepL::Requests::Document::GetStatus, request: 'result')
+        handle = DeepL::Resources::DocumentHandle.new('doc-id', 'doc-key', nil, nil)
+        expect(DeepL::Requests::Document::GetStatus).to receive(:new)
+          .with(deepl.api, 'doc-id', 'doc-key', {}, {})
+          .and_return(request)
 
-        rephrased_text = deepl.rephrase(text)
-        expect(rephrased_text).to be_a(DeepL::Resources::Text)
+        deepl.document.get_status(handle)
       end
+    end
 
-      it 'creates and call a request object when passing options' do
-        expect(DeepL::Requests::Rephrase).to receive(:new)
-          .with(deepl.api, text, target_lang, nil, nil, options).and_call_original
+    describe 'DocumentApi#download' do
+      it 'delegates to DeepL::Requests::Document::Download' do
+        request = instance_double(DeepL::Requests::Document::Download, request: 'result')
+        handle = DeepL::Resources::DocumentHandle.new('doc-id', 'doc-key', nil, nil)
+        expect(DeepL::Requests::Document::Download).to receive(:new)
+          .with(deepl.api, 'doc-id', 'doc-key', 'output-path')
+          .and_return(request)
 
-        rephrased_text = deepl.rephrase(text, target_lang, nil, nil, options)
-        expect(rephrased_text).to be_a(DeepL::Resources::Text)
+        deepl.document.download(handle, 'output-path')
       end
     end
   end
 end
+# rubocop:enable RSpec/StubbedMock

data/spec/integration_tests/document_api_spec.rb

@@ -6,16 +6,6 @@
 require 'spec_helper'
 
 describe DeepL::DocumentApi do
-  before do
-    VCR.turn_off!
-    WebMock.allow_net_connect!
-  end
-
-  after do
-    VCR.turn_on!
-    WebMock.disable_net_connect!
-  end
-
   include_context 'with temp dir'
 
   let(:default_lang_args) { { source_lang: 'EN', target_lang: 'DE' } }
@@ -63,8 +53,7 @@ describe DeepL::DocumentApi do
       expect(doc_status.status).to eq('done')
     end
 
-    it 'Translates a document after retrying the upload once' do # rubocop:disable RSpec/ExampleLength
-      skip 'Only runs on mock server' if real_server?
+    it 'Translates a document after retrying the upload once', :mock_server_only do # rubocop:disable RSpec/ExampleLength
       File.unlink(output_document_path)
       source_lang = default_lang_args[:source_lang]
       target_lang = default_lang_args[:target_lang]
@@ -85,8 +74,7 @@ describe DeepL::DocumentApi do
     end
   end
 
-  it 'Translates a document after waiting' do # rubocop:disable RSpec/ExampleLength
-    skip 'Only runs on mock server' if real_server?
+  it 'Translates a document after waiting', :mock_server_only do # rubocop:disable RSpec/ExampleLength
     File.unlink(output_document_path)
     source_lang = default_lang_args[:source_lang]
     target_lang = default_lang_args[:target_lang]
@@ -107,8 +95,7 @@ describe DeepL::DocumentApi do
     expect(doc_status.status).to eq('done')
   end
 
-  it 'Translates a large document' do # rubocop:disable RSpec/ExampleLength
-    skip 'Only runs on mock server' if real_server?
+  it 'Translates a large document', :mock_server_only do # rubocop:disable RSpec/ExampleLength
     File.unlink(output_document_path)
     source_lang = default_lang_args[:source_lang]
     target_lang = default_lang_args[:target_lang]
@@ -130,8 +117,7 @@ describe DeepL::DocumentApi do
     expect(doc_status.status).to eq('done')
   end
 
-  it 'Translates a document with formality set' do # rubocop:disable RSpec/ExampleLength
-    skip 'Only runs on mock server' if real_server?
+  it 'Translates a document with formality set', :mock_server_only do # rubocop:disable RSpec/ExampleLength
     File.unlink(output_document_path)
     source_lang = default_lang_args[:source_lang]
     target_lang = default_lang_args[:target_lang]

data/spec/integration_tests/document_error_paths_spec.rb

@@ -0,0 +1,33 @@
+# 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::DocumentApi do # rubocop:disable RSpec/SpecFilePathFormat
+  include_context 'with a live mock server'
+
+  let(:source_lang) { 'EN' }
+  let(:target_lang) { 'DE' }
+  let(:document_path) { example_document_path(source_lang) }
+
+  describe 'authorization failures' do
+    let(:unauthorized_documents) { described_class.new(unauthorized_api) }
+
+    it 'raises AuthorizationFailed when uploading with an invalid auth key' do
+      expect { unauthorized_documents.upload(document_path, source_lang, target_lang) }
+        .to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    end
+  end
+
+  describe 'translation failures' do
+    it 'reports an error status when the server fails the document', :mock_server_only do
+      handle = DeepL.document.upload(document_path, source_lang, target_lang,
+                                     File.basename(document_path), {}, fail_docs_header(1))
+      status = handle.wait_until_document_translation_finished
+
+      expect(status.status).to eq('error')
+    end
+  end
+end