evil-client 1.0.0 → 1.1.0

data/lib/evil/client/rspec/allow_stub.rb

@@ -0,0 +1,33 @@
+# @private
+module Evil::Client::RSpec
+  #
+  # Container to chain settings for allowing operation(s)
+  #
+  class AllowStub < BaseStub
+    def to_return(response = nil)
+      allow(Evil::Client::Container::Operation)
+        .to follow_expectation
+        .and_return double(:operation, call: response)
+    end
+
+    def to_raise(error = StandardError, *args)
+      allow(Evil::Client::Container::Operation)
+        .to follow_expectation
+        .and_return proc { raise(error, *args) }
+    end
+
+    def to_call_original
+      allow(Evil::Client::Container::Operation)
+        .to follow_expectation
+        .and_call_original
+    end
+
+    private
+
+    def follow_expectation
+      receive(:new).with evil_client_schema_matching(@klass, @name),
+                         *any_args, # logger
+                         @condition || anything
+    end
+  end
+end

data/lib/evil/client/rspec/base_stub.rb

@@ -0,0 +1,26 @@
+# @private
+module Evil::Client::RSpec
+  #
+  # Container to chain settings for stubbing operation(s)
+  #
+  class BaseStub
+    include RSpec::Mocks::ExampleMethods
+    include RSpec::Matchers
+
+    def with(condition = nil, &block)
+      update(condition || block)
+    end
+
+    private
+
+    def initialize(klass, name = nil, condition: nil)
+      @klass     = klass
+      @name      = name
+      @condition = condition
+    end
+
+    def update(condition)
+      self.class.new @klass, @name, condition: condition
+    end
+  end
+end

data/lib/evil/client/rspec/evil_client_schema_matching.rb

@@ -0,0 +1,21 @@
+# @private
+module Evil::Client::RSpec
+  #
+  # Checks whether an operation schema matches klass and name
+  #
+  # @example
+  #   expect(schema).to evil_client_schema_matching(MyClient, /users/)
+  #
+  ::RSpec::Matchers.define :evil_client_schema_matching do |klass, name = nil|
+    match do |schema|
+      expect(schema).to be_instance_of(Evil::Client::Schema::Operation)
+      expect(schema.client.ancestors).to include(klass)
+
+      case name
+      when NilClass then true
+      when Regexp   then schema.to_s[name]
+      else          schema.to_s == "#{klass}.#{name}"
+      end
+    end
+  end
+end

data/lib/evil/client/rspec/expect_stub.rb

@@ -0,0 +1,15 @@
+# @private
+module Evil::Client::RSpec
+  #
+  # Container to chain settings for allowing operation(s)
+  #
+  class ExpectStub < BaseStub
+    def to_have_been_performed
+      expect(Evil::Client::Container::Operation)
+        .to have_received(:new)
+        .with evil_client_schema_matching(@klass, @name),
+              *any_args, # logger
+              @condition || anything
+    end
+  end
+end

data/lib/evil/client/schema.rb

@@ -9,6 +9,8 @@ class Evil::Client
   # definitions.
   #
   class Schema
+    Names.clean(self) # Remove unnecessary methods from the instance
+
     # Loads concrete implementations of the abstract schema
     require_relative "schema/operation"
     require_relative "schema/scope"
@@ -33,7 +35,7 @@ class Evil::Client
     #
     # @return [Evil::Client]
     #
-    attr_reader :client # TODO: add spec
+    attr_reader :client
 
     # The human-friendly representation of the schema
     #

data/lib/evil/client/schema/scope.rb

@@ -39,7 +39,7 @@ class Evil::Client
     # @return [self]
     #
     def scope(name, &block)
-      key = NameError.check!(name, RESERVED)
+      key = NameError.check!(name)
       TypeError.check! self, key, :scope
       @__children__[key] ||= self.class.new(self, key)
       @__children__[key].instance_exec(&block)
@@ -53,7 +53,7 @@ class Evil::Client
     # @return [self]
     #
     def operation(name, &block)
-      key = NameError.check!(name, RESERVED)
+      key = NameError.check!(name)
       TypeError.check! self, key, :operation
       @__children__[key] ||= self.class.superclass.new(self, key)
       @__children__[key].instance_exec(&block)
@@ -66,8 +66,5 @@ class Evil::Client
       super
       @__children__ = {}
     end
-
-    RESERVED = \
-      %i[operations scopes scope options schema settings inspect logger].freeze
   end
 end

data/lib/evil/client/settings.rb

@@ -3,9 +3,9 @@ class Evil::Client
   # Container for settings assigned to some operation or scope.
   #
   class Settings
+    Names.clean(self) # Remove unnecessary methods from the instance
     require_relative "settings/validator"
-
-    extend Dry::Initializer
+    extend ::Dry::Initializer
 
     class << self
       # The schema klass settings belongs to
