evil-client 0.3.3 → 1.0.0

data/spec/features/operation_with_documentation_spec.rb

@@ -1,41 +0,0 @@
-RSpec.describe "operation with documentation" do
-  # see Test::Client definition in `/spec/support/test_client.rb`
-  before do
-    class Test::Client < Evil::Client
-      operation do |settings|
-        documentation "https://docs.example.com/v#{settings.version}/index.html"
-        http_method :get
-        path { "data" }
-      end
-
-      operation :clear_data
-      operation :find_data do |settings|
-        documentation "https://docs.example.com/v#{settings.version}/findData"
-      end
-    end
-
-    stub_request(:any, //)
-  end
-
-  let(:client) { Test::Client.new("foo", version: 3, user: "bar") }
-
-  it "displays default documentation in exception messages" do
-    begin
-      client.operations[:clear_data].call
-    rescue => error
-      expect(error.message).to include "https://docs.example.com/v3/index.html"
-    else
-      raise
-    end
-  end
-
-  it "reloads default value with operation-specific one" do
-    begin
-      client.operations[:find_data].call
-    rescue => error
-      expect(error.message).to include "https://docs.example.com/v3/findData"
-    else
-      raise
-    end
-  end
-end

data/spec/features/operation_with_files_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe "operation with files" do
-  # see Test::Client definition in `/spec/support/test_client.rb`
-  before do
-    class Test::Client < Evil::Client
-      operation :example do
-        http_method :get
-        path { "users" }
-        response :success, 200
-
-        files do |file:, **|
-          add file, type: "text/xml", charset: "utf-16", filename: "foo.xml"
-        end
-      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" }
-
-  subject { client.operations[:example].call file: "Hi!" }
-
-  it "builds a multipart body" do
-    request = a_request(:get, path).with do |req|
-      expect(req.body).to include "Content-Disposition: form-data;" \
-                                  ' name="AttachedFile1"; filename="foo.xml"'
-
-      expect(req.body).to include "Content-Type: text/xml; charset=utf-16"
-
-      expect(req.body).to include "Hi!"
-
-      expect(req.headers["Content-Type"]).to include "multipart/form-data"
-    end
-
-    subject
-
-    expect(request).to have_been_made
-  end
-end

data/spec/features/operation_with_form_body_spec.rb

@@ -1,158 +0,0 @@
-RSpec.describe "operation with form body" 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
-    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" }
-  let(:operation) { client.operations[:example] }
-
-  context "without operation-specific definition" do
-    before do
-      class Test::Client < Evil::Client
-        operation do
-          http_method :get
-          path { "users" }
-          response :success, 200
-
-          body format: "form" do
-            attribute :foo
-          end
-        end
-
-        operation :example do
-        end
-      end
-    end
-
-    it "uses the default one" do
-      request = a_request(:get, path).with do |req|
-        expect(req.body).to eq "foo[][bar][]=BAZ"
-        expect(req.headers)
-          .to include "Content-Type" => "application/x-www-form-urlencoded"
-      end
-
-      operation.call foo: [{ bar: [:BAZ] }], baz: :QUX
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "with operation-specific definition" do
-    before do
-      class Test::Client < Evil::Client
-        operation do
-          http_method :get
-          path { "users" }
-          response :success, 200
-
-          body format: "form" do
-            attribute :foo
-          end
-        end
-
-        operation :example do
-          body format: "form" do
-            attribute :baz
-          end
-        end
-      end
-    end
-
-    it "uses the specific one" do
-      request = a_request(:get, path).with body: "baz=QUX"
-
-      operation.call foo: [{ bar: [:BAZ] }], baz: :QUX
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "when appended with files" do
-    before do
-      class Test::Client < Evil::Client
-        operation :example do
-          body format: "form" do
-            attribute :baz
-          end
-
-          files do
-          end
-        end
-      end
-    end
-
-    it "skips body definition" do
-      request = a_request(:get, path).with do |req|
-        expect(req.body).to be_nil
-      end
-
-      operation.call foo: [{ bar: [:BAZ] }], baz: :QUX
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "with a model" do
-    before do
-      class Test::Client < Evil::Client
-        operation :example do
-          body format: "form", model: Test::User do
-            attribute :foo
-          end
-        end
-      end
-    end
-
-    it "extends the model" do
-      request = a_request(:get, path).with body: "name=Andy&foo=BAR"
-
-      operation.call foo: :BAR, name: "Andy"
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "with a model" do
-    before do
-      class Test::Client < Evil::Client
-        operation :example do
-          body format: "form" do
-            attribute :foo, type: Dry::Types["strict.string"]
-            attribute :bar, default: proc { 1 }
-            attribute :baz, optional: true
-          end
-        end
-      end
-    end
-
-    it "requires mandatory arguments" do
-      expect { operation.call bar: 2, baz: 3 }.to raise_error(ArgumentError)
-    end
-
-    it "applies type restrictions" do
-      expect { operation.call foo: :FOO }.to raise_error(TypeError)
-    end
-
-    it "uses default values and skips undefined optional attributes" do
-      request = a_request(:get, path).with body: "foo=BAR&bar=1"
-
-      operation.call foo: "BAR"
-
-      expect(request).to have_been_made
-    end
-  end
-end

data/spec/features/operation_with_headers_spec.rb

@@ -1,99 +0,0 @@
-RSpec.describe "operation with headers" 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" }
-
-        headers do
-          attribute :foo
-          attribute :bar, type: Dry::Types["strict.string"]
-          attribute :baz, optional: true
-        end
-
-        response :success, 200
-      end
-
-      operation :clear_data do
-      end
-
-      operation :get_data do
-        headers
-      end
-
-      operation :find_data do |settings|
-        headers do
-          attribute :foo  if settings.version < 2
-          attribute :bar, type: Dry::Types["coercible.int"]
-        end
-      end
-    end
-
-    stub_request(:any, //)
-  end
-
-  let(:path)   { "https://foo.example.com/api/v3/data" }
-  let(:client) { Test::Client.new("foo", version: 3, user: "bar") }
-
-  it "uses default value" do
-    client.operations[:clear_data].call foo: "FOO", bar: "BAR", baz: "BAZ"
-
-    request = a_request(:get, path) do |req|
-      expect(req.headers).to include "Foo" => "FOO",
-                                     "Bar" => "BAR",
-                                     "Baz" => "BAZ"
-    end
-
-    expect(request).to have_been_made
-  end
-
-  it "ingnores unknown attributes" do
-    client.operations[:clear_data]
-      .call foo: "FOO", bar: "BAR", baz: "BAZ", qux: "QUX"
-
-    request = a_request(:get, path).with do |req|
-      expect(req.headers.keys).not_to include "Qux"
-    end
-
-    expect(request).to have_been_made
-  end
-
-  it "requires mandatory headers" do
-    expect { client.operations[:clear_data].call bar: "BAR", baz: "BAZ" }
-      .to raise_error(ArgumentError)
-  end
-
-  it "applies type constraints" do
-    expect { client.operations[:clear_data].call foo: "FOO", bar: :BAR }
-      .to raise_error(TypeError)
-  end
-
-  it "skips optional headers" do
-    client.operations[:clear_data].call foo: "FOO", bar: "BAR"
-
-    request = a_request(:get, path).with do |req|
-      expect(req.headers.keys).not_to include "Baz"
-    end
-
-    expect(request).to have_been_made
-  end
-
-  it "can undefine default headers" do
-    client.operations[:get_data].call
-
-    expect(a_request(:get, path)).to have_been_made
-  end
-
-  it "can reload default headers for a specific operation" do
-    client.operations[:find_data].call foo: "FOO", bar: "01", baz: "BAZ"
-
-    request = a_request(:get, path).with do |req|
-      expect(req.headers).to include "Bar" => "1"
-      expect(req.headers.keys).not_to include "Foo"
-      expect(req.headers.keys).not_to include "Baz"
-    end
-
-    expect(request).to have_been_made
-  end
-end

data/spec/features/operation_with_http_method_spec.rb

@@ -1,45 +0,0 @@
-RSpec.describe "operation with http_method" do
-  # see Test::Client definition in `/spec/support/test_client.rb`
-  before do
-    class Test::Client < Evil::Client
-      operation do |settings|
-        http_method settings.version > 1 ? :post : :get
-        path { "data" }
-        response :success, 200
-      end
-
-      operation :clear_data do
-        http_method :delete
-      end
-
-      operation :find_data
-
-      operation :reset_data do |settings|
-        http_method settings.version > 2 ? :patch : :put
-      end
-    end
-
-    stub_request(:any, //)
-  end
-
-  let(:path)   { "https://foo.example.com/api/v3/data" }
-  let(:client) { Test::Client.new("foo", version: 3, user: "bar") }
-
-  it "uses default value" do
-    client.operations[:find_data].call
-
-    expect(a_request(:post, path)).to have_been_made
-  end
-
-  it "reloads default value with operation-specific one" do
-    client.operations[:clear_data].call
-
-    expect(a_request(:delete, path)).to have_been_made
-  end
-
-  it "is customizeable by settings" do
-    client.operations[:reset_data].call
-
-    expect(a_request(:patch, path)).to have_been_made
-  end
-end

data/spec/features/operation_with_json_body_spec.rb

@@ -1,156 +0,0 @@
-RSpec.describe "operation with json body" 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
-    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" }
-  let(:operation) { client.operations[:example] }
-
-  context "without operation-specific definition" do
-    before do
-      class Test::Client < Evil::Client
-        operation do
-          http_method :get
-          path { "users" }
-          response :success, 200
-
-          body do
-            attribute :foo
-          end
-        end
-
-        operation :example
-      end
-    end
-
-    it "uses the default one" do
-      request = a_request(:get, path).with do |req|
-        expect(req.body).to eq '{"foo":[{"bar":["BAZ"]}]}'
-        expect(req.headers).to include "Content-Type" => "application/json"
-      end
-
-      operation.call foo: [{ bar: [:BAZ] }], baz: :QUX
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "with operation-specific definition" do
-    before do
-      class Test::Client < Evil::Client
-        operation do
-          http_method :get
-          path { "users" }
-          response :success, 200
-
-          body do
-            attribute :foo
-          end
-        end
-
-        operation :example do
-          body do
-            attribute :baz
-          end
-        end
-      end
-    end
-
-    it "uses the specific one" do
-      request = a_request(:get, path).with body: '{"baz":"QUX"}'
-
-      operation.call foo: [{ bar: [:BAZ] }], baz: :QUX
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "when appended with files" do
-    before do
-      class Test::Client < Evil::Client
-        operation :example do
-          body do
-            attribute :baz
-          end
-
-          files do
-          end
-        end
-      end
-    end
-
-    it "skips body definition" do
-      request = a_request(:get, path).with do |req|
-        expect(req.body).to be_nil
-      end
-
-      operation.call foo: [{ bar: [:BAZ] }], baz: :QUX
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "with a model" do
-    before do
-      class Test::Client < Evil::Client
-        operation :example do
-          body model: Test::User do
-            attribute :foo
-          end
-        end
-      end
-    end
-
-    it "extends the model" do
-      request = a_request(:get, path).with body: '{"name":"Andy","foo":"BAR"}'
-
-      operation.call foo: :BAR, name: "Andy"
-
-      expect(request).to have_been_made
-    end
-  end
-
-  context "with a model" do
-    before do
-      class Test::Client < Evil::Client
-        operation :example do
-          body do
-            attribute :foo, type: Dry::Types["strict.string"]
-            attribute :bar, default: proc { 1 }
-            attribute :baz, optional: true
-          end
-        end
-      end
-    end
-
-    it "requires mandatory arguments" do
-      expect { operation.call bar: 2, baz: 3 }.to raise_error(ArgumentError)
-    end
-
-    it "applies type restrictions" do
-      expect { operation.call foo: :FOO }.to raise_error(TypeError)
-    end
-
-    it "uses default values and skips undefined optional attributes" do
-      request = a_request(:get, path).with body: '{"foo":"BAR","bar":1}'
-
-      operation.call foo: "BAR"
-
-      expect(request).to have_been_made
-    end
-  end
-end