functional-light-service 6.1.0 → 6.3.0

data/spec/action_promised_keys_spec.rb

@@ -1,126 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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 called directly" do
-    it "is expected to not be organized" do
-      result = TestDoubles::AddsTwoActionWithFetch.execute(context)
-
-      expect(result.organized_by).to be_nil
-    end
-  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

@@ -1,42 +0,0 @@
-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

@@ -1,289 +0,0 @@
-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
-    # la forma a blocco e' esattamente cio' che il test verifica
-    expect(context.fetch(:madeup) { :default }).to eq(:default) # rubocop:disable Style/RedundantFetchBlock
-  end
-
-  describe "#define_accessor_methods_for_keys" do
-    it "raises when a key conflicts with an existing Hash/Context method" do
-      expect { context.define_accessor_methods_for_keys([:size]) }
-        .to raise_error(FunctionalLightService::ReservedKeysInContextError, /:size conflicts/)
-    end
-
-    it "does not raise when re-defining accessors for the same key" do
-      ctx = FunctionalLightService::Context.make(:number => 1)
-      ctx.define_accessor_methods_for_keys([:number])
-
-      expect { ctx.define_accessor_methods_for_keys([:number]) }.not_to raise_error
-      expect(ctx.number).to eq(1)
-    end
-  end
-
-  describe "reserved keys" do
-    it "rejects infrastructure keys in expects/promises" do
-      action = Class.new do
-        extend FunctionalLightService::Action
-
-        expects :_before_actions
-        executed { |_ctx| } # rubocop:disable Lint/EmptyBlock
-      end
-
-      expect { action.execute(:_before_actions => []) }
-        .to raise_error(FunctionalLightService::ReservedKeysInContextError)
-    end
-  end
-
-  describe "#fail! does not mutate the caller's options hash" do
-    it "leaves :error_code in the original hash" do
-      options = { :error_code => 500 }
-      context.fail!("boom", options)
-
-      expect(options).to eq(:error_code => 500)
-      expect(context.error_code).to eq(500)
-    end
-  end
-
-  describe "#reset_skip_remaining!" do
-    it "clears the flag but keeps the outcome and its message" do
-      context.skip_remaining!("No need to process")
-      context.reset_skip_remaining!
-
-      expect(context.skip_remaining?).to be(false)
-      expect(context).to be_success
-      expect(context.message).to eq("No need to process")
-    end
-  end
-
-  describe "#fetch honours the Hash#fetch contract" do
-    it "raises KeyError for a missing key without default" do
-      expect { context.fetch(:madeup) }.to raise_error(KeyError)
-    end
-
-    it "does not write to the context when a default is used" do
-      context.fetch(:madeup, :default)
-      context.fetch(:another_madeup) { :default } # rubocop:disable Style/RedundantFetchBlock
-
-      expect(context.to_h).not_to have_key(:madeup)
-      expect(context.to_h).not_to have_key(:another_madeup)
-    end
-
-    it "returns existing falsy values instead of the default" do
-      context = FunctionalLightService::Context.make(:flag => false)
-
-      expect(context.fetch(:flag, true)).to eq(false)
-    end
-  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
-
-    it "resolves aliases on writes too, symmetrically with reads" do
-      context[:bar] = "updated"
-
-      expect(context[:bar]).to eq("updated")
-      expect(context[:foo]).to eq("updated")
-      # nessuna chiave duplicata: l'alias e' un nome alternativo, non una copia
-      expect(context.to_h).not_to have_key(:bar)
-    end
-
-    it "resolves aliases in #key? and friends" do
-      expect(context.key?(:bar)).to be(true)
-      expect(context.has_key?(:bar)).to be(true) # rubocop:disable Style/PreferredHashMethods
-      expect(context.member?(:bar)).to be(true)
-      expect(context.include?(:bar)).to be(true)
-      expect(context.key?(:madeup)).to be(false)
-    end
-
-    it "resolves aliases in #fetch with defaults" do
-      expect(context.fetch(:bar, :default)).to eq("foobar")
-    end
-  end
-end

data/spec/examples/amount_spec.rb

@@ -1,77 +0,0 @@
-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

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-module FunctionalLightService
-  module Procify
-    def py(m, *args)
-      args.any? ? 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