action_logic 0.0.3 → 0.0.4

data/spec/action_logic/action_task_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+require 'action_logic'
+require 'fixtures/tasks'
+
+module ActionLogic
+  describe ActionTask do
+
+    it "returns an instance of ActionContext" do
+      result = SimpleTestTask.execute()
+
+      expect(result).to be_a(ActionLogic::ActionContext)
+    end
+
+    it "sets an attribute and value on the context" do
+      result = SimpleTestTask.execute()
+
+      expect(result.new_attribute).to be_truthy
+    end
+
+    describe "around validations" do
+      describe "required attributes and type validation" do
+        it "does not raise error if context has required keys and values are of the correct type" do
+          expect { ValidateAroundTestTask.execute(Constants::VALID_ATTRIBUTES) }.to_not raise_error
+        end
+
+        it "raises error if context is missing required keys" do
+          expect { ValidateAroundTestTask.execute() }.to\
+            raise_error(ActionLogic::MissingAttributeError)
+        end
+
+        it "raises error if context has required keys but values are not of correct type" do
+          expect { ValidateAroundTestTask.execute(Constants::INVALID_ATTRIBUTES) }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "custom types" do
+        it "allows validation against custom defined types" do
+          expect { ValidateAroundCustomTypeTestTask.execute(:custom_type => CustomType1.new) }.to_not raise_error
+        end
+
+        it "raises error if context has custom type attribute but value is not correct custom type" do
+          expect { ValidateAroundCustomTypeTestTask.execute(:custom_type => CustomType2.new) }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "presence" do
+        it "validates presence if presence is specified" do
+          expect { ValidateAroundPresenceTestTask.execute(:integer_test => 1) }.to_not raise_error
+        end
+
+        it "raises error if context has required key but value is not defined when validation requires presence" do
+          expect { ValidateAroundPresenceTestTask.execute(:integer_test => nil) }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+      end
+
+      describe "custom presence" do
+        it "allows custom presence validation if custom presence is defined" do
+          expect { ValidateAroundCustomPresenceTestTask.execute(:array_test => [1]) }.to_not raise_error
+        end
+
+        it "raises error if custom presence validation is not satisfied" do
+          expect { ValidateAroundCustomPresenceTestTask.execute(:array_test => []) }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+
+        it "raises error if custom presence validation is not supported" do
+          expect { ValidateAroundUnrecognizablePresenceTestTask.execute(:integer_test => 1) }.to\
+            raise_error(ActionLogic::UnrecognizablePresenceValidatorError)
+        end
+      end
+    end
+
+    describe "before validations" do
+      describe "required attributes and type validation" do
+        it "does not raise error if context has required keys and values are of the correct type" do
+          expect { ValidateBeforeTestTask.execute(Constants::VALID_ATTRIBUTES) }.to_not raise_error
+        end
+
+        it "raises error if context is missing required keys" do
+          expect { ValidateBeforeTestTask.execute() }.to\
+            raise_error(ActionLogic::MissingAttributeError)
+        end
+
+        it "raises error if context has required keys but values are not of correct type" do
+          expect { ValidateBeforeTestTask.execute(Constants::INVALID_ATTRIBUTES) }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "custom types" do
+        it "allows validation against custom defined types" do
+          expect { ValidateBeforeCustomTypeTestTask.execute(:custom_type => CustomType1.new) }.to_not raise_error
+        end
+
+        it "raises error if context has custom type attribute but value is not correct custom type" do
+          expect { ValidateBeforeCustomTypeTestTask.execute(:custom_type => CustomType2.new) }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "presence" do
+        it "validates presence if presence is specified" do
+          expect { ValidateBeforePresenceTestTask.execute(:integer_test => 1) }.to_not raise_error
+        end
+
+        it "raises error if context has required key but value is not defined when validation requires presence" do
+          expect { ValidateBeforePresenceTestTask.execute(:integer_test => nil) }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+      end
+
+      describe "custom presence" do
+        it "allows custom presence validation if custom presence is defined" do
+          expect { ValidateBeforeCustomPresenceTestTask.execute(:array_test => [1]) }.to_not raise_error
+        end
+
+        it "raises error if custom presence validation is not satisfied" do
+          expect { ValidateBeforeCustomPresenceTestTask.execute(:array_test => []) }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+
+        it "raises error if custom presence validation is not supported" do
+          expect { ValidateBeforeUnrecognizablePresenceTestTask.execute(:integer_test => 1) }.to\
+            raise_error(ActionLogic::UnrecognizablePresenceValidatorError)
+        end
+      end
+    end
+
+    describe "after validations" do
+      describe "required attributes and type validation" do
+        it "does not raise error if the task sets all required keys and values are of the correct type" do
+          expect { ValidateAfterTestTask.execute() }.to_not raise_error
+        end
+
+        it "raises error if task does not provide the necessary keys" do
+          expect { ValidateAfterMissingAttributesTestTask.execute() }.to\
+            raise_error(ActionLogic::MissingAttributeError)
+        end
+
+        it "raises error if task has required key but is not of correct type" do
+          expect { ValidateAfterInvalidTypeTestTask.execute() }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "custom types" do
+        it "allows validation against custom defined types" do
+          expect { ValidateAfterCustomTypeTestTask.execute() }.to_not raise_error
+        end
+
+        it "raises error if context has custom type attribute but value is not correct custom type" do
+          expect { ValidateAfterInvalidCustomTypeTestTask.execute() }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "presence" do
+        it "validates presence if presence is specified" do
+          expect { ValidateAfterPresenceTestTask.execute() }.to_not raise_error
+        end
+
+        it "raises error if context has required key but value is not defined when validation requires presence" do
+          expect { ValidateAfterInvalidPresenceTestTask.execute() }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+      end
+
+      describe "custom presence" do
+        it "allows custom presence validation if custom presence is defined" do
+          expect { ValidateAfterCustomPresenceTestTask.execute() }.to_not raise_error
+        end
+
+        it "raises error if custom presence validation is not satisfied" do
+          expect { ValidateAfterInvalidCustomPresenceTestTask.execute() }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+
+        it "raises error if custom presence validation is not supported" do
+          expect { ValidateAfterUnrecognizablePresenceTestTask.execute() }.to\
+            raise_error(ActionLogic::UnrecognizablePresenceValidatorError)
+        end
+      end
+    end
+
+    describe "error handler" do
+      context "with error handler defined" do
+        it "does not catch exceptions due to before validation errors" do
+          expect { ErrorHandlerInvalidAttributesBeforeTestTask.execute() }.to\
+            raise_error(ActionLogic::MissingAttributeError)
+        end
+
+        it "does not catch exceptions due to after validation errors" do
+          expect { ErrorHandlerInvalidAttributesAfterTestTask.execute() }.to\
+            raise_error(ActionLogic::MissingAttributeError)
+        end
+
+        it "the error and context are passed to the error handler" do
+          result = ErrorHandlerTestTask.execute()
+
+          expect(result.e).to be_a(RuntimeError)
+          expect(result).to be_a(ActionLogic::ActionContext)
+        end
+      end
+
+      context "without error handler defined" do
+        it "raises original exception if error handler is not defined" do
+          expect { MissingErrorHandlerTestTask.execute() }.to\
+            raise_error(RuntimeError)
+        end
+      end
+    end
+
+    describe "fail!" do
+      it "returns the context with the correct status and failure message" do
+        result = FailureTestTask.execute()
+
+        expect(result.status).to eq(:failure)
+        expect(result.message).to eq(Constants::FAILURE_MESSAGE)
+      end
+    end
+
+    describe "halt!" do
+      it "returns the context with the correct status and halt message" do
+        result = HaltTestTask.execute()
+
+        expect(result.status).to eq(:halted)
+        expect(result.message).to eq(Constants::HALT_MESSAGE)
+      end
+    end
+  end
+end

