hexx 7.1.0 → 8.0.0

data/lib/hexx/service_invalid.rb

@@ -1,73 +0,0 @@
-require_relative "message"
-
-module Hexx
-
-  # The exception to be risen by invalid services.
-  #
-  # @example
-  #   service GetItem < Hexx::Service
-  #     allow_params :uuid
-  #     validates :uuid, presence: true
-  #     def run
-  #       validate!
-  #     end
-  #   end
-  #
-  #   service = GetItem.new
-  #   service.run # => fails with the {Hexx::ServiceInvalid}.
-  class ServiceInvalid < ::RuntimeError
-
-    # @!attribute [r] service
-    # @return [Hexx::Service] The invalid service object.
-    attr_reader :service
-
-    # @!scope class
-    # @!method new(service)
-    # Initializes the exception.
-    #
-    # @example
-    #   fail Hexx::ServiceInvalid.new service
-    #
-    # @param  [Hexx::Service] service The invalid service.
-    # @raise  [ArgumentError] if the argument is not a service object.
-    # @return [Hexx::ServiceInvalid] The exception.
-
-    # @api hide
-    def initialize(service)
-      @service = service
-    end
-
-    # @!attribute [r] message
-    # Returns a default text message for the exception.
-    #
-    # @example
-    #   error = Hexx::ServiceInvalid.new service
-    #   error.message # => "Service invalid: #<Hexx::Service... >"
-    #
-    # @return [String] The message.
-    def message
-      "Service invalid: #{ service.inspect }"
-    end
-
-    # @!attribute [r] messages
-    # Returns a list of error messages from the service.
-    #
-    # @example
-    #   service.errors.add :base, "some error"
-    #
-    #   error = Hexx::ServiceInvalid.new service
-    #   error.messages
-    #   # => [#<Hexx::Message @type="error" @text="some error" >]
-    #
-    # @return [Array<Hexx::Message>] The list of error messages.
-    def messages
-      errors.map { |text| Message.new type: "error", text: text }
-    end
-
-    private
-
-    def errors
-      service.errors.messages.values.flatten
-    end
-  end
-end

data/spec/hexx/coercible_spec.rb

@@ -1,72 +0,0 @@
-require "spec_helper"
-
-module Hexx
-  describe Coercible do
-
-    # ==========================================================================
-    # Prepare environment
-    # ==========================================================================
-
-    before { class  TestModel; extend Coercible; end }
-    before { module TestModule;  end }
-    before { class  TestCoercion < Struct.new(:string); end }
-
-    let(:test_model)    { TestModel   }
-    let(:test_module)   { TestModule  }
-    let(:test_coercion) { TestCoercion }
-
-    after { Hexx.send :remove_const, :TestCoercion }
-    after { Hexx.send :remove_const, :TestModule  }
-    after { Hexx.send :remove_const, :TestModel   }
-
-    # ==========================================================================
-    # Run tests
-    # ==========================================================================
-
-    describe ".attr_coerced" do
-
-      context "when the name is neither type nor symbol" do
-
-        it "fails with TypeError" do
-          expect { test_model.send :attr_coerced, 1, type: test_coercion }
-            .to raise_error(TypeError)
-        end
-      end
-
-      context "when the name is empty" do
-
-        it "fails with ArgumentError" do
-          expect { test_model.send :attr_coerced, "", type: test_coercion }
-            .to raise_error(ArgumentError)
-        end
-      end
-
-      context "when no type is set" do
-
-        it "fails with ArgumentError" do
-          expect { test_model.send :attr_coerced, :name }
-            .to raise_error(ArgumentError)
-        end
-      end
-
-      context "when a type is not a class" do
-
-        it "fails with TypeError" do
-          expect { test_model.send :attr_coerced, :name, type: test_module }
-            .to raise_error(TypeError)
-        end
-      end
-
-      context "with valid arguments" do
-
-        before  { test_model.send :attr_coerced, :name, type: test_coercion }
-        subject { test_model.new }
-
-        it "coerces an attribute with given type" do
-          subject.name = "some name"
-          expect(subject.name).to be_kind_of test_coercion
-        end
-      end
-    end
-  end
-end

data/spec/hexx/configurable_spec.rb

