functional-light-service 0.2.4

data/spec/action_promised_keys_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe ":promises macro" do
+  context "when the promised key is not in the context" do
+    it "raises an ArgumentError" do
+      module TestDoubles
+        class MakesCappuccinoAction1
+          extend FunctionalLightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context[:macchiato] = "#{context.coffee} - #{context.milk}"
+          end
+        end
+      end
+
+      exception_msg = "promised :cappuccino to be in the context during " \
+                      "TestDoubles::MakesCappuccinoAction1"
+      expect do
+        TestDoubles::MakesCappuccinoAction1.execute(:coffee => "espresso",
+                                                    :milk => "2%")
+      end.to \
+        raise_error(FunctionalLightService::PromisedKeysNotInContextError, exception_msg)
+    end
+
+    it "can fail the context without fulfilling its promise" do
+      module TestDoubles
+        class MakesCappuccinoAction2
+          extend FunctionalLightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context.fail!("Sorry, something bad has happened.")
+          end
+        end
+      end
+
+      result_context = TestDoubles::MakesCappuccinoAction2
+                       .execute(:coffee => "espresso",
+                                :milk => "2%")
+
+      expect(result_context).to be_failure
+      expect(result_context.keys).not_to include(:cappuccino)
+    end
+  end
+
+  context "when the promised key is in the context" do
+    it "can be set with an actual value" do
+      module TestDoubles
+        class MakesCappuccinoAction3
+          extend FunctionalLightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context.cappuccino = "#{context.coffee} - with #{context.milk} milk"
+            context.cappuccino += " hot"
+          end
+        end
+      end
+
+      result_context = TestDoubles::MakesCappuccinoAction3
+                       .execute(:coffee => "espresso",
+                                :milk => "2%")
+
+      expect(result_context).to be_success
+      expect(result_context.cappuccino).to eq("espresso - with 2% milk hot")
+    end
+
+    it "can be set with nil" do
+      module TestDoubles
+        class MakesCappuccinoAction4
+          extend FunctionalLightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context.cappuccino = nil
+          end
+        end
+      end
+      result_context = TestDoubles::MakesCappuccinoAction4
+                       .execute(:coffee => "espresso",
+                                :milk => "2%")
+
+      expect(result_context).to be_success
+      expect(result_context[:cappuccino]).to be_nil
+    end
+  end
+
+  context "when a reserved key is listed as a promised key" do
+    it "raises error indicating a reserved key has been promised" do
+      exception_msg = "promised or expected keys cannot be a reserved key: "\
+                      "[:message]"
+      expect do
+        TestDoubles::MakesTeaPromisingReservedKey.execute(:tea => "black")
+      end.to \
+        raise_error(FunctionalLightService::ReservedKeysInContextError, exception_msg)
+    end
+
+    it "raises error indicating multiple reserved keys have been promised" do
+      exception_msg = "promised or expected keys cannot be a reserved key: " \
+                      "[:message, :error_code, :current_action]"
+      expect do
+        ctx = { :tea => "black" }
+        TestDoubles::MakesTeaPromisingMultipleReservedKeys.execute(ctx)
+      end.to \
+        raise_error(FunctionalLightService::ReservedKeysInContextError, exception_msg)
+    end
+  end
+
+  context "when the `promised` macro is called multiple times" do
+    it "collects promised keys " do
+      result = TestDoubles::MultiplePromisesAction \
+               .execute(:coffee => "espresso", :milk => "2%")
+
+      expect(result.cappuccino).to \
+        eq("Cappucino needs espresso and a little milk")
+      expect(result.latte).to \
+        eq("Latte needs espresso and a lot of milk")
+    end
+  end
+end

