easy_command 1.0.0.pre.rc1

data/spec/easy_command/errors_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+require 'ostruct'
+
+describe EasyCommand::Errors do
+  let(:errors) { described_class.new }
+
+  describe '#add' do
+    it 'adds the error' do
+      errors.add :attribute, :some_error, 'some error description'
+      expect(errors[:attribute]).to eq([{ code: :some_error, message: 'some error description' }])
+    end
+
+    it 'adds the same error only once' do
+      errors.add :attribute, :some_error, 'some error description'
+      errors.add :attribute, :some_error, 'some error description'
+
+      expect(errors[:attribute]).to eq([{ code: :some_error, message: 'some error description' }])
+    end
+
+    it 'tries to localize the error message if possible' do
+      expect(I18n).to receive(:t!).with(:bad_post_code, anything).and_return("Very bad post code")
+
+      errors.add :address, :invalid, :bad_post_code
+      expect(errors[:address]).to eq([{ code: :invalid, message: "Very bad post code" }])
+    end
+
+    it 'symbolizes the code' do
+      errors.add :attribute, 'some_error', 'some error description'
+      expect(errors[:attribute]).to eq([{ code: :some_error, message: 'some error description' }])
+    end
+
+    context 'when the errors are for a i18n-scoped class' do
+      let(:scoped_klass) { Class.new { prepend EasyCommand }.tap { |c| c.i18n_scope = 'my.custom.scope' } }
+      let(:errors) { described_class.new(source: scoped_klass) }
+
+      it "takes the scope into account for localization" do
+        allow(I18n).to receive(:t!).with(:bad_post_code, anything).
+          and_return("Bad error message")
+        expect(I18n).to receive(:t!).with(:bad_post_code, hash_including(scope: 'my.custom.scope')).
+          and_return("Correct error message")
+
+        errors.add :address, :invalid, :bad_post_code
+        expect(errors[:address]).to eq([{ code: :invalid, message: "Correct error message" }])
+      end
+    end
+  end
+
+  describe '#exists?' do
+    it "indicates if the attribute has a specific error", :aggregate_failures do
+      expect(errors.exists?(:attribute, :some_error)).to eq(false)
+      errors.add(:attribute, :some_error, 'some message')
+      expect(errors.exists?(:attribute, :some_error)).to eq(true)
+    end
+  end
+
+  describe '#merge_from' do
+    # rubocop:disable Style/OpenStructUse
+    # We use it to quickly-mock objects, it's specs-only, that's fine
+
+    it 'can import errors from object with similar error sets' do
+      commandlike_object = OpenStruct.new(errors: described_class.new)
+      commandlike_object.errors.add(:name, :bad_name, "Bad name!")
+
+      errors.merge_from(commandlike_object)
+
+      expect(errors).to have_key(:name)
+      expect(errors[:name]).to include(code: :bad_name, message: "Bad name!")
+    end
+
+    it 'can import errors from any object responding to errors.details and errors.messages' do
+      recordlike_object = OpenStruct.new(errors: OpenStruct.new(messages: {}, details: {}))
+      recordlike_object.errors.messages[:name] = ["Bad name!"]
+      recordlike_object.errors.details[:name] = [{ error: :bad_name }]
+
+      errors.merge_from(recordlike_object)
+
+      expect(errors).to have_key(:name)
+      expect(errors[:name]).to include(code: :bad_name, message: "Bad name!")
+    end
+    # rubocop:enable Style/OpenStructUse
+  end
+
+  describe '#add_multiple_errors' do
+    let(:errors_list) do
+      {
+        attribute_a: [{ code: :some_error, message: 'some error description' }],
+        attribute_b: [{ code: :another_error, message: 'another error description' }],
+      }
+    end
+
+    before do
+      errors.add_multiple_errors errors_list
+    end
+
+    it 'populates itself with the added errors' do
+      expect(errors[:attribute_a]).to eq(errors_list[:attribute_a])
+      expect(errors[:attribute_b]).to eq(errors_list[:attribute_b])
+    end
+  end
+
+  describe '#full_messages' do
+    let(:errors_list) do
+      {
+        attribute_a: [
+          { code: :some_error, message: 'some error description' },
+          { code: :another_error, message: 'another error description' },
+        ],
+        attribute_b: [{ code: :another_error, message: 'another error description' }],
+      }
+    end
+
+    before do
+      errors.add_multiple_errors errors_list
+    end
+
+    it 'returns a messages array' do
+      expect(errors.full_messages).to eq(["Attribute_a some error description", "Attribute_a another error description", "Attribute_b another error description"])
+    end
+  end
+end

