evil-client 0.2.1

data/spec/features/operation_with_documentation_spec.rb

@@ -0,0 +1,41 @@
+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
+      fail
+    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
+      fail
+    end
+  end
+end

data/spec/features/operation_with_files_spec.rb

@@ -0,0 +1,40 @@
+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 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

@@ -0,0 +1,158 @@
+RSpec.describe "operation with form body" 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
+    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 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 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

@@ -0,0 +1,99 @@
+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 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

@@ -0,0 +1,45 @@
+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 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

@@ -0,0 +1,156 @@
+RSpec.describe "operation with json body" 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
+    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 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 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