data/spec/action_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe FunctionalLightService::Action do
+  let(:context) { FunctionalLightService::Context.make }
+
+  context "when the action context has failure" do
+    it "returns immediately" do
+      context.fail!("an error")
+
+      TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+      expect(context.to_hash.keys).to be_empty
+    end
+
+    it "returns the failure message in the context" do
+      context.fail!("an error")
+
+      returned_context = TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+      expect(returned_context.message).to eq("an error")
+    end
+  end
+
+  context "when the action has an explicit success message" do
+    it "returns the success message in the context" do
+      context.succeed!("successful")
+
+      returned_context = TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+      expect(returned_context.message).to eq("successful")
+    end
+  end
+
+  context "when the action context does not have failure" do
+    it "executes the block" do
+      TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+      expect(context.to_hash.keys).to eq [:number]
+      expect(context.fetch(:number)).to eq(2)
+    end
+  end
+
+  context "when the action context skips all" do
+    it "returns immediately" do
+      context.skip_remaining!
+
+      TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+      expect(context.to_hash.keys).to be_empty
+    end
+
+    it "does not execute skipped actions" do
+      TestDoubles::AddsTwoActionWithFetch.execute(context)
+      expect(context.to_hash).to eq(:number => 2)
+
+      context.skip_remaining!
+
+      TestDoubles::AddsTwoActionWithFetch.execute(context)
+      # Since the action was skipped, the number remains 2
+      expect(context.to_hash).to eq(:number => 2)
+    end
+  end
+
+  it "returns the context" do
+    result = TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+    expect(result.to_hash).to eq(:number => 2)
+  end
+
+  context "when invoked with hash" do
+    it "creates FunctionalLightService::Context implicitly" do
+      ctx = { :some_key => "some value" }
+      result = TestDoubles::AddsTwoActionWithFetch.execute(ctx)
+
+      expect(result).to be_success
+      expect(result.keys).to eq(%i[some_key number])
+    end
+  end
+
+  context "when invoked without arguments" do
+    it "creates FunctionalLightService::Context implicitly" do
+      result = TestDoubles::AddsTwoActionWithFetch.execute
+
+      expect(result).to be_success
+      expect(result.keys).to eq([:number])
+    end
+  end
+end

