deepl-rb 3.9.0 → 3.10.0

data/spec/offline/client_spec.rb

@@ -0,0 +1,273 @@
+# 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 'offline_helper'
+
+describe DeepL::Client do
+  # The operations are added to DeepL::Client separately; until then the client's connection is
+  # exercised with the usage request.
+  def usage(client)
+    DeepL::Requests::Usage.new(client.send(:api)).request
+  end
+
+  def stub_usage(base = OfflineHelper::HOST, headers: {})
+    stub = stub_request(:get, "#{base}/v2/usage")
+    stub = stub.with(headers: headers) unless headers.empty?
+    stub.to_return(usage_reply)
+  end
+
+  describe '#initialize' do
+    it 'sends the trimmed auth key to the Pro server' do
+      stub_usage(headers: { 'Authorization' => 'DeepL-Auth-Key abc' })
+
+      usage(described_class.new("  abc \n"))
+    end
+
+    it 'sends a Free key to the Free server' do
+      stub_usage('https://api-free.deepl.com',
+                 headers: { 'Authorization' => 'DeepL-Auth-Key a:fx' })
+
+      usage(described_class.new('a:fx'))
+    end
+
+    it 'keeps the path prefix of the server URL' do
+      stub_usage('http://localhost:3000/proxy')
+
+      usage(described_class.new('abc', server_url: 'http://localhost:3000/proxy'))
+    end
+
+    it 'reads no environment variables' do
+      env = ENV.to_h.slice('DEEPL_AUTH_KEY', 'DEEPL_SERVER_URL')
+      ENV['DEEPL_SERVER_URL'] = 'http://environment.example.test'
+      stub_usage(headers: { 'Authorization' => 'DeepL-Auth-Key abc' })
+
+      usage(described_class.new('abc'))
+    ensure
+      ENV.delete('DEEPL_SERVER_URL')
+      ENV.update(env)
+    end
+
+    it 'rejects an empty or blank auth key' do
+      ['', "  \t", nil].each do |key|
+        expect { described_class.new(key) }.to raise_error(ArgumentError, /auth_key/)
+      end
+    end
+
+    it 'does not show the auth key in inspect' do
+      expect(described_class.new('secret-key').inspect).not_to include('secret-key')
+    end
+
+    it 'does not expose its connection or configuration' do
+      client = described_class.new('abc')
+
+      expect(client).not_to respond_to(:api)
+      expect(client).not_to respond_to(:configuration)
+    end
+  end
+
+  describe 'headers' do
+    it 'lets the headers replace the Authorization header' do
+      stub_usage(headers: { 'Authorization' => 'DeepL-Auth-Key other', 'X-Custom' => 'v' })
+
+      usage(described_class.new('abc', headers: { 'X-Custom' => 'v',
+                                                  'authorization' => 'DeepL-Auth-Key other' }))
+    end
+
+    it 'replaces the User-Agent with the one in headers' do
+      stub_usage(headers: { 'User-Agent' => 'my-agent/1' })
+
+      usage(described_class.new('abc', headers: { 'user-agent' => 'my-agent/1' }))
+    end
+
+    it 'adds the app info to the User-Agent' do
+      stub_usage(headers: { 'User-Agent' => %r{\Adeepl-ruby/[^ ]+ my-app/1\.2\z} })
+
+      usage(described_class.new('abc', send_platform_info: false,
+                                       app_info: { app_name: 'my-app', app_version: '1.2' }))
+    end
+
+    it 'never mixes the options of two clients' do
+      stub_usage(headers: { 'Authorization' => 'DeepL-Auth-Key one', 'X-Client' => '1' })
+      stub_usage('http://localhost:3000',
+                 headers: { 'Authorization' => 'DeepL-Auth-Key two', 'X-Client' => '2' })
+
+      usage(described_class.new('one', headers: { 'X-Client' => '1' }))
+      usage(described_class.new('two', server_url: 'http://localhost:3000',
+                                       headers: { 'X-Client' => '2' }))
+    end
+  end
+
+  describe 'max_retries' do
+    it 'retries as often as configured' do
+      stub = stub_request(:get, url('/v2/usage')).to_return(reply({}, 429), usage_reply)
+
+      usage(described_class.new('abc', max_retries: 1))
+      expect(stub).to have_been_requested.twice
+    end
+
+    it 'does not retry with max_retries 0' do
+      stub = stub_request(:get, url('/v2/usage')).to_return(reply({}, 503))
+
+      client = described_class.new('abc', max_retries: 0)
+      expect { usage(client) }.to raise_error(DeepL::Exceptions::ServerError)
+      expect(stub).to have_been_requested.once
+    end
+  end
+
+  describe 'timeout' do
+    it 'applies the timeout to each attempt' do
+      stub_usage
+      client = described_class.new('abc', timeout: 3)
+
+      usage(client)
+
+      http = client.send(:api).http_client
+      expect([http.open_timeout, http.read_timeout, http.write_timeout]).to eq([3.0, 3.0, 3.0])
+    end
+
+    it 'defaults to 10 seconds and keeps the timeouts of the HTTP client options' do
+      stub_usage
+      options = DeepL::HTTPClientOptions.new({}, nil, read_timeout: 7)
+      client = described_class.new('abc', http_client_options: options)
+
+      usage(client)
+
+      http = client.send(:api).http_client
+      expect([http.open_timeout, http.read_timeout, http.write_timeout]).to eq([10.0, 7, 10.0])
+    end
+  end
+
+  describe 'proxy' do
+    def http_client(**options)
+      described_class.new('abc', **options).send(:api).http_client
+    end
+
+    it 'accepts a proxy URL with credentials' do
+      expect(http_client(proxy: 'http://us%40r:p%3Ass@proxy.example.test:3128'))
+        .to have_attributes(proxy_address: 'proxy.example.test', proxy_port: 3128,
+                            proxy_user: 'us@r', proxy_pass: 'p:ss')
+    end
+
+    it 'combines the proxy URL with the other HTTP client options' do
+      options = DeepL::HTTPClientOptions.new({}, nil, enable_ssl_verification: false)
+
+      expect(http_client(proxy: 'http://proxy.example.test:3128', http_client_options: options))
+        .to have_attributes(proxy_address: 'proxy.example.test',
+                            verify_mode: OpenSSL::SSL::VERIFY_NONE)
+    end
+
+    it 'rejects a proxy in both proxy: and http_client_options:' do
+      options = DeepL::HTTPClientOptions.new('http://other.example.test:1')
+
+      expect { http_client(proxy: 'http://proxy.example.test:3128', http_client_options: options) }
+        .to raise_error(ArgumentError, /proxy/)
+    end
+
+    it 'does not show the proxy credentials in inspect' do
+      client = described_class.new('abc', proxy: 'http://u:secret@proxy.test:3128')
+
+      expect(client.inspect).not_to include('secret')
+      expect(client.send(:api).inspect).not_to include('secret')
+      expect(client.send(:api).http_client_options.inspect).to include('proxy.test:3128')
+    end
+
+    it 'does not show the proxy credentials in the error for an invalid proxy URL' do
+      ['u:secret@proxy.test:3128', 'http://u:secret@proxy test:3128'].each do |proxy|
+        expect { described_class.new('abc', proxy: proxy) }
+          .to raise_error(ArgumentError) { |e| expect(e.full_message).not_to include('secret') }
+      end
+    end
+  end
+
+  describe '.free_account_auth_key?' do
+    it 'detects Free keys' do
+      expect(%w[a:fx a].map { |key| described_class.free_account_auth_key?(key) })
+        .to eq([true, false])
+      expect(described_class.free_account_auth_key?(nil)).to be(false)
+    end
+  end
+
+  describe '#translate_text' do
+    let(:client) { described_class.new(OfflineHelper::AUTH_KEY) }
+
+    def stub_translate(body, translations)
+      stub_request(:post, url('/v2/translate'))
+        .with(body: body, headers: json_headers)
+        .to_return(reply(translations: translations))
+    end
+
+    it 'sends the text, the options and show_billed_characters and returns one result' do
+      stub_translate({ text: ['Hello'], target_lang: 'DE', show_billed_characters: true,
+                       formality: 'less', glossary_id: 'g-1', split_sentences: '0' },
+                     [{ text: 'Hallo', billed_characters: 5 }])
+
+      result = client.translate_text('Hello', nil, 'DE', formality: 'less', glossary: 'g-1',
+                                                         split_sentences: false, context: nil)
+      expect([result.class, result.text, result.billed_characters])
+        .to eq([DeepL::Resources::Text, 'Hallo', 5])
+    end
+
+    it 'returns an array for a one-element array' do
+      stub_translate({ text: ['Hello'], source_lang: 'EN', target_lang: 'DE',
+                       show_billed_characters: true }, [{ text: 'Hallo' }])
+
+      expect(client.translate_text(['Hello'], 'EN', 'DE').map(&:text)).to eq(['Hallo'])
+    end
+  end
+
+  describe '#rephrase_text' do
+    let(:client) { described_class.new(OfflineHelper::AUTH_KEY) }
+
+    def stub_rephrase(body, improvements)
+      stub_request(:post, url('/v2/write/rephrase'))
+        .with(body: body, headers: json_headers)
+        .to_return(reply(improvements: improvements))
+    end
+
+    it 'sends the writing style and tone keywords, no nil options, and returns one result' do
+      stub_rephrase({ text: ['Hello'], target_lang: 'en-GB', writing_style: 'business',
+                      tone: 'friendly' },
+                    [{ text: 'Hi', detected_source_language: 'en', target_language: 'en-GB' }])
+
+      result = client.rephrase_text('Hello', 'en-GB', writing_style: 'business',
+                                                      tone: 'friendly', context: nil)
+      expect([result.class, result.text, result.target_language])
+        .to eq([DeepL::Resources::Text, 'Hi', 'en-GB'])
+    end
+
+    it 'applies extra_body_parameters last, replacing string or symbol keyed fields' do
+      stub_rephrase({ text: ['Hello'], tone: 'confident', beta: true }, [{ text: 'Hi' }])
+
+      client.rephrase_text('Hello', tone: 'friendly',
+                                    extra_body_parameters: { 'tone' => 'confident', beta: true })
+    end
+
+    it 'returns an array for a one-element array' do
+      stub_rephrase({ text: ['Hello'] }, [{ text: 'Hi' }])
+
+      expect(client.rephrase_text(['Hello']).map(&:text)).to eq(['Hi'])
+    end
+  end
+
+  describe '#correct_text' do
+    let(:client) { described_class.new(OfflineHelper::AUTH_KEY) }
+
+    it 'sends the text, the target language and the extra body parameters' do
+      stub_request(:post, url('/v2/write/correct'))
+        .with(body: { text: ['Helo'], target_lang: 'en-US', beta: 1 }, headers: json_headers)
+        .to_return(reply(improvements: [{ text: 'Hello', target_language: 'en-US' }]))
+
+      result = client.correct_text('Helo', 'en-US', extra_body_parameters: { beta: 1 })
+      expect([result.text, result.target_language]).to eq(%w[Hello en-US])
+    end
+
+    it 'returns an array for a one-element array' do
+      stub_request(:post, url('/v2/write/correct'))
+        .to_return(reply(improvements: [{ text: 'Hello' }]))
+
+      expect(client.correct_text(['Helo']).map(&:text)).to eq(['Hello'])
+    end
+  end
+end

