evil-client 0.3.3 → 1.0.0

data/spec/unit/resolver/response_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe Evil::Client::Resolver::Response, ".call" do
+  subject { described_class.call schema, settings, response }
+
+  let(:log)      { StringIO.new }
+  let(:logger)   { Logger.new log }
+  let(:response) { [201, { "Content-Language" => "en" }, ["success"]] }
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { responses: { 201 => proc { |*args| args } } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: {
+             responses: { 201 => proc { |_, _, body| body.first } }
+           },
+           parent: root_schema
+  end
+
+  let(:settings) do
+    double :my_settings, version: 77, token: "eoiqopr==", id: 43, logger: logger
+  end
+
+  it "applies most recent schema to response" do
+    expect(subject).to eq "success"
+  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 "201"
+    expect(log.string).to include "success"
+  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 root definition not reloaded" do
+    before { schema.definitions[:responses].delete 201 }
+
+    it "applies root schema to response" do
+      expect(subject).to eq response
+    end
+  end
+
+  context "when no definitions was given for the status" do
+    let(:response) { [202, { "Content-Language" => "en" }, ["success"]] }
+
+    it "raises Evil::Client::ResponseError" do
+      expect { subject }.to raise_error Evil::Client::ResponseError,
+                                        /202/
+    end
+  end
+end

data/spec/unit/resolver/security_spec.rb

@@ -0,0 +1,156 @@
+RSpec.describe Evil::Client::Resolver::Security do
+  let(:resolver) { described_class.new schema, settings }
+  let(:log)      { StringIO.new }
+  let(:logger)   { Logger.new log }
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { security: proc { key_auth :token, token } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { security: proc { key_auth :user, user } },
+           parent: root_schema
+  end
+
+  let(:settings) do
+    double :my_settings,
+           token: "foobar",
+           user: "foo",
+           password: "baz",
+           logger: logger
+  end
+
+  describe ".call" do
+    subject { described_class.call schema, settings }
+
+    it "resolves security settings from a schema" do
+      expect(subject).to eq headers: { "user" => "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 "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 security settings" do
+      before { schema.definitions.delete :security }
+
+      it "resolves security settings from a parent schema" do
+        expect(subject).to eq headers: { "token" => "foobar" }
+      end
+    end
+
+    context "when security settings not defined by any schema" do
+      before { schema.definitions.delete :security }
+      before { root_schema.definitions.delete :security }
+
+      it "resolves security settings to nil" do
+        expect(subject).to eq({})
+      end
+    end
+
+    context "when security settings reloaded by nil" do
+      before { schema.definitions[:security] = proc {} }
+
+      it "resolves security settings to nil" do
+        expect(subject).to eq({})
+      end
+    end
+
+    context "when security settings resolves to unknown key" do
+      before { schema.definitions[:security] = proc { { body: { id: 1 } } } }
+
+      it "raises Evil::Client::DefinitionError" do
+        expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                          /body/
+      end
+    end
+
+    context "when security settings resolves to not a hash" do
+      before { schema.definitions[:security] = proc { { query: :bar } } }
+
+      it "raises Evil::Client::DefinitionError" do
+        expect { subject }.to raise_error Evil::Client::DefinitionError,
+                                          /bar/
+      end
+    end
+  end
+
+  describe "#key_auth" do
+    let(:key)   { "foo" }
+    let(:value) { "bar" }
+    let(:opts)  { {} }
+
+    subject { resolver.key_auth key, value, **opts }
+
+    it "builds in-headers schema" do
+      expect(subject).to eq headers: { "foo" => "bar" }
+    end
+
+    context "when :inside was set to :query" do
+      let(:opts) { { inside: :query } }
+
+      it "builds in-query schema" do
+        expect(subject).to eq query: { "foo" => "bar" }
+      end
+    end
+  end
+
+  describe "#token_auth" do
+    let(:value) { "foobar" }
+    let(:opts)  { {} }
+
+    subject { resolver.token_auth value, **opts }
+
+    it "builds default in-headers schema for Authorization" do
+      expect(subject).to eq headers: { "Authorization" => "foobar" }
+    end
+
+    context "when :prefix was set" do
+      let(:opts) { { prefix: "bearer" } }
+
+      it "builds prefixed in-headers schema" do
+        expect(subject).to eq headers: { "Authorization" => "Bearer foobar" }
+      end
+    end
+
+    context "when :inside was set to :query" do
+      let(:opts) { { inside: :query } }
+
+      it "builds default in-query schema for access_token" do
+        expect(subject).to eq query: { "access_token" => "foobar" }
+      end
+
+      context "when :prefix was set" do
+        let(:opts) { { inside: :query, prefix: "bearer" } }
+
+        it "ignores prefix in a query" do
+          expect(subject).to eq query: { "access_token" => "foobar" }
+        end
+      end
+    end
+  end
+
+  describe "#basic_auth" do
+    subject { resolver.basic_auth "foo", "bar" }
+
+    it "builds basic Authorization schema" do
+      expect(subject).to eq headers: { "Authorization" => "Basic Zm9vOmJhcg==" }
+    end
+  end
+end

data/spec/unit/resolver/uri_spec.rb

@@ -0,0 +1,117 @@
+RSpec.describe Evil::Client::Resolver::Uri, ".call" do
+  subject { described_class.call schema, settings }
+
+  let(:log)      { StringIO.new }
+  let(:logger)   { Logger.new log }
+  let(:settings) { double :my_settings, version: 77, id: 42, logger: logger }
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { path: proc { "https://my_api.com/v#{version}" } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { path: proc { "/users/#{id}" } },
+           parent: root_schema
+  end
+
+  it "resolves uri from a schema" do
+    expect(subject).to eq URI("https://my_api.com/v77/users/42")
+  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 "https://my_api.com/v77/users/42"
+  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 an uri" do
+    before { schema.definitions.delete :path }
+
+    it "resolves uri from a parent schema" do
+      expect(subject).to eq URI("https://my_api.com/v77")
+    end
+  end
+
+  context "when path was defined with errors" do
+    before { root_schema.definitions.delete :path }
+
+    it "raises StandardError" do
+      expect { subject }.to raise_error StandardError
+    end
+
+    it "logs the result" do
+      subject rescue nil
+
+      expect(log.string).to include described_class.name
+      expect(log.string).to include "my_schema"
+      expect(log.string).to include "my_settings"
+    end
+  end
+
+  context "when uri cannot be resolved" do
+    let(:settings) { double :my_settings, version: 1, logger: logger }
+
+    it "raises StandardError" do
+      expect { subject }.to raise_error StandardError
+    end
+
+    it "logs the result" do
+      subject rescue nil
+
+      expect(log.string).to include described_class.name
+      expect(log.string).to include "my_schema"
+      expect(log.string).to include "my_settings"
+    end
+  end
+
+  context "when path wasn't defined" do
+    before { root_schema.definitions.delete :path }
+    before { schema.definitions.delete :path }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }
+        .to raise_error Evil::Client::DefinitionError,
+                        /base url should be defined/
+    end
+
+    it "logs the result" do
+      subject rescue nil
+
+      expect(log.string).to include described_class.name
+      expect(log.string).to include "my_schema"
+      expect(log.string).to include "my_settings"
+    end
+  end
+
+  context "when uri has a wrong schema" do
+    before { root_schema.definitions[:path] = proc { "ws://github.com" } }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }
+        .to raise_error Evil::Client::DefinitionError,
+                        /base url should use HTTP\(S\). 'ws' used instead/
+    end
+
+    it "logs the result" do
+      subject rescue nil
+
+      expect(log.string).to include described_class.name
+      expect(log.string).to include "my_schema"
+      expect(log.string).to include "my_settings"
+    end
+  end
+end

data/spec/unit/rspec_spec.rb

@@ -0,0 +1,342 @@
+RSpec.describe "rspec matcher :perform_operation" do
+  before { load "spec/fixtures/test_client.rb" }
+
+  let(:client) { Test::Client.new(subdomain: "foo", user: "bar", token: "baz") }
+  let(:users)  { client.crm(version: 7).users }
+
+  let(:fetch)    { users.fetch id: 5 }
+  let(:update_7) { users.update id: 5, name: "Joe", language: "en" }
+  let(:update_8) { users.update id: 5, name: "Joe", language: "en", version: 8 }
+
+  let(:name)  { "Test::Client.crm.users.update" }
+  let(:block) { proc { |version:, **| version == 7 } }
+
+  describe "base matcher" do
+    context "in a positive check" do
+      subject { expect { code }.to perform_operation(name) }
+
+      context "when operaton with expected name was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when operation with expected name wasn't performed" do
+        let(:code) { fetch }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+    end
+
+    context "in a negative check" do
+      subject { expect { code }.not_to perform_operation(name) }
+
+      context "when operaton with expected name was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when operation with expected name wasn't performed" do
+        let(:code) { fetch }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe "block argument" do
+    context "in a positive check" do
+      subject { expect { code }.to perform_operation(name, &block) }
+
+      context "when operaton with expected name/options was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when options differ from expected" do
+        let(:code) { fetch; update_8 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:code) { fetch }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+    end
+
+    context "in a negagive check" do
+      subject { expect { code }.not_to perform_operation(name, &block) }
+
+      context "when operaton with expected name/options was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when options differ from expected" do
+        let(:code) { fetch; update_8 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:code) { fetch }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe "#with modifier" do
+    let(:opts) { { version: 7 } }
+
+    context "in a positive check" do
+      subject { expect { code }.to perform_operation(name).with(opts) }
+
+      context "when operaton with expected name/options was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when options differ from expected" do
+        let(:code) { fetch; update_8 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:code) { fetch }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+    end
+
+    context "in a negative check" do
+      subject { expect { code }.not_to perform_operation(name).with(opts) }
+
+      context "when operaton with expected name/options was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when options differ from expected" do
+        let(:code) { fetch; update_8 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:code) { fetch }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe "#with_exactly modifier" do
+    let(:opts) do
+      {
+        id:        5,
+        language:  "en",
+        name:      "Joe",
+        subdomain: "foo",
+        token:     "baz",
+        user:      "bar",
+        version:   7
+      }
+    end
+
+    context "in a positive check" do
+      subject { expect { code }.to perform_operation(name).with_exactly(opts) }
+
+      context "when operaton with expected name/options was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when some options differ from expected" do
+        let(:code) { fetch; update_8 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when some options are not expected" do
+        before { opts.delete :version }
+        let(:code) { fetch; update_7 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:code) { fetch }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+    end
+
+    context "in a negative check" do
+      subject do
+        expect { code }.not_to perform_operation(name).with_exactly(opts)
+      end
+
+      context "when operaton with expected name/options was performed" do
+        let(:code) { fetch; update_7 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when some options differ from expected" do
+        let(:code) { fetch; update_8 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when some options are not expected" do
+        before { opts.delete :version }
+        let(:code) { fetch; update_7 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:code) { fetch }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe "#without modifier" do
+    context "in a positive check" do
+      subject { expect { code }.to perform_operation(name).without(opts) }
+
+      context "when operaton without options was performed" do
+        let(:opts) { %i[phone] }
+        let(:code) { fetch; update_7 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when operation contains a forbidden option" do
+        let(:opts) { %i[id] }
+        let(:code) { fetch; update_7 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:opts) { %i[phone] }
+        let(:code) { fetch }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+    end
+
+    context "in a negative check" do
+      subject { expect { code }.not_to perform_operation(name).without(opts) }
+
+      context "when operaton without options was performed" do
+        let(:opts) { %i[phone] }
+        let(:code) { fetch; update_7 }
+
+        it "fails" do
+          expect { subject }
+            .to raise_error RSpec::Expectations::ExpectationNotMetError
+        end
+      end
+
+      context "when operation contains a forbidden option" do
+        let(:opts) { %i[id] }
+        let(:code) { fetch; update_7 }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+
+      context "when operation wasn't performed" do
+        let(:opts) { %i[phone] }
+        let(:code) { fetch }
+
+        it "passes" do
+          expect { subject }.not_to raise_error
+        end
+      end
+    end
+  end
+end