deepl-rb 3.2.0 → 3.4.0

data/spec/api/deepl_spec.rb

@@ -1,431 +0,0 @@
-# Copyright 2018 Daniel Herzog
-# 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 'spec_helper'
-require 'tempfile'
-
-describe DeepL do
-  subject(:deepl) { described_class.dup }
-
-  around do |tests|
-    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
-    tests.call
-    ENV.replace(tmp_env)
-  end
-
-  describe '#configure' do
-    context 'when providing no block' do
-      let(:configuration) { DeepL::Configuration.new }
-
-      before do
-        deepl.configure
-      end
-
-      it 'uses default configuration' do
-        expect(deepl.configuration).to eq(configuration)
-      end
-    end
-
-    context 'when providing a valid configuration' do
-      let(:configuration) do
-        DeepL::Configuration.new({ auth_key: 'VALID', host: 'http://www.example.org',
-                                   version: 'v1' })
-      end
-
-      before do
-        deepl.configure do |config|
-          config.auth_key = configuration.auth_key
-          config.host = configuration.host
-          config.version = configuration.version
-        end
-      end
-
-      it 'uses the provided configuration' do
-        expect(deepl.configuration).to eq(configuration)
-      end
-    end
-
-    context 'when providing an invalid configuration' do
-      it 'raises an error' do
-        expect { deepl.configure { |c| c.auth_key = '' } }
-          .to raise_error(DeepL::Exceptions::Error)
-      end
-    end
-  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 } }
-
-      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
-
-  describe '#usage' do
-    let(:options) { {} }
-
-    around do |example|
-      deepl.configure
-      VCR.use_cassette('deepl_usage') { example.call }
-    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
-
-        usage = deepl.usage(options)
-        expect(usage).to be_a(DeepL::Resources::Usage)
-      end
-    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
-
-      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' } }
-
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_document') { example.call }
-      end
-
-      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
-    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
-
-      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
-    end
-
-    # rubocop:disable RSpec/InstanceVariable
-    describe '#document.download' do
-      before do
-        @tmpfile = Tempfile.new('bar')
-      end
-
-      after do
-        @tmpfile.close
-        @tmpfile.unlink
-      end
-
-      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' } }
-
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_document_download', preserve_exact_body_bytes: true) do
-          example.call
-        end
-      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
-    end
-  end
-  # rubocop:enable RSpec/InstanceVariable
-
-  describe '#languages' do
-    let(:options) { { type: :target } }
-
-    around do |example|
-      deepl.configure
-      VCR.use_cassette('deepl_languages') { example.call }
-    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
-
-        languages = deepl.languages(options)
-        expect(languages).to be_an(Array)
-        expect(languages).to(be_all { |l| l.is_a?(DeepL::Resources::Language) })
-      end
-    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' } }
-
-      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
-    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' }
-
-        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
-      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
-
-          glossaries = deepl.glossaries.list(options)
-          expect(glossaries).to all(be_a(DeepL::Resources::Glossary))
-        end
-      end
-    end
-
-    describe '#glossaries.destroy' 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 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
-      end
-
-      context 'when destroying 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::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
-      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
-
-      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
-      end
-    end
-
-    describe '#glossaries.language_pairs' do
-      let(:options) { {} }
-
-      around do |example|
-        deepl.configure
-        VCR.use_cassette('deepl_glossaries') { example.call }
-      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
-
-          language_pairs = deepl.glossaries.language_pairs(options)
-          expect(language_pairs).to all(be_a(DeepL::Resources::LanguagePair))
-        end
-      end
-    end
-  end
-end

data/spec/constants/constants_spec.rb

