deepl-rb 2.2.1 → 2.5.3

data/spec/fixtures/vcr_cassettes/usage.yml

@@ -2,11 +2,13 @@
 http_interactions:
 - request:
     method: get
-    uri: https://api.deepl.com/v2/usage?auth_key=VALID_TOKEN
+    uri: https://api-free.deepl.com/v2/usage
     body:
       encoding: US-ASCII
       string: ''
     headers:
+      Authorization:
+      - DeepL-Auth-Key VALID_TOKEN
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       Accept:
@@ -21,14 +23,17 @@ http_interactions:
       Server:
       - nginx
       Date:
-      - Tue, 08 May 2018 20:42:44 GMT
+      - Mon, 17 May 2021 14:18:32 GMT
+      Content-Type:
+      - application/json
       Content-Length:
-      - '52'
+      - '48'
       Connection:
       - keep-alive
+      Access-Control-Allow-Origin:
+      - "*"
     body:
       encoding: UTF-8
-      string: '{"character_count":805718,"character_limit":1000000}'
-    http_version: 
-  recorded_at: Tue, 08 May 2018 20:42:43 GMT
-recorded_with: VCR 4.0.0
+      string: '{"character_count":353,"character_limit":500000}'
+  recorded_at: Mon, 17 May 2021 14:18:32 GMT
+recorded_with: VCR 6.0.0

data/spec/requests/glossary/create_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Create do
+  let(:api) { build_deepl_api }
+  let(:name) { 'Mi Glosario' }
+  let(:source_lang) { 'EN' }
+  let(:target_lang) { 'ES' }
+  let(:entries) do
+    [
+      %w[Hello Hola],
+      %w[World Mundo]
+    ]
+  end
+  let(:entries_format) { 'tsv' }
+  let(:options) { {} }
+  subject do
+    DeepL::Requests::Glossary::Create.new(api, name, source_lang, target_lang, entries, options)
+  end
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+
+      it 'should set the default value for the entries format if not specified' do
+        request = DeepL::Requests::Glossary::Create.new(api, name, source_lang, target_lang,
+                                                        entries, options)
+        expect(request.entries_format).to eq('tsv')
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request with two glossary entries' do
+      it 'should return a glossaries object' do
+        glossary = subject.request
+        expect(glossary).to be_a(DeepL::Resources::Glossary)
+        expect(glossary.id).to be_kind_of(String)
+        expect(glossary.name).to eq('Mi Glosario')
+        expect(glossary.ready).to be(true).or be(false)
+        expect(glossary.source_lang).to eq('en')
+        expect(glossary.target_lang).to eq('es')
+        expect { Time.iso8601(glossary.creation_time) }.not_to raise_error
+        expect(glossary.entry_count).to eq(2)
+      end
+    end
+  end
+end