data/spec/action_logic/active_use_case_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+require 'action_logic'
+require 'fixtures/use_cases'
+require 'fixtures/custom_types'
+
+module ActionLogic
+  describe ActionUseCase do
+
+    it "returns an instance of ActionContext" do
+      result = SimpleTestUseCase.execute()
+
+      expect(result).to be_a(ActionLogic::ActionContext)
+    end
+
+    it "evalutes a task defined by the use case" do
+      result = SimpleTestUseCase.execute()
+
+      expect(result.new_attribute).to be_truthy
+    end
+
+    it "evalutes multiple tasks defined by the use case" do
+      result = SimpleTestUseCase2.execute()
+
+      expect(result.first).to eq("first")
+      expect(result.second).to eq("second")
+    end
+
+    it "calls the use case before evaluating the tasks" do
+      result = SimpleTestUseCase3.execute()
+
+      expect(result.first).to eq("first")
+      expect(result.second).to eq("defined in use case")
+    end
+
+    describe "before validations" do
+      describe "required attributes and type validation" do
+        it "does not raise error if context has required keys and values are of the correct type" do
+          expect { ValidateBeforeTestUseCase.execute(Constants::VALID_ATTRIBUTES) }.to_not raise_error
+        end
+
+        it "raises error if context is missing required keys" do
+          expect { ValidateBeforeTestUseCase.execute() }.to\
+            raise_error(ActionLogic::MissingAttributeError)
+        end
+
+        it "raises error if context has required key but is not of correct type" do
+          expect { ValidateBeforeTestUseCase.execute(Constants::INVALID_ATTRIBUTES) }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "custom types" do
+        it "allows validation against custom defined types" do
+          expect { ValidateBeforeCustomTypeTestUseCase.execute(Constants::CUSTOM_TYPE_ATTRIBUTES1) }.to_not raise_error
+        end
+
+        it "raises error if context has custom type attribute but value is not correct custom type" do
+          expect { ValidateBeforeCustomTypeTestUseCase.execute(Constants::CUSTOM_TYPE_ATTRIBUTES2) }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "presence" do
+        it "validates presence if presence is specified" do
+          expect { ValidateBeforePresenceTestUseCase.execute(:integer_test => 1) }.to_not raise_error
+        end
+
+        it "raises error if context has required key but value is not defined when validation requires presence" do
+          expect { ValidateBeforePresenceTestUseCase.execute(:integer_test => nil) }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+      end
+
+      describe "custom presence" do
+        it "allows custom presence validation if custom presence is defined" do
+          expect { ValidateBeforeCustomPresenceTestUseCase.execute(:array_test => [1]) }.to_not raise_error
+        end
+
+        it "raises error if custom presence validation is not satisfied" do
+          expect { ValidateBeforeCustomPresenceTestUseCase.execute(:array_test => []) }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+
+        it "raises error if custom presence validation is not supported" do
+          expect { ValidateBeforeUnrecognizablePresenceTestUseCase.execute(:integer_test => 1) }.to\
+            raise_error(ActionLogic::UnrecognizablePresenceValidatorError)
+        end
+      end
+    end
+
+    describe "after validations" do
+      describe "required attributes and type validation" do
+        it "does not raise error if the task sets all required keys and values are of the correct type" do
+          expect { ValidateAfterTestUseCase.execute() }.to_not raise_error
+        end
+
+        it "raises error if task does not provide the necessary keys" do
+          expect { ValidateAfterMissingAttributesTestUseCase.execute() }.to\
+            raise_error(ActionLogic::MissingAttributeError)
+        end
+
+        it "raises error if task has required key but is not of correct type" do
+          expect { ValidateAfterInvalidTypeTestUseCase.execute() }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "custom types" do
+        it "allows validation against custom defined types" do
+          expect { ValidateAfterCustomTypeTestUseCase.execute() }.to_not raise_error
+        end
+
+        it "raises error if context has custom type attribute but value is not correct custom type" do
+          expect { ValidateAfterInvalidCustomTypeTestUseCase.execute() }.to\
+            raise_error(ActionLogic::AttributeTypeError)
+        end
+      end
+
+      describe "presence" do
+        it "validates presence if presence is specified" do
+          expect { ValidateAfterPresenceTestUseCase.execute() }.to_not raise_error
+        end
+
+        it "raises error if context has required key but value is not defined when validation requires presence" do
+          expect { ValidateAfterInvalidPresenceTestUseCase.execute() }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+      end
+
+      describe "custom presence" do
+        it "allows custom presence validation if custom presence is defined" do
+          expect { ValidateAfterCustomPresenceTestUseCase.execute() }.to_not raise_error
+        end
+
+        it "raises error if custom presence validation is not satisfied" do
+          expect { ValidateAfterInvalidCustomPresenceTestUseCase.execute() }.to\
+            raise_error(ActionLogic::PresenceError)
+        end
+
+        it "raises error if custom presence validation is not supported" do
+          expect { ValidateAfterUnrecognizablePresenceTestUseCase.execute() }.to\
+            raise_error(ActionLogic::UnrecognizablePresenceValidatorError)
+        end
+      end
+    end
+
+    describe "fail!" do
+      it "returns the context with the correct status and failure message" do
+        result = FailureTestUseCase.execute()
+
+        expect(result.status).to eq(:failure)
+        expect(result.message).to eq(Constants::FAILURE_MESSAGE)
+      end
+
+      it "stops execution of tasks after a task fails the context" do
+        result = FailureTestUseCase.execute()
+
+        expect(result.first).to eq("first")
+        expect(result.second).to eq("second")
+        expect(result.third).to be_nil
+      end
+    end
+
+    describe "halt!" do
+      it "returns the context with the correct status and halt message" do
+        result = HaltTestUseCase.execute()
+
+        expect(result.status).to eq(:halted)
+        expect(result.message).to eq(Constants::HALT_MESSAGE)
+      end
+
+      it "stops execution of tasks after a task halts the context" do
+        result = HaltTestUseCase.execute()
+
+        expect(result.first).to eq("first")
+        expect(result.second).to eq("second")
+        expect(result.third).to be_nil
+      end
+    end
+
+    describe "multiple use cases" do
+      it "does not persist attributes set on contexts from different use cases" do
+        result = HaltTestUseCase.execute()
+
+        expect(result.first).to eq("first")
+        expect(result.second).to eq("second")
+        expect(result.third).to be_nil
+        expect(result.status).to eq(:halted)
+
+        result2 = ValidateAfterPresenceTestUseCase.execute()
+
+        expect(result2.first).to be_nil
+        expect(result2.second).to be_nil
+        expect(result2.integer_test).to eq(1)
+        expect(result2.success?).to be_truthy
+      end
+    end
+  end
+end

