functional-light-service 0.3.4 → 0.5.4

data/spec/acceptance/organizer/add_to_context_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe FunctionalLightService::Organizer do
+  class TestAddToContext
+    extend FunctionalLightService::Organizer
+
+    def self.call(context = FunctionalLightService::Context.make)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        # This will add the `:number` key to the context
+        # with the value of 0, so it's available for
+        # AddsOneAction
+        add_to_context(:number => 0),
+        TestDoubles::AddsOneAction,
+        add_to_context(:something => "hello")
+      ]
+    end
+  end
+
+  it "adds items to the context on the fly" do
+    result = TestAddToContext.call
+
+    expect(result).to be_success
+    expect(result.number).to eq(1)
+    expect(result[:something]).to eq("hello")
+  end
+end

data/spec/acceptance/organizer/iterate_spec.rb

@@ -20,6 +20,13 @@ RSpec.describe FunctionalLightService::Organizer do
     expect(result.number).to eq(5)
   end
 
+  it "knows that it's being iterated from within an organizer" do
+    result = TestDoubles::TestIterate.call(:number => 1,
+                                           :counters => [1, 2, 3, 4])
+
+    expect(result.organized_by).to eq TestDoubles::TestIterate
+  end
+
   it 'will not iterate over a failed context' do
     empty_context.fail!('Something bad happened')
 

data/spec/acceptance/organizer/reduce_if_spec.rb

@@ -48,4 +48,42 @@ RSpec.describe FunctionalLightService::Organizer do
     result = TestReduceIf.call(empty_context)
     expect(result).to be_success
   end
+
+  it "knows that it's being conditionally reduced from within an organizer" do
+    result = TestReduceIf.call(:number => 2)
+
+    expect(result.organized_by).to eq TestReduceIf
+  end
+
+  it 'skips actions within in its own scope' do
+    org = Class.new do
+      extend FunctionalLightService::Organizer
+
+      def self.call
+        reduce(actions)
+      end
+
+      def self.actions
+        [
+          reduce_if(
+            ->(c) { !c.nil? },
+            [
+              execute(->(c) { c[:first_reduce_if] = true }),
+              execute(->(c) { c.skip_remaining! }),
+              execute(->(c) { c[:second_reduce_if] = true })
+            ]
+          ),
+          execute(->(c) { c[:last_outside] = true })
+        ]
+      end
+    end
+
+    result = org.call
+
+    aggregate_failures do
+      expect(result[:first_reduce_if]).to be true
+      expect(result[:second_reduce_if]).to be_nil
+      expect(result[:last_outside]).to be true
+    end
+  end
 end

data/spec/acceptance/organizer/reduce_until_spec.rb

@@ -40,4 +40,10 @@ RSpec.describe FunctionalLightService::Organizer do
     result = TestReduceUntil.call(empty_context)
     expect(result).to be_success
   end
+
+  it "is expected to know its organizer when reducing until a condition" do
+    result = TestReduceUntil.call(:number => 1)
+
+    expect(result.organized_by).to eq TestReduceUntil
+  end
 end

data/spec/action_spec.rb

@@ -68,6 +68,14 @@ describe FunctionalLightService::Action do
     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" }

data/spec/context/inspect_spec.rb

@@ -13,13 +13,8 @@ RSpec.describe FunctionalLightService::Context do
   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: {}' \
-        + ')'
+        "FunctionalLightService::Context({}, success: true, message: '', error_code: nil, " \
+        "skip_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -28,13 +23,8 @@ RSpec.describe FunctionalLightService::Context 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: {}' \
-        + ')'
+        "FunctionalLightService::Context({}, success: false, message: 'There was an error', " \
+        "error_code: nil, skip_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -43,13 +33,8 @@ RSpec.describe FunctionalLightService::Context 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: {}' \
-        + ')'
+        "FunctionalLightService::Context({}, success: true, message: 'No need to process', " \
+        "error_code: nil, skip_remaining: true, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end

data/spec/context_spec.rb

@@ -167,7 +167,7 @@ RSpec.describe FunctionalLightService::Context do
   end
 
   it "allows a default block value for #fetch" do
-    expect(context.fetch(:madeup) { :default }).to eq(:default)
+    expect(context.fetch(:madeup, :default)).to eq(:default)
   end
 
   context "when aliases are included via .make" do

data/spec/lib/deterministic/monad_axioms.rb

