evil-client 0.2.1

data/spec/features/operation_with_path_spec.rb

@@ -0,0 +1,47 @@
+RSpec.describe "operation with path" do
+  # see Test::Client definition in `/spec/support/test_client.rb`
+  before do
+    class Test::Client < Evil::Client
+      operation do
+        http_method :get
+        path { "users" }
+        response 200
+      end
+
+      operation :find_users
+
+      operation :find_user do
+        path { |id:, **| "users/#{id}" }
+      end
+
+      operation :login do |settings|
+        path { "login/#{settings.token}" }
+      end
+    end
+
+    stub_request :get, //
+  end
+
+  let(:client) { Test::Client.new "foo", user: "bar", version: 3, token: "baz" }
+
+  it "uses default path" do
+    client.operations[:find_users].call
+
+    expect(a_request(:get, "https://foo.example.com/api/v3/users"))
+      .to have_been_made
+  end
+
+  it "uses request options" do
+    client.operations[:find_user].call(id: 42)
+
+    expect(a_request(:get, "https://foo.example.com/api/v3/users/42"))
+      .to have_been_made
+  end
+
+  it "uses settings" do
+    client.operations[:login].call
+
+    expect(a_request(:get, "https://foo.example.com/api/v3/login/baz"))
+      .to have_been_made
+  end
+end

data/spec/features/operation_with_query_spec.rb