data/spec/requests/glossary/destroy_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Destroy do
+  let(:api) { build_deepl_api }
+  let(:id) { '367eef44-b533-4d95-be19-74950c7760e9' }
+  subject { DeepL::Requests::Glossary::Destroy.new(api, id) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request' do
+      let(:new_glossary) do
+        DeepL::Requests::Glossary::Create.new(api, 'fixture', 'EN', 'ES', [%w[Hello Hola]]).request
+      end
+      subject { DeepL::Requests::Glossary::Destroy.new(api, new_glossary.id) }
+      it 'should return an empty object' do
+        response = subject.request
+        expect(response).to eq(new_glossary.id)
+      end
+    end
+
+    context 'When deleting a non existing glossary with a valid id' do
+      let(:id) { '00000000-0000-0000-0000-000000000000' }
+      subject { DeepL::Requests::Glossary::Destroy.new(api, id) }
+      it 'should raise a not found error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'When deleting a non existing glossary with an invalid id' do
+      let(:id) { 'invalid-uuid' }
+      subject { DeepL::Requests::Glossary::Destroy.new(api, id) }
+      it 'should raise a bad request error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/entries_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Entries do
+  let(:api) { build_deepl_api }
+  let(:id) { '012a5576-b551-4d4c-b917-ce01bc8debb6' }
+  subject { DeepL::Requests::Glossary::Entries.new(api, id) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request' do
+      it 'should return a list of entries in TSV format' do
+        entries = subject.request
+        expect(entries).to be_kind_of(Array)
+        expect(entries).to all(be_a(Array))
+        expect(entries.size).to eq(2)
+      end
+    end
+
+    context 'When requesting entries with a valid but non existing glossary id' do
+      let(:id) { '00000000-0000-0000-0000-000000000000' }
+      subject { DeepL::Requests::Glossary::Entries.new(api, id) }
+      it 'should raise a not found error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'When requesting entries with an invalid glossary id' do
+      let(:id) { 'invalid-uuid' }
+      subject { DeepL::Requests::Glossary::Entries.new(api, id) }
+      it 'should raise a bad request error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/find_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Find do
+  let(:api) { build_deepl_api }
+  let(:id) { 'd9ad833f-c818-430c-a3c9-47071384fa3e' }
+  let(:options) { {} }
+  subject { DeepL::Requests::Glossary::Find.new(api, id, options) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request' do
+      it 'should return a glossary object' do
+        glossary = subject.request
+        expect(glossary).to be_a(DeepL::Resources::Glossary)
+        expect(glossary.id).to eq('d9ad833f-c818-430c-a3c9-47071384fa3e')
+        expect(glossary.name).to eq('Mi Glosario')
+        expect(glossary.ready).to be(true).or be(false)
+        expect(glossary.source_lang).to eq('en')
+        expect(glossary.target_lang).to eq('es')
+        expect { Time.iso8601(glossary.creation_time) }.not_to raise_error
+        expect(glossary.entry_count).to eq(2)
+      end
+    end
+
+    context 'When requesting a non existing glossary with a valid id' do
+      let(:id) { 'a0af40e1-d81b-4aab-a95c-7cafbcfd1eb1' }
+      subject { DeepL::Requests::Glossary::Find.new(api, id, options) }
+      it 'should raise a not found error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'When requesting a non existing glossary with an invalid id' do
+      let(:id) { 'invalid-uuid' }
+      subject { DeepL::Requests::Glossary::Find.new(api, id, options) }
+      it 'should raise a bad request error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/language_pairs_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::LanguagePairs do
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+  subject { DeepL::Requests::Glossary::LanguagePairs.new(api, options) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When requesting a list of all language pairs supported by glossaries' do
+      it 'should return a language pairs object' do
+        language_pairs = subject.request
+        expect(language_pairs).to be_an(Array)
+      end
+    end
+  end
+end

data/spec/requests/glossary/list_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::List do
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+  subject { DeepL::Requests::Glossary::List.new(api, options) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When requesting a list of all glossaries' do
+      it 'should return a glossaries object' do
+        glossaries = subject.request
+        expect(glossaries).to be_an(Array)
+      end
+    end
+
+    context 'When performing a bad request' do
+      context 'When using an invalid token' do
+        let(:api) do
+          api = build_deepl_api
+          api.configuration.auth_key = 'invalid'
+          api
+        end
+
+        it 'should raise an unauthorized error' do
+          expect { subject.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+        end
+      end
+    end
+  end
+end

data/spec/requests/languages_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Languages do
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+  subject { DeepL::Requests::Languages.new(api, options) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('languages') { example.call }
+    end
+
+    context 'When requesting source languages' do
+      it 'should return an usage object' do
+        languages = subject.request
+
+        expect(languages).to be_an(Array)
+        expect(languages.size).to eq(24)
+        expect(languages.any? { |l| l.code == 'EN' && l.name == 'English' }).to be_truthy
+        expect(languages.any? { |l| l.code == 'ES' && l.name == 'Spanish' }).to be_truthy
+      end
+    end
+
+    context 'When requesting target languages' do
+      let(:options) { { type: :target } }
+
+      it 'should return an usage object' do
+        languages = subject.request
+
+        expect(languages).to be_an(Array)
+        expect(languages.size).to eq(26)
+        expect(languages.any? { |l| l.code == 'EN' && l.name == 'English' }).to be_falsey
+        expect(languages.any? { |l| l.code == 'ES' && l.name == 'Spanish' }).to be_truthy
+        expect(languages.any? { |l| l.code == 'EN-US' && l.name == 'English (American)' })
+          .to be_truthy
+      end
+    end
+
+    context 'When using an invalid type' do
+      let(:options) { { type: :invalid } }
+
+      it 'should return an usage object' do
+        message = "Parameter 'type' is invalid. 'source' and 'target' are valid values."
+        expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest, message)
+      end
+    end
+  end
+end

data/spec/requests/translate_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe DeepL::Requests::Translate do
-  let(:tags_str) { 'p, strong, span' }
+  let(:tags_str) { 'p,strong,span' }
   let(:tags_array) { %w[p strong span] }
 
   let(:api) { build_deepl_api }
@@ -9,6 +11,7 @@ describe DeepL::Requests::Translate do
   let(:source_lang) { 'EN' }
   let(:target_lang) { 'ES' }
   let(:options) { {} }
+
   subject { DeepL::Requests::Translate.new(api, text, source_lang, target_lang, options) }
 
   describe '#initialize' do
@@ -18,6 +21,33 @@ describe DeepL::Requests::Translate do
       end
     end
 
+    context 'when using `splitting_tags` options' do
+      it 'should work with a nil values' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, splitting_tags: nil)
+        expect(request.options[:splitting_tags]).to eq(nil)
+      end
+
+      it 'should work with a blank list' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, splitting_tags: '')
+        expect(request.options[:splitting_tags]).to eq('')
+      end
+
+      it 'should work with a comma-separated list' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, splitting_tags: tags_str)
+        expect(request.options[:splitting_tags]).to eq(tags_str)
+      end
+
+      it 'should convert arrays to strings' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, splitting_tags: tags_array)
+        expect(request.options[:splitting_tags]).to eq(tags_str)
+      end
+
+      it 'should leave strings as they are' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, splitting_tags: tags_str)
+        expect(request.options[:splitting_tags]).to eq(tags_str)
+      end
+    end
+
     context 'when using `non_splitting_tags` options' do
       it 'should work with a nil values' do
         request = DeepL::Requests::Translate.new(api, nil, nil, nil, non_splitting_tags: nil)
@@ -88,6 +118,11 @@ describe DeepL::Requests::Translate do
         expect(request.options[:split_sentences]).to eq('0')
       end
 
+      it 'should leave `nonewlines` as is' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, split_sentences: 'nonewlines')
+        expect(request.options[:split_sentences]).to eq('nonewlines')
+      end
+
       it 'should leave `1` as is' do
         request = DeepL::Requests::Translate.new(api, nil, nil, nil, split_sentences: '1')
         expect(request.options[:split_sentences]).to eq('1')
