evil-client 0.3.3 → 1.0.0

data/spec/features/operation_with_nested_responses_spec.rb

@@ -1,95 +0,0 @@
-RSpec.describe "operation with nested responses" do
-  # see Test::Client definition in `/spec/support/test_client.rb`
-  before do
-    class Test::User < Evil::Struct
-      attribute :name
-    end
-
-    class Test::Client < Evil::Client
-      operation do
-        http_method :get
-        path { "users" }
-
-        response :success, 200, format: :plain
-      end
-
-      operation :example do
-        responses format: :plain do
-          response :created, 201 do |body|
-            body.to_sym
-          end
-
-          responses raise: true do
-            response :not_found, 404
-
-            response :error, 422 do |body|
-              body.to_sym
-            end
-          end
-        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 eq "Hi!"
-  end
-
-  it "applies block to coerce data" do
-    stub_request(:get, //).to_return status: 201,
-                                     headers: { "Foo" => "BAR" },
-                                     body: "Hi!"
-
-    expect(subject).to eq :Hi!
-  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.data).to eq "Hi!"
-    else
-      raise
-    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
-      expect(error.data).to eq :Hi!
-    else
-      raise
-    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.data).to eq "Hi!"
-    else
-      raise
-    end
-  end
-end

data/spec/features/operation_with_path_spec.rb

@@ -1,47 +0,0 @@
-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    :success, 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

@@ -1,84 +0,0 @@
-RSpec.describe "operation with query" do
-  # see Test::Client definition in `/spec/support/test_client.rb`
-  before do
-    class Test::User < Evil::Struct
-      attribute :name
-    end
-
-    class Test::Client < Evil::Client
-      operation do
-        http_method :get
-        path { "users" }
-        response :success, 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_security_spec.rb

@@ -1,228 +0,0 @@
-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 :success, 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 :success, 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