evil-client 0.3.3 → 1.0.0

data/spec/unit/client_spec.rb

@@ -0,0 +1,137 @@
+RSpec.describe Evil::Client do
+  let(:klass) { Class.new(described_class) }
+
+  describe ".schema" do
+    subject { klass.schema }
+
+    it "returns a schema for the root scope" do
+      expect(subject).to be_a described_class::Schema::Scope
+      expect(subject.client).to eq klass
+    end
+  end
+
+  describe ".scopes" do
+    before  { klass.schema.scope(:users) {} }
+    subject { klass.scopes }
+
+    it "returns subscopes from the root schema" do
+      expect(subject).to eq klass.schema.scopes
+    end
+  end
+
+  describe ".operations" do
+    before  { klass.schema.operation(:users) {} }
+    subject { klass.operations }
+
+    it "returns operationss from the root schema" do
+      expect(subject).to eq klass.schema.operations
+    end
+  end
+
+  describe ".option" do
+    subject { klass.option(:users, optional: true) }
+
+    it "updates settings of the root schema" do
+      expect(klass.schema.settings)
+        .to receive(:option)
+        .with :users, nil, optional: true
+
+      subject
+    end
+  end
+
+  describe ".scope" do
+    subject { klass.scope(:users) {} }
+
+    it "updates root schema scopes" do
+      expect(klass.schema).to receive(:scope).with :users
+
+      subject
+    end
+  end
+
+  describe ".operation" do
+    subject { klass.operation(:users) {} }
+
+    it "updates root schema scopes" do
+      expect(klass.schema).to receive(:operation).with :users
+
+      subject
+    end
+  end
+
+  describe ".connection" do
+    subject { klass.connection }
+
+    it "return Evil::Client::Connection module by default" do
+      expect(subject).to eq Evil::Client::Connection
+    end
+  end
+
+  describe ".connection=" do
+    let(:new_connection) { double call: nil }
+    subject { klass.connection = new_connection }
+
+    it "sets new connection" do
+      expect { subject }.to change { klass.connection }.to new_connection
+    end
+
+    context "with nil" do
+      before  { klass.connection = new_connection }
+      subject { klass.connection = nil }
+
+      it "resets connection to default" do
+        expect { subject }
+          .to change { klass.connection }
+          .to Evil::Client::Connection
+      end
+    end
+  end
+
+  let(:client) do
+    klass.option :token
+    klass.new(token: "foo", version: 1)
+  end
+
+  describe "#options" do
+    subject { client.options }
+
+    it "returns options assigned to client settings" do
+      expect(subject).to eq token: "foo"
+    end
+  end
+
+  describe "#scopes" do
+    subject { client.scopes }
+
+    it "returns root scope scopes" do
+      expect(subject).to eq client.scope.scopes
+    end
+  end
+
+  describe "#operations" do
+    subject { client.operations }
+
+    it "returns root scope operations" do
+      expect(subject).to eq client.scope.operations
+    end
+  end
+
+  describe "#logger" do
+    before  { client.scope.logger = double :logger }
+    subject { client.logger }
+
+    it "returns root scope logger" do
+      expect(subject).to eq client.scope.logger
+    end
+  end
+
+  describe "#logger=" do
+    let(:new_logger) { double :logger }
+    subject { client.logger = new_logger }
+
+    it "sets root scope logger" do
+      expect { subject }.to change { client.scope.logger }.to new_logger
+    end
+  end
+end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Evil::Client::Connection, ".call" do
+  let(:logger) { Logger.new log }
+  let(:log)    { StringIO.new }
+  let(:env) do
+    {
+      "REQUEST_METHOD"  => "POST",
+      "SCRIPT_NAME"     => "",
+      "PATH_INFO"       => "/api/v77/users/43",
+      "QUERY_STRING"    => "version=77&verbose=true",
+      "SERVER_NAME"     => "foo.com",
+      "SERVER_PORT"     => 443,
+      "HTTP_Variables"  => {
+        "Foo" => "BAR",
+        "Baz" => "QUX",
+        "Authorization" => "Bearer eoiqopr==",
+        "Content-Type"  => "application/json"
+      },
+      "rack.version"      => Rack::VERSION,
+      "rack.input"        => "name=Andrew&age=46",
+      "rack.url_scheme"   => "https",
+      "rack.multithread"  => false,
+      "rack.multiprocess" => false,
+      "rack.run_once"     => false,
+      "rack.hijack?"      => false,
+      "rack.logger"       => logger
+    }
+  end
+
+  let(:request) do
+    a_request(:post, "https://foo.com/api/v77/users/43?version=77&verbose=true")
+      .with body: "name=Andrew&age=46",
+            headers: {
+              "Foo" => "BAR",
+              "Baz" => "QUX",
+              "Authorization" => "Bearer eoiqopr==",
+              "Content-Type"  => "application/json"
+            }
+  end
+
+  before do
+    stub_request(:any, //).to_return status:  200,
+                                     headers: { "Content-Language" => "en_AU" },
+                                     body:    "Done!"
+  end
+
+  subject { described_class.call(env) }
+
+  it "sends a request" do
+    subject
+    expect(request).to have_been_made
+  end
+
+  it "returns a response" do
+    expect(subject).to eq [200, { "content-language" => ["en_AU"] }, ["Done!"]]
+  end
+
+  it "logs the request" do
+    subject
+
+    <<-LOG.gsub(/^ +\|/, "").lines.each { |l| expect(log.string).to include l }
+      |INFO -- Evil::Client::Connection: sending request:
+      |INFO -- Evil::Client::Connection:  Url     | https://foo.com/api/v77/users/43?version=77&verbose=true
+      |INFO -- Evil::Client::Connection:  Headers | {"Foo"=>"BAR", "Baz"=>"QUX", "Authorization"=>"Bearer eoiqopr==", "Content-Type"=>"application/json"}
+      |INFO -- Evil::Client::Connection:  Body    | name=Andrew&age=46
+    LOG
+  end
+
+  it "logs the response" do
+    subject
+
+    <<-LOG.gsub(/^ +\|/, "").lines.each { |l| expect(log.string).to include l }
+      |INFO -- Evil::Client::Connection: receiving response:
+      |INFO -- Evil::Client::Connection:  Status  | 200
+      |INFO -- Evil::Client::Connection:  Headers | {\"content-language\"=>[\"en_AU\"]}
+      |INFO -- Evil::Client::Connection:  Body    | [\"Done!\"]
+    LOG
+  end
+end

data/spec/unit/container/operation_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe Evil::Client::Container::Operation do
+  before do
+    Test::Middleware = Struct.new(:app) do
+      def call(env)
+        env["HTTP_Variables"].update("Accept-Language" => "ru_RU")
+        app.call env
+      end
+    end
+  end
+
+  let(:operation)  { described_class.new schema, nil, opts }
+  let(:connection) { Evil::Client::Connection }
+  let(:schema) do
+    double :schema,
+           to_s:     "MyApi.users.update",
+           client:   double(:client, connection: connection),
+           parent:   nil,
+           settings: settings_klass,
+           definitions: {
+             path:        -> { "https://example.com/users/#{id}" },
+             http_method: -> { "PATCH" },
+             format:      -> { :json },
+             security:    -> { { headers: { "Authentication" => token } } },
+             headers:     -> { { "Content-Language" => language } },
+             query:       -> { { language: language } },
+             body:        -> { { name: name } },
+             middleware:  -> { Test::Middleware },
+             responses:   { 200 => proc { |_, _, body| JSON.parse body.first } }
+           }
+  end
+
+  let(:settings_klass) do
+    Class.new(Evil::Client::Settings) do
+      option :token
+      option :id
+      option :language
+      option :name
+    end
+  end
+
+  let(:opts) { { token: "qux", id: 7, language: "en_US", name: "Joe", age: 9 } }
+
+  before do
+    stub_request(:any, //).to_return status: 200, body: '{"result":"success"}'
+  end
+
+  it "is a subclass of base container" do
+    expect(described_class.superclass).to eq Evil::Client::Container
+  end
+
+  describe "#call" do
+    subject { operation.call }
+
+    let(:request) do
+      a_request(:patch, "https://example.com/users/7?language=en_US") do |r|
+        expect(r.body).to eq '{"name":"Joe"}'
+        expect(r.headers).to include "Authentication"   => "qux",
+                                     "Content-Language" => "en_US",
+                                     "Accept-Language"  => "ru_RU"
+      end
+    end
+
+    it "sends resolved request" do
+      subject
+      expect(request).to have_been_made
+    end
+
+    it "returns parsed response" do
+      expect(subject).to eq "result" => "success"
+    end
+
+    context "whe a client has custom connection" do
+      let(:connection) { double call: [200, {}, %w[{"result":"wow"}]] }
+
+      it "sends request to selected connection" do
+        expect(connection).to receive(:call)
+        expect(subject).to eq "result" => "wow"
+      end
+    end
+  end
+end

data/spec/unit/container/scope_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe Evil::Client::Container::Scope do
+  let(:scope)  { described_class.new schema, nil, opts }
+  let(:opts) { { token: "qux", id: 7, language: "en_US", name: "Joe", age: 9 } }
+  let(:update_schema) { double :update_schema, name: :update }
+  let(:admins_schema) { double :admins_schema, name: :admins }
+
+  let(:settings_klass) do
+    Class.new(Evil::Client::Settings) do
+      option :token
+      option :id
+      option :language
+      option :name
+    end
+  end
+
+  let(:schema) do
+    double :schema,
+           parent:     nil,
+           settings:   settings_klass,
+           operations: { update: update_schema },
+           scopes:     { admins: admins_schema }
+  end
+
+  it "is a subclass of base container" do
+    expect(described_class.superclass).to eq Evil::Client::Container
+  end
+
+  describe "#operations" do
+    subject { scope.operations[:update] }
+
+    it "contains sub-schemas with current settings" do
+      expect(subject).to be_a Evil::Client::Builder::Operation
+      expect(subject.schema).to eq update_schema
+      expect(subject.parent).to eq scope.settings
+    end
+  end
+
+  describe "#scopes" do
+    subject { scope.scopes[:admins] }
+
+    it "contains sub-schemas with current settings" do
+      expect(subject).to be_a Evil::Client::Builder::Scope
+      expect(subject.schema).to eq admins_schema
+      expect(subject.parent).to eq scope.settings
+    end
+  end
+
+  describe "chaining" do
+    before do
+      allow(scope.scopes[:admins])
+        .to receive(:call) { |id:, **| "admins #{id}" }
+      allow(scope.operations[:update])
+        .to receive(:call) { |id:, **| "update #{id}" }
+    end
+
+    it "is supported" do
+      expect(scope.admins(id: 8)).to eq "admins 8"
+      expect(scope.update(id: 9)).to eq "update 9"
+    end
+  end
+end

data/spec/unit/container_spec.rb

@@ -0,0 +1,107 @@
+RSpec.describe Evil::Client::Container do
+  let(:container) { described_class.new schema, logger, opts }
+  let(:logger)    { Logger.new log }
+  let(:log)       { StringIO.new }
+  let(:opts) do
+    { token: "qux", id: 7, language: "en_US", name: "Joe", age: 9 }
+  end
+
+  let(:settings_klass) do
+    Class.new(Evil::Client::Settings) do
+      option :token
+      option :id
+      option :language
+      option :name
+    end
+  end
+
+  let(:schema) do
+    double :schema,
+           to_s: "MyApi.users",
+           parent: nil,
+           settings: settings_klass,
+           definitions: {}
+  end
+
+  describe ".new" do
+    subject { container }
+
+    it "logs given options" do
+      subject
+      expect(log.string).to include opts.to_s
+    end
+
+    it "logs initialized settings" do
+      subject
+      expect(log.string).to include container.settings.to_s
+    end
+  end
+
+  describe "#to_s" do
+    subject { container.to_s }
+
+    it "returns human-friendly representation of container" do
+      expect(subject).to eq \
+        "#<MyApi.users @token=qux, @id=7, @language=en_US, @name=Joe>"
+    end
+  end
+
+  describe "#to_str" do
+    subject { container.to_str }
+
+    it "returns human-friendly representation of container" do
+      expect(subject).to eq \
+        "#<MyApi.users @token=qux, @id=7, @language=en_US, @name=Joe>"
+    end
+  end
+
+  describe "#inspect" do
+    subject { container.inspect }
+
+    it "returns human-friendly representation of container" do
+      expect(subject).to eq \
+        "#<MyApi.users @token=qux, @id=7, @language=en_US, @name=Joe>"
+    end
+  end
+
+  describe "#logger" do
+    subject { container.logger }
+
+    it "returns current logger" do
+      expect(subject).to eq logger
+    end
+  end
+
+  describe "#logger=" do
+    let(:new_logger) { Logger.new log }
+    subject { container.logger = new_logger }
+
+    it "sets new logger" do
+      expect { subject }.to change { container.logger }.to new_logger
+    end
+  end
+
+  describe "#schema" do
+    subject { container.schema }
+
+    it "returns current schema" do
+      expect(subject).to eq schema
+    end
+  end
+
+  describe "#settings" do
+    subject { container.settings }
+
+    it "returns current settings" do
+      expect(subject).to be_a settings_klass
+    end
+  end
+
+  describe "#options" do
+    subject { container.options }
+
+    it "returns settings options" do
+      expect(subject).to eq token: "qux", id: 7, language: "en_US", name: "Joe"
+    end
+  end
+end