deepl-rb 3.2.0 → 3.4.0

data/spec/requests/glossary/find_spec.rb

@@ -1,68 +0,0 @@
-# Copyright 2022 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'
-
-describe DeepL::Requests::Glossary::Find do
-  subject(:glossary_find) { described_class.new(api, id, options) }
-
-  around do |tests|
-    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
-    tests.call
-    ENV.replace(tmp_env)
-  end
-
-  let(:api) { build_deepl_api }
-  let(:id) { '9ab5dac2-b7b2-4b4a-808a-e8e305df5ecb' }
-  let(:options) { {} }
-
-  describe '#initialize' do
-    context 'when building a request' do
-      it 'creates a request object' do
-        expect(glossary_find).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 'returns a glossary object' do
-        glossary = glossary_find.request
-        expect(glossary).to be_a(DeepL::Resources::Glossary)
-        expect(glossary.id).to eq('9ab5dac2-b7b2-4b4a-808a-e8e305df5ecb')
-        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
-      subject(:glossary_find) { described_class.new(api, id, options) }
-
-      let(:id) { 'a0af40e1-d81b-4aab-a95c-7cafbcfd1eb1' }
-
-      it 'raises a not found error' do
-        expect { glossary_find.request }.to raise_error(DeepL::Exceptions::NotFound)
-      end
-    end
-
-    context 'when requesting a non existing glossary with an invalid id' do
-      subject(:glossary_find) { described_class.new(api, id, options) }
-
-      let(:id) { 'invalid-uuid' }
-
-      it 'raises a bad request error' do
-        expect { glossary_find.request }.to raise_error(DeepL::Exceptions::BadRequest)
-      end
-    end
-  end
-end

data/spec/requests/glossary/language_pairs_spec.rb

@@ -1,40 +0,0 @@
-# Copyright 2022 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'
-
-describe DeepL::Requests::Glossary::LanguagePairs do
-  subject(:language_pairs_obj) { described_class.new(api, options) }
-
-  around do |tests|
-    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
-    tests.call
-    ENV.replace(tmp_env)
-  end
-
-  let(:api) { build_deepl_api }
-  let(:options) { {} }
-
-  describe '#initialize' do
-    context 'when building a request' do
-      it 'creates a request object' do
-        expect(language_pairs_obj).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 'returns a language pairs object' do
-        language_pairs = language_pairs_obj.request
-        expect(language_pairs).to be_an(Array)
-      end
-    end
-  end
-end

data/spec/requests/glossary/list_spec.rb

