abbyy-cloud 0.0.3 → 0.0.4

data/spec/abbyy/cloud/models/source_segment_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe ABBYY::Cloud::Models::SourceSegment do
+  let(:data) do
+    {
+      text: "to be or not to be",
+      tags: [{ number: 1, type: "Start", position: 0 }]
+    }
+  end
+
+  subject { described_class.new(data) }
+
+  it { is_expected.to be_kind_of ABBYY::Cloud::Struct }
+  its(:to_h) { is_expected.to eq data }
+
+  context "without text:" do
+    before { data.delete :text }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid tags:" do
+    before { data[:tags] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid tag:" do
+    before { data[:tags].first[:type] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+end

data/spec/abbyy/cloud/models/source_tag_spec.rb

@@ -0,0 +1,56 @@
+RSpec.describe ABBYY::Cloud::Models::SourceTag do
+  let(:data) { { number: 1, type: "Start", position: 0 } }
+
+  subject { described_class.new(data) }
+
+  it { is_expected.to be_kind_of ABBYY::Cloud::Struct }
+  its(:to_h) { is_expected.to eq data }
+
+  context "with invalid number:" do
+    before { data[:number] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without number:" do
+    before { data.delete :number }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid type:" do
+    before { data[:type] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without type:" do
+    before { data.delete :type }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid position:" do
+    before { data[:position] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without position:" do
+    before { data.delete :position }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+end

data/spec/abbyy/cloud/models/transfer_data_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe ABBYY::Cloud::Models::TransferData do
+  let(:data) { { order: 1, position: 0 } }
+
+  subject { described_class.new(data) }
+
+  it { is_expected.to be_kind_of ABBYY::Cloud::Struct }
+  its(:to_h) { is_expected.to eq data }
+
+  context "with invalid order:" do
+    before { data[:order] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without order:" do
+    before { data.delete :order }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid position:" do
+    before { data[:position] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without position:" do
+    before { data.delete :position }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+end

data/spec/abbyy/cloud/models/translation_segment_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe ABBYY::Cloud::Models::TranslationSegment do
+  let(:data) do
+    {
+      id:   "foo",
+      text: "to be or not to be",
+      tags_transfer_data: [{ order: 1, position: 0 }]
+    }
+  end
+
+  subject { described_class.new(data) }
+
+  it { is_expected.to be_kind_of ABBYY::Cloud::Struct }
+  its(:to_h) { is_expected.to eq data }
+
+  context "without text:" do
+    before { data.delete :text }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid tags_transfer_data:" do
+    before { data[:tags_transfer_data] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid tag:" do
+    before { data[:tags_transfer_data].first[:order] = nil }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+end

data/spec/abbyy/cloud/models/unit_price_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe ABBYY::Cloud::Models::UnitPrice do
+  let(:data) { { unit_type: "Words", currency: "USD", amount: 0.03 } }
+
+  subject { described_class.new(data) }
+
+  it { is_expected.to be_kind_of ABBYY::Cloud::Struct }
+  its(:to_h) { is_expected.to eq data }
+
+  context "with invalid unit_type:" do
+    before { data[:unit_type] = "Miles" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without unit_type:" do
+    before { data.delete :unit_type }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid currency:" do
+    before { data[:currency] = "usd" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without currency:" do
+    before { data.delete :currency }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without amount:" do
+    before { data.delete :amount }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+end

data/spec/abbyy/cloud/settings_spec.rb

@@ -36,14 +36,6 @@ RSpec.describe ABBYY::Cloud::Settings do
         expect { subject }.to raise_error(StandardError)
       end
     end
-
-    context "with wrong version" do
-      before { options[:id] = 1 }
-
-      it "fails" do
-        expect { subject }.to raise_error(StandardError)
-      end
-    end
   end
 
   describe "#id" do
@@ -69,25 +61,11 @@ RSpec.describe ABBYY::Cloud::Settings do
     end
   end
 
-  describe "#version" do
-    subject { settings.version }
-
-    context "by default:" do
-      it { is_expected.to eq 0 }
-    end
-
-    context "when assigned:" do
-      before { options[:version] = 0 }
-      it { is_expected.to eq 0 }
-    end
-  end
-
   describe "#connection" do
     subject { settings.connection }
 
     it { is_expected.to be_instance_of ABBYY::Cloud::Connection }
-    its(:version) { is_expected.to eq settings.version }
-    its(:id)      { is_expected.to eq settings.id }
-    its(:token)   { is_expected.to eq settings.token }
+    its(:id)    { is_expected.to eq settings.id }
+    its(:token) { is_expected.to eq settings.token }
   end
 end

data/spec/abbyy/cloud_spec.rb

@@ -6,9 +6,8 @@ RSpec.describe ABBYY::Cloud do
     subject { cloud.settings }
 
     it { is_expected.to be_a ABBYY::Cloud::Settings }
-    its(:version) { is_expected.to eq 0 }
-    its(:engine)  { is_expected.to eq "Sandbox" }
-    its(:id)      { is_expected.to eq "foo" }
-    its(:token)   { is_expected.to eq "bar" }
+    its(:engine) { is_expected.to eq "Sandbox" }
+    its(:id)     { is_expected.to eq "foo" }
+    its(:token)  { is_expected.to eq "bar" }
   end
 end

data/spec/feature/abbyy/mt_default_engine_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe "mt.default_engine" do
+  let(:client)    { ABBYY::Cloud.new id: "foo", token: "bar", engine: "Bing" }
+  let(:namespace) { client.mt }
+  let(:opts)      { { languages: [], translation_directions: [] } }
+  let(:bing)      { ABBYY::Cloud::Models::Engine.new(name: "Bing", **opts) }
+  let(:google)    { ABBYY::Cloud::Models::Engine.new(name: "Google", **opts) }
+
+  before  { allow(namespace).to receive(:engines) { [bing, google] } }
+  subject { namespace.default_engine }
+
+  it { is_expected.to eql bing }
+end

data/spec/feature/abbyy/mt_engine_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe "mt.engine" do
+  let(:client)    { ABBYY::Cloud.new id: "foo", token: "bar" }
+  let(:namespace) { client.mt }
+  let(:opts)      { { languages: [], translation_directions: [] } }
+  let(:bing)      { ABBYY::Cloud::Models::Engine.new(name: "Bing", **opts) }
+  let(:google)    { ABBYY::Cloud::Models::Engine.new(name: "Google", **opts) }
+
+  before { allow(namespace).to receive(:engines) { [bing, google] } }
+
+  it "works" do
+    expect(namespace.engine("Bing")).to eq bing
+    expect(namespace.engine("Google")).to eq google
+    expect(namespace.engine("Unknonw")).to be_nil
+  end
+end

data/spec/feature/abbyy/mt_translate_segments_spec.rb

@@ -0,0 +1,136 @@
+RSpec.describe "mt.translate_segments" do
+  let(:client)          { ABBYY::Cloud.new settings }
+  let(:settings)        { { id: "foo", token: "bar", engine: default_engine } }
+  let(:default_engine)  { "Google" }
+  let(:custom_engine)   { "Bing" }
+  let(:source_language) { "ru" }
+  let(:target_language) { "en" }
+  let(:source_text)     { "Бить или не бить" }
+  let(:path)            { "https://api.abbyy.cloud/v1/order/mt/sync" }
+  let(:response_status) { 200 }
+  let(:response_model)  { { id: "42", text: "To beat or not to beat" } }
+  let(:params) do
+    { from: source_language, to: target_language, engine: custom_engine }
+  end
+
+  before do
+    stub_request(:post, path)
+      .with(basic_auth: %w(foo bar))
+      .to_return status:  response_status,
+                 headers: { "Content-Type" => "application/json" },
+                 body:    JSON([response_model])
+  end
+
+  subject { client.mt.translate_segments [source_text], params }
+
+  it "sends a request to ABBYY Cloud API" do
+    subject
+    expect(a_request(:post, path)).to have_been_made
+  end
+
+  it "returns translation model" do
+    item = subject.first
+    expect(item).to be_kind_of ABBYY::Cloud::Models::TranslationSegment
+    expect(item.to_h).to include response_model
+  end
+
+  context "without custom engine:" do
+    before { params.delete :engine }
+
+    let(:expected_request) do
+      a_request(:post, path).with do |req|
+        expect(JSON.parse(req.body)).to include "engine" => "Google"
+      end
+    end
+
+    it "uses default engine in the request" do
+      subject
+      expect(expected_request).to have_been_made
+    end
+  end
+
+  context "when no engine is set:" do
+    before { settings.delete :engine }
+    before { params.delete :engine }
+
+    let(:expected_request) do
+      a_request(:post, path).with do |req|
+        expect(JSON.parse(req.body)).to include "engine" => "Sandbox"
+      end
+    end
+
+    it "uses Sandbox engine in the request" do
+      subject
+      expect(expected_request).to have_been_made
+    end
+  end
+
+  context "without text to translate:" do
+    let(:source_text) { nil }
+
+    it "raises ArgumentError before sending a request" do
+      expect { subject }.to raise_error(ABBYY::Cloud::ArgumentError)
+      expect(a_request(:any, //)).not_to have_been_made
+    end
+  end
+
+  context "with invalid source language:" do
+    let(:source_language) { "1" }
+
+    it "raises ArgumentError before sending a request" do
+      expect { subject }.to raise_error(ABBYY::Cloud::ArgumentError)
+      expect(a_request(:any, //)).not_to have_been_made
+    end
+  end
+
+  context "without source language:" do
+    before { params.delete :from }
+
+    it "raises ArgumentError before sending a request" do
+      expect { subject }.to raise_error(::ArgumentError)
+      expect(a_request(:any, //)).not_to have_been_made
+    end
+  end
+
+  context "with invalid target language:" do
+    let(:target_language) { "1" }
+
+    it "raises ArgumentError before sending a request" do
+      expect { subject }.to raise_error(ABBYY::Cloud::ArgumentError)
+      expect(a_request(:any, //)).not_to have_been_made
+    end
+  end
+
+  context "without target language:" do
+    before { params.delete :to }
+
+    it "raises ArgumentError before sending a request" do
+      expect { subject }.to raise_error(::ArgumentError)
+      expect(a_request(:any, //)).not_to have_been_made
+    end
+  end
+
+  context "when API responded with error:" do
+    before { stub_request(:post, path).to_return status: 500 }
+
+    it "raises ResponseError" do
+      expect { subject }.to raise_error(ABBYY::Cloud::ResponseError)
+    end
+  end
+
+  context "when API returned data without an id:" do
+    let(:response_model) { { translation: "To beat or not to beat" } }
+
+    it "raises TypeError" do
+      expect { subject }.to raise_error(ABBYY::Cloud::TypeError)
+    end
+  end
+
+  context "when API returned data without a translation:" do
+    let(:response_model) { { id: 1 } }
+
+    it "raises TypeError" do
+      expect { subject }.to raise_error(ABBYY::Cloud::TypeError)
+    end
+  end
+end