deepl-rb 3.9.0 → 3.10.0

data/spec/integration_tests/document_api_spec.rb

@@ -1,211 +0,0 @@
-# Copyright 2024 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
-  include_context 'with temp dir'
-
-  let(:default_lang_args) { { source_lang: 'EN', target_lang: 'DE' } }
-
-  describe '#translate_document' do
-    it 'Translates a document from a filepath' do
-      File.unlink(output_document_path)
-      source_lang = default_lang_args[:source_lang]
-      target_lang = default_lang_args[:target_lang]
-      example_doc_path = example_document_path(source_lang)
-      DeepL.document.translate_document(example_doc_path, output_document_path,
-                                        source_lang, target_lang, File.basename(example_doc_path),
-                                        {})
-      output_file_contents = File.read(output_document_path)
-
-      expect(example_document_translation(target_lang)).to eq(output_file_contents)
-    end
-
-    it 'Translates a document from a filepath without a filename' do
-      File.unlink(output_document_path)
-      source_lang = default_lang_args[:source_lang]
-      target_lang = default_lang_args[:target_lang]
-      example_doc_path = example_document_path(source_lang)
-      DeepL.document.translate_document(example_doc_path, output_document_path,
-                                        source_lang, target_lang)
-      output_file_contents = File.read(output_document_path)
-
-      expect(example_document_translation(target_lang)).to eq(output_file_contents)
-    end
-
-    it 'Translates a document using the lower-level methods and returns the correct status' do # rubocop:disable RSpec/ExampleLength
-      File.unlink(output_document_path)
-      source_lang = default_lang_args[:source_lang]
-      target_lang = default_lang_args[:target_lang]
-      example_doc_path = example_document_path(source_lang)
-
-      handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                     File.basename(example_doc_path), {})
-      doc_status = handle.wait_until_document_translation_finished
-      DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-      output_file_contents = File.read(output_document_path)
-
-      expect(example_document_translation(target_lang)).to eq(output_file_contents)
-      expect(doc_status.billed_characters).to eq(example_document_translation(source_lang).length)
-      expect(doc_status.status).to eq('done')
-    end
-
-    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]
-      example_doc_path = example_document_path(source_lang)
-      doc_status = nil
-      DeepL.with_session(DeepL::HTTPClientOptions.new({}, nil, enable_ssl_verification: false,
-                                                               read_timeout: 1.0)) do |_session|
-        handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                       File.basename(example_doc_path), {}, no_response_header(1))
-        doc_status = handle.wait_until_document_translation_finished
-        DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-      end
-      output_file_contents = File.read(output_document_path)
-
-      expect(output_file_contents).to eq(example_document_translation(target_lang))
-      expect(doc_status.billed_characters).to eq(example_document_translation(source_lang).length)
-      expect(doc_status.status).to eq('done')
-    end
-  end
-
-  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]
-    example_doc_path = example_document_path(source_lang)
-    doc_status = nil
-    DeepL.with_session(DeepL::HTTPClientOptions.new({}, nil,
-                                                    enable_ssl_verification: false)) do |_session|
-      handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                     File.basename(example_doc_path), {},
-                                     doc_translation_queue_time_header(2000).merge(doc_translation_translation_time_header(2000))) # rubocop:disable Layout/LineLength
-      doc_status = handle.wait_until_document_translation_finished
-      DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-    end
-    output_file_contents = File.read(output_document_path)
-
-    expect(output_file_contents).to eq(example_document_translation(target_lang))
-    expect(doc_status.billed_characters).to eq(example_document_translation(source_lang).length)
-    expect(doc_status.status).to eq('done')
-  end
-
-  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]
-    example_doc_path = example_large_document_path(source_lang)
-    doc_status = nil
-    DeepL.with_session(DeepL::HTTPClientOptions.new({}, nil,
-                                                    enable_ssl_verification: false)) do |_session|
-      handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                     File.basename(example_doc_path), {})
-      doc_status = handle.wait_until_document_translation_finished
-      DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-    end
-    output_file_contents = File.read(output_document_path)
-
-    expect(output_file_contents).to eq(example_large_document_translation(target_lang))
-    expect(doc_status.billed_characters).to eq(
-      example_large_document_translation(source_lang).length
-    )
-    expect(doc_status.status).to eq('done')
-  end
-
-  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]
-    example_doc_path = example_large_document_path(source_lang)
-    doc_status = nil
-    DeepL.with_session(DeepL::HTTPClientOptions.new({}, nil,
-                                                    enable_ssl_verification: false)) do |_session|
-      handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                     File.basename(example_doc_path),
-                                     { 'formality' => 'prefer_more' })
-      doc_status = handle.wait_until_document_translation_finished
-      DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-    end
-    output_file_contents = File.read(output_document_path)
-
-    expect(output_file_contents).to eq(example_large_document_translation(target_lang))
-    expect(doc_status.billed_characters).to eq(
-      example_large_document_translation(source_lang).length
-    )
-    expect(doc_status.status).to eq('done')
-  end
-
-  it 'Translates a document with a style_id set', :mock_server_only do # rubocop:disable RSpec/ExampleLength
-    File.unlink(output_document_path)
-    # Mock's default style rule (dca2e053...) has language `en`, so the target
-    # language must be English.
-    source_lang = 'DE'
-    target_lang = 'EN-US'
-    example_doc_path = example_document_path(source_lang)
-    style_id = 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4'
-    doc_status = nil
-    DeepL.with_session(DeepL::HTTPClientOptions.new({}, nil,
-                                                    enable_ssl_verification: false)) do |_session|
-      handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                     File.basename(example_doc_path),
-                                     { style_rule: style_id })
-      doc_status = handle.wait_until_document_translation_finished
-      DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-    end
-    output_file_contents = File.read(output_document_path)
-
-    expect(example_document_translation(target_lang)).to eq(output_file_contents)
-    expect(doc_status.status).to eq('done')
-  end
-
-  it 'Translates a document with a translation_memory_id set', :mock_server_only do # rubocop:disable RSpec/ExampleLength
-    File.unlink(output_document_path)
-    # Mock's default translation memory (a74d88fb...) has source `de` and
-    # targets `en`/`es`/`fr`, so translate DE -> EN-US.
-    source_lang = 'DE'
-    target_lang = 'EN-US'
-    example_doc_path = example_document_path(source_lang)
-    translation_memory_id = 'a74d88fb-ed2a-4943-a664-a4512398b994'
-    doc_status = nil
-    DeepL.with_session(DeepL::HTTPClientOptions.new({}, nil,
-                                                    enable_ssl_verification: false)) do |_session|
-      handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                     File.basename(example_doc_path),
-                                     { translation_memory: translation_memory_id,
-                                       translation_memory_threshold: 80 })
-      doc_status = handle.wait_until_document_translation_finished
-      DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-    end
-    output_file_contents = File.read(output_document_path)
-
-    expect(example_document_translation(target_lang)).to eq(output_file_contents)
-    expect(doc_status.status).to eq('done')
-  end
-
-  it 'Translates a document with extra_body_parameters' do # rubocop:disable RSpec/ExampleLength
-    File.unlink(output_document_path)
-    source_lang = default_lang_args[:source_lang]
-    target_lang = default_lang_args[:target_lang]
-    example_doc_path = example_document_path(source_lang)
-
-    handle = DeepL.document.upload(example_doc_path, source_lang, target_lang,
-                                   File.basename(example_doc_path),
-                                   {
-                                     extra_body_parameters: {
-                                       target_lang: 'FR',
-                                       debug: '1'
-                                     }
-                                   })
-    doc_status = handle.wait_until_document_translation_finished
-    DeepL.document.download(handle, output_document_path) if doc_status.status != 'error'
-    output_file_contents = File.read(output_document_path)
-
-    expect(example_document_translation('FR')).to eq(output_file_contents)
-    expect(doc_status.status).to eq('done')
-  end
-end