@@ -34,7 +34,7 @@ class Evil::Client
       # @return      [self]
       #
       def option(key, type = nil, as: key.to_sym, **opts)
-        NameError.check!(as, RESERVED)
+        NameError.check!(as)
         super
         self
       end
@@ -46,7 +46,7 @@ class Evil::Client
       # @return [self]
       #
       def let(key, &block)
-        NameError.check!(key, RESERVED)
+        NameError.check!(key)
         define_method(key) do
           instance_variable_get(:"@#{key}") ||
             instance_variable_set(:"@#{key}", instance_exec(&block))
@@ -97,10 +97,6 @@ class Evil::Client
       rescue => error
         raise ValidationError, error.message
       end
-
-      # @private
-      RESERVED = \
-        %i[options datetime scope logger basic_auth key_auth token_auth].freeze
     end
 
     # The processed hash of options contained by the instance of settings
@@ -108,7 +104,7 @@ class Evil::Client
     # @return [Hash<Symbol, Object>]
     #
     def options
-      @__options__
+      Options.new @__options__
     end
 
     # @!attribute logger

data/lib/evil/client/settings/validator.rb

@@ -55,7 +55,7 @@ class Evil::Client
     end
 
     def validate!(settings, block)
-      settings.instance_eval(&block) && true
+      settings.instance_exec(&block) && true
     rescue => error
       settings&.logger&.error(self) { "broken for #{settings} with #{error}" }
       raise

data/spec/unit/container_spec.rb

@@ -1,4 +1,5 @@
 RSpec.describe Evil::Client::Container do
+  let(:klass)     { double :class }
   let(:container) { described_class.new schema, logger, opts }
   let(:logger)    { Logger.new log }
   let(:log)       { StringIO.new }
@@ -18,6 +19,7 @@ RSpec.describe Evil::Client::Container do
   let(:schema) do
     double :schema,
            to_s: "MyApi.users",
+           client: klass,
            parent: nil,
            settings: settings_klass,
            definitions: {}
@@ -37,6 +39,14 @@ RSpec.describe Evil::Client::Container do
     end
   end
 
+  describe "#name" do
+    subject { container.name }
+
+    it "returns human-friendly representation of the schema" do
+      expect(subject).to eq "MyApi.users"
+    end
+  end
+
   describe "#to_s" do
     subject { container.to_s }
 
@@ -97,6 +107,14 @@ RSpec.describe Evil::Client::Container do
     end
   end
 
+  describe "#client" do
+    subject { container.client }
+
+    it "returns current client" do
+      expect(subject).to eq klass
+    end
+  end
+
   describe "#options" do
     subject { container.options }
 

data/spec/unit/exceptions/name_error_spec.rb

@@ -1,10 +1,9 @@
 RSpec.describe Evil::Client::NameError do
-  let(:error)     { described_class.new name, forbidden }
-  let(:name)      { "foo" }
-  let(:forbidden) { %i[foo bar] }
+  let(:error) { described_class.new name }
+  let(:name)  { "object_id" }
 
   describe ".check!" do
-    subject { described_class.check! name, forbidden }
+    subject { described_class.check! name }
 
     context "with a valid name" do
       let(:name) { "qux_3" }
@@ -55,7 +54,7 @@ RSpec.describe Evil::Client::NameError do
     end
 
     context "with a forbidden name" do
-      let(:name) { "foo" }
+      let(:name) { "object_id" }
 
       it "raises itself" do
         expect { subject }.to raise_error described_class
@@ -67,11 +66,7 @@ RSpec.describe Evil::Client::NameError do
     subject { error.message }
 
     it "builds a proper error message" do
-      expect(subject).to eq "Invalid name :foo." \
-        " It should contain latin letters in the lower case," \
-        " digits, and underscores only; have minimum 2 chars;" \
-        " start from a letter; end with either letter or digit." \
-        " The following names: 'foo', 'bar' are already used by Evil::Client."
+      expect(subject).to include "Invalid name :object_id."
     end
   end
 end

data/spec/unit/options_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe Evil::Client::Options do
+  let(:options) { described_class.new source }
+  let(:source)  { { foo: :FOO, bar: :BAR, baz: :BAZ } }
+
+  describe "#slice" do
+    subject { source.slice :foo, :baz }
+
+    it "slices keys from a hash" do
+      expect(subject).to eq foo: :FOO, baz: :BAZ
+    end
+  end
+
+  describe "#except" do
+    subject { source.except :foo, :baz }
+
+    it "removes keys from a hash" do
+      expect(subject).to eq bar: :BAR
+    end
+  end
+end