data/spec/fixtures/constants.rb

@@ -0,0 +1,46 @@
+require 'fixtures/custom_types'
+
+class Constants
+  ALL_VALIDATIONS = { :integer_test => { :type => :integer, :presence => true },
+                      :float_test   => { :type => :float, :presence => true },
+                      :string_test  => { :type => :string, :presence => true },
+                      :bool_test    => { :type => :boolean, :presence => true },
+                      :hash_test    => { :type => :hash, :presence => true },
+                      :array_test   => { :type => :array, :presence => true },
+                      :symbol_test  => { :type => :symbol, :presence => true },
+                      :nil_test     => { :type => :nil } }
+
+  INVALID_ATTRIBUTES = { :integer_test => nil,
+                         :float_test   => nil,
+                         :string_test  => nil,
+                         :bool_test    => nil,
+                         :hash_test    => nil,
+                         :array_test   => nil,
+                         :symbol_test  => nil,
+                         :nil_test     => 1 }
+
+  VALID_ATTRIBUTES = { :integer_test => 1,
+                       :float_test => 1.0,
+                       :string_test => "string",
+                       :bool_test => true,
+                       :hash_test => {},
+                       :array_test => [],
+                       :symbol_test => :symbol,
+                       :nil_test => nil }
+
+  CUSTOM_TYPE_VALIDATION1 = { :custom_type => { :type => :customtype1, :presence => true } }
+
+  CUSTOM_TYPE_ATTRIBUTES1 = { :custom_type => CustomType1.new }
+
+  CUSTOM_TYPE_VALIDATION2 = { :custom_type => { :type => :customtype2, :presence => true } }
+
+  CUSTOM_TYPE_ATTRIBUTES2 = { :custom_type => CustomType2.new }
+
+  PRESENCE_VALIDATION = { :integer_test => { :presence => true } }
+
+  CUSTOM_PRESENCE_VALIDATION = { :array_test => { :presence => ->(array_test) { array_test.any? } } }
+
+  FAILURE_MESSAGE = "error"
+
+  HALT_MESSAGE = "halt"
+end