evil-client 0.3.3 → 1.0.0

data/spec/features/operation/request_spec.rb

@@ -0,0 +1,94 @@
+RSpec.describe "operation request" do
+  before { load "spec/fixtures/test_client.rb" }
+  before { stub_request(:any, //) }
+
+  let(:users) do
+    Test::Client.new(subdomain: "europe", user: "andy", password: "foo")
+                .crm(version: 4)
+                .users
+  end
+
+  shared_examples :valid_client do |details = "properly"|
+    let(:request) { a_request(meth, path).with(body: body, headers: head) }
+
+    it "[builds a request #{details}]" do
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  it_behaves_like :valid_client do
+    subject    { users.fetch id: 87 }
+
+    let(:path) { "https://europe.example.com/crm/v4/users/87" }
+    let(:meth) { :get }
+    let(:body) { nil }
+    let(:head) { { "Content-Type" => "application/json" } }
+  end
+
+  it_behaves_like :valid_client, "using current definition" do
+    subject    { users.filter id: 89 }
+
+    let(:path) { "https://europe.example.com/crm/v4/users" }
+    let(:meth) { :get }
+    let(:body) { nil }
+    let(:head) { { "Content-Type" => "application/json" } }
+  end
+
+  it_behaves_like :valid_client, "with a proper query" do
+    subject    { users.create id: 89, name: "Andy", language: :de }
+
+    let(:path) { "https://europe.example.com/crm/v4/users?language=de" }
+    let(:meth) { :post }
+    let(:body) { '{"name":"Andy"}' }
+    let(:head) do
+      {
+        "Authorization" => "Basic YW5keTpmb28=",
+        "Content-Type"  => "application/json"
+      }
+    end
+  end
+
+  it_behaves_like :valid_client, "with a proper query" do
+    subject    { users.create id: 89, name: "Andy", language: :de }
+
+    let(:path) { "https://europe.example.com/crm/v4/users?language=de" }
+    let(:meth) { :post }
+    let(:body) { '{"name":"Andy"}' }
+    let(:head) do
+      {
+        "Authorization" => "Basic YW5keTpmb28=",
+        "Content-Type"  => "application/json"
+      }
+    end
+  end
+
+  it_behaves_like :valid_client, "using current settings" do
+    subject    { users.update id: 89, name: "Joe", language: "it" }
+
+    let(:path) { "https://europe.example.com/crm/v4/users/89?language=it" }
+    let(:meth) { :patch }
+    let(:body) { '{"name":"Joe"}' }
+    let(:head) { {} }
+    let(:head) do
+      {
+        "Authorization" => "Basic YW5keTpmb28=",
+        "Content-Type"  => "application/json"
+      }
+    end
+  end
+
+  it_behaves_like :valid_client, "using reloaded settings" do
+    subject    { users.update id: 89, name: "Joe", language: "it", version: 0 }
+
+    let(:path) { "https://europe.example.com/crm/v0/users/89?language=it" }
+    let(:meth) { :put }
+    let(:body) { "name=Joe" }
+    let(:head) do
+      {
+        "Authorization" => "Basic YW5keTpmb28=",
+        "Content-Type"  => "application/x-www-form-urlencoded"
+      }
+    end
+  end
+end

data/spec/features/operation/response_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe "operation request" do
+  before do
+    load "spec/fixtures/test_client.rb"
+    stub_request(:any, //)
+      .to_return(status: status, body: raw_body, headers: {})
+  end
+
+  let(:status)   { 200 }
+  let(:raw_body) { '{"id":3,"name":"andy"}' }
+  let(:users) do
+    Test::Client.new(subdomain: "europe", user: "andy", password: "foo")
+                .crm(version: 4)
+                .users
+  end
+
+  shared_examples :valid_client do |details = "properly"|
+    it "[processes a response #{details}]" do
+      expect(subject).to eq response
+    end
+  end
+
+  it_behaves_like :valid_client do
+    subject { users.fetch(id: 3) }
+    let(:response) { [200, {}, [raw_body]] }
+  end
+
+  it_behaves_like :valid_client, "using operation-specific handler" do
+    subject { users.filter(id: 3) }
+    let(:response) { [{ "id" => 3, "name" => "andy" }] }
+  end
+
+  context "when handler raises an exception" do
+    let(:status) { 404 }
+
+    it "raises the original exception" do
+      expect { users.fetch(id: 3) }.to raise_error RuntimeError, /Not found/
+    end
+  end
+
+  context "when server responded with unexpected status" do
+    let(:status) { 403 }
+
+    it "raises Evil::Client::ResponseError" do
+      expect { users.fetch(id: 3) }
+        .to raise_error Evil::Client::ResponseError, /403/
+    end
+  end
+end

data/spec/features/scope/options_spec.rb

@@ -0,0 +1,52 @@
+RSpec.describe "scope options" do
+  before { load "spec/fixtures/test_client.rb" }
+
+  let(:params) { { subdomain: "europe", user: "andy", token: "foo", foo: 0 } }
+  let(:client) { Test::Client.new(params) }
+  let(:crm)    { client.crm(version: 4) }
+
+  shared_examples :valid_client do |details = "properly"|
+    it "[assigns scope options #{details}]" do
+      expect(subject.options).to eq options
+    end
+  end
+
+  it_behaves_like :valid_client, "with defined options" do
+    subject { crm.users }
+    let(:options) do
+      { subdomain: "europe", user: "andy", token: "foo", version: 4 }
+    end
+  end
+
+  it_behaves_like :valid_client, "with reloaded scope options" do
+    subject { crm.users(version: 8) }
+    let(:options) do
+      { subdomain: "europe", user: "andy", token: "foo", version: 8 }
+    end
+  end
+
+  it_behaves_like :valid_client, "with reloaded root options" do
+    subject { crm.users(user: "leo") }
+    let(:options) do
+      { subdomain: "europe", user: "leo", token: "foo", version: 4 }
+    end
+  end
+
+  context "when required options missed" do
+    subject { client.crm }
+
+    it "raises Evil::Client::ValidationError" do
+      expect { subject }
+        .to raise_error Evil::Client::ValidationError, /version/
+    end
+  end
+
+  context "when some validation failed" do
+    subject { crm.users(token: nil) }
+
+    it "raises Evil::Client::ValidationError" do
+      expect { subject }
+        .to raise_error Evil::Client::ValidationError, /token/
+    end
+  end
+end

data/spec/fixtures/locales/en.yml

@@ -0,0 +1,16 @@
+---
+en:
+  evil:
+    client:
+      errors:
+        test/api:
+          users:
+            update:
+              token_present: "To update user id:%{id} you must provide a token"
+              name_present:  "The user has no name"
+        test/client:
+          valid_credentials: You should set either token or password to authenticate the client
+          crm:
+            users:
+              filter:
+                  filter_given: You should define some filter with either name, email, or id

data/spec/fixtures/test_client.rb

@@ -0,0 +1,76 @@
+module Test
+  class Client < Evil::Client
+    option :subdomain
+    option :user
+    option :token,    optional: true
+    option :password, optional: true
+    validate(:valid_credentials) { token.nil? ^ password.nil? }
+
+    path { "https://#{subdomain}.example.com" }
+
+    response(200)
+    response(404) { raise "Not found" }
+    response(500) { raise "Server error" }
+
+    scope :crm do
+      option :version, defaul: proc { 1 }
+      format { version.to_i > 2 ? :json : :form }
+      path   { "crm/v#{version}" }
+
+      scope :users do
+        path "users"
+
+        operation :filter do
+          option :name,  optional: true
+          option :id,    optional: true
+          option :email, optional: true
+
+          validate(:filter_given) { name || id || email }
+
+          http_method   :get
+          response(200) { |*res| res.last.flat_map { |item| JSON.parse(item) } }
+        end
+
+        operation :fetch do
+          option :id
+
+          path        { id }
+          http_method :get
+        end
+
+        operation :create do
+          option :name
+          option :language
+          option :email, optional: true
+
+          http_method :post
+          security    { token ? token_auth(token) : basic_auth(user, password) }
+          body        { options.select { |k| %i[name email].include? k } }
+          query       { { language: language } }
+          response    201
+        end
+
+        operation :update do
+          option :id
+          option :name
+          option :language
+          option :email, optional: true
+
+          path        { id }
+          http_method { version > 2 ? :patch : :put }
+          security    { token ? token_auth(token) : basic_auth(user, password) }
+          body        { options.select { |k| %i[name email].include? k } }
+          query       { { language: language } }
+        end
+
+        operation :drop do
+          option :id
+
+          path        { id }
+          http_method { :delete }
+          security    { token ? token_auth(token) : basic_auth(user, password) }
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,20 +4,32 @@ rescue LoadError
   nil
 end
 
-require "evil/client"
-require "dry-types"
+require "bundler/setup"
 require "webmock/rspec"
+require "rspec/its"
+require "timecop"
+require "evil/client"
+require "evil/client/rspec"
+
+require_relative "support/fixtures_helper"
 
 RSpec.configure do |config|
   config.order = :random
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
 
-  # Prepare the Test namespace for constants defined in specs
-  config.around(:each) do |example|
+  config.before(:each) do
+    # Stub all requests using webmock
     stub_request(:any, //)
-    load File.expand_path("../support/test_client.rb", __FILE__)
-    example.run
+    # Prepare the Test namespace for constants defined in specs
+    module Test; end
+    # Load translations
+    en_translations = yaml_fixture_file "locales/en.yml"
+    I18n.available_locales = %i[en]
+    I18n.backend.store_translations :en, en_translations["en"]
+  end
+
+  config.after(:each) do
     Object.send :remove_const, :Test
   end
 end

data/spec/support/fixtures_helper.rb

@@ -0,0 +1,7 @@
+def fixture_file_path(filename)
+  File.expand_path "spec/fixtures/#{filename}"
+end
+
+def yaml_fixture_file(filename)
+  YAML.load_file(fixture_file_path(filename))
+end

data/spec/unit/builder/operation_spec.rb

@@ -0,0 +1,90 @@
+RSpec.describe Evil::Client::Builder::Operation do
+  let(:builder) { described_class.new schema, parent }
+  let(:options) { { id: 83, password: "qux", age: 38 } }
+  let(:parent)  { double :parent, options: { user: "foo", password: "bar" } }
+  let(:schema)  { double :schema, name: "fetch", settings: settings }
+
+  let(:settings) do
+    Class.new(Evil::Client::Settings) do
+      option :id
+      option :user
+      option :password
+    end
+  end
+
+  describe "#to_s" do
+    subject { builder.to_s }
+
+    it "represents the builder in a human-friendly manner" do
+      expect(subject).to eq "#[Double :parent].operations[:fetch]"
+    end
+  end
+
+  describe "#to_str" do
+    subject { builder.to_str }
+
+    it "represents the builder in a human-friendly manner" do
+      expect(subject).to eq "#[Double :parent].operations[:fetch]"
+    end
+  end
+
+  describe "#inspect" do
+    subject { builder.inspect }
+
+    it "represents the builder in a human-friendly manner" do
+      expect(subject).to eq "#[Double :parent].operations[:fetch]"
+    end
+  end
+
+  describe "#schema" do
+    subject { builder.schema }
+
+    it "refers to the wrapped schema" do
+      expect(subject).to eq schema
+    end
+  end
+
+  describe "#parent" do
+    subject { builder.parent }
+
+    it "refers to wrapped parent" do
+      expect(subject).to eq parent
+    end
+  end
+
+  describe "#new" do
+    subject { builder.new options }
+
+    it "creates operation with inherited options accepted by settings" do
+      expect(subject).to be_a Evil::Client::Container::Operation
+      expect(subject.schema).to eq schema
+      expect(subject.options).to eq id: 83, user: "foo", password: "qux"
+    end
+  end
+
+  describe "#call" do
+    let(:operation) { double call: "success" }
+
+    before  { allow(builder).to receive(:new) { operation } }
+    subject { builder.call options }
+
+    it "builds and calls the operation at once" do
+      expect(builder).to receive(:new).with options
+      expect(operation).to receive(:call)
+      expect(subject).to eq "success"
+    end
+  end
+
+  describe "#[]" do
+    let(:operation) { double call: "success" }
+
+    before  { allow(builder).to receive(:new) { operation } }
+    subject { builder[options] }
+
+    it "is an alias for #call" do
+      expect(builder).to receive(:new).with options
+      expect(operation).to receive(:call)
+      expect(subject).to eq "success"
+    end
+  end
+end

data/spec/unit/builder/scope_spec.rb

@@ -0,0 +1,84 @@
+RSpec.describe Evil::Client::Builder::Scope do
+  let(:builder) { described_class.new schema, parent }
+  let(:options) { { id: 83, password: "qux", age: 38 } }
+  let(:parent)  { double :parent, options: { user: "foo", password: "bar" } }
+  let(:schema)  { double :schema, name: "fetch", settings: settings }
+
+  let(:settings) do
+    Class.new(Evil::Client::Settings) do
+      option :id
+      option :user
+      option :password
+    end
+  end
+
+  describe "#to_s" do
+    subject { builder.to_s }
+
+    it "represents the builder in a human-friendly manner" do
+      expect(subject).to eq "#[Double :parent].scopes[:fetch]"
+    end
+  end
+
+  describe "#to_str" do
+    subject { builder.to_str }
+
+    it "represents the builder in a human-friendly manner" do
+      expect(subject).to eq "#[Double :parent].scopes[:fetch]"
+    end
+  end
+
+  describe "#inspect" do
+    subject { builder.inspect }
+
+    it "represents the builder in a human-friendly manner" do
+      expect(subject).to eq "#[Double :parent].scopes[:fetch]"
+    end
+  end
+
+  describe "#schema" do
+    subject { builder.schema }
+
+    it "refers to the wrapped schema" do
+      expect(subject).to eq schema
+    end
+  end
+
+  describe "#parent" do
+    subject { builder.parent }
+
+    it "refers to wrapped parent" do
+      expect(subject).to eq parent
+    end
+  end
+
+  describe "#new" do
+    subject { builder.new options }
+
+    it "creates scope with inherited options accepted by settings" do
+      expect(subject).to be_a Evil::Client::Container::Scope
+      expect(subject.schema).to eq schema
+      expect(subject.options).to eq id: 83, user: "foo", password: "qux"
+    end
+  end
+
+  describe "#call" do
+    subject { builder.call options }
+
+    it "creates scope with inherited options accepted by settings" do
+      expect(subject).to be_a Evil::Client::Container::Scope
+      expect(subject.schema).to eq schema
+      expect(subject.options).to eq id: 83, user: "foo", password: "qux"
+    end
+  end
+
+  describe "#[]" do
+    subject { builder[options] }
+
+    it "creates scope with inherited options accepted by settings" do
+      expect(subject).to be_a Evil::Client::Container::Scope
+      expect(subject.schema).to eq schema
+      expect(subject.options).to eq id: 83, user: "foo", password: "qux"
+    end
+  end
+end