data/spec/unit/rspec/evil_client_shema_matching_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe "rspec matcher :evil_client_schema_matching" 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(:schema) { users.operations[:fetch].schema }
+
+  it "passes when schema matches a client" do
+    expect(schema).to evil_client_schema_matching(Test::Client)
+  end
+
+  it "fails when schema not matches a client superclass" do
+    expect(schema).to evil_client_schema_matching(Evil::Client)
+  end
+
+  it "fails when schema not matches a client" do
+    expect(schema).not_to evil_client_schema_matching(String)
+  end
+
+  it "passes when schema matches client and full path" do
+    expect(schema)
+      .to evil_client_schema_matching(Test::Client, "crm.users.fetch")
+  end
+
+  it "failse when schema matches client but not a full path" do
+    expect(schema).not_to evil_client_schema_matching(Test::Client, "crm.users")
+  end
+
+  it "passes when schema matches client and path regex" do
+    expect(schema).to evil_client_schema_matching(Test::Client, /crm\.users/)
+  end
+
+  it "passes when schema matches client and path regex" do
+    expect(schema)
+      .not_to evil_client_schema_matching(Test::Client, /crm\.fetch/)
+  end
+end

data/spec/unit/rspec/expect_client_operation_spec.rb

@@ -0,0 +1,143 @@
+RSpec.describe Evil::Client::RSpec, "#expect_client_operation" do
+  include described_class
+  before { load "spec/fixtures/test_client.rb" }
+  before { stub_client_operation.to_return }
+
+  let(:client)  { Test::Client.new(subdomain: "x", user: "y", token: "z") }
+  let(:perform) { client.crm(version: 7).users.fetch id: 5 }
+
+  before { perform }
+
+  context "with client class" do
+    let(:klass) { Test::Client }
+
+    it "passes" do
+      expect { expect_client_operation(klass).to_have_been_performed }
+        .not_to raise_error
+    end
+  end
+
+  context "with client's superclass" do
+    let(:klass) { Evil::Client }
+
+    it "passes" do
+      expect { expect_client_operation(klass).to_have_been_performed }
+        .not_to raise_error
+    end
+  end
+
+  context "with neither a client nor its superclass" do
+    let(:klass) { String }
+
+    it "fails" do
+      expect { expect_client_operation(klass).to_have_been_performed }
+        .to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+  end
+
+  context "with client class and fully qualified name" do
+    let(:klass) { Test::Client }
+    let(:name)  { "crm.users.fetch" }
+
+    it "passes" do
+      expect do
+        expect_client_operation(klass, name).to_have_been_performed
+      end.not_to raise_error
+    end
+  end
+
+  context "with client class and underqualified name" do
+    let(:klass) { Test::Client }
+    let(:name)  { "crm.users" }
+
+    it "fails" do
+      expect do
+        expect_client_operation(klass, name).to_have_been_performed
+      end.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+  end
+
+  context "with client class and partially qualified name" do
+    let(:klass) { Test::Client }
+    let(:name)  { /crm\.users/ }
+
+    it "passes" do
+      expect do
+        expect_client_operation(klass, name).to_have_been_performed
+      end.not_to raise_error
+    end
+  end
+
+  context "with client class and wrongly qualified name" do
+    let(:klass) { Test::Client }
+    let(:name)  { /^crm.users$/ }
+
+    it "fails" do
+      expect do
+        expect_client_operation(klass, name).to_have_been_performed
+      end.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+  end
+
+  context "with client class and expected options" do
+    let(:klass) { Test::Client }
+    let(:name)  { "crm.users.fetch" }
+    let(:opts) do
+      { subdomain: "x", user: "y", token: "z", version: 7, id: 5 }
+    end
+
+    it "passes" do
+      expect do
+        expect_client_operation(klass, name)
+          .with(opts)
+          .to_have_been_performed
+      end.not_to raise_error
+    end
+  end
+
+  context "with client class and block expectation" do
+    let(:klass) { Test::Client }
+    let(:name)  { "crm.users.fetch" }
+    let(:opts) do
+      { subdomain: "x", user: "y", token: "z", version: 7, id: 5 }
+    end
+
+    it "passes" do
+      expect do
+        expect_client_operation(klass, name)
+          .with { |o| o == opts }
+          .to_have_been_performed
+      end.not_to raise_error
+    end
+  end
+
+  context "with client class and overexpected options" do
+    let(:klass) { Test::Client }
+    let(:name)  { "crm.users.fetch" }
+    let(:opts) do
+      { subdomain: "x", user: "y", token: "z", version: 7 }
+    end
+
+    it "fails" do
+      expect do
+        expect_client_operation(klass, name)
+          .with { |o| o == opts }
+          .to_have_been_performed
+      end.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+  end
+
+  context "with client class and partially expected options" do
+    let(:klass) { Test::Client }
+    let(:name)  { "crm.users.fetch" }
+    let(:opts)  { hash_including subdomain: "x" }
+
+    it "passes" do
+      expect do
+        expect_client_operation(klass, name)
+          .with(opts)
+          .to_have_been_performed
+      end.not_to raise_error
+    end
+  end
+end