evil-client 0.3.3 → 1.0.0

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

@@ -1,29 +0,0 @@
-describe Evil::Client::DSL::Operations do
-  let(:operations) { described_class.new }
-  let(:settings) do
-    double(:settings, version: 1, user: "foo", password: "bar")
-  end
-
-  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].call).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

@@ -1,32 +0,0 @@
-RSpec.describe Evil::Client::DSL, ".scope" do
-  before do
-    class Test::Foo
-      extend Evil::Client::DSL
-
-      base_url { "https://example.com" }
-
-      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

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

@@ -1,135 +0,0 @@
-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 "raises" 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/middleware/merge_security_spec.rb

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

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

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

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

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

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