@@ -0,0 +1,84 @@
+RSpec.describe "operation with query" do
+  # see Test::Client definition in `/spec/support/test_client.rb`
+  before do
+    class Test::User < Evil::Client::Model
+      attribute :name
+    end
+
+    class Test::Client < Evil::Client
+      operation do
+        http_method :get
+        path { "users" }
+        response 200
+      end
+
+      operation :filter do
+        query do
+          attribute :age,  type:     Dry::Types["coercible.int"]
+          attribute :male, default:  proc { true }
+          attribute :name, optional: true
+        end
+      end
+
+      operation :search do
+        query model: Test::User
+      end
+    end
+
+    stub_request(:get, //)
+  end
+
+  let(:path)   { "https://foo.example.com/api/v3/users" }
+  let(:client) { Test::Client.new "foo", user: "bar", version: 3, token: "baz" }
+
+  it "provides a query from options ordered by name" do
+    client.operations[:filter].call age: 48, male: false, name: "John"
+
+    expect(a_request(:get, "#{path}?age=48&male=false&name=John"))
+      .to have_been_made
+  end
+
+  it "uses http encoding" do
+    client.operations[:filter].call age: 7, name: "Ян"
+
+    expect(a_request(:get, "#{path}?age=7&male=true&name=%D0%AF%D0%BD"))
+      .to have_been_made
+  end
+
+  it "skips unassigned optional attributes" do
+    client.operations[:filter].call age: 7
+
+    expect(a_request(:get, "#{path}?age=7&male=true")).to have_been_made
+  end
+
+  it "accepts a model" do
+    client.operations[:search].call name: "Joe"
+
+    expect(a_request(:get, "#{path}?name=Joe")).to have_been_made
+  end
+
+  it "ignores unspecified options" do
+    client.operations[:search].call id: 1, name: "Joe"
+
+    expect(a_request(:get, "#{path}?name=Joe")).to have_been_made
+  end
+
+  it "applies type restrictuions" do
+    expect { client.operations[:filter].call id: 1, name: "Joe" }
+      .to raise_error(ArgumentError)
+  end
+
+  it "supports nesting in a Rails style" do
+    client.operations[:search].call name: {
+      "first": "John", last: "Doe", middle: %w(Juan Andre)
+    }
+    query = [
+      "name%5Bfirst%5D=John",
+      "name%5Blast%5D=Doe",
+      "name%5Bmiddle%5D%5B0%5D=Juan",
+      "name%5Bmiddle%5D%5B1%5D=Andre"
+    ].join("&")
+
+    expect(a_request(:get, "#{path}?#{query}")).to have_been_made
+  end
+end

data/spec/features/operation_with_response_spec.rb

@@ -0,0 +1,109 @@
+RSpec.describe "operation with query" do
+  # see Test::Client definition in `/spec/support/test_client.rb`
+  before do
+    class Test::User < Evil::Client::Model
+      attribute :name
+    end
+
+    class Test::Client < Evil::Client
+      operation do
+        http_method :get
+        path { "users" }
+
+        response 200
+      end
+
+      operation :example do
+        response 201 do |body:, header:, response:|
+          [body, header, response]
+        end
+
+        response 404, raise: true
+
+        response 422, raise: true do |body:, header:, response:|
+          [body, header, response]
+        end
+      end
+    end
+  end
+
+  let(:client) { Test::Client.new "foo", user: "bar", version: 3, token: "baz" }
+
+  subject { client.operations[:example].call }
+
+  it "takes default setting" do
+    stub_request(:get, //).to_return status: 200,
+                                     headers: { "Foo" => "BAR" },
+                                     body: "Hi!"
+
+    expect(subject).to be_kind_of Rack::Response
+    expect(subject.headers).to include "foo" => ["BAR"]
+    expect(subject.body).to eq ["Hi!"]
+  end
+
+  it "applies block to coerce data" do
+    stub_request(:get, //).to_return status: 201,
+                                     headers: { "Foo" => "BAR" },
+                                     body: "Hi!"
+
+    body, headers, response = subject
+
+    expect(response.headers).to include "foo" => ["BAR"]
+    expect(response.body).to eq ["Hi!"]
+
+    expect(body).to eq response.body
+    expect(headers).to eq response.headers
+  end
+
+  it "raises ResponseError when necessary" do
+    stub_request(:get, //).to_return status: 404,
+                                     headers: { "Foo" => "BAR" },
+                                     body: "Hi!"
+
+    begin
+      subject
+    rescue Evil::Client::Operation::ResponseError => error
+      expect(error.response).to be_kind_of Rack::Response
+      expect(error.response.headers).to include "foo" => ["BAR"]
+      expect(error.response.body).to eq ["Hi!"]
+    else
+      fail
+    end
+  end
+
+  it "can raise ResponseError with coercion" do
+    stub_request(:get, //).to_return status: 422,
+                                     headers: { "Foo" => "BAR" },
+                                     body: "Hi!"
+
+    begin
+      subject
+    rescue Evil::Client::Operation::ResponseError => error
+      body, headers, response = error.response
+
+      expect(response.headers).to include "foo" => ["BAR"]
+      expect(response.body).to eq ["Hi!"]
+
+      expect(body).to eq response.body
+      expect(headers).to eq response.headers
+    else
+      fail
+    end
+  end
+
+  it "raises UnexpectedResponseError when a status not expected" do
+    stub_request(:get, //).to_return status: 400,
+                                     headers: { "Foo" => "BAR" },
+                                     body: "Hi!"
+
+    begin
+      subject
+    rescue Evil::Client::Operation::UnexpectedResponseError => error
+      expect(error.response).to be_kind_of Rack::Response
+      expect(error.response.headers).to include "foo" => ["BAR"]
+      expect(error.response.body).to eq ["Hi!"]
+    else
+      fail
+    end
+  end
+end

data/spec/features/operation_with_security_spec.rb

@@ -0,0 +1,228 @@
+RSpec.describe "operation with security" do
+  # see Test::Client definition in `/spec/support/test_client.rb`
+  before do
+    class Test::Client < Evil::Client
+      operation do
+        http_method :get
+        path { "data" }
+        response 200
+      end
+    end
+
+    stub_request(:get, //)
+  end
+
+  let(:path) { "https://foo.example.com/api/v3/data" }
+  let(:client) do
+    Test::Client.new "foo",
+                     version:  3,
+                     user:     "bar",
+                     password: "baz",
+                     token:    "qux"
+  end
+
+  subject { client.operations[:example].call }
+
+  context "without operation-specific settings" do
+    before do
+      class Test::Client < Evil::Client
+        operation do |settings|
+          http_method :get
+          path { "data" }
+          response 200
+
+          security do
+            basic_auth settings.user, settings.password
+          end
+        end
+
+        operation :example
+      end
+    end
+
+    it "uses default settings" do
+      request = a_request(:get, path).with do |req|
+        expect(req.headers).to include "Authorization" => "Basic YmFyOmJheg=="
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with basic_auth" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |settings|
+          security { basic_auth settings.user, settings.password }
+        end
+      end
+    end
+
+    it "adds header" do
+      request = a_request(:get, path).with do |req|
+        expect(req.headers).to include "Authorization" => "Basic YmFyOmJheg=="
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with prefixed token_auth in headers" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |settings|
+          security { token_auth settings.token, prefix: "Bearer" }
+        end
+      end
+    end
+
+    it "adds header" do
+      request = a_request(:get, path).with do |req|
+        expect(req.headers).to include "Authorization" => "Bearer qux"
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with token_auth without prefix in headers" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |settings|
+          security { token_auth settings.token }
+        end
+      end
+    end
+
+    it "adds header" do
+      request = a_request(:get, path).with do |req|
+        expect(req.headers).to include "Authorization" => "qux"
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with token_auth in query" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |settings|
+          security { token_auth settings.token, using: :query }
+        end
+      end
+    end
+
+    it "adds options to query" do
+      request = a_request(:get, "#{path}?access_token=qux").with do |req|
+        expect(req.headers.keys).not_to include "Authorization"
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with token_auth in json body" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |settings|
+          security { token_auth settings.token, using: :body }
+          body format: "json"
+        end
+      end
+    end
+
+    it "adds options to body" do
+      request = a_request(:get, path).with do |req|
+        expect(req.body).to eq '{"access_token":"qux"}'
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with token_auth in a plain(form) body" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |settings|
+          security { token_auth settings.token, using: :body }
+          body format: "form"
+        end
+      end
+    end
+
+    it "adds options to body" do
+      request = a_request(:get, path).with do |req|
+        expect(req.body).to eq "access_token=qux"
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with key_auth in headers" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do
+          security { key_auth "fOo", "bAr" }
+        end
+      end
+    end
+
+    it "adds header" do
+      request = a_request(:get, path).with do |req|
+        expect(req.headers).to include "Foo" => "bAr"
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with key_auth in query" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |_settings|
+          security { key_auth :fOo, :bAr, using: :query }
+        end
+      end
+    end
+
+    it "adds options to query" do
+      request = a_request(:get, "#{path}?fOo=bAr")
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+
+  context "with several methods at once" do
+    before do
+      class Test::Client < Evil::Client
+        operation :example do |_settings|
+          security do
+            key_auth   "foo", "bar", using: :query
+            key_auth   "baz", "qux"
+            basic_auth "foo", "bar"
+          end
+        end
+      end
+    end
+
+    it "combines definitions" do
+      request = a_request(:get, "#{path}?foo=bar").with do |req|
+        expect(req.headers).to include "Authorization" => "Basic Zm9vOmJhcg==",
+                                       "Baz" => "qux"
+      end
+
+      subject
+      expect(request).to have_been_made
+    end
+  end
+end