@@ -1,158 +0,0 @@
-# Copyright 2025 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 'spec_helper'
-
-describe 'DeepL::Constants' do
-  describe DeepL::Constants::Tone do
-    subject(:tone) { described_class }
-
-    it 'includes all expected tone values' do # rubocop:disable RSpec/ExampleLength
-      expect(tone.options).to contain_exactly(
-        'confident',
-        'default',
-        'diplomatic',
-        'enthusiastic',
-        'friendly',
-        'prefer_confident',
-        'prefer_diplomatic',
-        'prefer_enthusiastic',
-        'prefer_friendly'
-      )
-    end
-
-    it 'validates correct tone values' do
-      expect(tone.valid?('enthusiastic')).to be true
-      expect(tone.valid?('friendly')).to be true
-      expect(tone.valid?('confident')).to be true
-      expect(tone.valid?('diplomatic')).to be true
-      expect(tone.valid?('default')).to be true
-    end
-
-    it 'invalidates incorrect tone values' do
-      expect(tone.valid?('angry')).to be false
-      expect(tone.valid?('')).to be false
-      expect(tone.valid?(nil)).to be false
-    end
-  end
-
-  describe DeepL::Constants::WritingStyle do
-    subject(:writing_style) { described_class }
-
-    it 'includes all expected writing style values' do # rubocop:disable RSpec/ExampleLength
-      expect(writing_style.options).to contain_exactly(
-        'default',
-        'simple',
-        'business',
-        'academic',
-        'casual',
-        'prefer_academic',
-        'prefer_business',
-        'prefer_casual',
-        'prefer_simple'
-      )
-    end
-
-    it 'validates correct writing style values' do
-      expect(writing_style.valid?('simple')).to be true
-      expect(writing_style.valid?('business')).to be true
-      expect(writing_style.valid?('academic')).to be true
-      expect(writing_style.valid?('casual')).to be true
-      expect(writing_style.valid?('default')).to be true
-    end
-
-    it 'invalidates incorrect writing style values' do
-      expect(writing_style.valid?('wordy')).to be false
-      expect(writing_style.valid?('')).to be false
-      expect(writing_style.valid?(nil)).to be false
-    end
-  end
-
-  describe DeepL::Constants::TagHandling do
-    subject(:tag_handling) { described_class }
-
-    it 'includes all expected tag handling values' do
-      expect(tag_handling.options).to contain_exactly('xml', 'html')
-    end
-
-    it 'validates correct tag handling values' do
-      expect(tag_handling.valid?('xml')).to be true
-      expect(tag_handling.valid?('html')).to be true
-    end
-
-    it 'invalidates incorrect tag handling values' do
-      expect(tag_handling.valid?('json')).to be false
-      expect(tag_handling.valid?('')).to be false
-      expect(tag_handling.valid?(nil)).to be false
-    end
-  end
-
-  describe DeepL::Constants::SplitSentences do
-    subject(:split_sentences) { described_class }
-
-    it 'includes all expected split sentences values' do
-      expect(split_sentences.options).to contain_exactly('0', '1', 'nonewlines')
-    end
-
-    it 'validates correct split sentences values' do
-      expect(split_sentences.valid?('0')).to be true
-      expect(split_sentences.valid?('1')).to be true
-      expect(split_sentences.valid?('nonewlines')).to be true
-    end
-
-    it 'invalidates incorrect split sentences values' do
-      expect(split_sentences.valid?('2')).to be false
-      expect(split_sentences.valid?('')).to be false
-      expect(split_sentences.valid?(nil)).to be false
-    end
-  end
-
-  describe DeepL::Constants::ModelType do
-    subject(:model_type) { described_class }
-
-    it 'includes all expected model type values' do
-      expect(model_type.options).to contain_exactly(
-        'quality_optimized',
-        'prefer_quality_optimized',
-        'latency_optimized'
-      )
-    end
-
-    it 'validates correct model type values' do
-      expect(model_type.valid?('quality_optimized')).to be true
-      expect(model_type.valid?('prefer_quality_optimized')).to be true
-      expect(model_type.valid?('latency_optimized')).to be true
-    end
-
-    it 'invalidates incorrect model type values' do
-      expect(model_type.valid?('speed_optimized')).to be false
-      expect(model_type.valid?('')).to be false
-      expect(model_type.valid?(nil)).to be false
-    end
-  end
-
-  describe DeepL::Constants::Formality do
-    subject(:formality) { described_class }
-
-    it 'includes all expected formality values' do
-      expect(formality.options).to contain_exactly('default', 'more', 'less', 'prefer_more',
-                                                   'prefer_less')
-    end
-
-    it 'validates correct formality values' do
-      expect(formality.valid?('default')).to be true
-      expect(formality.valid?('more')).to be true
-      expect(formality.valid?('less')).to be true
-      expect(formality.valid?('prefer_more')).to be true
-      expect(formality.valid?('prefer_less')).to be true
-    end
-
-    it 'invalidates incorrect formality values' do
-      expect(formality.valid?('neutral')).to be false
-      expect(formality.valid?('')).to be false
-      expect(formality.valid?(nil)).to be false
-    end
-  end
-end

