functional-light-service 0.5.4 → 6.1.0

data/spec/lib/deterministic/sequencer_spec.rb

@@ -0,0 +1,506 @@
+require 'spec_helper'
+
+describe FunctionalLightService::Sequencer do
+  include FunctionalLightService::Prelude::Result
+
+  let(:test_class) { Class.new { include FunctionalLightService::Sequencer } }
+  let(:test_instance) { test_class.new }
+  let(:arbitrary_success) { Success(double) }
+
+  # This mock method makes #arbitrary_success available within the operations
+  # in the test sequences
+  before { allow(test_instance).to receive(:arbitrary_success).and_return(arbitrary_success) }
+
+  it 'requires #and_yield to be specified' do
+    expect do
+      in_sequence do
+        get(:_) { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield not called')
+  end
+
+  it 'does not allow calling #and_yield multiple times' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        and_yield { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #get after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        get(:_) { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #let after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        let(:_) { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #and_then after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        and_then { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #observe after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        observe { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'requires a block for every operation' do
+    expect { in_sequence { get(:_) } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { let(:_) } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { and_then } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { observe } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { and_yield } }.to raise_error(ArgumentError, 'no block given')
+  end
+
+  context 'when #and_yield succeeds' do
+    let(:yielder_result) { Success('yield') }
+    before { allow(test_instance).to receive(:yielder).and_return(yielder_result) }
+
+    it "returns and_yield's result" do
+      result = in_sequence do
+        and_yield { yielder }
+      end
+      expect(result).to eq(yielder_result)
+    end
+
+    it 'ignores the return value of the #in_sequence block' do
+      result = in_sequence do
+        and_yield { yielder }
+        'a different return value'
+      end
+      expect(result).to eq(yielder_result)
+    end
+  end
+
+  context 'when #and_yield fails' do
+    let(:yielder_result) { Failure('yield') }
+    before { allow(test_instance).to receive(:yielder).and_return(yielder_result) }
+
+    it "returns and_yield's result" do
+      result = in_sequence do
+        and_yield { yielder }
+      end
+      expect(result).to eq(yielder_result)
+    end
+  end
+
+  context 'when #get succeeds' do
+    let(:getter_result) { Success('get') }
+    before { allow(test_instance).to receive(:getter).and_return(getter_result) }
+
+    it 'its result is available in a subsequent #get' do
+      allow(test_instance).to receive(:second_getter).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        get(:_) { second_getter(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:second_getter).with(getter_result.value)
+    end
+
+    it 'its result is not available in a previous #get' do
+      allow(test_instance).to receive(:second_getter)
+
+      expect do
+        in_sequence do
+          get(:_) { second_getter(get_result) }
+          get(:get_result) { getter }
+          and_yield { arbitrary_success }
+        end
+      end.to raise_error(NameError)
+    end
+
+    it 'its result is available in a subsequent #and_then' do
+      allow(test_instance).to receive(:and_then_function).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_then { and_then_function(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:and_then_function).with(getter_result.value)
+    end
+
+    it 'its result is available in a subsequent #observe' do
+      allow(test_instance).to receive(:observer)
+
+      in_sequence do
+        get(:get_result) { getter }
+        observe { observer(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:observer).with(getter_result.value)
+    end
+
+    it 'its result is available in #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_yield { yielder(get_result) }
+      end
+
+      expect(test_instance).to have_received(:yielder).with(getter_result.value)
+    end
+  end
+
+  context 'when multiple #gets succeed' do
+    let(:first_getter_result) { Success('get1') }
+    let(:second_getter_result) { Success('get2') }
+
+    before do
+      allow(test_instance).to receive(:first_getter).and_return(first_getter_result)
+      allow(test_instance).to receive(:second_getter).and_return(second_getter_result)
+    end
+
+    it 'both results are available in subsequent operations' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:first_get_result) { first_getter }
+        get(:second_get_result) { second_getter }
+        and_yield { yielder(first_get_result, second_get_result) }
+      end
+
+      expect(test_instance).to have_received(:yielder)
+        .with(first_getter_result.value, second_getter_result.value)
+    end
+  end
+
+  context 'when #get fails' do
+    let(:getter_result) { Failure('get') }
+    before { allow(test_instance).to receive(:getter).and_return(getter_result) }
+
+    it 'does not invoke subsequent #gets' do
+      allow(test_instance).to receive(:second_getter).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        get(:_) { second_getter(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:second_getter)
+    end
+
+    it 'does not invoke subsequent #and_thens' do
+      allow(test_instance).to receive(:and_then_function).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_then { and_then_function(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:and_then_function)
+    end
+
+    it 'does not invoke subsequent #observes' do
+      allow(test_instance).to receive(:observer)
+
+      in_sequence do
+        get(:get_result) { getter }
+        observe { observer(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:observer)
+    end
+
+    it 'does not invoke #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_yield { yielder }
+      end
+
+      expect(test_instance).not_to have_received(:yielder)
+    end
+
+    it 'returns the failure' do
+      result = in_sequence do
+        get(:get_result) { getter }
+        and_yield { arbitrary_success }
+      end
+
+      expect(result).to eq(getter_result)
+    end
+  end
+
+  context 'when #let succeeds' do
+    let(:object) { { :a => 'a' } }
+    before { allow(test_instance).to receive(:object).and_return(object) }
+
+    it 'its result is available in a subsequent #let' do
+      allow(test_instance).to receive(:test_function)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        let(:_) { test_function(a) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:test_function).with(object.fetch(:a))
+    end
+
+    it 'its result is available in a subsequent #and_then' do
+      allow(test_instance).to receive(:and_then_function).and_return(arbitrary_success)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        and_then { and_then_function(a) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:and_then_function).with(object.fetch(:a))
+    end
+
+    it 'its result is available in a subsequent #observe' do
+      allow(test_instance).to receive(:observer)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        observe { observer(a) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:observer).with(object.fetch(:a))
+    end
+
+    it 'its result is available in #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        and_yield { yielder(a) }
+      end
+
+      expect(test_instance).to have_received(:yielder).with(object.fetch(:a))
+    end
+  end
+
+  context 'when #let raises an error' do
+    let(:object) { { :a => 'a' } }
+    before { allow(test_instance).to receive(:object).and_return(object) }
+
+    it 'bubbles the raised error' do
+      expect do
+        in_sequence do
+          let(:b) { object.fetch(:b) }
+          and_yield { arbitrary_success }
+        end
+      end.to raise_error(KeyError)
+    end
+
+    it 'does not invoke #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      begin
+        in_sequence do
+          let(:b) { object.fetch(:b) }
+          and_yield { yielder }
+        end
+      rescue KeyError
+        # Ignore
+      end
+
+      expect(test_instance).not_to have_received(:yielder)
+    end
+  end
+
+  context 'when #and_then succeeds' do
+    let(:and_then_result) { Success('and_then') }
+    before { allow(test_instance).to receive(:and_then_function).and_return(and_then_result) }
+
+    it 'continues the sequence' do
+      allow(test_instance).to receive(:another_step).and_return(arbitrary_success)
+
+      in_sequence do
+        and_then { and_then_function }
+        and_then { another_step }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:another_step)
+    end
+  end
+
+  context 'when #and_then fails' do
+    let(:and_then_result) { Failure('and_then') }
+    before { allow(test_instance).to receive(:and_then_function).and_return(and_then_result) }
+
+    it 'does not continue the sequence' do
+      allow(test_instance).to receive(:another_step).and_return(arbitrary_success)
+
+      in_sequence do
+        and_then { and_then_function }
+        and_then { another_step }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:another_step)
+    end
+
+    it 'returns the failure' do
+      result = in_sequence do
+        and_then { and_then_function }
+        and_yield { arbitrary_success }
+      end
+
+      expect(result).to eq(and_then_result)
+    end
+  end
+
+  context 'when #observe returns a failure' do
+    let(:observe_result) { Failure('observe') }
+    before { allow(test_instance).to receive(:observer).and_return(observe_result) }
+
+    it 'its return value is ignored and the sequence continues' do
+      allow(test_instance).to receive(:another_step).and_return(arbitrary_success)
+
+      in_sequence do
+        observe { observer }
+        and_then { another_step }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:another_step)
+    end
+  end
+
+  it 'does not allow calling methods outside of the wrapped instance' do
+    expect do
+      in_sequence do
+        and_yield { top_level_test_method }
+      end
+    end.to raise_error(NameError)
+  end
+
+  context 'when including FunctionalLightService::Prelude' do
+    let(:test_class) { Class.new { include FunctionalLightService::Prelude } }
+
+    it '#in_sequence is available' do
+      expect do
+        in_sequence do
+          and_yield { arbitrary_success }
+        end
+      end.not_to raise_error
+    end
+  end
+
+  context 'readme example' do
+    let(:test_class) do
+      Class.new do
+        include FunctionalLightService::Prelude
+
+        # rubocop:disable Metrics/AbcSize
+        def call(input)
+          in_sequence do
+            get(:sanitized_input) { sanitize(input) }
+            and_then              { validate(sanitized_input) }
+            get(:user)            { get_user_from_db(sanitized_input) }
+            let(:name)            { user.fetch(:name) }
+            observe               { log('user name', name) }
+            get(:request)         { build_request(sanitized_input, user) }
+            observe               { log('sending request', request) }
+            get(:response)        { send_request(request) }
+            observe               { log('got response', response) }
+            and_yield             { format_response(response) }
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def sanitize(input)
+          sanitized_input = input
+          Success(sanitized_input)
+        end
+
+        def validate(sanitized_input)
+          Success(sanitized_input)
+        end
+
+        def get_user_from_db(sanitized_input)
+          Success(:type => :admin, :id => sanitized_input.fetch(:id), :name => 'John')
+        end
+
+        def build_request(sanitized_input, user)
+          Success(:input => sanitized_input, :user => user)
+        end
+
+        def log(message, data)
+          # logger.info(message, data)
+        end
+
+        def send_request(_request)
+          Success(:status => 200)
+        end
+
+        def format_response(response)
+          Success(:response => response, :message => 'it worked')
+        end
+      end
+    end
+
+    it 'returns expected result' do
+      result = test_instance.call(:id => 1)
+
+      expect(result).to eq(Success(
+                             :response => { :status => 200 },
+                             :message => 'it worked'
+                           ))
+    end
+
+    it 'logs expected values' do
+      allow(test_instance).to receive(:log).and_call_original
+
+      test_instance.call(:id => 1)
+
+      expect(test_instance).to have_received(:log)
+        .with('user name', 'John')
+        .ordered
+      expect(test_instance).to have_received(:log)
+        .with('sending request',
+              :input => { :id => 1 },
+              :user => { :type => :admin, :id => 1, :name => 'John' })
+        .ordered
+      expect(test_instance).to have_received(:log)
+        .with('got response', :status => 200)
+        .ordered
+    end
+  end
+
+  def in_sequence(&block)
+    test_instance.instance_eval do
+      in_sequence(&block)
+    end
+  end
+end
+
+def top_level_test_method
+  :empty
+end

data/spec/lib/edge_cases_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+require 'functional-light-service/functional/maybe'
+
+# Copertura dei path d'errore e delle API minori emersi dall'audit
+describe "edge cases and error paths" do
+  include FunctionalLightService::Prelude::Result
+  include FunctionalLightService::Prelude::Option
+
+  describe FunctionalLightService::Context do
+    it "#add_to_context merges values" do
+      ctx = FunctionalLightService::Context.make(:a => 1)
+      ctx.add_to_context(:b => 2)
+
+      expect(ctx[:b]).to eq(2)
+    end
+  end
+
+  describe FunctionalLightService::Context::KeyVerifier do
+    it "the base verifier requires throw_error_predicate to be overridden" do
+      ctx = FunctionalLightService::Context.make
+      verifier = described_class.new(ctx, nil)
+
+      expect { verifier.throw_error_predicate([]) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "Object monkey patch (opt-in via functional/maybe)" do
+    it "defines null? and some? on every object" do
+      expect("anything".null?).to be(false)
+      expect("anything".some?).to be(true)
+    end
+  end
+
+  describe Null do
+    it "class-level unknown messages return the singleton" do
+      expect(Null.anything_at_all).to eq(Null.instance)
+    end
+
+    it "class-level respond_to? is permissive" do
+      expect(Null.respond_to?(:anything_at_all)).to be(true)
+    end
+
+    it "compares equal to another Null" do
+      expect(Null.instance == Null.instance).to be(true) # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      expect(Null.instance == "not null").to be(false)
+    end
+
+    it "a mimic only responds to the mimicked interface" do
+      klass = Class.new { def foo; end }
+      mimic = Null.mimic(klass)
+
+      expect(mimic.respond_to?(:foo)).to be(true)
+      expect(mimic.respond_to?(:bar)).to be(false)
+      expect { mimic.bar }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "enum error paths" do
+    it "raises when a variant is defined twice" do
+      expect do
+        FunctionalLightService.enum do
+          Dup()
+          Dup()
+        end
+      end.to raise_error(ArgumentError, /already defined/)
+    end
+
+    it "the enum builder responds to any variant name" do
+      builder = FunctionalLightService::EnumBuilder.new(Class.new)
+
+      expect(builder.respond_to?(:AnyVariantName)).to be(true)
+    end
+
+    it "raises MatchError when the match is not exhaustive" do
+      expect do
+        Some(1).match do
+          Some() { |s| s }
+        end
+      end.to raise_error(FunctionalLightService::Enum::MatchError, /non-exhaustive/)
+    end
+
+    it "raises MatchError when the block arity does not match the variant" do
+      expect do
+        Some(1).match do
+          Some() { |a, b| [a, b] }
+          None() { nil }
+        end
+      end.to raise_error(FunctionalLightService::Enum::MatchError, /must match/)
+    end
+
+    it "raises MatchError when no guard matches" do
+      expect do
+        Some(1).match do
+          Some(where { s > 100 }) { |s| s }
+          None() { nil }
+        end
+      end.to raise_error(FunctionalLightService::Enum::MatchError, /No match could be made/)
+    end
+
+    it "rejects unnamed/rest block parameters" do
+      # su Ruby 3.1 |*| appare come [[:rest]] (ramo "Unnamed param"),
+      # da Ruby 3.2 come [[:rest, :*]] (ramo "Only :req & :opt")
+      expect do
+        Some(1).match do
+          Some() { |*| nil }
+          None() { nil }
+        end
+      end.to raise_error(ArgumentError, /Unnamed param|Only :req & :opt/)
+    end
+
+    it "rejects keyword block parameters" do
+      expect do
+        Some(1).match do
+          Some() { |**opts| opts }
+          None() { nil }
+        end
+      end.to raise_error(ArgumentError, /Only :req & :opt params allowed/)
+    end
+
+    it "None deconstructs to an empty hash and array" do
+      none = FunctionalLightService::Option::None.new
+
+      expect(none.deconstruct).to eq([])
+      expect(none.deconstruct_keys(nil)).to eq({})
+    end
+  end
+
+  describe "Option minor APIs" do
+    it "#value_to_a returns the raw value" do
+      expect(Some(1).value_to_a).to eq(1)
+      expect(FunctionalLightService::Option::None.new.value_to_a).to be_nil
+    end
+
+    it "Prelude None() builds the shared None" do
+      expect(None().none?).to be(true)
+    end
+
+    it "Prelude Option() returns the Option enum" do
+      expect(Option()).to eq(FunctionalLightService::Option)
+    end
+  end
+
+  describe "Result minor APIs" do
+    it "#+ raises NotMonadError for non-Result operands" do
+      expect { Success(1) + "not a result" } # rubocop:disable Style/StringConcatenation
+        .to raise_error(FunctionalLightService::Monad::NotMonadError)
+    end
+
+    it "Prelude try! wraps exceptions in Failure" do
+      result = try! { raise "boom" }
+
+      expect(result).to be_failure
+      expect(result.value).to be_a(RuntimeError)
+    end
+  end
+end

data/spec/lib/enum_spec.rb

@@ -20,7 +20,7 @@ describe FunctionalLightService::Enum do
 
     it "can't instantiate parent" do
       expect { MyEnym.new }.to \
-        raise_error NoMethodError, "private method `new' called for MyEnym:Class"
+        raise_error NoMethodError, /private method [`']new'/
     end
 
     it "Nullary" do