@@ -115,6 +150,52 @@ describe DeepL::Requests::Translate do
         expect(request.options[:preserve_formatting]).to eq('1')
       end
     end
+
+    context 'when using `outline_detection` options' do
+      it 'should convert `true` to `1`' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: true)
+        expect(request.options[:outline_detection]).to eq('1')
+      end
+
+      it 'should convert `false` to `0`' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: false)
+        expect(request.options[:outline_detection]).to eq('0')
+      end
+
+      it 'should leave `0` as is' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: '0')
+        expect(request.options[:outline_detection]).to eq('0')
+      end
+
+      it 'should leave `1` as is' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: '1')
+        expect(request.options[:outline_detection]).to eq('1')
+      end
+    end
+
+    context 'when using `glossary_id` options' do
+      it 'should work with a nil values' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, glossary_id: nil)
+        expect(request.options[:glossary_id]).to eq(nil)
+      end
+
+      it 'should work with a string' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, glossary_id: 'sample_id')
+        expect(request.options[:glossary_id]).to eq('sample_id')
+      end
+    end
+
+    context 'when using `formality` options' do
+      it 'should work with a nil values' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, formality: nil)
+        expect(request.options[:formality]).to eq(nil)
+      end
+
+      it 'should work with a string' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, formality: 'more')
+        expect(request.options[:formality]).to eq('more')
+      end
+    end
   end
 
   describe '#request' do
@@ -149,6 +230,7 @@ describe DeepL::Requests::Translate do
 
     context 'When performing a valid request with tag handling' do
       let(:text) { '<p>Sample text</p>' }
+      let(:options) { { tag_handling: 'xml' } }
 
       it 'should return a text object' do
         text = subject.request
