hexx 0.0.1

data/lib/hexx/version.rb

@@ -0,0 +1,4 @@
+# Core classes to follow hexagonal domain architecture.
+module Hexx
+  VERSION = "0.0.1"
+end

data/spec/hexx/exceptions/not_found_error_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+module Hexx
+  describe NotFoundError do
+
+    let!(:subject) { NotFoundError }
+
+    it "inherits RuntimeError" do
+      expect(subject.ancestors).to be_include Hexx::RuntimeError
+    end
+
+    describe "#message" do
+
+      let!(:object) { double "object" }
+      let!(:errors) { double "errors" }
+      before { allow(object).to receive(:errors) { errors } }
+
+      it "customized" do
+        begin
+          fail subject.new(object)
+        rescue => error
+          expect(error.message).to eq "Not found: #{ errors.inspect }"
+        end
+      end
+    end
+  end
+end

data/spec/hexx/exceptions/record_invalid_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+module Hexx
+  describe RecordInvalid do
+
+    let!(:subject) { RecordInvalid }
+
+    it "inherits RuntimeError" do
+      expect(subject.ancestors).to be_include Hexx::RuntimeError
+    end
+
+    describe "#message" do
+
+      let!(:object) { double "object" }
+      let!(:errors) { double "errors" }
+      before { allow(object).to receive(:errors) { errors } }
+
+      it "customized" do
+        begin
+          fail subject.new(object)
+        rescue => error
+          expect(error.message).to eq "Invalid use case: #{ errors.inspect }"
+        end
+      end
+    end
+  end
+end

data/spec/hexx/exceptions/runtime_error_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+module Hexx
+  describe RuntimeError do
+
+    let!(:subject) { RuntimeError }
+    let!(:object)  { double "object" }
+    let!(:errors)  { double "errors" }
+    before { allow(object).to receive(:errors) { errors } }
+
+    let!(:error)  { subject.new object }
+
+    it "inherits core RuntimeError" do
+      expect(subject.ancestors).to be_include ::RuntimeError
+    end
+
+    describe ".new" do
+
+      it "initializes the object attribute" do
+        expect(subject).to respond_to(:new).with(1).argument
+      end
+    end
+
+    describe "#object" do
+
+      it "is public" do
+        expect(error).to respond_to :object
+      end
+
+      it "initializes the #object attribute" do
+        expect(error.object).to eq object
+      end
+    end
+
+    describe "#errors" do
+
+      it "is public" do
+        expect(error).to respond_to :errors
+      end
+
+      it "delegated to object" do
+        expect(error.errors).to eq errors
+      end
+
+      it "set to nil unless object is set" do
+        expect(subject.new(nil).errors).to be_nil
+      end
+    end
+
+    describe "#message" do
+
+      it "customized" do
+        begin
+          fail error
+        rescue => e
+          expect(e.message).to eq "Runtime error: #{ errors.inspect }"
+        end
+      end
+    end
+  end
+end

data/spec/hexx/exceptions/use_case_invalid_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+module Hexx
+  describe UseCaseInvalid do
+
+    let!(:subject) { UseCaseInvalid }
+
+    it "inherits RuntimeError" do
+      expect(subject.ancestors).to be_include Hexx::RuntimeError
+    end
+
+    describe "#message" do
+
+      let!(:object) { double "object" }
+      let!(:errors) { double "errors" }
+      before { allow(object).to receive(:errors) { errors } }
+
+      it "customized" do
+        begin
+          fail subject.new(object)
+        rescue => error
+          expect(error.message).to eq "Invalid use case: #{ errors.inspect }"
+        end
+      end
+    end
+  end
+end

data/spec/hexx/models_spec.rb

@@ -0,0 +1,64 @@
+module Hexx
+  describe Models do
+
+    # ==========================================================================
+    # Prepare environment
+    # ==========================================================================
+
+    around do |example|
+      class TestModel; include Models; end
+      class TestAttribute; end
+      example.run
+      Hexx.send :remove_const, :TestAttribute
+      Hexx.send :remove_const, :TestModel
+    end
+
+    let!(:coerced_attribute) { double "coerced attribute" }
+    before do
+      allow(TestAttribute).to receive(:new) { |val| coerced_attribute if val }
+    end
+
+    # ==========================================================================
+    # Prepare variables
+    # ==========================================================================
+
+    let!(:subject) { TestModel }
+
+    # ==========================================================================
+    # Run tests
+    # ==========================================================================
+
+    describe "#validate!" do
+
+      let!(:object)  { subject.new }
+
+      it "is public" do
+        expect(object).to respond_to(:validate!).with(0).arguments
+      end
+
+      it "returns true for valid instance" do
+        allow(object).to receive(:valid?) { true }
+        expect(object.validate!).to be_truthy
+      end
+
+      it "fails with Hexx::RecordInvalid for invalid instance" do
+        allow(object).to receive(:valid?) { false }
+        expect { object.validate! }.to raise_error do |error|
+          expect(error).to be_kind_of Hexx::RecordInvalid
+          expect(error.object).to eq object
+        end
+      end
+    end
+
+    describe ".attr_coerced" do
+
+      it "coerces an attribute with given type" do
+        subject.send :attr_coerced, :name, type: TestAttribute
+        object = subject.new
+        expect { object.name = "some name" }
+          .to change { object.name }
+          .from(nil).to coerced_attribute
+      end
+    end
+  end
+end

