evil-client 0.2.1

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

@@ -0,0 +1,135 @@
+RSpec.describe Evil::Client::DSL::Security do
+  subject { described_class.new(&block).call }
+
+  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 #key_auth using headers:" do
+    let(:block) do
+      proc do
+        key_auth "foo", "bar"
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to eq headers: { "foo" => "bar" }
+    end
+  end
+
+  context "from block with #key_auth using body:" do
+    let(:block) do
+      proc do
+        key_auth "foo", "bar", using: :body
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to eq body: { "foo" => "bar" }
+    end
+  end
+
+  context "from block with #key_auth using query:" do
+    let(:block) do
+      proc do
+        key_auth "foo", "bar", using: :query
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to eq query: { "foo" => "bar" }
+    end
+  end
+
+  context "from block with #key_auth using unknown part:" do
+    let(:block) do
+      proc do
+        key_auth "foo", "bar", using: :unknown
+      end
+    end
+
+    it "fails" do
+      expect { subject }.to raise_error ArgumentError
+    end
+  end
+
+  context "from block with #token_auth using headers:" do
+    let(:block) do
+      proc do
+        token_auth "foo"
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to eq headers: { "authorization" => "foo" }
+    end
+  end
+
+  context "from block with #token_auth with a prefix:" do
+    let(:block) do
+      proc do
+        token_auth "foo", prefix: "Digest"
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to eq headers: { "authorization" => "Digest foo" }
+    end
+  end
+
+  context "from block with #token_auth using body:" do
+    let(:block) do
+      proc do
+        token_auth "foo", using: :body
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to eq body: { "access_token" => "foo" }
+    end
+  end
+
+  context "from block with #token_auth using query:" do
+    let(:block) do
+      proc do
+        token_auth "foo", using: :query
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject).to eq query: { "access_token" => "foo" }
+    end
+  end
+
+  context "from block with #basic_auth:" do
+    let(:block) do
+      proc do
+        basic_auth "foo", "bar"
+      end
+    end
+
+    it "provides a schema" do
+      expect(subject)
+        .to eq headers: { "authorization" => "Basic Zm9vOmJhcg==" }
+    end
+  end
+
+  context "from block with several definitions:" do
+    let(:block) do
+      proc do
+        basic_auth "foo", "bar"
+        token_auth "baz", using: :query
+      end
+    end
+
+    it "provides a full schema" do
+      expect(subject).to eq \
+        headers: { "authorization" => "Basic Zm9vOmJhcg==" },
+        query:   { "access_token" => "baz" }
+    end
+  end
+end

data/spec/unit/evil/client/dsl_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe Evil::Client::DSL do
+  before do
+    class Test::Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        app.call(env).reverse
+      end
+    end
+
+    class Test::Foo
+      extend Evil::Client::DSL
+
+      settings do
+        param  :version,  type: Dry::Types["coercible.int"]
+        option :user,     type: Dry::Types["strict.string"]
+        option :password, type: Dry::Types["strict.string"]
+      end
+
+      base_url do |settings|
+        "https://example.com/v#{settings.version}"
+      end
+
+      connection do |_|
+        run Test::Middleware
+      end
+
+      operation do |settings|
+        security { basic_auth settings.user, settings.password }
+      end
+
+      operation :find_user do |_|
+        path { |id:| "users/#{id}" }
+        http_method :get
+
+        response 200 do |data|
+          data.reverse
+        end
+      end
+    end
+  end
+
+  subject { Test::Foo.finalize(4, user: "foo", password: "bar") }
+
+  it "builds a proper schema" do
+    operation = subject[:operations][:find_user]
+
+    expect(operation[:security].call)
+      .to eq headers: { "authorization" => "Basic Zm9vOmJhcg==" }
+    expect(operation[:path].call(id: 3)).to eq "users/3"
+    expect(operation[:method]).to eq "get"
+
+    expect(operation[:responses][200][:coercer].call "foo").to eq "oof"
+  end
+end