@@ -1,93 +0,0 @@
-require "spec_helper"
-
-module Hexx
-  describe Configurable do
-
-    # Mocks gem core module to test dependencies from
-    before { module Test; extend Configurable; end }
-    after  { Hexx.send :remove_const, :Test }
-
-    let(:described_module) { Test }
-
-    describe ".configure" do
-
-      it "is defined" do
-        expect(described_module).to respond_to :configure
-      end
-
-      it "yields block with self" do
-        described_module.configure do |config|
-          expect(config).to eq described_module
-        end
-      end
-    end
-
-    describe ".depends_on" do
-
-      it "is defined" do
-        expect(described_module).to respond_to :depends_on
-      end
-
-      it "accepts symbolic attributes" do
-        expect { described_module.depends_on :item }.not_to raise_error
-      end
-
-      it "accepts string attributes" do
-        expect { described_module.depends_on "item" }.not_to raise_error
-      end
-
-      it "accepts arrays" do
-        expect { described_module.depends_on "item", [:item] }
-          .not_to raise_error
-      end
-
-      it "accepts default option" do
-        expect { described_module.depends_on :item, default: Hexx::Service }
-          .not_to raise_error
-      end
-
-      it "fails when wrong object given" do
-        expect { described_module.depends_on 1 }.to raise_error TypeError
-      end
-
-      it "fails when blank object given" do
-        expect { described_module.depends_on "" }.to raise_error ArgumentError
-      end
-
-      it "adds dependencies getters" do
-        described_module.depends_on :item, "user"
-        expect(described_module).to respond_to :item
-        expect(described_module).to respond_to :user
-      end
-
-      it "adds dependencies setters" do
-        described_module.depends_on :item, "user"
-        expect(described_module).to respond_to :item=
-        expect(described_module).to respond_to :user=
-      end
-
-      context ":item" do
-
-        before { described_module.depends_on :item }
-
-        it "makes a setter to allow modules" do
-          described_module.item = String
-          expect(described_module.item).to eq String
-        end
-
-        it "makes a setter to require modules" do
-          expect { described_module.item = :String }.to raise_error TypeError
-        end
-      end
-
-      context ":item, default: Hexx::Service" do
-
-        before { described_module.depends_on :item, default: Hexx::Service  }
-
-        it "sets default value for the item" do
-          expect(described_module.item).to eq Hexx::Service
-        end
-      end
-    end
-  end
-end

data/spec/hexx/dependable_spec.rb

@@ -1,125 +0,0 @@
-require "spec_helper"
-
-module Hexx
-  describe Dependable do
-
-    # ==========================================================================
-    # Prepare environment
-    # ==========================================================================
-
-    before { class Test; extend Dependable; end }
-    before { module TestModule; end }
-    before { class TestClass; end }
-
-    let(:described_class) { Test }
-    let(:test_module)     { TestModule }
-    let(:test_class)      { TestModule }
-
-    after  { Hexx.send :remove_const, :TestClass }
-    after  { Hexx.send :remove_const, :TestModule }
-    after  { Hexx.send :remove_const, :Test }
-
-    # ==========================================================================
-    # Run tests
-    # ==========================================================================
-
-    describe ".depends_on" do
-
-      it "is private" do
-        expect { described_class.depends_on :item }.to raise_error
-        expect { described_class.send :depends_on, :item }.not_to raise_error
-      end
-
-      it "accepts string argument" do
-        expect { described_class.send :depends_on, "item" }.not_to raise_error
-      end
-
-      it "requires non-empty argument" do
-        expect { described_class.send :depends_on, "" }
-          .to raise_error(ArgumentError)
-      end
-
-      it "requires string or symbol" do
-        expect { described_class.send :depends_on, 1 }
-          .to raise_error(TypeError)
-      end
-
-      it "accepts the :default option with class value" do
-        expect { described_class.send :depends_on, :item, default: test_class }
-          .not_to raise_error
-      end
-
-      it "accepts the :default option with module value" do
-        expect { described_class.send :depends_on, :item, default: test_module }
-          .not_to raise_error
-      end
-
-      it "accepts the :default option with nil" do
-        expect { described_class.send :depends_on, :item, default: nil }
-          .not_to raise_error
-      end
-
-      it "requires the :default option to be nil, class or module" do
-        expect { described_class.send :depends_on, :item, default: 1 }
-          .to raise_error { TypeError }
-      end
-
-      context "with a default implementation" do
-
-        before  { described_class.send :depends_on, :item, default: test_class }
-        subject { described_class.new }
-
-        it "declares a getter" do
-          expect(subject).to respond_to :item
-        end
-
-        it "declares a setter" do
-          expect(subject).to respond_to :item=
-          expect { subject.item = described_class }
-            .to change { subject.item }.to described_class
-        end
-
-        it "makes a setter to require module or class" do
-          expect { subject.item = 1 }.to raise_error { TypeError }
-        end
-
-        it "sets implementation by default" do
-          expect(subject.item).to eq test_class
-        end
-
-        it "resets implementation to default" do
-          expect { subject.item = nil }.not_to change { subject.item }
-        end
-      end
-
-      context "without a default implementation" do
-
-        before  { described_class.send :depends_on, :item }
-        subject { described_class.new }
-
-        it "declares a getter" do
-          expect(subject).to respond_to :item
-        end
-
-        it "declares a setter" do
-          expect(subject).to respond_to :item=
-          subject.item = test_class
-          expect(subject.item).to be test_class
-        end
-
-        it "makes a setter to require module or class" do
-          expect { subject.item = 1 }.to raise_error(TypeError)
-        end
-
-        it "fails before the dependency not implemented" do
-          expect { subject.item }.to raise_error(NotImplementedError)
-        end
-
-        it "fails when the dependency implementation resets" do
-          subject.item = test_class
-          expect { subject.item = nil }.to raise_error(NotImplementedError)
-        end
-      end
-    end
-  end
-end