@@ -161,13 +243,57 @@ describe DeepL::Requests::Translate do
 
     context 'When performing a valid request and passing a variable' do
       let(:text) { 'Welcome and <code>Hello great World</code> Good Morning!' }
-      let(:options) { { ignore_tags: 'code, span' } }
+      let(:options) { { tag_handling: 'xml', ignore_tags: %w[code span] } }
 
       it 'should return a text object' do
         text = subject.request
 
         expect(text).to be_a(DeepL::Resources::Text)
-        expect(text.text).to eq('Bienvenido y <code>Hello great World</code> Buenos días!')
+        expect(text.text).to eq('Bienvenido y <code>Hello great World</code> ¡Buenos días!')
+        expect(text.detected_source_language).to eq('EN')
+      end
+    end
+
+    context 'When performing a valid request with an HTML document' do
+      let(:text) do
+        <<~XML
+          <document>
+            <meta>
+              <title>A document's title</title>
+            </meta>
+            <content>
+              <par>This is the first sentence. Followed by a second one.</par>
+              <par>This is the third sentence.</par>
+            </content>
+          </document>
+        XML
+      end
+      let(:options) do
+        {
+          tag_handling: 'xml',
+          split_sentences: 'nonewlines',
+          outline_detection: false,
+          splitting_tags: %w[title par]
+        }
+      end
+
+      it 'should return a text object' do
+        text = subject.request
+
+        expect(text).to be_a(DeepL::Resources::Text)
+        expect(text.text).to eq(
+          <<~XML
+            <document>
+              <meta>
+                <title>El título de un documento</title>
+              </meta>
+              <content>
+                <par>Es la primera frase. Seguido de una segunda.</par>
+                <par>Esta es la tercera frase.</par>
+              </content>
+            </document>
+          XML
+        )
         expect(text.detected_source_language).to eq('EN')
       end
     end
@@ -198,10 +324,19 @@ describe DeepL::Requests::Translate do
         let(:target_lang) { nil }
 
         it 'should raise a bad request error' do
-          message = "Parameter 'target_lang' not specified."
+          message = "Value for 'target_lang' not supported."
           expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest, message)
         end
       end
     end
+
+    context 'When performing a request with too many texts' do
+      let(:text) { Array.new(10_000) { |i| "This is the sentence number #{i}" } }
+
+      it 'should raise a request entity too large error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::RequestEntityTooLarge,
+                                                  /request size has reached the supported limit/)
+      end
+    end
   end
 end

data/spec/requests/usage_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe DeepL::Requests::Usage do

data/spec/resources/glossary_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Resources::Glossary do
+  subject do
+    described_class.new({
+                          'glossary_id' => 'def3a26b-3e84-45b3-84ae-0c0aaf3525f7',
+                          'name' => 'Mein Glossar',
+                          'ready' => true,
+                          'source_lang' => 'EN',
+                          'target_lang' => 'DE',
+                          'creation_time' => '2021-08-03T14:16:18.329Z',
+                          'entry_count' => 1
+                        }, nil, nil)
+  end
+
+  describe '#initialize' do
+    context 'When building a basic object' do
+      it 'should create a resource' do
+        expect(subject).to be_a(described_class)
+      end
+
+      it 'should assign the attributes' do
+        expect(subject.id).to eq('def3a26b-3e84-45b3-84ae-0c0aaf3525f7')
+        expect(subject.name).to eq('Mein Glossar')
+        expect(subject.ready).to eq(true)
+        expect(subject.source_lang).to eq('EN')
+        expect(subject.target_lang).to eq('DE')
+        expect(subject.creation_time).to eq('2021-08-03T14:16:18.329Z')
+        expect(subject.entry_count).to eq(1)
+      end
+    end
+  end
+end

data/spec/resources/language_pair_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Resources::LanguagePair do
+  subject { described_class.new('en', 'de', nil, nil) }
+
+  describe '#initialize' do
+    context 'When building a basic object' do
+      it 'should create a resource' do
+        expect(subject).to be_a(described_class)
+      end
+
+      it 'should assign the attributes' do
+        expect(subject.source_lang).to eq('en')
+        expect(subject.target_lang).to eq('de')
+      end
+    end
+  end
+end