@@ -34,7 +34,9 @@ shared_examples 'a Monad' do
 
     it '#bind must return a monad' do
       expect(monad.new(1).bind { |v| monad.new(v) }).to eq monad.new(1)
+      # rubocop:disable Lint/EmptyBlock
       expect { monad.new(1).bind {} }.to raise_error(FunctionalLightService::Monad::NotMonadError)
+      # rubocop:enable Lint/EmptyBlock
     end
 
     it '#new must return a monad' do

data/spec/lib/deterministic/monad_spec.rb

@@ -21,8 +21,10 @@ describe FunctionalLightService::Monad do
 
   context '#bind' do
     it "raises an error if the passed function does not return a monad of the same class" do
+      # rubocop:disable Lint/EmptyBlock
       expect { Identity.new(1).bind {} }.to \
         raise_error(FunctionalLightService::Monad::NotMonadError)
+      # rubocop:enable Lint/EmptyBlock
     end
     specify { expect(Identity.new(1).bind { |value| Identity.new(value) }).to eq Identity.new(1) }
 

data/spec/lib/deterministic/null_spec.rb

@@ -38,7 +38,9 @@ describe Null do
     null = Null.instance
     expect(null.to_str).to eq ""
     expect(null.to_ary).to eq []
+    # rubocop:disable Style/StringConcatenation
     expect("" + null).to eq ""
+    # rubocop:enable Style/StringConcatenation
 
     a, b, c = null
     expect(a).to be_nil

data/spec/lib/deterministic/option_spec.rb

@@ -72,27 +72,31 @@ describe FunctionalLightService::Option do
   end
 
   it "match" do
-    # expect(
-    #   Some(0).match do
-    #     Some(where { s == 1 }) { |_s| 99 }
-    #     Some(where { s == 0 }) { |s| s + 1 }
-    #     None() {}
-    #   end
-    # ).to eq 1
+    expect(
+      # rubocop:disable Lint/UnusedBlockArgument
+      # rubocop:disable Lint/EmptyBlock
+      Some(0).match do
+        Some(where { s == 1 }) { |s| 99 }
+        Some(where { s == 0 }) { |s| s + 1 }
+        None() {}
+      end
+    ).to eq 1
 
     expect(
       Some(1).match do
         None() { 0 }
-        Some() { |_s| 1 }
+        Some() { |s| 1 }
       end
     ).to eq 1
 
