abbyy-cloud 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cababb6c66e2c17fe4b3b8536f61ca2273695712
+  data.tar.gz: aa4eb72f7805fd507c529ffd8fb79d2ad8f3f8dd
+SHA512:
+  metadata.gz: 67a49f25576bbece4ee85226116275642bc5e3b3a1bcf86e4bf0182ee318de16687ef206f43edb59048ceb71151f28138be10d4765f2d8bf600ef7a4b1ecb9da
+  data.tar.gz: 394413929ad8198cde627b12056c8119aefafa2a358e5f93dd59024604eb9d2bb3203a8a524b69b67ffe898d77ece5e917371bf5c3d0e12c72570010806d1eb5

data/.gitignore

@@ -0,0 +1,11 @@
+/*.gem
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/log/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,81 @@
+require: rubocop-rspec
+
+AllCops:
+  Include:
+    - ./Gemfile
+    - ./config.ru
+  Exclude:
+    - db/**/*
+    - config/**/*
+    - script/**/*
+    - bin/*
+    - vendor/**/*
+  TargetRubyVersion: 2.3
+
+RSpec/NamedSubject:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Documentation:
+  Enabled: false
+
+Lint/HandleExceptions:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Lint/RescueException:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Metrics/LineLength:
+  Max: 80
+  Exclude:
+    - spec/**/*_spec.rb
+
+Style/AccessorMethodName:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Style/Alias:
+  Enabled: false # `alias_method` and `alias` have diferent behaviour
+
+Style/FileName:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false # not to be used before migration to Ruby 3+
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/Semicolon:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Style/SingleLineMethods:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - Gemfile
+    - abbyy-cloud.gemspec
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrivialAccessors:
+  Exclude:
+    - spec/**/*_spec.rb

data/.travis.yml