data/spec/fixtures/vcr_cassettes/deepl_document.yml

@@ -1,95 +0,0 @@
----
-http_interactions:
-- request:
-    method: post
-    uri: https://api.deepl.com/v2/document
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Authorization:
-      - DeepL-Auth-Key VALID_TOKEN
-      User-Agent:
-      - deepl-ruby/3.0.2 (darwin23) ruby/3.3.3
-      Content-Type:
-      - multipart/form-data
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      Fake-Header:
-      - fake_value
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Date:
-      - Tue, 09 Jul 2024 02:02:17 GMT
-      Content-Type:
-      - application/json; charset=utf-8
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      Access-Control-Allow-Origin:
-      - "*"
-      X-Trace-Id:
-      - cdde031b7a5e48d7a8c4a5a2f1b9dc6e
-      Strict-Transport-Security:
-      - max-age=63072000; includeSubDomains; preload
-      Server-Timing:
-      - l7_lb_tls;dur=100, l7_lb_idle;dur=2, l7_lb_receive;dur=0, l7_lb_total;dur=192
-      Access-Control-Expose-Headers:
-      - Server-Timing, X-Trace-ID
-    body:
-      encoding: ASCII-8BIT
-      string: '{"document_id":"9B7CB9418DCDEBF2C4C519F65A32B99F","document_key":"EA637EA43BB3F8A52A2A25B76EF3E0C72CE9CD00C881148D1236CB584CB34815"}'
-  recorded_at: Tue, 09 Jul 2024 02:02:17 GMT
-- request:
-    method: post
-    uri: https://api.deepl.com/v2/document/9B7CB9418DCDEBF2C4C519F65A32B99F
-    body:
-      encoding: UTF-8
-      string: '{"document_key":"EA637EA43BB3F8A52A2A25B76EF3E0C72CE9CD00C881148D1236CB584CB34815","param":"fake"}'
-    headers:
-      Authorization:
-      - DeepL-Auth-Key VALID_TOKEN
-      User-Agent:
-      - deepl-ruby/3.0.2 (darwin23) ruby/3.3.3
-      Content-Type:
-      - application/json
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      Fake-Header:
-      - fake_value
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Date:
-      - Tue, 09 Jul 2024 02:03:49 GMT
-      Content-Type:
-      - application/json; charset=utf-8
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      Access-Control-Allow-Origin:
-      - "*"
-      X-Trace-Id:
-      - 73fc4be8f3964b4080f89ee686c090be
-      Strict-Transport-Security:
-      - max-age=63072000; includeSubDomains; preload
-      Server-Timing:
-      - l7_lb_tls;dur=152, l7_lb_idle;dur=9, l7_lb_receive;dur=0, l7_lb_total;dur=166
-      Access-Control-Expose-Headers:
-      - Server-Timing, X-Trace-ID
-    body:
-      encoding: ASCII-8BIT
-      string: '{"document_id":"9B7CB9418DCDEBF2C4C519F65A32B99F","status":"done","billed_characters":256}'
-  recorded_at: Tue, 09 Jul 2024 02:03:49 GMT
-recorded_with: VCR 6.2.0