data/spec/{api → offline}/configuration_spec.rb

@@ -4,7 +4,7 @@
 # frozen_string_literal: true
 
 require 'logger'
-require 'spec_helper'
+require_relative 'offline_helper'
 
 describe DeepL::Configuration do
   subject(:config) { described_class.new(attributes) }
@@ -25,6 +25,7 @@ describe DeepL::Configuration do
         expect(config.host).to eq('https://api.deepl.com')
         expect(config.max_doc_status_queries).to be_nil
         expect(config.version).to eq('v2')
+        expect(config.timeout).to eq(60.0)
       end
 
       it 'sends platform information' do
@@ -48,6 +49,23 @@ describe DeepL::Configuration do
       end
     end
 
+    context 'when the environment provides the key and the server URL' do
+      before do
+        ENV['DEEPL_AUTH_KEY'] = 'env-key'
+        ENV['DEEPL_SERVER_URL'] = 'https://api.example.test'
+      end
+
+      it 'uses the environment values' do
+        expect(config.auth_key).to eq('env-key')
+        expect(config.host).to eq('https://api.example.test')
+      end
+
+      it 'prefers the given attributes' do
+        config = described_class.new(auth_key: 'given', host: 'https://given.example.test')
+        expect([config.auth_key, config.host]).to eq(%w[given https://given.example.test])
+      end
+    end
+
     context 'when using a free key' do
       let(:attributes) { { auth_key: '123e4567-e89b-12d3-a456-426614174000:fx' } }
 
@@ -56,6 +74,22 @@ describe DeepL::Configuration do
       end
     end
 
+    context 'when the free key is set after the configuration was created' do
+      it 'uses the free API URL' do
+        config.auth_key = 'abc:fx'
+
+        expect(config.host).to eq('https://api-free.deepl.com')
+      end
+    end
+
+    context 'when the free key has surrounding whitespace' do
+      let(:attributes) { { auth_key: 'abc:fx ' } }
+
+      it 'uses the free API URL' do
+        expect(config.host).to eq('https://api-free.deepl.com')
+      end
+    end
+
     context 'when using a pro key' do
       let(:attributes) { { auth_key: '123e4567-e89b-12d3-a456-426614174000' } }
 
@@ -103,7 +137,7 @@ describe DeepL::Configuration do
   describe '#validate!' do
     let(:auth_message) { 'auth_key not provided' }
 
-    context 'when providing a valid auth key' do
+    context 'when the auth key is empty' do
       let(:attributes) { { auth_key: '' } }
 
       it 'raises an error' do
@@ -111,7 +145,15 @@ describe DeepL::Configuration do
       end
     end
 
-    context 'when providing an invalid auth key' do
+    context 'when the auth key is blank' do
+      let(:attributes) { { auth_key: "  \n" } }
+
+      it 'raises an error' do
+        expect { config.validate! }.to raise_error(DeepL::Exceptions::Error, auth_message)
+      end
+    end
+
+    context 'when the auth key is set' do
       let(:attributes) { { auth_key: 'not-empty' } }
 
       it 'does not raise an error' do

data/spec/{constants → offline}/constants_spec.rb

@@ -3,7 +3,7 @@
 # license that can be found in the LICENSE.md file.
 # frozen_string_literal: true
 
-require 'spec_helper'
+require_relative 'offline_helper'
 
 describe 'DeepL::Constants' do
   describe DeepL::Constants::Tone do
@@ -89,6 +89,28 @@ describe 'DeepL::Constants' do
     end
   end
 
+  describe DeepL::Constants::TagHandlingVersion do
+    it 'includes v1 and v2' do
+      expect([described_class::V1, described_class::V2]).to eq(%w[v1 v2])
+      expect(described_class.options).to contain_exactly('v1', 'v2')
+    end
+  end
+
+  describe DeepL::Constants::LanguageResourceName do
+    it 'includes the resources of the languages endpoint' do
+      expect(described_class.options).to contain_exactly(
+        'translate_text', 'translate_document', 'glossary', 'voice', 'write', 'style_rules',
+        'translation_memory'
+      )
+    end
+  end
+
+  describe DeepL::Constants::LanguageInclude do
+    it 'includes beta and external' do
+      expect([described_class::BETA, described_class::EXTERNAL]).to eq(%w[beta external])
+    end
+  end
+
   describe DeepL::Constants::SplitSentences do
     subject(:split_sentences) { described_class }
 

data/spec/offline/correct_text_spec.rb

@@ -0,0 +1,50 @@
+# 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 'offline_helper'
+
+describe 'DeepL::Client#correct_text' do
+  let(:client) { DeepL::Client.new(OfflineHelper::AUTH_KEY) }
+
+  def stub_correct(body = nil)
+    request = stub_request(:post, url('/v2/write/correct'))
+    request = request.with(body: body, headers: json_headers) unless body.nil?
+    request
+  end
+
+  it 'sends only the text when no target language is given' do
+    stub_correct(text: ['Helo']).to_return(reply(improvements: [{ text: 'Hello' }]))
+    client.correct_text('Helo')
+  end
+
+  it 'sends several texts' do
+    stub_correct(text: %w[a b], target_lang: 'en-US')
+      .to_return(reply(improvements: [{ text: 'a' }, { text: 'b' }]))
+
+    client.correct_text(%w[a b], 'en-US')
+  end
+
+  it 'returns a text for a string' do
+    stub_correct.to_return(reply(improvements: [{ text: 'Hello' }]))
+
+    expect(client.correct_text('Helo')).to be_a(DeepL::Resources::Text)
+  end
+
+  [['Helo', []], [%w[a b], [{ text: 'x' }]]].each do |text, improvements|
+    it "raises DeepL::Exceptions::Error for #{improvements.size} improvements of #{text.inspect}" do
+      stub_correct.to_return(reply(improvements: improvements))
+
+      expect { client.correct_text(text) }
+        .to raise_error(an_instance_of(DeepL::Exceptions::Error), /expected \d improvements/)
+    end
+  end
+
+  [[''], [[]], [['a', '']]].each do |args|
+    it "raises ArgumentError for #{args.first.inspect} without sending a request" do
+      expect { client.correct_text(*args) }.to raise_error(ArgumentError, /non-empty/)
+      expect(a_request(:any, /.*/)).not_to have_been_made
+    end
+  end
+end

data/spec/offline/deprecation_spec.rb

@@ -0,0 +1,32 @@
+# 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 'offline_helper'
+
+describe DeepL::Deprecation do
+  around do |example|
+    enabled = Warning[:deprecated]
+    example.run
+  ensure
+    Warning[:deprecated] = enabled
+  end
+
+  it "prints nothing while Ruby's deprecation warnings are off" do
+    Warning[:deprecated] = false
+
+    expect { described_class.warn_once('spec-off', 'm') }.not_to output.to_stderr
+  end
+
+  it 'warns in the deprecated category when they are on' do
+    Warning[:deprecated] = true
+
+    if RUBY_VERSION >= '3.0'
+      expect(Warning).to receive(:warn).with(/m/, category: :deprecated)
+      described_class.warn_once('spec-on', 'm')
+    else
+      expect { described_class.warn_once('spec-on', 'm') }.to output(/m/).to_stderr
+    end
+  end
+end

data/spec/offline/errors_spec.rb

@@ -0,0 +1,92 @@
+# 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 'offline_helper'
+
+describe 'DeepL error mapping' do
+  {
+    401 => [DeepL::Exceptions::AuthorizationFailed, /Authorization failed/],
+    403 => [DeepL::Exceptions::AuthorizationFailed, /Authorization failed/],
+    456 => [DeepL::Exceptions::QuotaExceeded, /Quota exceeded/],
+    413 => [DeepL::Exceptions::RequestEntityTooLarge,
+            /request size has reached the supported limit/],
+    418 => [DeepL::Exceptions::RequestError, 'Request failed with HTTP status 418: m']
+  }.each do |status, (error_class, message)|
+    it "raises #{error_class.name.split('::').last} for status #{status} without retrying" do
+      stub = stub_request(:get, url('/v2/usage')).to_return(status: status, body: '{"message":"m"}')
+
+      expect { DeepL.usage }.to raise_error(error_class, message)
+      expect(stub).to have_been_requested.once
+    end
+  end
+
+  {
+    400 => DeepL::Exceptions::BadRequest,
+    404 => DeepL::Exceptions::NotFound
+  }.each do |status, error_class|
+    it "raises #{error_class.name.split('::').last} with the API message for status #{status}" do
+      stub = stub_request(:get,
+                          url('/v2/usage')).to_return(reply({ message: 'Value for x invalid' },
+                                                            status))
+
+      expect { DeepL.usage }.to raise_error(error_class, 'Value for x invalid')
+      expect(stub).to have_been_requested.once
+    end
+
+    it "raises #{error_class.name.split('::').last} with a plain-text body as the message" do
+      stub_request(:get, url('/v2/usage')).to_return(status: status, body: 'plain text')
+
+      expect { DeepL.usage }.to raise_error(error_class, 'plain text')
+    end
+  end
+
+  it 'retries a 503 reply and raises ServerError with its status' do
+    stub = stub_request(:get, url('/v2/usage')).to_return(status: 503, body: '')
+
+    expect { DeepL.usage }
+      .to raise_error(DeepL::Exceptions::ServerError) { |e| expect(e.http_status_code).to eq(503) }
+    expect(stub).to have_been_requested.times(3)
+  end
+
+  it 'keeps the status code and the failed request on the raised error' do
+    stub_request(:get, url('/v2/usage')).to_return(status: 418, body: '')
+
+    expect { DeepL.usage }.to(raise_error(DeepL::Exceptions::RequestError) do |error|
+      expect([error.http_status_code, error.request.path, error.message])
+        .to eq([418, '/v2/usage', 'Request failed with HTTP status 418.'])
+    end)
+  end
+
+  it 'uses the raw body as the message of a 400 reply with a JSON array' do
+    stub_request(:get, url('/v2/usage')).to_return(status: 400, body: '["x"]')
+
+    expect { DeepL.usage }.to raise_error(DeepL::Exceptions::BadRequest, '["x"]')
+  end
+
+  ['not json', '[]', '{"translations":[1]}'].each do |body|
+    it "raises DeepL::Exceptions::Error for the malformed response #{body}" do
+      stub_request(:post, url('/v2/translate')).to_return(status: 200, body: body)
+
+      expect { DeepL.translate('a', nil, 'DE') }
+        .to raise_error(an_instance_of(DeepL::Exceptions::Error), /Unexpected response/)
+    end
+  end
+
+  it 'keeps the response on the raised error' do
+    stub_request(:get, url('/v2/usage')).to_return(status: 456, body: 'quota')
+
+    expect { DeepL.usage }.to(raise_error { |error| expect(error.response.body).to eq('quota') })
+  end
+
+  it 'raises the errors of every endpoint family the same way' do
+    stub_request(:post, %r{/v2/(translate|write/rephrase)}).to_return(status: 403)
+    stub_request(:delete, url('/v2/glossaries/g-1')).to_return(status: 404,
+                                                               body: '{"message":"gone"}')
+
+    expect { DeepL.translate('a', nil, 'DE') }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    expect { DeepL.rephrase('a') }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+    expect { DeepL.glossaries.destroy('g-1') }.to raise_error(DeepL::Exceptions::NotFound, 'gone')
+  end
+end

data/spec/offline/glossaries_spec.rb

@@ -0,0 +1,98 @@
+# 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 'offline_helper'
+
+describe DeepL::GlossaryApi do
+  let(:glossaries) { DeepL.glossaries }
+  let(:glossary_json) do
+    { glossary_id: 'g-1', name: 'terms', ready: true, source_lang: 'en', target_lang: 'de',
+      creation_time: '2026-01-02T03:04:05.678Z', entry_count: 2 }
+  end
+
+  describe '#create' do
+    it 'sends the entries of an array as TSV' do
+      stub_request(:post, url('/v2/glossaries')).with(
+        body: { name: 'terms', source_lang: 'EN', target_lang: 'DE',
+                entries: "Apple\tApfel\nBanana\tBanane\n", entries_format: 'tsv' },
+        headers: json_headers
+      ).to_return(reply(glossary_json, 201))
+
+      glossaries.create('terms', 'EN', 'DE', [%w[Apple Apfel], %w[Banana Banane]])
+    end
+
+    it 'sends a string of entries and the entries format as given' do
+      stub_request(:post, url('/v2/glossaries')).with(
+        body: { name: 'terms', source_lang: 'EN', target_lang: 'DE', entries: "Apple,Apfel\n",
+                entries_format: 'csv' }
+      ).to_return(reply(glossary_json, 201))
+
+      glossaries.create('terms', 'EN', 'DE', "Apple,Apfel\n", entries_format: 'csv')
+    end
+
+    it 'strips surrounding whitespace from the terms of an array' do
+      stub_request(:post, url('/v2/glossaries'))
+        .with(body: hash_including(entries: "Apple\tApfel\n"))
+        .to_return(reply(glossary_json, 201))
+
+      glossaries.create('terms', 'EN', 'DE', [[' Apple ', "Apfel\n"]])
+    end
+
+    it 'returns a glossary' do
+      stub_request(:post, url('/v2/glossaries')).to_return(reply(glossary_json, 201))
+
+      expect(glossaries.create('terms', 'EN', 'DE', [%w[a b]])).to be_a(DeepL::Resources::Glossary)
+    end
+  end
+
+  describe '#create with invalid terms' do
+    [[%W[Apple\tPie Apfel]], [%W[Apple Apfel\nKuchen]], [['Apple', ' ']]].each do |entries|
+      it "raises ValidationError for #{entries.inspect} and sends no request" do
+        expect { glossaries.create('terms', 'EN', 'DE', entries) }
+          .to raise_error(DeepL::Exceptions::ValidationError)
+        expect(a_request(:any, /.*/)).not_to have_been_made
+      end
+    end
+  end
+
+  describe '#find' do
+    it 'sends a GET without a body' do
+      stub_request(:get, url('/v2/glossaries/g-1')).with(headers: auth_headers) { bodyless?(_1) }
+                                                   .to_return(reply(glossary_json))
+
+      glossaries.find('g-1')
+    end
+  end
+
+  describe '#list' do
+    it 'returns one glossary per entry of the reply' do
+      second = glossary_json.merge(glossary_id: 'g-2')
+      stub_request(:get, url('/v2/glossaries'))
+        .with(headers: auth_headers) { bodyless?(_1) }
+        .to_return(reply(glossaries: [glossary_json, second]))
+
+      expect(glossaries.list.size).to eq(2)
+    end
+  end
+
+  describe '#entries' do
+    it 'parses the TSV reply into pairs' do
+      stub_request(:get, url('/v2/glossaries/g-1/entries'))
+        .with(headers: auth_headers) { bodyless?(_1) }
+        .to_return(status: 200, body: "Apple\tApfel\nBanana\tBanane")
+
+      expect(glossaries.entries('g-1')).to eq([%w[Apple Apfel], %w[Banana Banane]])
+    end
+  end
+
+  describe '#destroy' do
+    it 'sends a DELETE without a body and returns the ID' do
+      stub_request(:delete, url('/v2/glossaries/g-1')).with(headers: auth_headers) { bodyless?(_1) }
+                                                      .to_return(status: 204)
+
+      expect(glossaries.destroy('g-1')).to eq('g-1')
+    end
+  end
+end