evil-client 0.2.1

data/spec/features/scoping_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe "scoping" do
+  # see Test::Client definition in `/spec/support/test_client.rb`
+  before do
+    class Test::Client < Evil::Client
+      operation :update_user do
+        http_method :put
+        path { |id:, **| "users/#{id}" }
+
+        query do
+          attribute :token
+        end
+
+        body format: :form do
+          attribute :name
+        end
+
+        response 200
+      end
+
+      scope do
+        param :token
+
+        scope :users do
+          scope do
+            param :id
+
+            def update(name:)
+              operations[:update_user].call(id: id, token: token, name: name)
+            end
+          end
+        end
+      end
+    end
+
+    stub_request(:put, //)
+  end
+
+  let(:path) { "https://foo.example.com/api/v3/users/7?token=qux" }
+  let(:client) do
+    Test::Client.new "foo", version: 3, user: "bar"
+  end
+
+  it "provides access to params over nested scopes" do
+    client["qux"].users[7].update name: "baz"
+
+    expect(a_request(:put, path).with body: "name=baz").to have_been_made
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+begin
+  require "pry"
+rescue LoadError
+  nil
+end
+
+require "evil/client"
+require "dry-types"
+require "webmock/rspec"
+
+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|
+    stub_request(:any, //)
+    load File.expand_path("../support/test_client.rb", __FILE__)
+    example.run
+    Object.send :remove_const, :Test
+  end
+end

data/spec/support/test_client.rb

@@ -0,0 +1,15 @@
+module Test
+  class Client < Evil::Client
+    settings do
+      param  :subdomain, type: Dry::Types["strict.string"]
+      option :version,   type: Dry::Types["coercible.int"], default: proc { 1 }
+      option :user,      type: Dry::Types["strict.string"]
+      option :password,  type: Dry::Types["coercible.string"], optional: true
+      option :token,     type: Dry::Types["coercible.string"], optional: true
+    end
+
+    base_url do |settings|
+      "https://#{settings.subdomain}.example.com/api/v#{settings.version}/"
+    end
+  end
+end

data/spec/unit/evil/client/connection/net_http_spec.rb

@@ -0,0 +1,38 @@
+require "evil/client/connection/net_http"
+
+describe Evil::Client::Connection::NetHTTP do
+  let(:uri)        { URI("https://example.com/foo/") }
+  let(:connection) { described_class.new(uri) }
+  let(:env) do
+    {
+      http_method:  "post",
+      path:         "bar/baz",
+      headers:      { "Content-Type": "text/plain", "Accept": "text/plain" },
+      body_string:  "Check!",
+      query_string: "status=new"
+    }
+  end
+
+  before do
+    stub_request(:post, "https://example.com/foo/bar/baz?status=new")
+      .to_return status:  201,
+                 body:    "Success!",
+                 headers: { "Content-Type" => "text/plain; charset: utf-8" }
+  end
+
+  subject { connection.call env }
+
+  it "sends a request" do
+    subject
+    expect(a_request(:post, "https://example.com/foo/bar/baz?status=new"))
+      .to have_been_made
+  end
+
+  it "returns rack-compatible response" do
+    expect(subject).to eq [
+      201,
+      { "content-type" => ["text/plain; charset: utf-8"] },
+      ["Success!"]
+    ]
+  end
+end

data/spec/unit/evil/client/dsl/files_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Evil::Client::DSL::Files do
+  subject do
+    described_class.new(&block).call file:     "Hi!",
+                                     charset:  "utf-16",
+                                     type:     "application/json",
+                                     filename: "greetings.json",
+                                     text:     "Hoorah!"
+  end
+
+  context "from block without definitions:" do
+    let(:block) { proc {} }
+
+    it "provides an empty schema" do
+      expect(subject).to eq([])
+    end
+  end
+
+  context "from block with definitions:" do
+    let(:block) do
+      proc do |file:, **opts|
+        add file, **opts
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to be_a Array
+      expect(subject.count).to eq 1
+
+      item = subject.first
+      expect(item[:file]).to be_a StringIO
+      expect(item[:file].read).to eq "Hi!"
+      expect(item[:type]).to eq MIME::Types["application/json"].first
+      expect(item[:charset]).to eq "utf-16"
+      expect(item[:filename]).to eq "greetings.json"
+    end
+  end
+end

data/spec/unit/evil/client/dsl/operation_spec.rb

@@ -0,0 +1,233 @@
+RSpec.describe Evil::Client::DSL::Operation do
+  let(:operation) { described_class.new(:some_operation, block) }
+  let(:settings)  { double version: 3, user: "foo", password: "bar" }
+
+  subject { operation.finalize(settings) }
+
+  context "without definitions" do
+    let(:block) { proc {} }
+    it "returns a hash" do
+      expect(subject).to eq key: :some_operation, responses: {}
+    end
+  end
+
+  context "with #documentation" do
+    let(:block) do
+      proc { |settings| documentation "https://foo.bar/v#{settings.version}" }
+    end
+
+    it "defines link to :doc" do
+      expect(subject[:doc]).to eq "https://foo.bar/v3"
+    end
+  end
+
+  context "with #http_method" do
+    let(:block) do
+      proc { |settings| http_method settings.version > 2 ? "post" : "get" }
+    end
+
+    it "defines :method" do
+      expect(subject[:method]).to eq "post"
+    end
+  end
+
+  context "with #path" do
+    let(:block) do
+      proc do |settings|
+        path { |id:, **| "/v#{settings.version}/users/#{id}/" }
+      end
+    end
+
+    it "defines :path without trailing slashes" do
+      path = subject[:path]
+      expect(path).to be_kind_of Proc
+      expect(path.call(id: 55)).to eq "v3/users/55"
+    end
+  end
+
+  context "with #files" do
+    let(:block) do
+      proc do
+        files do |file:, **options|
+          add file, **options
+        end
+      end
+    end
+
+    it "sets format to file" do
+      expect(subject[:format]).to eq "multipart"
+    end
+
+    it "defines schema for a file" do
+      file = Tempfile.new
+
+      schema = subject[:files].call file:     file,
+                                    type:     "text/html",
+                                    charset:  "utf-16"
+
+      expect(schema).to contain_exactly \
+        file:     file,
+        type:     MIME::Types["text/html"].first,
+        charset:  "utf-16",
+        filename: nil
+    end
+
+    it "wraps string to StringIO" do
+      schema = subject[:files].call file: "Hello!"
+      file = schema.first[:file]
+
+      expect(file).to be_kind_of StringIO
+      expect(file.read).to eq "Hello!"
+    end
+  end
+
+  context "with #security" do
+    let(:block) do
+      proc do |settings|
+        security do
+          basic_auth settings.user, settings.password
+        end
+      end
+    end
+
+    it "defines :security schema" do
+      expect(subject[:security].call)
+        .to eq headers: { "authorization" => "Basic Zm9vOmJhcg==" }
+    end
+  end
+
+  context "with #body" do
+    context "with block without :model" do
+      let(:block) do
+        proc do |_|
+          body do
+            attribute :foo
+            attribute :bar
+          end
+        end
+      end
+
+      it "sets format to json" do
+        expect(subject[:format]).to eq "json"
+      end
+
+      it "defines :block as model filter" do
+        model = subject[:body][foo: :FOO, bar: :BAR, baz: :BAZ]
+        expect(model).to eq foo: :FOO, bar: :BAR
+      end
+    end
+
+    context "with :model without block" do
+      before do
+        class Test::Foo < Evil::Client::Model
+          attribute :qux
+        end
+      end
+
+      let(:block) do
+        proc do |_|
+          body model: Test::Foo
+        end
+      end
+
+      it "defines :block as model filter" do
+        model = subject[:body][foo: :FOO, bar: :BAR, qux: :QUX, baz: :BAZ]
+        expect(model).to eq qux: :QUX
+      end
+    end
+
+    context "with :model and block" do
+      before do
+        class Test::Foo < Evil::Client::Model
+          attribute :qux
+        end
+      end
+
+      let(:block) do
+        proc do |_|
+          body model: Test::Foo do
+            attribute :foo
+            attribute :bar
+          end
+        end
+      end
+
+      it "defines :block as model filter" do
+        model = subject[:body][foo: :FOO, bar: :BAR, qux: :QUX, baz: :BAZ]
+        expect(model).to eq foo: :FOO, bar: :BAR, qux: :QUX
+      end
+    end
+  end
+
+  context "with #query" do
+    before do
+      class Test::Foo < Evil::Client::Model
+        attribute :qux
+      end
+    end
+
+    let(:block) do
+      proc do |settings|
+        query model: Test::Foo do
+          attribute settings.user
+          attribute :bar
+        end
+      end
+    end
+
+    it "defines :block as model filter" do
+      model = subject[:query][foo: :FOO, bar: :BAR, qux: :QUX, baz: :BAZ]
+      expect(model).to eq foo: :FOO, bar: :BAR, qux: :QUX
+    end
+  end
+
+  context "with #headers" do
+    before do
+      class Test::Foo < Evil::Client::Model
+        attribute :qux
+      end
+    end
+
+    let(:block) do
+      proc do |settings|
+        headers model: Test::Foo do
+          attribute settings.user
+          attribute :bar
+        end
+      end
+    end
+
+    it "defines :block as model filter" do
+      model = subject[:headers][foo: :FOO, bar: :BAR, qux: :QUX, baz: :BAZ]
+      expect(model).to eq foo: :FOO, bar: :BAR, qux: :QUX
+    end
+  end
+
+  context "with #response" do
+    let(:block) do
+      proc do |_|
+        response 200 do |value|
+          value.to_sym
+        end
+
+        response 404, raise: true do |value|
+          value.to_s
+        end
+
+        response 500, raise: true
+      end
+    end
+
+    it "defines :responses" do
+      responses = subject[:responses]
+
+      expect(responses[200]).to include raise: false
+      expect(responses[404]).to include raise: true
+      expect(responses[500]).to include raise: true
+
+      expect(responses[200][:coercer]["foo"]).to eq :foo
+      expect(responses[404][:coercer][:foo]).to eq "foo"
+      expect(responses[500][:coercer][response: :foo]).to eq :foo
+    end
+  end
+end

data/spec/unit/evil/client/dsl/operations_spec.rb

@@ -0,0 +1,27 @@
+describe Evil::Client::DSL::Operations do
+  let(:operations) { described_class.new }
+  let(:settings)   { double(:settings, version: 1, user: "foo", password: "bar") }
+
+  before do
+    operations.register(nil) do |settings|
+      http_method :post
+      security    { basic_auth settings.user, settings.password }
+    end
+
+    operations.register(:find_user) do |_|
+      http_method :get
+      path        { |id:, **| "/users/#{id}" }
+    end
+  end
+
+  subject { operations.finalize(settings) }
+
+  it "builds a proper schema" do
+    find_user = subject[:find_user]
+
+    expect(find_user[:method]).to eq "get"
+    expect(find_user[:path].call(id: 7)).to eq "users/7"
+    expect(find_user[:security].call)
+      .to eq headers: { "authorization" => "Basic Zm9vOmJhcg==" }
+  end
+end

data/spec/unit/evil/client/dsl/scope_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Evil::Client::DSL, ".scope" do
+  before do
+    class Test::Foo
+      extend Evil::Client::DSL
+
+      scope :foo do
+        param :bar
+
+        scope do
+          param :baz
+
+          def find
+            qux(bar: bar, baz: baz)
+          end
+        end
+      end
+
+      def qux(bar:, baz:)
+        "#{bar}/#{baz}"
+      end
+    end
+  end
+
+  let(:client) { Test::Foo.new }
+  subject { client.foo("users")[54].find }
+
+  it "provides access to params and methods via nested scopes" do
+    expect(subject).to eq "users/54"
+  end
+end