@@ -1,54 +0,0 @@
-# Copyright 2022 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'
-
-describe DeepL::Requests::Glossary::List do
-  subject(:glossary_list) { described_class.new(api, options) }
-
-  around do |tests|
-    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
-    tests.call
-    ENV.replace(tmp_env)
-  end
-
-  let(:api) { build_deepl_api }
-  let(:options) { {} }
-
-  describe '#initialize' do
-    context 'when building a request' do
-      it 'creates a request object' do
-        expect(glossary_list).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 'returns a glossaries object' do
-        glossaries = glossary_list.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 'raises an unauthorized error' do
-          expect { glossary_list.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-        end
-      end
-    end
-  end
-end

data/spec/requests/languages_spec.rb

@@ -1,68 +0,0 @@
-# Copyright 2021 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'
-
-describe DeepL::Requests::Languages do
-  subject(:languages_obj) { described_class.new(api, options) }
-
-  around do |tests|
-    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
-    tests.call
-    ENV.replace(tmp_env)
-  end
-
-  let(:api) { build_deepl_api }
-  let(:options) { {} }
-
-  describe '#initialize' do
-    context 'when building a request' do
-      it 'creates a request object' do
-        expect(languages_obj).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 'returns a valid list of source languages' do
-        languages = languages_obj.request
-
-        expect(languages).to be_an(Array)
-        expect(languages.size).to eq(29)
-        expect(languages).to(be_any { |l| l.code == 'EN' && l.name == 'English' })
-        expect(languages).to(be_any { |l| l.code == 'ES' && l.name == 'Spanish' })
-      end
-    end
-
-    context 'when requesting target languages' do
-      let(:options) { { type: :target } }
-
-      it 'returns a valid list of target languages' do
-        languages = languages_obj.request
-
-        expect(languages).to be_an(Array)
-        expect(languages.size).to eq(31)
-        expect(languages).not_to(be_any { |l| l.code == 'EN' && l.name == 'English' })
-        expect(languages).to(be_any { |l| l.code == 'ES' && l.name == 'Spanish' })
-        expect(languages)
-          .to(be_any { |l| l.code == 'EN-US' && l.name == 'English (American)' })
-      end
-    end
-
-    context 'when using an invalid type' do
-      let(:options) { { type: :invalid } }
-
-      it 'returns an usage object' do
-        message = "Parameter 'type' is invalid. 'source' and 'target' are valid values."
-        expect { languages_obj.request }.to raise_error(DeepL::Exceptions::BadRequest, message)
-      end
-    end
-  end
-end

data/spec/requests/rephrase_spec.rb

@@ -1,172 +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::Requests::Rephrase do
-  subject(:rephrase) { described_class.new(api, text, target_lang, writing_style, tone, options) }
-
-  around do |tests|
-    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
-    tests.call
-    ENV.replace(tmp_env)
-  end
-
-  let(:api) { build_deepl_api }
-  let(:text) do
-    'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.'
-  end
-  let(:target_lang) { 'EN' }
-  let(:writing_style) { nil }
-  let(:tone) { nil }
-  let(:options) { {} }
-
-  describe '#request' do
-    around do |example|
-      VCR.use_cassette('rephrase_texts') { example.call }
-    end
-
-    context 'without a style or tone applied' do
-      context 'with a string as input' do
-        it 'returns a valid response as a DeepL Text resource' do
-          original_length = text.length
-          response_text = rephrase.request
-
-          expect(response_text).to be_a(DeepL::Resources::Text)
-          expect(response_text.text.length).not_to eq(original_length)
-          expect(response_text.detected_source_language.upcase).to eq('EN')
-        end
-      end
-
-      context 'with an array of texts as input' do
-        let(:text) do
-          [
-            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
-            'He lay on his armour-like back, and if he lifted his head a little'
-          ]
-        end
-
-        it 'returns a valid response as an array of DeepL Text resources' do
-          response_texts = rephrase.request
-
-          expect(response_texts).to all(be_a(DeepL::Resources::Text))
-          response_texts.each_with_index do |response_text, index|
-            expect(response_text.text.length).not_to eq(text[index].length)
-            expect(response_text.detected_source_language.upcase).to eq('EN')
-          end
-        end
-      end
-    end
-
-    context 'with a valid tone applied' do
-      let(:tone) { 'friendly' }
-
-      context 'with a string as input' do
-        it 'returns a valid response with a string as text input' do
-          original_length = text.length
-          response_text = rephrase.request
-
-          expect(response_text).to be_a(DeepL::Resources::Text)
-          expect(response_text.text.length).not_to eq(original_length)
-          expect(response_text.detected_source_language.upcase).to eq('EN')
-        end
-      end
-
-      context 'with an array of texts as input' do
-        let(:text) do
-          [
-            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
-            'He lay on his armour-like back, and if he lifted his head a little'
-          ]
-        end
-
-        it 'returns an array of valid text objects' do
-          response_texts = rephrase.request
-
-          expect(response_texts).to all(be_a(DeepL::Resources::Text))
-          response_texts.each_with_index do |response_text, index|
-            expect(response_text.text.length).not_to eq(text[index].length)
-            expect(response_text.detected_source_language.upcase).to eq('EN')
-          end
-        end
-      end
-    end
-
-    context 'with a valid writing style applied' do
-      let(:writing_style) { 'business' }
-
-      context 'with a string as input' do
-        it 'returns a valid response with a string as text input' do
-          original_length = text.length
-          response_text = rephrase.request
-
-          expect(response_text).to be_a(DeepL::Resources::Text)
-          expect(response_text.text.length).not_to eq(original_length)
-          expect(response_text.detected_source_language.upcase).to eq('EN')
-        end
-      end
-
-      context 'with an array of texts as input' do
-        let(:text) do
-          [
-            'As Gregor Samsa awoke one morning from uneasy dreams he found himself transformed.',
-            'He lay on his armour-like back, and if he lifted his head a little'
-          ]
-        end
-
-        it 'returns an array of valid text objects' do
-          response_texts = rephrase.request
-
-          expect(response_texts).to all(be_a(DeepL::Resources::Text))
-          response_texts.each_with_index do |response_text, index|
-            expect(response_text.text.length).not_to eq(text[index].length)
-            expect(response_text.detected_source_language.upcase).to eq('EN')
-          end
-        end
-      end
-    end
-
-    context 'with a writing style or tone from the provided constants applied' do
-      let(:writing_style) { DeepL::Constants::WritingStyle::BUSINESS }
-      let(:tone) { DeepL::Constants::Tone::FRIENDLY }
-
-      it 'has the correct writing style and tone applied' do
-        expect(rephrase.writing_style).to eq('business')
-        expect(rephrase.tone).to eq('friendly')
-      end
-    end
-
-    context 'with an invalid writing style applied' do
-      let(:writing_style) { 'angry' }
-
-      it 'raises a bad request error' do
-        expect { rephrase.request }.to raise_error(DeepL::Exceptions::BadRequest)
-      end
-    end
-
-    context 'when both writing style and tone are applied' do
-      let(:writing_style) { 'business' }
-      let(:tone) { 'friendly' }
-
-      it 'raises a bad request error' do
-        expect { rephrase.request }.to raise_error(DeepL::Exceptions::BadRequest)
-      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 'raises an unauthorized error' do
-          expect { rephrase.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
-        end
-      end
-    end
-  end
-end