deepl-rb 3.9.0 → 3.10.0

data/spec/real_api/admin_client_spec.rb

@@ -0,0 +1,77 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+require_relative 'real_api_helper'
+
+describe DeepL::AdminClient do
+  subject(:client) do
+    described_class.new(ENV.fetch('DEEPL_ADMIN_KEY'),
+                        server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  before do
+    next unless ENV.fetch('DEEPL_ADMIN_KEY', '').empty?
+
+    raise 'DEEPL_ADMIN_KEY must be set to run the Admin API specs'
+  end
+
+  let(:end_date) { Time.now.utc.to_date }
+  let(:start_date) { end_date - 7 }
+
+  def key_listed?(client, key_id)
+    5.times do |attempt|
+      return true if client.list_developer_keys.map(&:key_id).include?(key_id)
+
+      sleep 1 unless attempt == 4
+    end
+    false
+  end
+
+  it 'sends GET /v2/admin/analytics and parses the report' do
+    report = client.get_usage_analytics(start_date, end_date,
+                                        group_by: DeepL::Constants::AdminUsageGroupBy::KEY_AND_DAY)
+
+    expect(report.start_date).not_to be_nil
+    expect(report.end_date).not_to be_nil
+    expect(report.group_by).to eq('keyAndDay')
+  end
+
+  it 'sends GET /v2/admin/analytics/custom-tags and parses the report' do
+    report = client.get_custom_tag_usage_analytics(
+      start_date, end_date, aggregate_by: DeepL::Constants::CustomTagUsageAggregateBy::DAY
+    )
+
+    expect(report.start_date).not_to be_nil
+    expect(report.end_date).not_to be_nil
+    expect(report.aggregate_by).to eq('day')
+  end
+
+  it 'sends the developer key requests: create, list, rename, set limits and deactivate' do
+    key = client.create_developer_key(label: unique_name('developer-key'))
+    failure = nil
+    begin
+      expect(key.deactivated?).to be(false)
+      expect(key_listed?(client, key.key_id)).to be(true), 'created key not listed after 5 attempts'
+      renamed = client.rename_developer_key(key, "#{key.label}-renamed")
+      expect(renamed.label).to eq("#{key.label}-renamed")
+      limited = client.set_developer_key_usage_limits(key, characters: 5000,
+                                                           speech_to_text_milliseconds: nil)
+      expect(limited.usage_limits).to have_attributes(characters: 5000,
+                                                      speech_to_text_milliseconds: nil)
+    rescue StandardError, RSpec::Expectations::ExpectationNotMetError => e
+      failure = e
+      raise
+    ensure
+      begin
+        deactivated = client.deactivate_developer_key(key)
+      rescue DeepL::Exceptions::NotFound
+        deactivated = nil
+      rescue StandardError
+        raise if failure.nil?
+      end
+    end
+    expect(deactivated&.deactivated?).to be(true)
+  end
+end

data/spec/real_api/correct_text_spec.rb

@@ -0,0 +1,20 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL::Client#correct_text' do
+  let(:client) do
+    DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'), server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  it 'sends POST /v2/write/correct and parses the result' do
+    result = client.correct_text('Protonenstrahl', 'de')
+
+    expect(result).to be_a(DeepL::Resources::Text)
+    expect(result.text).to be_a(String)
+    expect(result.detected_source_language).not_to be_empty
+  end
+end

data/spec/real_api/glossaries_spec.rb

@@ -0,0 +1,28 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL.glossaries' do
+  it 'sends the v2 glossary requests: create, get, list, entries and delete' do
+    glossaries = DeepL.glossaries
+    name = unique_name('glossary')
+    entries = [%w[Apple Apfel], %w[Banana Banane]]
+
+    glossary = glossaries.create(name, 'EN', 'DE', entries)
+    begin
+      expect([glossary.name, glossary.source_lang, glossary.target_lang, glossary.entry_count])
+        .to eq([name, 'en', 'de', 2])
+
+      fetched = retry_while_not_found { glossaries.find(glossary.id) }
+      expect([fetched.id, fetched.name]).to eq([glossary.id, name])
+      expect(glossaries.list.map(&:id)).to include(glossary.id)
+      expect(glossaries.entries(glossary.id)).to match_array(entries)
+    ensure
+      delete_quietly { glossaries.destroy(glossary.id) }
+    end
+    expect { glossaries.find(glossary.id) }.to raise_error(DeepL::Exceptions::NotFound)
+  end
+end

data/spec/real_api/languages_spec.rb

@@ -0,0 +1,27 @@
+# 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_relative 'real_api_helper'
+
+describe 'languages' do
+  it 'sends GET /v3/languages and parses the source languages' do
+    languages = DeepL.languages
+    codes = languages.map(&:code)
+
+    expect(codes).to include('EN')
+    expect(codes).to eq(codes.map(&:upcase))
+    expect(languages.map(&:name)).to all(be_a(String))
+  end
+
+  it 'sends GET /v3/languages/resources and parses the resources and their features' do
+    client = DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'),
+                               server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+    resources = client.get_language_resources
+
+    translate_text = resources.find { |resource| resource.name == 'translate_text' }
+    expect(translate_text.features['glossary'].needs_source_support?).to be(true)
+    expect(translate_text.features['glossary'].needs_target_support?).to be(true)
+  end
+end

data/spec/real_api/multilingual_glossaries_spec.rb

@@ -0,0 +1,53 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE file.
+# frozen_string_literal: true
+
+require_relative 'real_api_helper'
+
+describe 'DeepL::Client multilingual glossaries' do
+  let(:client) do
+    DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'), server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  def pairs_of(glossary)
+    glossary.dictionaries.map { |d| "#{d.source_lang}-#{d.target_lang}" }
+  end
+
+  it 'creates, reads, updates, replaces and deletes a multilingual glossary' do
+    name = unique_name('glossary-v3')
+    dictionaries = [
+      DeepL::Resources::MultilingualGlossaryDictionaryEntries.new('EN', 'DE', [%w[Apple Apfel]]),
+      { source_lang: 'EN', target_lang: 'FR', entries: [%w[Apple Pomme]] }
+    ]
+
+    glossary = client.create_multilingual_glossary(name, dictionaries)
+    begin
+      expect(glossary.name).to eq(name)
+      expect(glossary.creation_time).to be_a(Time)
+      expect(pairs_of(glossary)).to contain_exactly('en-de', 'en-fr')
+
+      fetched = retry_while_not_found { client.get_multilingual_glossary(glossary) }
+      expect([fetched.id, fetched.name]).to eq([glossary.id, name])
+      expect(client.list_multilingual_glossaries.map(&:id)).to include(glossary.id)
+
+      entries = client.get_multilingual_glossary_dictionary_entries(glossary, 'EN', 'DE')
+      expect(entries.entries).to eq('Apple' => 'Apfel')
+
+      pear = { source_lang: 'EN', target_lang: 'DE', entries: [%w[Pear Birne]] }
+      updated = client.update_multilingual_glossary(glossary, name: "#{name}-renamed",
+                                                              dictionaries: [pear])
+      expect(updated.name).to eq("#{name}-renamed")
+
+      replaced = client.replace_multilingual_glossary_dictionary(
+        glossary, { source_lang: 'EN', target_lang: 'DE', entries: [%w[Cherry Kirsche]] }
+      )
+      expect([replaced.source_lang, replaced.target_lang, replaced.entry_count])
+        .to eq(['en', 'de', 1])
+
+      expect(client.delete_multilingual_glossary_dictionary(glossary, 'EN', 'FR')).to be_nil
+    ensure
+      delete_quietly { client.delete_multilingual_glossary(glossary) }
+    end
+  end
+end

data/spec/real_api/proxy_spec.rb

@@ -0,0 +1,41 @@
+# 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 'webrick'
+require 'webrick/httpproxy'
+require_relative 'real_api_helper'
+
+# A forward proxy that records the target of each CONNECT.
+class RecordingProxy < WEBrick::HTTPProxyServer
+  def connect_targets
+    @connect_targets ||= []
+  end
+
+  def do_CONNECT(req, res) # rubocop:disable Naming/MethodName
+    connect_targets << req.unparsed_uri
+    super
+  end
+end
+
+describe 'DeepL.with_session' do
+  it 'sends requests through the configured proxy' do
+    proxy = RecordingProxy.new(Port: 0, BindAddress: '127.0.0.1', AccessLog: [],
+                               Logger: WEBrick::Log.new(File::NULL))
+    thread = Thread.new { proxy.start }
+    begin
+      port = proxy.listeners.first.addr[1]
+      options = DeepL::HTTPClientOptions.new({ 'proxy_addr' => '127.0.0.1', 'proxy_port' => port })
+
+      usage = DeepL.with_session(options) { DeepL.usage }
+
+      host = URI(DeepL.configuration.host)
+      expect(usage.character_limit).to be_an(Integer)
+      expect(proxy.connect_targets).to eq(["#{host.host}:#{host.port}"])
+    ensure
+      proxy.shutdown
+      thread.join
+    end
+  end
+end

data/spec/real_api/real_api_helper.rb

@@ -0,0 +1,65 @@
+# 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
+
+# The real-API suite sends one real request per SDK operation to the API at DEEPL_SERVER_URL.
+# Run it on its own: bundle exec rspec spec/real_api
+
+raise 'DEEPL_AUTH_KEY must be set to run spec/real_api' if ENV.fetch('DEEPL_AUTH_KEY', '').empty?
+if defined?(WebMock)
+  raise 'spec/real_api and spec/offline cannot run in one process: WebMock blocks the network'
+end
+
+require 'securerandom'
+require_relative '../spec_helper'
+require_relative '../fixtures'
+
+module RealApiHelper
+  RUN_ID = "#{Time.now.utc.strftime('%Y%m%d%H%M')}-#{SecureRandom.alphanumeric(6).downcase}"
+
+  # Name of a resource created by this run, for example sdktest-ruby-202610151530-k3f9qz-glossary.
+  def unique_name(label)
+    "sdktest-ruby-#{RUN_ID}-#{label}"
+  end
+
+  # A new glossary can be briefly invisible: retry NotFound for a few seconds.
+  def retry_while_not_found(attempts: 10)
+    tries = 0
+    begin
+      yield
+    rescue DeepL::Exceptions::NotFound
+      tries += 1
+      raise if tries >= attempts
+
+      sleep(1)
+      retry
+    end
+  end
+
+  # Cleanup that must not hide the failure of the example it runs after.
+  def delete_quietly
+    yield
+  rescue DeepL::Exceptions::Error
+    nil
+  end
+
+  # Fetches pages of 0-based index until +id+ is in one of them. The block returns the IDs of a
+  # page; an empty page ends the list.
+  def found_on_any_page?(id, max_pages: 20)
+    max_pages.times do |page|
+      ids = yield(page)
+      return false if ids.empty?
+      return true if ids.include?(id)
+    end
+    false
+  end
+end
+
+# The host comes from DEEPL_SERVER_URL, which Configuration reads itself.
+DeepL.configure { |config| config.auth_key = ENV.fetch('DEEPL_AUTH_KEY') }
+
+RSpec.configure do |config|
+  config.include RealApiHelper
+  config.include Fixtures
+end

data/spec/real_api/rephrase_text_spec.rb

@@ -0,0 +1,16 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL.rephrase' do
+  it 'sends POST /v2/write/rephrase and parses the result' do
+    result = DeepL.rephrase('Protonenstrahl', 'de')
+
+    expect(result).to be_a(DeepL::Resources::Text)
+    expect(result.text).to be_a(String)
+    expect(result.detected_source_language).not_to be_empty
+  end
+end

data/spec/real_api/spoken_terms_spec.rb

@@ -0,0 +1,56 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL::Client spoken terms' do
+  let(:client) do
+    DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'), server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  def term_lists_of(collection)
+    collection.term_lists.map { |list| [list.lang, list.entry_count] }
+  end
+
+  it 'creates, reads, updates, replaces and deletes a spoken terms collection' do
+    name = unique_name('spokenTerms')
+
+    term_list = DeepL::Resources::SpokenTermsEntries.new('en', %w[DeepL webhook])
+    created = client.create_spoken_terms(name, [term_list])
+    id = created.spoken_terms_id
+    begin
+      expect(created.name).to eq(name)
+      expect(created.creation_time).to be_a(Time)
+      expect(term_lists_of(created)).to eq([['en', 2]])
+
+      fetched = retry_while_not_found { client.get_spoken_terms(id) }
+      expect([fetched.spoken_terms_id, fetched.name]).to eq([id, name])
+      expect(client.list_spoken_terms.map(&:spoken_terms_id)).to include(id)
+
+      more = [{ lang: 'en', entries: ['authentication'] }]
+      updated = client.update_spoken_terms(created, term_lists: more)
+      expect(term_lists_of(updated)).to eq([['en', 3]])
+      entries = client.get_spoken_terms_entries(id, 'en')
+      expect(entries.lang).to eq('en')
+      expect(entries.entries).to contain_exactly('DeepL', 'authentication', 'webhook')
+
+      replaced = client.replace_spoken_terms_list(id, { lang: 'en', entries: ['API'] })
+      expect([replaced.lang, replaced.entry_count]).to eq(['en', 1])
+      expect(client.get_spoken_terms_entries(id, 'en').entries).to eq(['API'])
+
+      added = client.replace_spoken_terms_list(
+        created, DeepL::Resources::SpokenTermsEntries.new('de', ['Schnittstelle'])
+      )
+      expect([added.lang, added.entry_count]).to eq(['de', 1])
+      expect(client.delete_spoken_terms_list(id, 'de')).to be_nil
+      expect(term_lists_of(client.get_spoken_terms(id))).to eq([['en', 1]])
+
+      expect(client.delete_spoken_terms(id)).to be_nil
+      expect { client.get_spoken_terms(id) }.to raise_error(DeepL::Exceptions::NotFound)
+    ensure
+      delete_quietly { client.delete_spoken_terms(id) }
+    end
+  end
+end

data/spec/real_api/style_profiles_spec.rb

@@ -0,0 +1,46 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL::Client style profiles' do
+  let(:client) do
+    DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'), server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  it 'creates, reads, lists, updates and deletes a style profile' do
+    rule = DeepL.style_rules.create(unique_name('styleProfileRule'), 'de')
+    rule_id = rule.style_id
+    id = nil
+    begin
+      name = unique_name('styleProfile')
+      profile = client.create_style_profile(name, description: 'SDK test', style_rule_ids: [rule])
+      id = profile.style_profile_id
+      expect([profile.name, profile.description, profile.style_rule_ids])
+        .to eq([name, 'SDK test', [rule_id]])
+      expect([profile.glossary_ids, profile.translation_memory_ids]).to eq([[], []])
+
+      fetched = retry_while_not_found { client.get_style_profile(id) }
+      expect([fetched.style_profile_id, fetched.name, fetched.description, fetched.style_rule_ids])
+        .to eq([id, name, 'SDK test', [rule_id]])
+      expect(fetched.creation_time).to be_a(Time)
+
+      expect(found_on_any_page?(id) do |page|
+        client.list_style_profiles(page: page, page_size: 100).map(&:style_profile_id)
+      end).to be(true)
+
+      updated = client.update_style_profile(profile, name: "#{name}-renamed", industry: 'Legal',
+                                                     description: '', style_rule_ids: [])
+      expect([updated.name, updated.industry, updated.description, updated.style_rule_ids])
+        .to eq(["#{name}-renamed", 'Legal', nil, []])
+
+      expect(client.delete_style_profile(id)).to be_nil
+      expect { client.get_style_profile(id) }.to raise_error(DeepL::Exceptions::NotFound)
+    ensure
+      delete_quietly { client.delete_style_profile(id) } if id
+      delete_quietly { DeepL.style_rules.destroy(rule_id) }
+    end
+  end
+end

data/spec/real_api/style_rules_spec.rb

@@ -0,0 +1,46 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL::Client style rules' do
+  let(:client) do
+    DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'), server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  it 'sends the style rule requests: create, get, list, rename, configure, instructions, delete' do
+    name = unique_name('style-rule')
+    rules = { dates_and_times: { calendar_era: 'use_bc_and_ad' } }
+
+    rule = client.create_style_rule(name, 'en', configured_rules: rules,
+                                                custom_instructions: [{ label: 'Init',
+                                                                        prompt: 'Be formal',
+                                                                        source_language: 'de' }])
+    begin
+      expect([rule.name, rule.language, rule.creation_time.class]).to eq([name, 'en', Time])
+
+      fetched = client.get_style_rule(rule.style_id)
+      expect([fetched.style_id, fetched.name]).to eq([rule.style_id, name])
+      expect(found_on_any_page?(rule.style_id) do |page|
+        client.get_all_style_rules(page: page, page_size: 25, detailed: true).map(&:style_id)
+      end).to be(true)
+
+      expect(client.update_style_rule_name(rule, "#{name}-renamed").name).to eq("#{name}-renamed")
+      expect(client.update_style_rule_configured_rules(rule, rules).style_id).to eq(rule.style_id)
+
+      instruction = client.create_style_rule_custom_instruction(rule, 'Label', 'Prompt',
+                                                                source_language: 'de')
+      expect([instruction.id.class, instruction.label]).to eq([String, 'Label'])
+      found = client.get_style_rule_custom_instruction(rule, instruction)
+      expect(found.prompt).to eq('Prompt')
+      updated = client.update_style_rule_custom_instruction(rule, instruction.id, 'New Label',
+                                                            'New Prompt', source_language: 'en')
+      expect(updated.label).to eq('New Label')
+      expect(client.delete_style_rule_custom_instruction(rule, instruction)).to be_nil
+    ensure
+      delete_quietly { client.delete_style_rule(rule) }
+    end
+  end
+end

data/spec/real_api/translate_document_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_relative 'real_api_helper'
+
+describe 'DeepL.document' do
+  include_context 'with a temporary directory'
+
+  it 'uploads, polls and downloads a .txt document' do
+    input, output = create_text_document(temp_dir)
+
+    DeepL.document.translate_document(input, output, 'EN', 'DE')
+
+    expect(File.size(output)).to be_positive
+  end
+end

data/spec/real_api/translate_text_spec.rb

@@ -0,0 +1,16 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL.translate' do
+  it 'sends POST /v2/translate and parses the result' do
+    result = DeepL.translate('proton beam', nil, 'DE')
+
+    expect(result).to be_a(DeepL::Resources::Text)
+    expect(result.text).to be_a(String)
+    expect(result.detected_source_language).not_to be_empty
+  end
+end

data/spec/real_api/translation_memories_spec.rb

@@ -0,0 +1,56 @@
+# 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_relative 'real_api_helper'
+
+# The import appears as a translation memory only after about a minute, and a run killed in that
+# window leaves one memory behind.
+describe 'DeepL::Client translation memories' do
+  include_context 'with a temporary directory'
+
+  let(:client) do
+    DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'), server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  let(:job_timeout_s) { 120 }
+
+  it 'sends the translation memory requests: import, upload, get, list, segments, export, delete' do
+    name = unique_name('translation-memory')
+    memory_id = nil
+    begin
+      created = client.create_translation_memory_import('example.tmx',
+                                                        Fixtures::EXAMPLE_TMX.bytesize,
+                                                        display_name: name)
+      expect([created.job_id.class, created.upload_url.class]).to eq([String, String])
+
+      client.upload_translation_memory_file(created, Fixtures::EXAMPLE_TMX)
+      import_job = client.wait_until_translation_memory_job_done(created.job_id,
+                                                                 timeout_s: job_timeout_s)
+      memory_id = import_job.result.translation_memory_id
+      expect([import_job.operation, import_job.status, memory_id.class])
+        .to eq(['import', 'completed', String])
+
+      fetched = client.get_translation_memory(memory_id)
+      expect([fetched.translation_memory_id, fetched.name]).to eq([memory_id, name])
+      expect(found_on_any_page?(memory_id) do |page|
+        client.list_translation_memories(page: page, page_size: 100).map(&:translation_memory_id)
+      end).to be(true)
+
+      segments = client.list_translation_memory_segments(memory_id)
+      expect(segments.segments).not_to be_empty
+      expect(segments.segments.first.source_segment_id).to be_a(String)
+
+      exported = client.create_translation_memory_export(memory_id)
+      export_job = client.wait_until_translation_memory_job_done(
+        client.get_translation_memory_job(exported.job_id), timeout_s: job_timeout_s
+      )
+      output = File.join(temp_dir, 'export.tmx')
+      client.download_translation_memory_export(export_job, output)
+      expect(File.read(output)).to include('<tmx')
+    ensure
+      delete_quietly { client.delete_translation_memory(memory_id) } unless memory_id.nil?
+    end
+  end
+end

data/spec/real_api/usage_spec.rb

@@ -0,0 +1,20 @@
+# 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_relative 'real_api_helper'
+
+describe 'DeepL::Client#get_usage' do
+  let(:client) do
+    DeepL::Client.new(ENV.fetch('DEEPL_AUTH_KEY'), server_url: ENV.fetch('DEEPL_SERVER_URL', nil))
+  end
+
+  it 'sends GET /v2/usage and parses the usage' do
+    usage = client.get_usage
+
+    expect(usage.character.count).to be_an(Integer)
+    expect(usage.character.limit).to be_an(Integer)
+    expect(usage.any_limit_reached?).to be(true).or be(false)
+  end
+end

data/spec/spec_helper.rb

@@ -3,60 +3,11 @@
 # license that can be found in the LICENSE.md file.
 # frozen_string_literal: true
 
-# Coverage
+# Coverage. It must start before the library is loaded.
 require 'simplecov'
 SimpleCov.start
 
 require 'simplecov-cobertura'
 SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
 
-# Load lib
 require_relative '../lib/deepl'
-require_relative 'integration_tests/integration_test_utils'
-
-# Auto-load test helpers under spec/support
-Dir[File.expand_path('support/**/*.rb', __dir__)].sort.each { |f| require f }
-
-# Lib config
-ENV['DEEPL_AUTH_KEY'] ||= 'TEST-TOKEN'
-
-RSpec.configure do |config|
-  config.include ManagedGlossary
-  config.include ManagedStyleRule
-  config.include ManagedTranslationMemory
-
-  config.before(:each, :mock_server_only) do
-    skip 'Only runs on mock server' unless ENV.key?('DEEPL_MOCK_SERVER_PORT')
-  end
-
-  config.before(:each, :real_server_only) do
-    skip 'Only runs on real server' if ENV.key?('DEEPL_MOCK_SERVER_PORT')
-  end
-end
-
-# General helpers
-def build_deepl_api
-  DeepL::API.new(DeepL::Configuration.new)
-end
-
-# Test helpers
-
-def replace_env_preserving_deepl_vars
-  env_auth_key = ENV.fetch('DEEPL_AUTH_KEY', false)
-  env_server_url = ENV.fetch('DEEPL_SERVER_URL', false)
-  env_mock_server_port = ENV.fetch('DEEPL_MOCK_SERVER_PORT', false)
-  tmp_env = ENV.to_hash
-  ENV.clear
-  ENV['DEEPL_AUTH_KEY'] = (env_auth_key || 'VALID')
-  ENV['DEEPL_SERVER_URL'] = (env_server_url || '')
-  ENV['DEEPL_MOCK_SERVER_PORT'] = (env_mock_server_port || '')
-  tmp_env
-end
-
-def replace_env_preserving_deepl_vars_except_mock_server
-  env_auth_key = ENV.fetch('DEEPL_AUTH_KEY', false)
-  tmp_env = ENV.to_hash
-  ENV.clear
-  ENV['DEEPL_AUTH_KEY'] = (env_auth_key || 'VALID')
-  tmp_env
-end