data/spec/context/inspect_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Context do
+  subject(:context) { FunctionalLightService::Context.make }
+
+  describe 'to_s' do
+    it 'prints the context hash' do
+      expect(context.to_s).to eq('{}')
+    end
+  end
+
+  describe '#inspect' do
+    it 'inspects the hash with all the fields' do
+      inspected_context =
+        'FunctionalLightService::Context({}, ' \
+        + 'success: true, ' \
+        + 'message: \'\', ' \
+        + 'error_code: nil, ' \
+        + 'skip_remaining: false, ' \
+        + 'aliases: {}' \
+        + ')'
+
+      expect(context.inspect).to eq(inspected_context)
+    end
+
+    it 'prints the error message' do
+      context.fail!('There was an error')
+
+      inspected_context =
+        'FunctionalLightService::Context({}, ' \
+        + 'success: false, ' \
+        + 'message: \'There was an error\', ' \
+        + 'error_code: nil, ' \
+        + 'skip_remaining: false, ' \
+        + 'aliases: {}' \
+        + ')'
+
+      expect(context.inspect).to eq(inspected_context)
+    end
+
+    it 'prints skip_remaining' do
+      context.skip_remaining!('No need to process')
+
+      inspected_context =
+        'FunctionalLightService::Context({}, ' \
+        + 'success: true, ' \
+        + 'message: \'No need to process\', ' \
+        + 'error_code: nil, ' \
+        + 'skip_remaining: true, ' \
+        + 'aliases: {}' \
+        + ')'
+
+      expect(context.inspect).to eq(inspected_context)
+    end
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Context do
+  let(:context) { FunctionalLightService::Context.make }
+
+  describe "can be made" do
+    context "with no arguments" do
+      subject { FunctionalLightService::Context.make }
+      it { is_expected.to be_success }
+      specify "message is empty string" do
+        expect(context.message).to be_empty
+      end
+    end
+
+    context "with a hash" do
+      it "has the hash values" do
+        context = FunctionalLightService::Context.make(:one => 1)
+
+        expect(context[:one]).to eq(1)
+      end
+    end
+
+    context "with FAILURE" do
+      it "is failed" do
+        outcome = FunctionalLightService::Result::Failure(:message => '', :error => nil)
+        context = FunctionalLightService::Context.new({}, outcome)
+
+        expect(context).to be_failure
+      end
+    end
+  end
+
+  describe "can't be made" do
+    specify "with invalid parameters" do
+      expect { FunctionalLightService::Context.make([]) }.to raise_error(ArgumentError)
+    end
+  end
+
+  it "can be asked for success?" do
+    outcome = FunctionalLightService::Result::Success(:message => '', :error => nil)
+    context = FunctionalLightService::Context.new({}, outcome)
+
+    expect(context).to be_success
+  end
+
+  it "can be asked for failure?" do
+    outcome = FunctionalLightService::Result::Failure(:message => '', :error => nil)
+    context = FunctionalLightService::Context.new({}, outcome)
+
+    expect(context).to be_failure
+  end
+
+  it "can be asked for skip_remaining?" do
+    context.skip_remaining!
+
+    expect(context.skip_remaining?).to be_truthy
+  end
+
+  it "can be pushed into a SUCCESS state" do
+    context.succeed!("a happy end")
+
+    expect(context).to be_success
+  end
+
+  it "can be pushed into a SUCCESS state without a message" do
+    context.succeed!
+
+    expect(context).to be_success
+    expect(context.message).to be_nil
+  end
+
+  it "can be pushed into a FAILURE state without a message" do
+    context.fail!
+
+    expect(context).to be_failure
+    expect(context.message).to be_nil
+  end
+
+  it "can be pushed into a FAILURE state with a message" do
+    context.fail!("a sad end")
+
+    expect(context).to be_failure
+  end
+
+  it "can be pushed into a FAILURE state with a message in an options hash" do
+    context.fail!("a sad end")
+
+    expect(context).to be_failure
+    expect(context.message).to eq("a sad end")
+    expect(context.error_code).to be_nil
+  end
+
+  it "can be pushed into a FAILURE state with an error code in options hash" do
+    context.fail!("a sad end", 10_005)
+
+    expect(context).to be_failure
+    expect(context.message).to eq("a sad end")
+    expect(context.error_code).to eq(10_005)
+  end
+
+  it "uses localization adapter to translate failure message" do
+    action_class = TestDoubles::AnAction
+    expect(FunctionalLightService::Configuration.localization_adapter)
+      .to receive(:failure)
+      .with(:failure_reason, action_class, {})
+      .and_return("message")
+
+    context = FunctionalLightService::Context.make
+    context.current_action = action_class
+    context.fail!(:failure_reason)
+
+    expect(context).to be_failure
+    expect(context.message).to eq("message")
+  end
+
+  it "uses localization adapter to translate success message" do
+    action_class = TestDoubles::AnAction
+    expect(FunctionalLightService::Configuration.localization_adapter)
+      .to receive(:success)
+      .with(:action_passed, action_class, {})
+      .and_return("message")
+
+    context = FunctionalLightService::Context.make
+    context.current_action = action_class
+    context.succeed!(:action_passed)
+
+    expect(context).to be_success
+    expect(context.message).to eq("message")
+  end
+
+  it "can set a flag to skip all subsequent actions" do
+    context.skip_remaining!
+
+    expect(context).to be_skip_remaining
+  end
+
+  context "stopping additional processing in an action" do
+    it "flags processing to stop on failure" do
+      context.fail!("on purpose")
+      expect(context.stop_processing?).to be_truthy
+    end
+
+    it "flags processing to stop when remaining actions should be skipped" do
+      context.skip_remaining!
+      expect(context.stop_processing?).to be_truthy
+    end
+  end
+
+  it "can fail with FailWithRollBackError" do
+    expect { context.fail_with_rollback!("roll me back") }.to \
+      raise_error(FunctionalLightService::FailWithRollbackError)
+  end
+
+  it "exptected outcome reader get Success and message empty and error nil" do
+    outcome = FunctionalLightService::Result::Success(:message => "", :error => nil)
+    expect(context.outcome).to eq(outcome)
+  end
+
+  it "can contain false values" do
+    context = FunctionalLightService::Context.make(:foo => false)
+    expect(context[:foo]).to eq false
+  end
+
+  it "allows a default value for #fetch" do
+    expect(context.fetch(:madeup, :default)).to eq(:default)
+  end
+
+  it "allows a default block value for #fetch" do
+    expect(context.fetch(:madeup) { :default }).to eq(:default)
+  end
+
+  context "when aliases are included via .make" do
+    let(:context) do
+      FunctionalLightService::Context.make(
+        :foo => "foobar",
+        :foo2 => false,
+        :_aliases => aliases
+      )
+    end
+    let(:aliases) { { :foo => :bar, :foo2 => :bar2 } }
+
+    it "contains the aliases" do
+      expect(context.aliases).to eq(aliases)
+      expect(context).to include(:foo, :bar)
+    end
+
+    it "returns the correct values for #[] and #fetch" do
+      expect(context[:bar]).to eq context[:foo]
+      expect(context.fetch(:bar)).to eq context[:foo]
+    end
+
+    it "can contain false values" do
+      expect(context[:bar2]).to eq false
+    end
+  end
+end