data/spec/hexx/settings_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+module Hexx
+  describe Settings do
+
+    around do |example|
+      module TestModule; include Settings; end
+      class TestClass; end
+      example.run
+      Hexx.send :remove_const, :TestClass
+      Hexx.send :remove_const, :TestModule
+    end
+
+    let!(:subject) { TestModule }
+
+    describe ".configure" do
+
+      it "is public" do
+        expect(subject).to respond_to(:configure).with(0).arguments
+      end
+
+      it "sends itself to a block" do
+        subject.configure do |c|
+          expect(c).to eq subject
+        end
+      end
+    end
+
+    describe ".depends_on" do
+
+      it "is public" do
+        expect(subject).to respond_to(:depends_on).with(1).argument
+      end
+
+      it "defines name settings accessor" do
+        subject.depends_on :test_class
+        expect(subject).to respond_to(:test_class_name).with(0).arguments
+        expect(subject).to respond_to(:test_class_name=).with(1).argument
+        expect { subject.test_class_name = "TestClass" }
+          .to change { subject.test_class_name }.from(nil).to "TestClass"
+      end
+
+      it "defines corresponding constant reader" do
+        subject.depends_on :test_class
+        expect(subject).to respond_to(:test_class).with(0).arguments
+        expect { subject.test_class_name = "Hexx::TestClass" }
+          .to change { subject.test_class }.from(nil).to TestClass
+      end
+    end
+  end
+end

data/spec/hexx/use_case_spec.rb