data/spec/easy_command/result_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+RSpec.describe EasyCommand::Result do
+  let(:monad) { described_class.new(5) }
+
+  it "carries a result" do
+    expect(monad.result).to eq(5)
+  end
+
+  describe "default" do
+    it "is a success" do
+      expect(monad.success?).to eq(true)
+    end
+
+    it "isn't a failure" do
+      expect(monad.failure?).to eq(false)
+    end
+
+    it "has no errors" do
+      expect(monad.errors).to be_empty
+    end
+  end
+
+  describe EasyCommand::Success do
+    let(:monad) { described_class.new(5) }
+
+    it "is a success" do
+      expect(monad.success?).to eq(true)
+    end
+
+    it "isn't a failure" do
+      expect(monad.failure?).to eq(false)
+    end
+
+    it "has no errors" do
+      expect(monad.errors).to be_empty
+    end
+  end
+
+  describe EasyCommand::Params do
+    let(:monad) { described_class.new(5) }
+
+    it "is a success" do
+      expect(monad.success?).to eq(true)
+    end
+
+    it "isn't a failure" do
+      expect(monad.failure?).to eq(false)
+    end
+
+    it "has no errors" do
+      expect(monad.errors).to be_empty
+    end
+  end
+
+  describe EasyCommand::Failure do
+    let(:monad) { described_class.new(5) }
+
+    it "isn't a success" do
+      expect(monad.success?).to eq(false)
+    end
+
+    it "is a failure" do
+      expect(monad.failure?).to eq(true)
+    end
+
+    it "can be instantiated with errors" do
+      errors = EasyCommand::Errors.new
+      errors.add(:attribute, :error)
+      monad = described_class.new(nil).with_errors(errors)
+      expect(monad.errors).to have_error(:attribute, :error)
+    end
+  end
+
+  describe "callbacks" do
+    describe "#on_success" do
+      context "when calld on a Success monads" do
+        let(:monad) { EasyCommand::Success.new(5) }
+
+        it "executes the block" do
+          block_executed = false
+          monad.on_success do
+            block_executed = true
+          end
+          expect(block_executed).to eq true
+        end
+
+        it "passes the content of the monad to the block" do
+          monad.on_success do |arg|
+            expect(arg).to eq(5)
+          end
+        end
+      end
+
+      context "when called on a Failure monads" do
+        let(:monad) { EasyCommand::Failure.new(5) }
+
+        it "doesn't execute the block" do
+          block_executed = false
+          monad.on_success do
+            block_executed = true
+          end
+          expect(block_executed).to eq false
+        end
+      end
+    end
+
+    describe "#on_failure" do
+      context "when called on a Success monads" do
+        let(:monad) { EasyCommand::Success.new(5) }
+
+        it "doesn't execute the block" do
+          block_executed = false
+          monad.on_failure do
+            block_executed = true
+          end
+          expect(block_executed).to eq false
+        end
+      end
+
+      context "when called on a Failure monads" do
+        let(:errors) { EasyCommand::Errors.new.tap { |err| err.add :attribute, :code } }
+        let(:monad) { EasyCommand::Failure.new(5).with_errors(errors) }
+
+        it "executes the block" do
+          block_executed = false
+          monad.on_failure do
+            block_executed = true
+          end
+          expect(block_executed).to eq true
+        end
+
+        it "passes the content of the monad to the block" do
+          monad.on_failure do |arg|
+            expect(arg).to eq(errors)
+          end
+        end
+      end
+    end
+  end
+
+  describe "chaining mechanism" do
+    let(:callable_object) do
+      Class.new { def self.call(*); :toto end }
+    end
+
+    it "calls the chained object" do
+      expect(callable_object).to receive(:call)
+      monad.then(callable_object)
+    end
+
+    it "passes its own result to the call" do
+      allow(callable_object).to receive(:call) do |arg|
+        expect(arg).to eq 5
+      end
+      monad.then(callable_object)
+    end
+
+    it "returns the result of the call" do
+      expect(monad.then(callable_object)).to eq(:toto)
+    end
+
+    context "when it's a failure" do
+      let(:monad) { EasyCommand::Failure.new(nil) }
+
+      it "doesn't call the chained object" do
+        expect(callable_object).not_to receive(:call)
+        monad.then(callable_object)
+      end
+
+      it "returns itself" do
+        expect(monad.then(callable_object)).to eq(monad)
+      end
+    end
+  end
+end