data/spec/integration_tests/document_error_paths_spec.rb

@@ -1,33 +0,0 @@
-# Copyright 2026 DeepL SE (https://www.deepl.com)
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe DeepL::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

data/spec/integration_tests/glossary_api_spec.rb

@@ -1,114 +0,0 @@
-# Copyright 2026 DeepL SE (https://www.deepl.com)
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe DeepL::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

@@ -1,107 +0,0 @@
-# Copyright 2026 DeepL SE (https://www.deepl.com)
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE file.
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe DeepL::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/integration_test_utils.rb

@@ -1,178 +0,0 @@
-# Copyright 2024 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 'tempfile'
-
-module IntegrationTestUtils # rubocop:disable Metrics/ModuleLength
-  EXAMPLE_TEXT = {
-    'BG' => 'протонен лъч',
-    'CS' => 'protonový paprsek',
-    'DA' => 'protonstråle',
-    'DE' => 'Protonenstrahl',
-    'EL' => 'δέσμη πρωτονίων',
-    'EN' => 'proton beam',
-    'EN-US' => 'proton beam',
-    'EN-GB' => 'proton beam',
-    'ES' => 'haz de protones',
-    'ET' => 'prootonikiirgus',
-    'FI' => 'protonisäde',
-    'FR' => 'faisceau de protons',
-    'HU' => 'protonnyaláb',
-    'ID' => 'berkas proton',
-    'IT' => 'fascio di protoni',
-    'JA' => '陽子ビーム',
-    'KO' => '양성자 빔',
-    'LT' => 'protonų spindulys',
-    'LV' => 'protonu staru kūlis',
-    'NB' => 'protonstråle',
-    'NL' => 'protonenbundel',
-    'PL' => 'wiązka protonów',
-    'PT' => 'feixe de prótons',
-    'PT-BR' => 'feixe de prótons',
-    'PT-PT' => 'feixe de prótons',
-    'RO' => 'fascicul de protoni',
-    'RU' => 'протонный луч',
-    'SK' => 'protónový lúč',
-    'SL' => 'protonski žarek',
-    'SV' => 'protonstråle',
-    'TR' => 'proton ışını',
-    'UK' => 'протонний пучок',
-    'ZH' => '质子束'
-  }.freeze
-
-  def mock_server?
-    ENV.key?('DEEPL_MOCK_SERVER_PORT')
-  end
-
-  def mock_proxy_server?
-    ENV.key?('DEEPL_MOCK_PROXY_SERVER_PORT')
-  end
-
-  def real_server?
-    !mock_server?
-  end
-
-  def setup
-    @input_file = nil
-    @input_file_extension = nil
-    @output_file = nil
-    DeepL.configure do |config|
-      config.auth_key = 'your-api-token'
-    end
-  end
-
-  def teardown
-    unless @input_file.nil?
-      @input_file.close
-      @input_file.unlink
-    end
-    return if @output_file.nil?
-
-    @output_file.close
-    @output_file.unlink
-  end
-
-  def example_document_path(document_language)
-    setup_example_document(EXAMPLE_TEXT[document_language])
-  end
-
-  def example_large_document_path(document_language)
-    setup_example_document("#{EXAMPLE_TEXT[document_language]}\n" * 1000)
-  end
-
-  def setup_example_document(file_content)
-    @input_file_base_name = 'example_input_document' if @input_file_base_name.nil?
-    @input_file_extension = '.txt' if @input_file_extension.nil?
-    if @input_file.nil?
-      @input_file = Tempfile.new([@input_file_base_name, @input_file_extension])
-      @input_file.write(file_content)
-      @input_file.close
-    end
-    @input_file.path
-  end
-
-  def example_document_translation(document_language)
-    EXAMPLE_TEXT[document_language]
-  end
-
-  def example_large_document_translation(document_language)
-    "#{EXAMPLE_TEXT[document_language]}\n" * 1000
-  end
-
-  def output_document_path
-    @output_file = Tempfile.new('example_output_document') if @output_file.nil?
-    @output_file.path
-  end
-
-  # For detailed explanations of these header, check the deepl-mock README.md
-  def no_response_header(no_response_count)
-    { 'mock-server-session-no-response-count' => no_response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def respond_with_429_header(response_count)
-    { 'mock-server-session-429-count' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def set_character_limit_header(response_count) # rubocop:disable Naming/AccessorMethodName
-    { 'mock-server-session-init-character-limit' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def set_document_limit_header(response_count) # rubocop:disable Naming/AccessorMethodName
-    { 'mock-server-session-init-document-limit' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def set_team_document_limit_header(response_count) # rubocop:disable Naming/AccessorMethodName
-    { 'mock-server-session-init-team-document-limit' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def fail_docs_header(response_count)
-    { 'mock-server-session-doc-failure' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def doc_translation_queue_time_header(response_count)
-    { 'mock-server-session-doc-queue-time' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def doc_translation_translation_time_header(response_count)
-    { 'mock-server-session-doc-translate-time' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  # Makes a translation memory import or export job report its non-terminal status, such as
-  # `awaiting_input` for an uploaded import, for the given number of status queries before it
-  # completes. Without it a job completes on the first query.
-  def tm_job_processing_polls_header(poll_count)
-    { 'mock-server-session-tm-job-processing-polls' => poll_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-
-  def expect_proxy_header(response_count)
-    { 'mock-server-session-expect-proxy' => response_count.to_s,
-      'mock-server-session' => SecureRandom.uuid }
-  end
-end
-
-shared_context 'with temp dir' do
-  around do |example|
-    Dir.mktmpdir('deepl-rspec-') do |dir|
-      @temp_dir = dir
-      example.run
-    end
-  end
-
-  attr_reader :temp_dir, :input_file_base_name, :input_file_extension
-end
-
-RSpec.configure do |c|
-  c.include IntegrationTestUtils
-end