data/spec/examples/amount_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'functional-light-service/functional/enum'
+
+Amount = FunctionalLightService.enum do
+  Due(:amount)
+  Paid(:amount)
+  Info(:amount)
+end
+
+class Amount
+  def self.from_f(f)
+    f >= 0 ? Amount::Due.new(f) : Amount::Paid.new(-1 * f)
+  end
+end
+
+FunctionalLightService.impl(Amount) do
+  def to_s
+    match do
+      Due()  { |a| format("%0.2f", a) }
+      Paid() { |a| format("-%0.2f", a) }
+      Info() { |a| format("(%0.2f)", a) }
+    end
+  end
+
+  def to_f
+    match do
+      Info() { |_a| 0 }
+      Due()  { |a| a }
+      Paid() { |a| -1 * a }
+    end
+  end
+
+  def +(other)
+    raise TypeError "Expected other to be an Amount, got #{other.class}" unless other.is_a? Amount
+
+    Amount.from_f(to_f + other.to_f)
+  end
+end
+
+describe Amount do
+  # rubocop:disable Naming/MethodName
+  def Due(a)
+    Amount::Due.new(a)
+  end
+
+  def Paid(a)
+    Amount::Paid.new(a)
+  end
+
+  def Info(a)
+    Amount::Info.new(a)
+  end
+  # rubocop:enable Naming/MethodName
+
+  it "due" do
+    amount = Amount::Due.new(100.2)
+    expect(amount.to_s).to eq "100.20"
+  end
+
+  it "paid" do
+    amount = Amount::Paid.new(100.1)
+    expect(amount.to_s).to eq "-100.10"
+  end
+
+  it "paid" do
+    amount = Amount::Info.new(100.31)
+    expect(amount.to_s).to eq "(100.31)"
+  end
+
+  it "+" do
+    expect(Due(10) + Paid(20)).to eq Paid(10)
+    expect(Due(10) + Paid(10)).to eq Due(0)
+    expect(Due(10) + Due(10)).to eq Due(20)
+    expect(Paid(10) + Paid(10)).to eq Paid(20)
+    expect(Paid(10) + Due(1) + Info(99)).to eq Paid(9)
+  end
+end

data/spec/examples/controller_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module FunctionalLightService
+  module Procify
+    def py(m, *args)
+      args.count > 0 ? method(m).to_proc.curry[*args] : method(m)
+    end
+  end
+end
+
+class BookingController
+  include FunctionalLightService::Prelude::Result
+  include FunctionalLightService::Procify
+
+  Context = Struct.new(:booking, :ability, :format)
+
+  def index(id, format = :html)
+    get_booking(id) << log(:booking) >>
+      py(:ability)              << log(:ability) >>
+      py(:present, format)      << log(:presenter) >>
+      py(:render)               << log(:render)
+  end
+
+  def log(step)
+    ->(data) { [step, data] }
+  end
+
+  def ability(ctx)
+    ctx.ability = {} # Ability.new(@booking)
+    Success(ctx)
+  end
+
+  def present(format, ctx)
+    ctx.format = format
+
+    Success(ctx)
+  end
+
+  def render(ctx)
+    send(ctx.format, ctx)
+  end
+
+  def html(ctx)
+    Success(ctx)
+  end
+
+  def get_booking(id)
+    ctx = Context.new
+    ctx.booking = { :ref_anixe => id }
+    Success(ctx)
+    # @booking = @bms.booking_by_id(id)
+    # rescue BSON::InvalidObjectId => ex
+    # @booking = nil
+    # @ui.error(404, ex.message)
+  end
+end
+
+describe BookingController do
+  it "does something" do
+    bc = BookingController.new
+    bc.index('1234', :html)
+  end
+end

data/spec/examples/validate_address_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+# A Unit of Work for validating an address
+module ValidateAddress
+  extend FunctionalLightService::Prelude::Result
+
+  def self.call(candidate)
+    errors = {}
+    errors[:street] = "Street cannot be empty" unless candidate.key? :street
+    errors[:city]   = "Street cannot be empty" unless candidate.key? :city
+    errors[:postal] = "Street cannot be empty" unless candidate.key? :postal
+
+    errors.empty? ? Success(candidate) : Failure(errors)
+  end
+end
+
+describe ValidateAddress do
+  include FunctionalLightService
+  subject { ValidateAddress.call(candidate) }
+  context 'sunny day' do
+    let(:candidate) do
+      { :title => "Hobbiton",
+        :street => "501 Buckland Rd",
+        :city => "Matamata",
+        :postal => "3472",
+        :country => "nz" }
+    end
+    specify { expect(subject).to be_a FunctionalLightService::Result::Success }
+    specify { expect(subject.value).to eq candidate }
+  end
+
+  context 'empty data' do
+    let(:candidate) { {} }
+    specify { expect(subject).to be_a FunctionalLightService::Result::Failure }
+    specify { expect(subject.value).to include(:street, :city, :postal) }
+  end
+end

data/spec/lib/deterministic/class_mixin_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'Class Mixin' do
+  describe 'try' do
+    module MyApp
+      class Thing
+        include FunctionalLightService::Prelude::Result
+
+        def run
+          Success(11) >> method(:double)
+        end
+
+        def double(num)
+          Success(num * 2)
+        end
+      end
+    end
+
+    it "cleanly mixes into a class" do
+      result = MyApp::Thing.new.run
+      expect(result).to eq FunctionalLightService::Result::Success.new(22)
+    end
+  end
+end