@@ -0,0 +1,262 @@
+require "spec_helper"
+
+module Hexx
+  describe UseCase do
+
+    around :each do |example|
+      class TestCase < UseCase; end
+      example.run
+      Hexx.send :remove_const, :TestCase
+    end
+
+    let!(:subject) { TestCase }
+
+    # ==========================================================================
+    # Tests
+    # ==========================================================================
+
+    it "includes ActiveModel validations" do
+      expect(subject.ancestors).to be_include ActiveModel::Validations
+    end
+
+    describe ".new" do
+
+      it "accepts 0 to 1 arguments" do
+        expect(subject).to respond_to(:new).with(0).arguments
+        expect(subject).to respond_to(:new).with(1).arguments
+      end
+
+      it "without arguments sets #params to {}" do
+        use_case = subject.new
+        expect(use_case.send(:params)).to eq({})
+      end
+
+      it "with unknown key sets #params to {}" do
+        use_case = subject.new id: 1
+        expect(use_case.send(:params)).to eq({})
+      end
+
+      it "with non-hash argument sets #params to {}" do
+        use_case = subject.new 1
+        expect(use_case.send(:params)).to eq({})
+      end
+    end
+
+    describe ".allow_params" do
+
+      it "allows #params to accept value from arguments" do
+        subject.send :allow_params, :id, :name
+        use_case = subject.new id: 1, name: "text", wrong: :wrong
+        expect(use_case.send(:params)).to eq("id" => 1, "name" => "text")
+      end
+
+      it "stringifies keys" do
+        subject.send :allow_params, :"1"
+        use_case = subject.new 1 => 1, "1" => 2, :"1" => 3
+        expect(use_case.send(:params)).to eq("1" => 3)
+      end
+    end
+
+    describe "#params" do
+
+      it "is private" do
+        expect(subject.new).not_to respond_to :params
+      end
+    end
+
+    describe "#valid?" do
+
+      it "is private" do
+        expect(subject.new).not_to respond_to :valid?
+      end
+    end
+
+    describe "#invalid?" do
+
+      it "is private" do
+        expect(subject.new).not_to respond_to :valid?
+      end
+    end
+
+    describe "#validate!" do
+
+      let!(:use_case) { subject.new }
+
+      it "is private" do
+        expect(use_case).not_to respond_to :validate!
+      end
+
+      context "invalid use_case" do
+
+        before { allow(use_case).to receive(:valid?) { false } }
+
+        it "calls the #valid? method" do
+          expect(use_case).to receive :valid?
+          begin; use_case.send :validate!; rescue Exception; end
+        end
+
+        it "fails" do
+          expect { use_case.send :validate! }.to raise_error do |error|
+            expect(error).to be_kind_of UseCaseInvalid
+          end
+        end
+      end
+
+      context "valid use_case" do
+
+        it "passes" do
+          expect { use_case.send :validate! }.not_to raise_error
+        end
+
+        it "not changes it" do
+          expect { use_case.send :validate! }.not_to change { use_case }
+        end
+      end
+    end
+
+    describe "#run!" do
+
+      let!(:use_case) { subject.new }
+
+      it "is public" do
+        expect(use_case).to respond_to(:run!).with(0).arguments
+      end
+
+      it "raises NotImplementedError" do
+        expect { use_case.run! }.to raise_error do |error|
+          expect(error).to be_kind_of NotImplementedError
+        end
+      end
+    end
+
+    describe "#run" do
+
+      let!(:use_case) { subject.new }
+      let!(:object)   { double "entity" }
+      let!(:errors)   { { base: :invalid } }
+      let!(:listener) { double "listener" }
+
+      before { allow(object).to receive(:errors) { errors } }
+      before { use_case.subscribe listener }
+
+      it "calls the #run!" do
+        expect(use_case).to receive(:run!)
+        begin; use_case.run; rescue Exception; end
+      end
+
+      context "if the #run! passes" do
+
+        let!(:result) { double "result" }
+        before { allow(use_case).to receive(:run!) { result } }
+
+        it "returns its output" do
+          expect(use_case.run).to eq result
+        end
+      end
+
+      context "if the #run! raises NotFoundError" do
+
+        before do
+          allow(use_case).to receive(:run!) { fail NotFoundError.new object }
+        end
+
+        it "doesn't raise" do
+          expect { use_case.run }.not_to raise_error
+        end
+
+        it "publishes the :not_found notification" do
+          expect(listener).to receive(:not_found) do |messages|
+            expect(messages).to eq errors.values
+          end
+          use_case.run
+        end
+
+        it "returns nil" do
+          expect(use_case.run).to be_nil
+        end
+      end
+
+      context "if the #run! raises another Hexx::Runtime error" do
+
+        before do
+          allow(use_case).to receive(:run!) { fail RuntimeError.new object }
+        end
+
+        it "doesn't raise" do
+          expect { use_case.run }.not_to raise_error
+        end
+
+        it "publishes the :error notification" do
+          expect(listener).to receive(:error) do |messages|
+            expect(messages).to eq errors.values
+          end
+          use_case.run
+        end
+
+        it "returns nil" do
+          expect(use_case.run).to be_nil
+        end
+      end
+
+      context "if the #run! raises core StandardError" do
+
+        before do
+          allow(use_case).to receive(:run!) { fail ::StandardError }
+        end
+
+        it "doesn't raise" do
+          expect { use_case.run }.not_to raise_error
+        end
+
+        it "publishes the :error notification" do
+          expect(listener).to receive(:error) do |arg|
+            expect(arg).to eq ["StandardError"]
+          end
+          use_case.run
+        end
+
+        it "returns nil" do
+          expect(use_case.run).to be_nil
+        end
+      end
+
+      context "if the #run! raises non-runtime error" do
+
+        before do
+          allow(use_case).to receive(:run!) { fail Exception }
+        end
+
+        it "re-raises the error" do
+          expect { use_case.run }.to raise_error do |error|
+            expect(error.inspect).to eq Exception.new.inspect
+          end
+        end
+      end
+    end
+
+    describe "#subscribe" do
+
+      let!(:use_case) { subject.new }
+      let!(:listener) { double "listener" }
+      let!(:messages) { double "messages" }
+
+      before do
+        allow(use_case)
+          .to receive(:run!) { use_case.send :publish, :ok, messages }
+      end
+
+      it "is public" do
+        expect(use_case).to respond_to(:subscribe).with(1).argument
+        expect(use_case).to respond_to(:subscribe).with(2).arguments
+      end
+
+      it "subscribes a listener to use_case notifications" do
+        use_case.subscribe listener
+        expect(listener).to receive(:ok) do |messages|
+          expect(messages).to eq messages
+        end
+        use_case.run!
+      end
+    end
+  end
+end