data/spec/easy_command_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+
+describe EasyCommand do
+  let(:command) { SuccessCommand.new(2) }
+
+  describe ".call" do
+    before do
+      allow(SuccessCommand).to receive(:new).and_return(command)
+      allow(command).to receive(:call)
+    end
+
+    it "initializes the command" do
+      expect(SuccessCommand).to receive(:new)
+
+      SuccessCommand.call 2
+    end
+
+    it "calls #call method" do
+      expect(command).to receive(:call)
+
+      SuccessCommand.call 2
+    end
+  end
+
+  describe "#call" do
+    let(:missed_call_command) { MissedCallCommand.new(2) }
+
+    it "returns a Success" do
+      expect(command.call).to be_a(EasyCommand::Success)
+    end
+
+    it "raises an exception if the method is not defined in the command" do
+      expect { missed_call_command.call }.to raise_error(EasyCommand::NotImplementedError)
+    end
+
+    it "returns a Failure if something went wrong" do
+      command.errors.add(:some_error, 'some message')
+      expect(command.call).to be_a(EasyCommand::Failure)
+    end
+  end
+
+  describe '#abort' do
+    let(:aborting_command) {
+      Class.new do
+        prepend EasyCommand
+
+        def call
+          abort :base, :some_error, 'Error message', result: 3
+          raise "We shouldn't reach this" # rubocop:disable Lint/UnreachableCode
+        end
+      end
+    }
+
+    it "stops the execution as soon as it's called" do
+      expect { aborting_command.call }.not_to raise_error
+    end
+
+    it "stops add the error passed as args" do
+      expect(aborting_command.call.errors).to have_error(:base, :some_error)
+    end
+
+    it "stops let Failure carry the result" do
+      expect(aborting_command.call.result).to eq(3)
+    end
+  end
+
+  describe '#assert' do
+    let(:asserting_command) {
+      Class.new do
+        prepend EasyCommand
+
+        def initialize(should_error, with_result: false)
+          @should_error = should_error
+          @with_result = with_result
+        end
+
+        def call
+          if @with_result
+            assert potential_error, result: 4
+          else
+            assert potential_error
+          end
+          raise "We shouldn't reach this"
+        end
+
+        def potential_error
+          if @should_error
+            errors.add :base, :error1
+            errors.add :base, :error2
+          end
+        end
+      end
+    }
+
+    it "stops the execution as soon as it's called" do
+      expect { asserting_command.call(true) }.not_to raise_error
+    end
+
+    it "adds the error passed as args" do
+      expect(asserting_command.call(true).errors).
+        to have_error(:base, :error1).
+        and have_error(:base, :error2)
+    end
+
+    context "with a result along side the error" do
+      it "lets Failure carry the result" do
+        expect(asserting_command.call(true, with_result: true).result).to eq(4)
+      end
+    end
+  end
+
+  describe "#success?" do
+    it "is true by default" do
+      expect(command.call).to be_success
+    end
+
+    it "is false if something went wrong" do
+      command.errors.add(:some_error, 'some message')
+      expect(command.call).not_to be_success
+    end
+  end
+
+  describe "#result" do
+    it "returns the result of command execution" do
+      expect(command.call.result).to eq(4)
+    end
+
+    context "when call is not called yet" do
+      it "returns nil" do
+        expect(command.result).to be_nil
+      end
+    end
+
+    context "when command fails" do
+      let(:command) { FailureCommand.new(2) }
+
+      it "still returns the result" do
+        expect(command.call.result).to eq(4)
+      end
+    end
+  end
+
+  describe "#failure?" do
+    it "is false by default" do
+      expect(command.call).not_to be_failure
+    end
+
+    it "is true if something went wrong" do
+      command.errors.add(:some_error, 'some message')
+      expect(command.call).to be_failure
+    end
+  end
+
+  describe "#errors" do
+    it "returns an EasyCommand::Errors" do
+      expect(command.errors).to be_a(EasyCommand::Errors)
+    end
+
+    context "with no errors" do
+      it "is empty" do
+        expect(command.errors).to be_empty
+      end
+    end
+
+    context "with errors" do
+      before do
+        command.errors.add(:attribute, :some_error, 'some message')
+      end
+
+      it "has a key with error message" do
+        expect(command.errors[:attribute]).to eq([{ code: :some_error, message: 'some message' }])
+      end
+    end
+  end
+
+  describe "#has_error?" do
+    it "indicates if the command has an error", :aggregate_failures do
+      expect(command.has_error?(:attribute, :some_error)).to eq(false)
+      command.errors.add(:attribute, :some_error, 'some message')
+      expect(command.has_error?(:attribute, :some_error)).to eq(true)
+    end
+  end
+
+  describe ".i18n_scope" do
+    after do
+      # Resetting to prevent leaks across specs
+      command.class.i18n_scope = 'errors.messages'
+    end
+
+    it "has a default value of 'errors.messages'" do
+      expect(command.class.i18n_scope).to eq('errors.messages')
+    end
+
+    it "can be overriden" do
+      command.class.i18n_scope = 'errors.new_scope'
+      expect(command.class.i18n_scope).to eq('errors.new_scope')
+    end
+  end
+
+  describe "#on_success" do
+    let(:command) { CallbackCommand.new(add_error: false) }
+
+    before do
+      allow(command).to receive(:call).and_call_original
+      allow(command).to receive(:on_success).and_call_original
+    end
+
+    it "is executed after #call" do
+      expect(command).to receive(:call).ordered
+      expect(command).to receive(:on_success).ordered
+      command.call
+    end
+
+    context "when there are errors" do
+      let(:command) { CallbackCommand.new(add_error: true) }
+
+      it "does not call #on_success" do
+        expect(command).to receive(:call).ordered
+        expect(command).not_to receive(:on_success)
+        command.call
+      end
+    end
+
+    context "when using sub command" do
+      let(:command) { CallbackCommand.new(add_error: false, with_subcommand: true) }
+      let(:subcommand) { SubCommand.new(add_error: false) }
+
+      before do
+        allow(SubCommand).to receive(:new).and_return(subcommand)
+        allow(subcommand).to receive(:on_success).and_call_original
+        allow(subcommand).to receive(:code_execution).and_call_original
+
+        allow(command).to receive(:code_execution).and_call_original
+      end
+
+      specify "#on_success are called in order" do
+        expect(command).to receive(:on_success).ordered
+        expect(subcommand).to receive(:on_success).ordered
+        command.call
+      end
+
+      specify "Sub command #on_success code are executed before parent" do
+        expect(subcommand).to receive(:code_execution).ordered
+        expect(command).to receive(:code_execution).ordered
+        command.call
+      end
+
+      context "when parent has errors" do
+        let(:command) { CallbackCommand.new(add_error: true) }
+
+        it "does not call #on_success neither for parent nor for children" do
+          expect(command).not_to receive(:on_success)
+          expect(subcommand).not_to receive(:on_success)
+          command.call
+        end
+      end
+
+      context "when subcommand has error" do
+        let(:subcommand) { SubCommand.new(add_error: true) }
+
+        it "does not call #on_success neither for parents nor for children" do
+          command.call
+          expect(command).not_to receive(:on_success)
+          expect(subcommand).not_to receive(:on_success)
+        end
+      end
+    end
+  end
+
+  describe "Subcommmand mechanism" do
+    it "can call other commands", :aggregate_failures do
+      expect(AdditionCommand).to receive(:new).and_call_original
+      expect(MultiplicationCommand).to receive(:new).and_call_original
+      expect(AddThenMultiplyCommand.call(2, 3, 4).result).to eq(20)
+    end
+
+    context "when the first command fails" do
+      before do
+        double_addition = AdditionCommand.new(2, 3)
+        allow(AdditionCommand).to receive(:new).and_return(double_addition)
+        allow(double_addition).to receive(:call).and_wrap_original do |m, *|
+          double_addition.errors.add(:addition, :failed)
+          m.call
+        end
+      end
+
+      it "merges the errors from the failing command in the calling command" do
+        result = AddThenMultiplyCommand.call(2, 3, 4)
+        expect(result.errors).to have_error(:addition, :failed)
+      end
+
+      it "stops the flow" do
+        expect(MultiplicationCommand).not_to receive(:new)
+        AddThenMultiplyCommand.call(2, 3, 4)
+      end
+    end
+  end
+end