data/spec/hexx/helpers/exceptions_spec.rb

@@ -1,96 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-
-module Hexx
-  describe Helpers::Exceptions do
-
-    before { class Test; include Helpers::Exceptions; end }
-    after  { Hexx.send :remove_const, :Test }
-
-    let(:service_invalid) { Hexx::ServiceInvalid }
-    let(:message)         { Hexx::Message.new type: "error", text: "text" }
-    let(:described_class) { Test }
-    subject { described_class.new }
-
-    it "includes Messages" do
-      expect(described_class).to include Helpers::Messages
-    end
-
-    describe ".raises" do
-
-      it "declares the specific StandardError exception(s)" do
-        described_class.send :raises, :TestException
-        exception = described_class.const_get :TestException
-        expect(exception.new).to be_kind_of StandardError
-      end
-
-      it "accepts a list of values" do
-        expect { described_class.send :raises, :One, :Two }.not_to raise_error
-        expect(described_class.const_defined? :One).to be_truthy
-        expect(described_class.const_defined? :Two).to be_truthy
-      end
-
-      it "accepts an array of values" do
-        expect { described_class.send :raises, %w(One Two) }.not_to raise_error
-        expect(described_class.const_defined? :One).to be_truthy
-        expect(described_class.const_defined? :Two).to be_truthy
-      end
-
-      it "requires value" do
-        expect { described_class.send :raises }.to raise_error ArgumentError
-      end
-
-      it "fails if non-string or non-symbol value given" do
-        expect { described_class.send :raises, 1 }.to raise_error TypeError
-      end
-    end
-
-    describe "#on_error" do
-
-      it "fails with ServiceInvalid" do
-        expect { subject.on_error [message] }.to raise_error service_invalid
-      end
-
-      it "adds errors to the service" do
-        begin; subject.on_error [message]; rescue; end
-        expect(subject.errors.messages).to eq(base: ["text"])
-      end
-    end
-
-    describe "#escape" do
-
-      it "yields a block" do
-        value  = "Hello!"
-        result = subject.escape { value }
-        expect(result).to eq value
-      end
-
-      context "when a block raises ServiceInvalid error" do
-
-        let!(:exception) { service_invalid.new(subject) }
-
-        it "re-raises the exception" do
-          expect { subject.escape { fail exception } }
-            .to raise_error { exception }
-        end
-      end
-
-      context "when a block raises StandardError" do
-
-        let(:run)     { subject.escape { fail "text" } }
-
-        it "re-raises the ServiceInvalid" do
-          expect { run }.to raise_error service_invalid
-        end
-
-        it "adds error to the messages" do
-          begin
-            run
-          rescue => err
-            expect(err.messages).to contain_exactly message
-          end
-        end
-      end
-    end
-  end
-end