evil-client 0.3.3 → 1.0.0

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

@@ -1,40 +0,0 @@
-RSpec.describe Evil::Client::Middleware::StringifyQuery 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 query:" do
-    let(:env) do
-      { query: { foo: :FOO, bar: [:BAR], baz: { qux: :QUX }, qux: nil } }
-    end
-
-    it "stringifies the query" do
-      subject
-      expect(@result[:query_string]).to eq "foo=FOO&bar[]=BAR&baz[qux]=QUX&qux="
-    end
-  end
-
-  context "with empty query:" do
-    let(:env) { { query: {} } }
-
-    it "does nothing" do
-      subject
-      expect(@result).to eq env
-    end
-  end
-
-  context "without a query:" do
-    let(:env) { {} }
-
-    it "does nothing" do
-      subject
-      expect(@result).to eq env
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-RSpec.describe Evil::Client::Middleware do
-  before do
-    class Test::Bar
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        @app.call(env) << " bar"
-      end
-    end
-
-    class Test::Baz
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        @app.call(env) << " baz"
-      end
-    end
-  end
-
-  let(:connection) do
-    double(:connection).tap do |conn|
-      allow(conn).to receive(:call) { |value| value << " foo" }
-    end
-  end
-
-  let(:middleware) do
-    described_class.new do |settings|
-      run Test::Baz if settings.baz
-      run Test::Bar
-    end
-  end
-
-  it "builds full stack parameterized by settings" do
-    settings = double baz: false
-    response = middleware.finalize(settings).call(connection).call("qux")
-    expect(response).to eq "qux foo bar"
-
-    settings = double baz: true
-    response = middleware.finalize(settings).call(connection).call("qux")
-    expect(response).to eq "qux foo bar baz"
-  end
-end

data/spec/unit/evil/client/operation/request_spec.rb

@@ -1,49 +0,0 @@
-RSpec.describe Evil::Client::Operation::Request do
-  before do
-    class Test::Body < Evil::Struct
-      attribute :foo
-    end
-
-    class Test::Query < Evil::Struct
-      attribute :bar
-    end
-
-    class Test::Headers < Evil::Struct
-      attribute :baz
-    end
-  end
-
-  let(:request) { described_class.new(schema) }
-  let(:file)    { StringIO.new "Hi!" }
-  let(:schema) do
-    {
-      format:   "multipart",
-      method:   proc { "patch" },
-      path:     proc { |id:, **| "users/#{id}" },
-      files:    Evil::Client::DSL::Files.new { |file:, **| add file },
-      security: Evil::Client::DSL::Security.new { basic_auth "qux", "abc" },
-      query:    Test::Query,
-      body:     Test::Body,
-      headers:  Test::Headers
-    }
-  end
-
-  subject { request.build file: file, foo: :FOO, bar: :BAR, baz: :BAZ, id: 1 }
-
-  it "builds final request env" do
-    expect(subject).to eq \
-      format:      "multipart",
-      http_method: "patch",
-      path:        "users/1",
-      security: { headers: { "authorization" => "Basic cXV4OmFiYw==" } },
-      files:    [{
-        file:     file,
-        type:     MIME::Types["text/plain"].first,
-        charset:  "utf-8",
-        filename: nil
-      }],
-      query:   { bar: :BAR },
-      body:    { foo: :FOO },
-      headers: { baz: :BAZ }
-  end
-end

data/spec/unit/evil/client/operation/response_spec.rb

@@ -1,63 +0,0 @@
-RSpec.describe Evil::Client::Operation::Response do
-  let(:response) { [status, {}, ["foo"]] }
-  let(:schema) do
-    {
-      key: :find_user,
-      doc: "http://example.com/users",
-      responses: {
-        success: {
-          status:  200,
-          coercer: proc { |body| body.upcase.to_sym },
-          raise:   false
-        },
-        error: {
-          status:  400,
-          coercer: proc { |body| body.upcase.to_sym },
-          raise:   true
-        }
-      }
-    }
-  end
-
-  subject { described_class.new(schema).handle(response) }
-
-  context "when response status should not cause an exception:" do
-    let(:status) { 200 }
-
-    it "returns coerced body" do
-      expect(subject).to eq :FOO
-    end
-  end
-
-  context "when response status should cause an exception:" do
-    let(:status) { 400 }
-
-    it "raises ResponseError with coerced response" do
-      begin
-        subject
-      rescue Evil::Client::Operation::ResponseError => error
-        expect(error.message).to include "find_user"
-        expect(error.data).to eq :FOO
-      else
-        raise
-      end
-    end
-  end
-
-  context "when response status is unknown:" do
-    let(:status) { 404 }
-
-    it "raises UnexpectedResponseError with raw response" do
-      begin
-        subject
-      rescue Evil::Client::Operation::UnexpectedResponseError => error
-        expect(error.message).to include "find_user"
-        expect(error.message).to include "http://example.com/users"
-        expect(error.data).to eq "foo"
-        expect(error.status).to eq 404
-      else
-        raise
-      end
-    end
-  end
-end