data/spec/factories/addition_command.rb

@@ -0,0 +1,12 @@
+class AdditionCommand
+  prepend EasyCommand
+
+  def call
+    @a + @b
+  end
+
+  def initialize(a,b)
+    @a = a
+    @b = b
+  end
+end

data/spec/factories/callback_command.rb

@@ -0,0 +1,20 @@
+class CallbackCommand
+  prepend EasyCommand
+
+  def initialize(add_error: false, with_subcommand: false)
+    @add_error = add_error
+    @with_subcommand = with_subcommand
+  end
+
+  def call
+    assert_subcommand(SubCommand) if @with_subcommand
+    errors.add(:something, :forbidden) if @add_error
+  end
+
+  def on_success
+    code_execution __method__
+  end
+
+  def code_execution(method)
+  end
+end

data/spec/factories/failure_command.rb

@@ -0,0 +1,12 @@
+class FailureCommand
+  prepend EasyCommand
+
+  def initialize(input)
+    @input = input
+  end
+
+  def call
+    errors.add(:base, :some_error, 'Error message')
+    @input * 2
+  end
+end

data/spec/factories/missed_call_command.rb

@@ -0,0 +1,7 @@
+class MissedCallCommand
+  prepend EasyCommand
+
+  def initialize(input)
+    @input = input
+  end
+end

data/spec/factories/multiplication_command.rb

@@ -0,0 +1,12 @@
+class MultiplicationCommand
+  prepend EasyCommand
+
+  def call
+    @a * @b
+  end
+
+  def initialize(a,b)
+    @a = a
+    @b = b
+  end
+end

data/spec/factories/sub_command.rb

@@ -0,0 +1,19 @@
+class SubCommand
+  prepend EasyCommand
+
+  def initialize(add_error: false)
+    @add_error = add_error
+    @execution_orders = []
+  end
+
+  def call
+    errors.add(:something, :forbidden) if @add_error
+  end
+
+  def on_success
+    code_execution __method__
+  end
+
+  def code_execution(method)
+  end
+end

data/spec/factories/subcommand_command.rb

@@ -0,0 +1,14 @@
+class AddThenMultiplyCommand
+  prepend EasyCommand
+
+  def call
+    sum = assert_subcommand AdditionCommand, @a, @b
+    assert_subcommand MultiplicationCommand, sum, @c
+  end
+
+  def initialize(a,b,c)
+    @a = a
+    @b = b
+    @c = c
+  end
+end