-    # expect(
-    #   Some(1).match do
-    #     None() { 0 }
-    #     Some(where { s.is_a? Integer }) { |_s| 1 }
-    #   end
-    # ).to eq 1
+    expect(
+      Some(1).match do
+        None() { 0 }
+        Some(where { s.is_a? Integer }) { |s| 1 }
+      end
+      # rubocop:enable Lint/UnusedBlockArgument
+      # rubocop:enable Lint/EmptyBlock
+    ).to eq 1
 
     expect(
       None.match do

data/spec/lib/enum_spec.rb

@@ -8,7 +8,7 @@ describe FunctionalLightService::Enum do
       InvalidEnum = FunctionalLightService.enum do
         Unary(:value)
       end
-    end .to raise_error ArgumentError
+    end.to raise_error ArgumentError
   end
 
   context "Nullary, Unary, Binary" do
@@ -32,7 +32,9 @@ describe FunctionalLightService::Enum do
       expect { n.value }.to raise_error NoMethodError
       expect(n.inspect).to eq "Nullary"
       expect(n.to_s).to eq ""
+      # rubocop:disable Lint/EmptyBlock
       expect(n.fmap {}).to eq n
+      # rubocop:enable Lint/EmptyBlock
     end
 
     it "Unary" do

data/spec/organizer_spec.rb

@@ -19,6 +19,11 @@ describe FunctionalLightService::Organizer do
       result = TestDoubles::AnOrganizer.call(:user => user)
       expect(result).to eq(ctx)
     end
+
+    it "sets itself as the organizer" do
+      result = TestDoubles::AnOrganizer.call(:user => user)
+      expect(result.organized_by).to eq TestDoubles::AnOrganizer
+    end
   end
 
   context "when #with is called with Context" do
@@ -90,4 +95,20 @@ describe FunctionalLightService::Organizer do
       expect(reduced).to eq(ctx)
     end
   end
+
+  context "can add items to the context" do
+    specify 'with #add_to_context' do
+      result = TestDoubles::AnOrganizerThatAddsToContext.call
+      expect(result[:strongest_avenger]).to eq :thor
+      expect(result[:last_jedi]).to eq "Rey"
+    end
+  end
+
+  context "can assign key aliaeses" do
+    it 'with #add_aliases' do
+      result = TestDoubles::AnOrganizerThatAddsAliases.call
+      expect(result[:foo]).to eq :bar
+      expect(result[:baz]).to eq :bar
+    end
+  end
 end

data/spec/sample/looks_up_tax_percentage_action_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 require_relative 'tax/looks_up_tax_percentage_action'
 
-class TaxRange; end
+class TaxRange
+  extend FunctionalLightService::Action
+end
 
 describe LooksUpTaxPercentageAction do
   let(:region) { double('region') }

data/spec/sample/provides_free_shipping_action_spec.rb

@@ -15,7 +15,7 @@ describe ProvidesFreeShippingAction do
   end
 
   context "when the order total with tax is <= 200" do
-    specify "order gets free shipping" do
+    specify "order does not get free shipping" do
       allow(order).to receive_messages(:total_with_tax => 200)
       expect(order).not_to receive(:provide_free_shipping!)
 

data/spec/spec_helper.rb

@@ -10,11 +10,14 @@ if ENV['RUN_COVERAGE_REPORT']
   end
 
   SimpleCov.minimum_coverage_by_file 90
+
+  require "simplecov-cobertura"
+  SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
 end
 
-require 'functional-light-service'
-require 'functional-light-service/testing'
+require "functional-light-service"
+require "functional-light-service/testing"
 require "functional-light-service/functional/null"
-require 'support'
-require 'test_doubles'
-require 'stringio'
+require "support"
+require "test_doubles"
+require "stringio"

data/spec/test_doubles.rb

@@ -45,6 +45,7 @@ module TestDoubles
 
   class TestLogger
     attr_accessor :logs
+
     def initialize
       @logs = []
     end
@@ -83,8 +84,13 @@ module TestDoubles
     end
   end
 
-  class AnAction; end
-  class AnotherAction; end
+  class AnAction
+    extend FunctionalLightService::Action
+  end
+
+  class AnotherAction
+    extend FunctionalLightService::Action
+  end
 
   class AnOrganizer
     extend FunctionalLightService::Organizer
@@ -166,14 +172,18 @@ module TestDoubles
     promises :latte
 
     executed do |context|
+      context.fail!("Can't make a latte from a milk that's very hot!") if context.milk == :very_hot
+
+      if context.milk == :super_hot
+        error_message = "Can't make a latte from a milk that's super hot!"
+        context.fail_with_rollback!(error_message)
+      end
+
       context[:latte] = "#{context.coffee} - with lots of #{context.milk}"
-      case context.milk
-      when :very_hot then
-        context.fail!("Can't make a latte from a milk that's very hot!")
-      when :super_hot then
-        context.fail_with_rollback!("Can't make a latte from a milk that's super hot!")
-      when "5%" then
-        context.skip_remaining!("Can't make a latte with a fatty milk like that!")
+
+      if context.milk == "5%"
+        msg = "Can't make a latte with a fatty milk like that!"
+        context.skip_remaining!(msg)
         next context
       end
     end
@@ -472,7 +482,9 @@ module TestDoubles
   class NullAction
     extend FunctionalLightService::Action
 
+    # rubocop:disable Lint/EmptyBlock
     executed { |_ctx| }
+    # rubocop:enable Lint/EmptyBlock
   end
 
   class TestIterate
@@ -549,4 +561,39 @@ module TestDoubles
       ctx.total += ctx.number
     end
   end
+
+  class CapitalizeMessage
+    extend FunctionalLightService::Action
+    expects :a_message
+    promises :final_message
+
+    executed do |ctx|
+      ctx.final_message = ctx.a_message.upcase
+    end
+  end
+
+  class AnOrganizerThatAddsToContext
+    extend FunctionalLightService::Organizer
+    def self.call
+      with.reduce(actions)
+    end
+
+    def self.actions
+      [add_to_context(
+        :strongest_avenger => :thor,
+        :last_jedi => "Rey"
+      )]
+    end
+  end
+
+  class AnOrganizerThatAddsAliases
+    extend FunctionalLightService::Organizer
+    def self.call
+      with(:foo => :bar).reduce(actions)
+    end
+
+    def self.actions
+      [add_aliases(:foo => :baz)]
+    end
+  end
 end