@@ -0,0 +1,17 @@
+---
+sudo:     false
+language: ruby
+cache:    bundler
+script:
+  - bundle exec rspec
+  - bundle exec rubocop
+rvm:
+  - '2.3.0'
+  - ruby-head
+  - jruby-9
+  - jruby-head
+before_install: gem install bundler -v 1.12.5
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+# Specify your gem"s dependencies in abbyy-cloud.gemspec
+gemspec
+
+group :test do
+  gem "pry",        platform: :mri
+  gem "pry-byebug", platform: :mri
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Andrew Kozin (andrew.kozin@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# [WIP] ABBYY::Cloud
+
+[![Gem Version](https://img.shields.io/gem/v/abbyy-cloud.svg?style=flat)][gem]
+[![Build Status](https://img.shields.io/travis/nepalez/abbyy-cloud/master.svg?style=flat)][travis]
+[![Dependency Status](https://img.shields.io/gemnasium/nepalez/abbyy-cloud.svg?style=flat)][gemnasium]
+[![Code Climate](https://img.shields.io/codeclimate/github/nepalez/abbyy-cloud.svg?style=flat)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/nepalez/abbyy-cloud.svg)][inch]
+
+JSON HTTP client to the [ABBYY Cloud API][abbyy-api].
+
+## Setup
+
+The library is available as a gem `abbyy-cloud`.
+
+## Usage
+
+Initialize the client with a corresponding credentials:
+
+```ruby
+CLIENT = ABBYY::Cloud.new(id: "foo", token: "bar")
+```
+
+The only supported API version is `0`. By default the translation engine is set to "Sandbox".
+
+You can set these options explicitly:
+
+```ruby
+CLIENT = ABBYY::Cloud.new id:      "foo",
+                          token:   "bar",
+                          engine:  "Sandbox", # default engine for translations
+                          version: 0          # the only supported version
+```
+
+### Instant Translation
+
+See [the specification](https://api.abbyy.cloud/swagger/ui/index#!/Order/Order_Translate).
+
+```ruby
+result = CLIENT.translate("To be or not to be", from: :en, to: :ru)
+
+result.class       # => ABBYY::Cloud::Translation
+result.translation # => "Быть или не быть"
+result.order_id    # => 2832934
+```
+
+You can specify an engine (different from default):
+
+```ruby
+CLIENT.translate("To be or not to be", from: :en, to: :ru, engine: "Bing")
+```
+
+The method raises an exception in case the cloud responded with error.
+
+```ruby
+error = \
+  begin
+    CLIENT.translate("To be or not to be")
+  rescue ABBYY::Cloud::Error => error
+    error
+  end
+
+error.class  # => ABBYY::Cloud::ResponceError
+error.status # => 400
+error.data.to_h
+# => {
+#   model_state: {},
+#   requiest_id: "string",
+#   error: "error message",
+#   error_description: "some details"
+# }
+
+error.data.error # => "error message"
+# etc.
+```
+
+## Compatibility
+
+[WIP] Compatible to [ABBYY Cloud API v.0][abbyy-api].
+
+Tested under [rubies compatible to MRI 2.3+][rubies] using [RSpec][rspec] 3.0+.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[abbyy-api]: https://api.abbyy.cloud/swagger/ui/index
+[codeclimate]: https://codeclimate.com/github/nepalez/abbyy-cloud
+[gem]: https://rubygems.org/gems/abbyy-cloud
+[gemnasium]: https://gemnasium.com/nepalez/abbyy-cloud
+[github]: https://github.com/nepalez/abbyy-cloud
+[inch]: https://inch-ci.org/github/nepalez/abbyy-cloud
+[rspec]: http://rspec.info/
+[rubies]: .travis.yml
+[travis]: https://travis-ci.org/nepalez/abbyy-cloud

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new :default

data/abbyy-cloud.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |gem|
+  gem.name     = "abbyy-cloud"
+  gem.version  = "0.0.1"
+  gem.authors  = ["Andrew Kozin"]
+  gem.email    = ["andrew.kozin@gmail.com"]
+  gem.summary  = "HTTP client to ABBYY Cloud API"
+  gem.homepage = "https://github.com/nepalez/abbyy-cloud"
+  gem.license  = "MIT"
+
+  gem.files            = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.test_files       = gem.files.grep(/^spec/)
+  gem.extra_rdoc_files = Dir["README.md", "LICENSE", "CHANGELOG.md"]
+  gem.require_paths    = %w(lib)
+
+  gem.required_ruby_version = ">= 2.3.0"
+
+  gem.add_runtime_dependency "dry-initializer", "~> 0.4.0"
+  gem.add_runtime_dependency "dry-struct", "~> 0.0.1"
+  gem.add_runtime_dependency "dry-types", "~> 0.8.0"
+
+  gem.add_development_dependency "bundler", "~> 1.12"
+  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "rspec", "~> 3.0"
+  gem.add_development_dependency "rspec-its", "~> 1.2"
+  gem.add_development_dependency "rubocop-rspec", "~> 1.6"
+  gem.add_development_dependency "webmock", "~> 2.0"
+end

data/lib/abbyy/cloud.rb

@@ -0,0 +1,40 @@
+require "dry-initializer"
+require "dry-struct"
+require "dry-types"
+require "json"
+require "net/http"
+require "net/https"
+
+module ABBYY
+  class Cloud
+    require_relative "cloud/struct"
+    require_relative "cloud/types"
+    require_relative "cloud/response_error"
+    require_relative "cloud/argument_error"
+    require_relative "cloud/type_error"
+    require_relative "cloud/connection"
+    require_relative "cloud/operation"
+    require_relative "cloud/operation/translate"
+
+    include Dry::Initializer.define -> do
+      option :id,      type: Types::AuthId
+      option :token,   type: Types::AuthToken
+      option :version, type: Types::Version, default: proc { 0 }
+      option :engine,  type: Types::Engine,  default: proc { "Sandbox" }
+    end
+
+    def translate(text, from:, to:, **opts)
+      Operation::Translate.new(connection).call source_text:     text,
+                                                source_language: from,
+                                                target_language: to,
+                                                engine:          engine,
+                                                **opts
+    end
+
+    private
+
+    def connection
+      @connection ||= Connection.new(version: version, id: id, token: token)
+    end
+  end
+end

data/lib/abbyy/cloud/argument_error.rb

@@ -0,0 +1,14 @@
+# The exception to be risen when arguments of the operation
+# mismatches ABBYY Cloud API spec
+class ABBYY::Cloud
+  class ArgumentError < ::ArgumentError
+    def initialize(link, arguments, details)
+      super <<-MESSAGE.gsub(/ +\|/, "")
+        |The arguments of operation mismatch ABBYY Cloud API specification
+        |  arguments:     #{arguments}
+        |  specification: #{link}
+        |  details:       #{details}
+      MESSAGE
+    end
+  end
+end

data/lib/abbyy/cloud/connection.rb

@@ -0,0 +1,46 @@
+# Underlying Net::HTTP-based connection responds for sending requests
+# and handling responses depending on their statuses.
+#
+# It validates neither request's, no response's contents.
+# Those are provided by [ABBYY::Cloud::Operation] and its subclasses.
+#
+class ABBYY::Cloud
+  class Connection
+    include Dry::Initializer.define -> do
+      option :version
+      option :id
+      option :token
+    end
+
+    def call(http_method, path, body: nil, headers: nil)
+      uri = root.merge(path).tap { |item| item.scheme = "https" }
+      req = prepare_request(http_method, uri, body.to_h, headers.to_h)
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+        handle_response http.request(req)
+      end
+    end
+
+    private
+
+    def root
+      @root ||= URI("https://api.abbyy.cloud").merge("v#{version}")
+    end
+
+    def prepare_request(http_method, uri, body, headers)
+      Net::HTTP.const_get(http_method.capitalize).new(uri).tap do |req|
+        req.body = body
+        req.basic_auth id, token
+        req["accept-charset"] = "utf-8"
+        req["accept"] = "application/json"
+        req["content-type"] = "application/json"
+        headers.each { |key, value| req[key.to_s] = value }
+      end
+    end
+
+    def handle_response(response)
+      raise ResponseError.new(response) unless response.is_a? Net::HTTPSuccess
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/abbyy/cloud/operation.rb

@@ -0,0 +1,76 @@
+# Base class for specific operations
+# It validates request and response using corresponding structs
+#
+# @abstract
+#
+class ABBYY::Cloud
+  class Operation
+    # Contains helper methods to specify concrete operations
+    class << self
+      include Forwardable
+
+      def http_method(value = nil)
+        @http_method = value.to_s.capitalize if value
+        @http_method || "Post"
+      end
+
+      def path(value = nil)
+        value ? @path = value : @path
+      end
+
+      def link(value = nil)
+        value ? @link = value : @link
+      end
+
+      def request_body(struct = nil, &block)
+        provide_struct :@request_body, struct, &block
+      end
+
+      def response_body(struct = nil, &block)
+        provide_struct :@response_body, struct, &block
+      end
+
+      private
+
+      def provide_struct(variable, struct, &block)
+        if block || instance_variable_get(variable).nil?
+          struct ||= Class.new(Struct).tap { |item| item.instance_eval(&block) }
+          instance_variable_set(variable, struct)
+        else
+          instance_variable_get(variable)
+        end
+      end
+    end
+
+    def_delegators :"self.class",
+                   :link,
+                   :http_method,
+                   :path,
+                   :request_body,
+                   :response_body
+
+    include Dry::Initializer.define -> do
+      param :connection
+    end
+
+    def call(**data)
+      body = prepare_request_body(data)
+      res  = connection.call(http_method, path, body: body)
+      handle_response_body(res)
+    end
+
+    private
+
+    def prepare_request_body(data)
+      request_body[data]
+    rescue => error
+      raise ArgumentError.new(link, data, error.message)
+    end
+
+    def handle_response_body(data)
+      response_body[data].to_h
+    rescue => error
+      raise TypeError.new(link, data, error.message)
+    end
+  end
+end

data/lib/abbyy/cloud/operation/translate.rb

@@ -0,0 +1,21 @@
+class ABBYY::Cloud
+  class Operation
+    class Translate < Operation
+      link "https://api.abbyy.cloud/swagger/ui/index#!/Order/Order_Translate"
+      path "order/mt/sync"
+      http_method "post"
+
+      request_body do
+        attribute :engine,          Types::Engine
+        attribute :source_language, Types::Language
+        attribute :target_language, Types::Language
+        attribute :source_text,     Types::Strict::String
+      end
+
+      response_body do
+        attribute :id,          Types::OrderId
+        attribute :translation, Types::Strict::String
+      end
+    end
+  end
+end

data/lib/abbyy/cloud/response_error.rb

@@ -0,0 +1,26 @@
+# The exception to be risen when ABBYY Cloud API responded with error status.
+# It takes a raw Net::HTTPResponse and extracts all the data returned by API.
+class ABBYY::Cloud
+  class ResponseError < StandardError
+    class Data < Struct
+      attribute :request_id,        Types::Coercible::String.optional
+      attribute :error,             Types::Coercible::String.optional
+      attribute :error_description, Types::Coercible::String.optional
+      attribute :model_state,       Types::Hash.optional
+    end
+
+    attr_reader :status, :data
+
+    def initialize(response)
+      @data   = Data[JSON.parse(response.body)]
+      @status = response.code.to_i
+
+      super <<-MESSAGE.gsub(/ +\|/, "")
+        |ABBYY Cloud API responded to the request {data.request_id} with a status #{status}
+        |  error:       #{data.error}
+        |  description: #{data.error_description}
+        |  model_state: #{data.model_state}
+      MESSAGE
+    end
+  end
+end

data/lib/abbyy/cloud/struct.rb

@@ -0,0 +1,10 @@
+class ABBYY::Cloud::Struct < Dry::Struct
+  def self.[](data)
+    default = schema.keys.each_with_object({}) { |key, hash| hash[key] = nil }
+    actual  = data.to_hash.each_with_object({}) do |(key, val), hash|
+      hash[key.to_sym] = val
+    end
+
+    new default.merge(actual)
+  end
+end

data/lib/abbyy/cloud/type_error.rb

@@ -0,0 +1,14 @@
+# The exception to be risen when ABBYY Cloud API returned data that
+# mismatches the specification
+class ABBYY::Cloud
+  class TypeError < ::TypeError
+    def initialize(link, data, details)
+      super <<-MESSAGE.gsub(/ +\|/, "")
+        |The data returned by ABBYY Cloud API mismatch its specification
+        |  returned data: #{data}
+        |  specification: #{link}
+        |  details:       #{details}
+      MESSAGE
+    end
+  end
+end

data/lib/abbyy/cloud/types.rb

@@ -0,0 +1,15 @@
+module ABBYY::Cloud::Types
+  include Dry::Types.module
+
+  ENGINES  = %w(Sandbox Bing Google Systran).freeze
+  VERSIONS = [0].freeze
+  LANGUAGE = /\A[a-z]{2}(_[A-Z]{2})?\z/
+
+  # Gem-specific primitive types
+  AuthId    = Strict::String
+  AuthToken = Strict::String
+  Engine    = Coercible::String.constrained(included_in: ENGINES)
+  Language  = Strict::String.constrained(format: LANGUAGE)
+  OrderId   = Strict::String
+  Version   = Coercible::Int.constrained(included_in: VERSIONS)
+end

data/spec/abbyy/cloud/connection_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe ABBYY::Cloud::Connection do
+  let(:connection) { described_class.new version: 0, id: "baz", token: "qux" }
+
+  subject do
+    connection.call :post,
+                    "/foo/bar",
+                    body:    { question: "The ultimate question" },
+                    headers: { "X-Receiver": "Universe" }
+  end
+
+  let(:expected_request) do
+    a_request(:post, "https://api.abbyy.cloud/foo/bar") do |req|
+      expect(req.body).to eq(question: "The ultimate question")
+      expect(req.headers).to include "Accept"         => "application/json",
+                                     "Accept-Charset" => "utf-8",
+                                     "Authorization"  => "Basic YmF6OnF1eA==",
+                                     "Content-Type"   => "application/json",
+                                     "Id"             => "baz",
+                                     "Token"          => "qux",
+                                     "X-Receiver"     => "Universe"
+    end
+  end
+
+  context "when a server responded with success:" do
+    before do
+      stub_request(:post, "https://api.abbyy.cloud/foo/bar")
+        .with(basic_auth: %w(baz qux))
+        .to_return status:  200,
+                   headers: { "Content-Type" => "application/json" },
+                   body:    JSON(answer: 42)
+    end
+
+    it "sends the request" do
+      subject
+      expect(expected_request).to have_been_made
+    end
+
+    it "returns the response body" do
+      expect(subject).to eq("answer" => 42)
+    end
+  end
+
+  context "when a server responded with error:" do
+    before do
+      stub_request(:post, "https://api.abbyy.cloud/foo/bar")
+        .with(basic_auth: %w(baz qux))
+        .to_return status:  400,
+                   headers: { "Content-Type" => "application/json" },
+                   body:    JSON(error: "Wrong question")
+    end
+
+    it "fails" do
+      expect { subject }.to raise_error do |error|
+        expect(error).to be_kind_of ABBYY::Cloud::ResponseError
+        expect(error.status).to eq 400
+        expect(error.data.to_h).to include(error: "Wrong question")
+      end
+    end
+  end
+end

data/spec/abbyy/cloud/response_error_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe ABBYY::Cloud::ResponseError do
+  let(:data) do
+    {
+      request_id: "foobar",
+      error: "Unprocessable entity",
+      error_description: "Wrong language",
+      model_state: { "id" => 0, "language" => "en_FR" }
+    }
+  end
+
+  let(:response) do
+    instance_double "Net::HTTPResponse", code: "400", body: JSON(data)
+  end
+
+  subject { described_class.new response }
+
+  it { is_expected.to be_kind_of StandardError }
+  its(:status)     { is_expected.to eq 400 }
+  its("data.to_h") { is_expected.to eq data }
+end

data/spec/abbyy/cloud_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe ABBYY::Cloud do
+  let(:options) { { id: "foo", token: "bar" } }
+  let(:cloud)   { described_class.new options }
+
+  describe ".new" do
+    subject { cloud }
+
+    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" }
+
+    context "with custom engine" do
+      before { options[:engine] = "Google" }
+      its(:engine) { is_expected.to eq "Google" }
+    end
+
+    context "with wrong engine" do
+      before { options[:engine] = "Wrong" }
+
+      it "fails" do
+        expect { subject }.to raise_error(StandardError)
+      end
+    end
+
+    context "without id" do
+      before { options.delete :id }
+
+      it "fails" do
+        expect { subject }.to raise_error(StandardError)
+      end
+    end
+
+    context "without token" do
+      before { options.delete :token }
+
+      it "fails" do
+        expect { subject }.to raise_error(StandardError)
+      end
+    end
+
+    context "with empty id" do
+      before { options[:id] = nil }
+
+      it "fails" do
+        expect { subject }.to raise_error(StandardError)
+      end
+    end
+
+    context "with empty token" do
+      before { options[:token] = nil }
+
+      it "fails" do
+        expect { subject }.to raise_error(StandardError)
+      end
+    end
+  end
+end

data/spec/feature/abbyy/cloud_translate_spec.rb

@@ -0,0 +1,130 @@
+RSpec.describe ABBYY::Cloud, "#translate" do
+  let(:client)          { described_class.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_EN" }
+  let(:source_text)     { "Бить или не бить" }
+  let(:path)            { "https://api.abbyy.cloud/order/mt/sync" }
+  let(:response_status) { 200 }
+  let(:response_model)  { { id: "42", translation: "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.translate source_text, params }
+
+  it "sends a request to ABBYY Cloud API and returns translation as a hash" do
+    expect(subject).to eq response_model
+    expect(a_request(:post, path)).to have_been_made
+  end
+
+  context "without custom engine:" do
+    before { params.delete :engine }
+
+    let(:expected_request) do
+      a_request(:post, path).with do |req|
+        expect(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(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) { "ru_12" }
+
+    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) { "neoru" }
+
+    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
+    let(:response_status) { 400 }
+
+    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

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require "rspec"
+require "rspec/its"
+require "webmock/rspec"
+
+begin
+  require "pry"
+rescue LoadError
+  nil
+end
+
+Bundler.require
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.disable_monkey_patching!
+  config.profile_examples = 10
+  config.order = :random
+
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: abbyy-cloud
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Kozin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 
+email:
+- andrew.kozin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- abbyy-cloud.gemspec
+- lib/abbyy/cloud.rb
+- lib/abbyy/cloud/argument_error.rb
+- lib/abbyy/cloud/connection.rb
+- lib/abbyy/cloud/operation.rb
+- lib/abbyy/cloud/operation/translate.rb
+- lib/abbyy/cloud/response_error.rb
+- lib/abbyy/cloud/struct.rb
+- lib/abbyy/cloud/type_error.rb
+- lib/abbyy/cloud/types.rb
+- spec/abbyy/cloud/connection_spec.rb
+- spec/abbyy/cloud/response_error_spec.rb
+- spec/abbyy/cloud_spec.rb
+- spec/feature/abbyy/cloud_translate_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nepalez/abbyy-cloud
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: HTTP client to ABBYY Cloud API
+test_files:
+- spec/abbyy/cloud/connection_spec.rb
+- spec/abbyy/cloud/response_error_spec.rb
+- spec/abbyy/cloud_spec.rb
+- spec/feature/abbyy/cloud_translate_spec.rb
+- spec/spec_helper.rb