data/spec/unit/evil/client/middleware/merge_security_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Evil::Client::Middleware::MergeSecurity do
+  let(:stack) { described_class.new(app) }
+  let(:app)   { double :app }
+
+  def update!(env)
+    @result = env
+  end
+
+  before  { allow(app).to receive(:call) { |env| update! env } }
+  subject { stack.call env }
+
+  let(:env) do
+    {
+      body:    { "foo" => :FOO, "access_key" => :FOO },
+      query:   { "bar" => :BAR, "access_key" => :FOO },
+      headers: { "baz" => :BAZ, "authorization" => :FOO },
+      security: {
+        body:    { "access_key" => :QUX },
+        query:   { "access_key" => :ZYX },
+        headers: { "authorization" => "Basic 3ou08314tq==" }
+      }
+    }
+  end
+
+  it "merges security schema to env" do
+    subject
+    expect(@result).to eq \
+      body:    { "foo" => :FOO, "access_key" => :QUX },
+      query:   { "bar" => :BAR, "access_key" => :ZYX },
+      headers: { "baz" => :BAZ, "authorization" => "Basic 3ou08314tq==" }
+  end
+end

data/spec/unit/evil/client/middleware/normalize_headers_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Evil::Client::Middleware::NormalizeHeaders do
+  let(:stack) { described_class.new(app) }
+  let(:app)   { double :app }
+  let(:env)   { { headers: { Foo: :BAR } } }
+
+  def update!(env)
+    @result = env
+  end
+
+  before  { allow(app).to receive(:call) { |env| update! env } }
+  subject { stack.call env }
+
+  it "normalizes headers" do
+    subject
+    expect(@result[:headers]).to eq "foo" => "BAR"
+  end
+end

data/spec/unit/evil/client/middleware/stringify_form_spec.rb

@@ -0,0 +1,63 @@
+RSpec.describe Evil::Client::Middleware::StringifyForm do
+  let(:stack) { described_class.new(app) }
+  let(:app)   { double :app }
+
+  def update!(env)
+    @result = env
+  end
+
+  before  { allow(app).to receive(:call) { |env| update! env } }
+  subject { stack.call env }
+
+  context "with a non-empty body:" do
+    let(:env) do
+      {
+        body:   { foo: :FOO, bar: [:BAR], baz: { qux: :QUX }, qux: nil },
+        format: "form"
+      }
+    end
+
+    it "stringifies the body" do
+      subject
+      expect(@result[:body_string]).to eq "foo=FOO&bar[]=BAR&baz[qux]=QUX&qux="
+    end
+
+    it "adds content-type header" do
+      subject
+      expect(@result[:headers])
+        .to eq "content-type" => "application/x-www-form-urlencoded"
+    end
+  end
+
+  context "when format is not a form:" do
+    let(:env) do
+      {
+        body:   { foo: :FOO, bar: [:BAR], baz: { qux: :QUX }, qux: nil },
+        format: "json"
+      }
+    end
+
+    it "does nothing" do
+      subject
+      expect(@result).to eq env
+    end
+  end
+
+  context "with empty body:" do
+    let(:env) { { body: {}, format: "form" } }
+
+    it "does nothing" do
+      subject
+      expect(@result).to eq env
+    end
+  end
+
+  context "without a body:" do
+    let(:env) { { format: "form" } }
+
+    it "does nothing" do
+      subject
+      expect(@result).to eq env
+    end
+  end
+end

data/spec/unit/evil/client/middleware/stringify_json_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe Evil::Client::Middleware::StringifyJson do
+  def update!(result)
+    @result = result
+  end
+
+  let(:app) { double :app }
+
+  before  { allow(app).to receive(:call) { |env| update!(env) } }
+  subject { described_class.new(app).call(env) }
+
+  context "with a body:" do
+    let(:env) { { format: "json", body: { foo: :bar } } }
+
+    it "stringifies a body" do
+      subject
+      expect(@result[:body_string]).to eq '{"foo":"bar"}'
+    end
+
+    it "sets content-type" do
+      subject
+      expect(@result[:headers]).to eq "content-type" => "application/json"
+    end
+  end
+
+  context "when format is not json:" do
+    let(:env) { { format: "form", body: { foo: :bar } } }
+
+    it "does nothing" do
+      subject
+      expect(@result).to eq env
+    end
+  end
+
+  context "with empty body:" do
+    let(:env) { { format: "json", body: {} } }
+
+    it "stringifies an empty body" do
+      subject
+      expect(@result[:body_string]).to eq "{}"
+    end
+
+    it "sets content-type" do
+      subject
+      expect(@result[:headers]).to eq "content-type" => "application/json"
+    end
+  end
+
+  context "without a body:" do
+    let(:env) { { format: "json" } }
+
+    it "stringifies an empty body" do
+      subject
+      expect(@result[:body_string]).to eq "{}"
+    end
+
+    it "sets content-type" do
+      subject
+      expect(@result[:headers]).to eq "content-type" => "application/json"
+    end
+  end
+end

