evil-client 0.3.3 → 1.0.0

data/spec/unit/resolver/format_spec.rb

@@ -0,0 +1,66 @@
+RSpec.describe Evil::Client::Resolver::Format, ".call" do
+  subject { described_class.call schema, settings }
+
+  let(:log)      { StringIO.new }
+  let(:logger)   { Logger.new log }
+  let(:settings) { double :my_settings, version: 77, logger: logger }
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { format: proc { :form } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { format: proc { version > 2 ? :json : :form } },
+           parent: root_schema
+  end
+
+  it "resolves format from a schema" do
+    expect(subject).to eq :json
+  end
+
+  it "logs the result" do
+    subject
+
+    expect(log.string).to include described_class.name
+    expect(log.string).to include "my_schema"
+    expect(log.string).to include "my_settings"
+    expect(log.string).to include "json"
+  end
+
+  context "when logger level was set to INFO" do
+    before { logger.level = Logger::INFO }
+
+    it "skips logging" do
+      expect { subject }.not_to change { log.string }
+    end
+  end
+
+  context "when current schema not defines a format" do
+    before { schema.definitions.delete :format }
+
+    it "resolves format from a parent schema" do
+      expect(subject).to eq :form
+    end
+  end
+
+  context "when format not defined by any schema" do
+    before { schema.definitions.delete :format }
+    before { root_schema.definitions.delete :format }
+
+    it "resolves format to :json" do
+      expect(subject).to eq :json
+    end
+  end
+
+  context "when format resolves to inacceptable value" do
+    before { schema.definitions[:format] = proc { :foo } }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                        /foo/
+    end
+  end
+end

data/spec/unit/resolver/headers_spec.rb

@@ -0,0 +1,93 @@
+RSpec.describe Evil::Client::Resolver::Headers, ".call" do
+  subject { described_class.call schema, settings }
+
+  let(:log)    { StringIO.new }
+  let(:logger) { Logger.new log }
+
+  let(:settings) do
+    double :my_settings, name: "foo", value: "bar", logger: logger
+  end
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { headers: proc { { name: name.capitalize } } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { headers: proc { { Value: value.upcase } } },
+           parent: root_schema
+  end
+
+  it "resolves headers from a schema" do
+    expect(subject).to eq "name" => "Foo", "Value" => "BAR"
+  end
+
+  it "logs the result" do
+    subject
+
+    expect(log.string).to include described_class.name
+    expect(log.string).to include "my_schema"
+    expect(log.string).to include "my_settings"
+    expect(log.string).to include "Foo"
+  end
+
+  context "when some header has empty value" do
+    before { schema.definitions[:headers] = proc { { Value: "" } } }
+
+    it "is ignored" do
+      expect(subject).to eq "name" => "Foo"
+    end
+  end
+
+  context "when header values are arrays" do
+    before { schema.definitions[:headers] = proc { { foo: [:bar] } } }
+
+    it "resolves header values to array of strings" do
+      expect(subject).to eq "foo" => ["bar"], "name" => "Foo"
+    end
+  end
+
+  context "when header values are nested arrays" do
+    before { schema.definitions[:headers] = proc { { foo: [[:bar]] } } }
+
+    it "resolves header values to array of strings" do
+      expect(subject).to eq "foo" => ["[:bar]"], "name" => "Foo"
+    end
+  end
+
+  context "when logger level was set to INFO" do
+    before { logger.level = Logger::INFO }
+
+    it "skips logging" do
+      expect { subject }.not_to change { log.string }
+    end
+  end
+
+  context "when current schema not defines headers" do
+    before { schema.definitions.delete :headers }
+
+    it "resolves headers from a parent schema only" do
+      expect(subject).to eq "name" => "Foo"
+    end
+  end
+
+  context "when headers not defined by any schema" do
+    before { schema.definitions.delete :headers }
+    before { root_schema.definitions.delete :headers }
+
+    it "resolves headers to empty hash" do
+      expect(subject).to eq({})
+    end
+  end
+
+  context "when headers resolves to inacceptable value" do
+    before { schema.definitions[:headers] = proc { :foo } }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                        /foo/
+    end
+  end
+end

data/spec/unit/resolver/http_method_spec.rb

@@ -0,0 +1,67 @@
+RSpec.describe Evil::Client::Resolver::HttpMethod, ".call" do
+  subject { described_class.call schema, settings }
+
+  let(:log)      { StringIO.new }
+  let(:logger)   { Logger.new log }
+  let(:settings) { double :my_settings, version: 77, logger: logger }
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { http_method: proc { :put } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { http_method: proc { version > 2 ? :patch : :put } },
+           parent: root_schema
+  end
+
+  it "resolves http method from a schema" do
+    expect(subject).to eq "PATCH"
+  end
+
+  it "logs the result" do
+    subject
+
+    expect(log.string).to include described_class.name
+    expect(log.string).to include "my_schema"
+    expect(log.string).to include "my_settings"
+    expect(log.string).to include "PATCH"
+  end
+
+  context "when logger level was set to INFO" do
+    before { logger.level = Logger::INFO }
+
+    it "skips logging" do
+      expect { subject }.not_to change { log.string }
+    end
+  end
+
+  context "when current schema not defines a http method" do
+    before { schema.definitions.delete :http_method }
+
+    it "resolves http method from a parent schema" do
+      expect(subject).to eq "PUT"
+    end
+  end
+
+  context "when http method resolves to inacceptable value" do
+    before { schema.definitions[:http_method] = proc { :foo } }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                        /FOO/
+    end
+  end
+
+  context "when http method not defined by any schema" do
+    before { schema.definitions.delete :http_method }
+    before { root_schema.definitions.delete :http_method }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                        /http_method/
+    end
+  end
+end

data/spec/unit/resolver/middleware_spec.rb

@@ -0,0 +1,83 @@
+RSpec.describe Evil::Client::Resolver::Middleware, ".call" do
+  subject { described_class.call schema, settings }
+
+  before do
+    class Test::Foo; end
+    class Test::Bar; end
+    class Test::Baz; end
+  end
+
+  let(:log)    { StringIO.new }
+  let(:logger) { Logger.new log }
+
+  let(:settings) do
+    double :my_settings, name: "Andy", gender: "man", logger: logger
+  end
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { middleware: proc { [Test::Foo, Test::Bar] } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { middleware: proc { Test::Baz } },
+           parent: root_schema
+  end
+
+  it "resolves middleware from a schema in a reverse order" do
+    expect(subject).to eq [Test::Baz, Test::Bar, Test::Foo]
+  end
+
+  it "logs the result" do
+    subject
+
+    expect(log.string).to include described_class.name
+    expect(log.string).to include "my_schema"
+    expect(log.string).to include "my_settings"
+    expect(log.string).to include "[Test::Baz, Test::Bar, Test::Foo]"
+  end
+
+  context "when logger level was set to INFO" do
+    before { logger.level = Logger::INFO }
+
+    it "skips logging" do
+      expect { subject }.not_to change { log.string }
+    end
+  end
+
+  context "when current schema not defines a middleware" do
+    before { schema.definitions.delete :middleware }
+
+    it "resolves middleware from a parent schema in a reverse order" do
+      expect(subject).to eq [Test::Bar, Test::Foo]
+    end
+  end
+
+  context "when root middleware definitions was reloaded by nil" do
+    before { schema.definitions[:middleware] = proc {} }
+
+    it "resolves middleware to empty list" do
+      expect(subject).to eq []
+    end
+  end
+
+  context "when middleware not defined by any schema" do
+    before { schema.definitions.delete :middleware }
+    before { root_schema.definitions.delete :middleware }
+
+    it "resolves middleware to empty list" do
+      expect(subject).to eq []
+    end
+  end
+
+  context "when middleware defintion has wrong format" do
+    before { schema.definitions[:middleware] = proc { 1323 } }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                        /1323/
+    end
+  end
+end

data/spec/unit/resolver/query_spec.rb

@@ -0,0 +1,85 @@
+RSpec.describe Evil::Client::Resolver::Query, ".call" do
+  subject { described_class.call schema, settings }
+
+  let(:log)    { StringIO.new }
+  let(:logger) { Logger.new log }
+
+  let(:settings) do
+    double :my_settings, name: "Andy", gender: "man", logger: logger
+  end
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { query: proc { { user: { name: name } } } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { query: proc { { user: { gender: gender } } } },
+           parent: root_schema
+  end
+
+  it "resolves query from a schema" do
+    expect(subject).to eq "user" => { "name" => "Andy", "gender" => "man" }
+  end
+
+  it "logs the result" do
+    subject
+
+    expect(log.string).to include described_class.name
+    expect(log.string).to include "my_schema"
+    expect(log.string).to include "my_settings"
+    expect(log.string).to include "Andy"
+  end
+
+  context "when logger level was set to INFO" do
+    before { logger.level = Logger::INFO }
+
+    it "skips logging" do
+      expect { subject }.not_to change { log.string }
+    end
+  end
+
+  context "when current schema not defines a query" do
+    before { schema.definitions.delete :query }
+
+    it "resolves query from a parent schema" do
+      expect(subject).to eq "user" => { name: "Andy" }
+    end
+  end
+
+  context "when current schema definitions incompatible to root" do
+    before { schema.definitions[:query] = proc { { user: [gender: :man] } } }
+
+    it "resolves query from a current schema only" do
+      expect(subject).to eq "user" => [{ gender: :man }]
+    end
+  end
+
+  context "when root query definitions was reloaded by nil" do
+    before { schema.definitions[:query] = proc {} }
+
+    it "resolves query to empty hash" do
+      expect(subject).to eq({})
+    end
+  end
+
+  context "when query not defined by any schema" do
+    before { schema.definitions.delete :query }
+    before { root_schema.definitions.delete :query }
+
+    it "resolves query to empty hash" do
+      expect(subject).to eq({})
+    end
+  end
+
+  context "when query defintion returns neither hash nor nil" do
+    before { schema.definitions[:query] = proc { 1323 } }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                        /1323/
+    end
+  end
+end

data/spec/unit/resolver/request_spec.rb

@@ -0,0 +1,121 @@
+RSpec.describe Evil::Client::Resolver::Request, ".call" do
+  subject { described_class.call schema, settings }
+
+  let(:log)    { StringIO.new }
+  let(:logger) { Logger.new log }
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: {
+             body:        proc { %W[v#{version}] },
+             format:      proc { :form },
+             headers:     proc { { "Foo" => "BAR" } },
+             http_method: proc { :get },
+             query:       proc { { version: version } },
+             security:    proc { token_auth token },
+             path:        proc { "https://myhost.com/api/v#{version}" }
+           },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           to_s: "MySchema.users.fetch",
+           definitions: {
+             body:        proc { { version: "v#{version}" } },
+             format:      proc { :json if version > 76 },
+             headers:     proc { { "Baz" => "QUX" } },
+             http_method: proc { :post if version > 75 },
+             query:       proc { { verbose: true } },
+             security:    proc { token_auth token, prefix: "Bearer" },
+             path:        proc { "users/#{id}" }
+           },
+           parent: root_schema
+  end
+
+  let(:opts)     { { version: 77, token: "eoiqopr==", id: 43 } }
+  let(:settings) { double :my_settings, options: opts, logger: logger, **opts }
+
+  let(:environment) do
+    {
+      "REQUEST_METHOD"  => "POST",
+      "SCRIPT_NAME"     => "",
+      "PATH_INFO"       => "/api/v77/users/43",
+      "QUERY_STRING"    => "version=77&verbose=true",
+      "SERVER_NAME"     => "myhost.com",
+      "SERVER_PORT"     => 443,
+      "HTTP_Variables"  => {
+        "Foo" => "BAR",
+        "Baz" => "QUX",
+        "Authorization" => "Bearer eoiqopr==",
+        "Content-Type"  => "application/json"
+      },
+      "rack.version"      => Rack::VERSION,
+      "rack.input"        => '{"version":"v77"}',
+      "rack.url_scheme"   => "https",
+      "rack.multithread"  => false,
+      "rack.multiprocess" => false,
+      "rack.run_once"     => false,
+      "rack.hijack?"      => false,
+      "rack.logger"       => logger
+    }
+  end
+
+  context "with default :json format" do
+    it "resolves request schema for settings to rack-compatible env" do
+      expect(subject).to eq environment
+    end
+  end
+
+  context "with :yaml format" do
+    before do
+      schema.definitions[:format] = -> { :yaml }
+      environment["rack.input"] = "---\n:version: v77\n"
+      environment["HTTP_Variables"]["Content-Type"] = "application/yaml"
+    end
+
+    it "resolves request schema for settings to rack-compatible env" do
+      expect(subject).to eq environment
+    end
+  end
+
+  context "with :text format" do
+    before do
+      schema.definitions[:format] = -> { :text }
+      environment["rack.input"] = '{:version=>"v77"}'
+      environment["HTTP_Variables"]["Content-Type"] = "text/plain"
+    end
+
+    it "resolves request schema for settings to rack-compatible env" do
+      expect(subject).to eq environment
+    end
+  end
+
+  context "with :form format" do
+    before do
+      schema.definitions[:format] = -> { :form }
+      environment["rack.input"] = "version=v77"
+      environment["HTTP_Variables"]["Content-Type"] = \
+        "application/x-www-form-urlencoded"
+    end
+
+    it "resolves request schema for settings to rack-compatible env" do
+      expect(subject).to eq environment
+    end
+  end
+
+  context "with :multipart format" do
+    before { schema.definitions[:format] = -> { :multipart } }
+
+    it "resolves request schema for settings to rack-compatible env" do
+      expect(subject["HTTP_Variables"]["Content-Type"])
+        .to match %r{multipart/form-data; boundary=\w{20}}
+
+      expect(subject["rack.input"])
+        .to include 'Content-Disposition: form-data; name="Part1"'
+
+      expect(subject["rack.input"])
+        .to include "version=v77"
+    end
+  end
+end