data/spec/unit/evil/client/middleware/stringify_multipart/part_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe Evil::Client::Middleware::StringifyMultipart::Part do
+  let(:file)    { StringIO.new "Hello!" }
+  let(:type)    { MIME::Types["text/html"].first }
+  let(:charset) { "utf-8" }
+  let(:part) do
+    described_class.new(file: file, type: type, charset: charset)
+  end
+
+  subject { part.to_s }
+
+  shared_examples :building_part do
+    it "includes content disposition" do
+      expect(subject).to include \
+        'Content-Disposition: form-data; name="AttachedFile"; filename='
+    end
+
+    it "includes content type" do
+      expect(subject).to include "Content-Type: text/html; charset=utf-8"
+    end
+
+    it "includes content" do
+      expect(subject).to include "Hello!"
+    end
+  end
+
+  context "with a name" do
+    let(:part) { described_class.new(file: file, name: "UploadedFile") }
+
+    it "includes part name" do
+      expect(subject).to include 'name="UploadedFile"'
+    end
+  end
+
+  context "with a filename" do
+    let(:part) { described_class.new(file: file, filename: "weird_thing.json") }
+
+    it "includes part name" do
+      expect(subject).to include 'filename="weird_thing.json"'
+    end
+  end
+
+  context "from file" do
+    let(:file) { instance_double ::File, path: "foo/bar.html", read: "Hello!" }
+    it_behaves_like :building_part
+
+    it "includes filename" do
+      expect(subject).to include 'filename="bar.html"'
+    end
+  end
+
+  context "from io" do
+    it_behaves_like :building_part
+  end
+
+  context "from text" do
+    let(:file) { "Hello!" }
+    it_behaves_like :building_part
+  end
+end

data/spec/unit/evil/client/middleware/stringify_multipart_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe Evil::Client::Middleware::StringifyMultipart do
+  let(:app)  { double :app }
+  let(:type) { "file" }
+  let(:env) do
+    {
+      format:  "multipart",
+      headers: {},
+      files:   [
+        {
+          file:     StringIO.new('{"text":"Hello!"}'),
+          type:     MIME::Types["application/json"].first,
+          charset:  "utf-16",
+          filename: "greetings.json"
+        }
+      ]
+    }
+  end
+
+  def update!(result)
+    @result = result
+  end
+
+  before  { allow(app).to receive(:call) { |env| update!(env) } }
+  subject { described_class.new(app).call(env) }
+
+  context "with a multipart format:" do
+    let(:body_string) { @result[:body_string] }
+
+    it "builds multipart body_string" do
+      subject
+      expect(body_string).to include '{"text":"Hello!"}'
+    end
+
+    it "uses name and filename" do
+      subject
+      expect(body_string).to include "Content-Disposition: form-data;" \
+                                     ' name="AttachedFile1";' \
+                                     ' filename="greetings.json"'
+    end
+
+    it "uses content-type and charset" do
+      subject
+      expect(body_string)
+        .to include "Content-Type: application/json; charset=utf-16"
+    end
+
+    it "adds the header" do
+      subject
+      expect(@result[:headers]["content-type"])
+        .to include "multipart/form-data; boundary="
+    end
+  end
+
+  context "with non-multipart format:" do
+    before { env[:format] = "json" }
+
+    it "does nothing" do
+      subject
+      expect(@result).to eq env
+    end
+  end
+end