functional-light-service 0.4.4 → 6.0.0

data/spec/organizer_spec.rb

@@ -1,93 +1,115 @@
-require 'spec_helper'
-require 'test_doubles'
-
-describe FunctionalLightService::Organizer do
-  let(:ctx) { FunctionalLightService::Context.make(:user => user) }
-  let(:user) { double(:user) }
-
-  context "when #with is called with hash" do
-    before do
-      expect(TestDoubles::AnAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-      expect(TestDoubles::AnotherAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-    end
-
-    it "implicitly creates a Context" do
-      result = TestDoubles::AnOrganizer.call(:user => user)
-      expect(result).to eq(ctx)
-    end
-  end
-
-  context "when #with is called with Context" do
-    before do
-      expect(TestDoubles::AnAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-      expect(TestDoubles::AnotherAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-    end
-
-    it "uses that Context without recreating it" do
-      result = TestDoubles::AnOrganizer.call(ctx)
-      expect(result).to eq(ctx)
-    end
-  end
-
-  context "when no Actions are specified" do
-    it "throws a Runtime error" do
-      expect { TestDoubles::AnOrganizer.do_something_with_no_actions(ctx) }.to \
-        raise_error(RuntimeError, "No action(s) were provided")
-    end
-  end
-
-  context "when aliases are declared" do
-    let(:organizer) do
-      Class.new do
-        extend FunctionalLightService::Organizer
-        aliases :foo => :bar
-
-        def self.call
-          with.reduce(TestDoubles::AnAction)
-        end
-      end
-    end
-
-    it "merges the aliases into the data" do
-      with_reducer = double(:reduce => true)
-
-      allow(described_class::WithReducerFactory).to receive(:make)
-        .and_return(with_reducer)
-
-      expect(with_reducer).to receive(:with)
-        .with(hash_including(:_aliases => { :foo => :bar }))
-        .and_return(with_reducer)
-
-      organizer.call
-    end
-  end
-
-  context "when an organizer is nested and reduced within another" do
-    let(:reduced) { TestDoubles::NestingOrganizer.call(ctx) }
-    let(:organizer_result) do
-      TestDoubles::NotExplicitlyReturningContextOrganizer.call(ctx)
-    end
-
-    it "reduces an organizer which returns something" do
-      expect(organizer_result).to eq([1, 2, 3])
-    end
-
-    it "adds :foo and :bar to the context" do
-      reduced
-      expect(ctx[:foo]).to eq([1, 2, 3])
-      expect(ctx[:bar]).to eq(ctx[:foo])
-    end
-
-    it "returns the context" do
-      expect(reduced).to eq(ctx)
-    end
-  end
-end
+require 'spec_helper'
+require 'test_doubles'
+
+describe FunctionalLightService::Organizer do
+  let(:ctx) { FunctionalLightService::Context.make(:user => user) }
+  let(:user) { double(:user) }
+
+  context "when #with is called with hash" do
+    before do
+      expect(TestDoubles::AnAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
+      expect(TestDoubles::AnotherAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
+    end
+
+    it "implicitly creates a Context" 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
+    before do
+      expect(TestDoubles::AnAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
+      expect(TestDoubles::AnotherAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
+    end
+
+    it "uses that Context without recreating it" do
+      result = TestDoubles::AnOrganizer.call(ctx)
+      expect(result).to eq(ctx)
+    end
+  end
+
+  context "when no Actions are specified" do
+    it "throws a Runtime error" do
+      expect { TestDoubles::AnOrganizer.do_something_with_no_actions(ctx) }.to \
+        raise_error(RuntimeError, "No action(s) were provided")
+    end
+  end
+
+  context "when aliases are declared" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        aliases :foo => :bar
+
+        def self.call
+          with.reduce(TestDoubles::AnAction)
+        end
+      end
+    end
+
+    it "merges the aliases into the data" do
+      with_reducer = double(:reduce => true)
+
+      allow(described_class::WithReducerFactory).to receive(:make)
+        .and_return(with_reducer)
+
+      expect(with_reducer).to receive(:with)
+        .with(hash_including(:_aliases => { :foo => :bar }))
+        .and_return(with_reducer)
+
+      organizer.call
+    end
+  end
+
+  context "when an organizer is nested and reduced within another" do
+    let(:reduced) { TestDoubles::NestingOrganizer.call(ctx) }
+    let(:organizer_result) do
+      TestDoubles::NotExplicitlyReturningContextOrganizer.call(ctx)
+    end
+
+    it "reduces an organizer which returns something" do
+      expect(organizer_result).to eq([1, 2, 3])
+    end
+
+    it "adds :foo and :bar to the context" do
+      reduced
+      expect(ctx[:foo]).to eq([1, 2, 3])
+      expect(ctx[:bar]).to eq(ctx[:foo])
+    end
+
+    it "returns the context" 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/readme_spec.rb

@@ -1,47 +1,45 @@
-require 'spec_helper'
-
-# rubocop:disable Style/MixinUsage
-include FunctionalLightService::Prelude::Result
-# rubocop:enable Style/MixinUsage
-
-Success(1).to_s                        # => "1"
-Success(Success(1))                    # => Success(1)
-
-Failure(1).to_s                        # => "1"
-Failure(Failure(1))                    # => Failure(1)
-
-Success(1).fmap { |v| v + 1 }           # => Success(2)
-Failure(1).fmap { |v| v - 1 }           # => Failure(0)
-
-Threenum = FunctionalLightService.enum do
-  Nullary()
-  Unary(:a)
-  Binary(:a, :b)
-end
-
-FunctionalLightService.impl(Threenum) do
-  def sum
-    match do
-      Nullary() {        0 }
-      Unary()   { |u|    u }
-      Binary()  { |a, b| a + b }
-    end
-  end
-
-  def +(other)
-    match do
-      Nullary() {        other.sum }
-      Unary()   { |_a|   sum + other.sum }
-      Binary()  { |_a, _b| sum + other.sum }
-    end
-  end
-end
-
-describe Threenum do
-  it "works" do
-    expect(Threenum.Nullary + Threenum.Unary(1)).to eq 1
-    expect(Threenum.Nullary + Threenum.Binary(2, 3)).to eq 5
-    expect(Threenum.Unary(1) + Threenum.Binary(2, 3)).to eq 6
-    expect(Threenum.Binary(2, 3) + Threenum.Binary(2, 3)).to eq 10
-  end
-end
+require 'spec_helper'
+
+include FunctionalLightService::Prelude::Result
+
+Success(1).to_s                        # => "1"
+Success(Success(1))                    # => Success(1)
+
+Failure(1).to_s                        # => "1"
+Failure(Failure(1))                    # => Failure(1)
+
+Success(1).fmap { |v| v + 1 }           # => Success(2)
+Failure(1).fmap { |v| v - 1 }           # => Failure(0)
+
+Threenum = FunctionalLightService.enum do
+  Nullary()
+  Unary(:a)
+  Binary(:a, :b)
+end
+
+FunctionalLightService.impl(Threenum) do
+  def sum
+    match do
+      Nullary() {        0 }
+      Unary()   { |u|    u }
+      Binary()  { |a, b| a + b }
+    end
+  end
+
+  def +(other)
+    match do
+      Nullary() {        other.sum }
+      Unary()   { |_a|   sum + other.sum }
+      Binary()  { |_a, _b| sum + other.sum }
+    end
+  end
+end
+
+describe Threenum do
+  it "works" do
+    expect(Threenum.Nullary + Threenum.Unary(1)).to eq 1
+    expect(Threenum.Nullary + Threenum.Binary(2, 3)).to eq 5
+    expect(Threenum.Unary(1) + Threenum.Binary(2, 3)).to eq 6
+    expect(Threenum.Binary(2, 3) + Threenum.Binary(2, 3)).to eq 10
+  end
+end

data/spec/sample/calculates_order_tax_action_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
-require_relative 'tax/calculates_order_tax_action'
-
-describe CalculatesOrderTaxAction do
-  let(:order) { double('order') }
-  let(:context) do
-    data = { :order => order, :tax_percentage => 7.2 }
-    ::FunctionalLightService::Context.make(data)
-  end
-
-  it "calculates the tax based on the tax percentage" do
-    allow(order).to receive_messages(:total => 100)
-    expect(order).to receive(:tax=).with 7.2
-    CalculatesOrderTaxAction.execute(context)
-  end
-end
+require 'spec_helper'
+require_relative 'tax/calculates_order_tax_action'
+
+describe CalculatesOrderTaxAction do
+  let(:order) { double('order') }
+  let(:context) do
+    data = { :order => order, :tax_percentage => 7.2 }
+    FunctionalLightService::Context.make(data)
+  end
+
+  it "calculates the tax based on the tax percentage" do
+    allow(order).to receive_messages(:total => 100)
+    expect(order).to receive(:tax=).with 7.2
+    CalculatesOrderTaxAction.execute(context)
+  end
+end

data/spec/sample/calculates_tax_spec.rb

@@ -10,7 +10,7 @@ describe CalculatesTax do
 
   it "calls the actions in order" do
     allow(FunctionalLightService::Context).to receive(:make)
-      .with(:order => order)
+      .with({ :order => order })
       .and_return(ctx)
 
     allow(LooksUpTaxPercentageAction).to receive(:execute)

data/spec/sample/looks_up_tax_percentage_action_spec.rb

@@ -1,55 +1,55 @@
-require 'spec_helper'
-require_relative 'tax/looks_up_tax_percentage_action'
-
-class TaxRange
-  extend FunctionalLightService::Action
-end
-
-describe LooksUpTaxPercentageAction do
-  let(:region) { double('region') }
-  let(:order) do
-    order = double('order')
-    allow(order).to receive_messages(:region => region)
-    allow(order).to receive_messages(:total => 200)
-    order
-  end
-  let(:context) do
-    ::FunctionalLightService::Context.make(:order => order)
-  end
-  let(:tax_percentage) { double('tax_percentage') }
-  let(:tax_ranges) { double('tax_ranges') }
-
-  context "when the tax_ranges were not found" do
-    it "sets the context to failure" do
-      allow(TaxRange).to receive(:for_region).with(region).and_return nil
-      LooksUpTaxPercentageAction.execute(context)
-
-      expect(context).to be_failure
-      expect(context.message).to eq "The tax ranges were not found"
-    end
-  end
-
-  context "when the tax_percentage is not found" do
-    it "sets the context to failure" do
-      allow(TaxRange).to receive(:for_region).with(region).and_return tax_ranges
-      allow(tax_ranges).to receive_messages(:for_total => nil)
-
-      LooksUpTaxPercentageAction.execute(context)
-
-      expect(context).to be_failure
-      expect(context.message).to eq "The tax percentage was not found"
-    end
-  end
-
-  context "when the tax_percentage is found" do
-    it "sets the tax_percentage in context" do
-      allow(TaxRange).to receive(:for_region).with(region).and_return tax_ranges
-      allow(tax_ranges).to receive_messages(:for_total => 25)
-
-      LooksUpTaxPercentageAction.execute(context)
-
-      expect(context).to be_success
-      expect(context.fetch(:tax_percentage)).to eq 25
-    end
-  end
-end
+require 'spec_helper'
+require_relative 'tax/looks_up_tax_percentage_action'
+
+class TaxRange
+  extend FunctionalLightService::Action
+end
+
+describe LooksUpTaxPercentageAction do
+  let(:region) { double('region') }
+  let(:order) do
+    order = double('order')
+    allow(order).to receive_messages(:region => region)
+    allow(order).to receive_messages(:total => 200)
+    order
+  end
+  let(:context) do
+    FunctionalLightService::Context.make(:order => order)
+  end
+  let(:tax_percentage) { double('tax_percentage') }
+  let(:tax_ranges) { double('tax_ranges') }
+
+  context "when the tax_ranges were not found" do
+    it "sets the context to failure" do
+      allow(TaxRange).to receive(:for_region).with(region).and_return nil
+      LooksUpTaxPercentageAction.execute(context)
+
+      expect(context).to be_failure
+      expect(context.message).to eq "The tax ranges were not found"
+    end
+  end
+
+  context "when the tax_percentage is not found" do
+    it "sets the context to failure" do
+      allow(TaxRange).to receive(:for_region).with(region).and_return tax_ranges
+      allow(tax_ranges).to receive_messages(:for_total => nil)
+
+      LooksUpTaxPercentageAction.execute(context)
+
+      expect(context).to be_failure
+      expect(context.message).to eq "The tax percentage was not found"
+    end
+  end
+
+  context "when the tax_percentage is found" do
+    it "sets the tax_percentage in context" do
+      allow(TaxRange).to receive(:for_region).with(region).and_return tax_ranges
+      allow(tax_ranges).to receive_messages(:for_total => 25)
+
+      LooksUpTaxPercentageAction.execute(context)
+
+      expect(context).to be_success
+      expect(context.fetch(:tax_percentage)).to eq 25
+    end
+  end
+end

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/sample/tax/calculates_order_tax_action.rb

@@ -1,9 +1,10 @@
-class CalculatesOrderTaxAction
-  extend ::FunctionalLightService::Action
-  expects :order, :tax_percentage
-
-  executed do |ctx|
-    order_total = (ctx.order.total * (ctx.tax_percentage / 100))
-    ctx.order.tax = order_total.round(2)
-  end
-end
+class CalculatesOrderTaxAction
+  extend ::FunctionalLightService::Action
+
+  expects :order, :tax_percentage
+
+  executed do |ctx|
+    order_total = (ctx.order.total * (ctx.tax_percentage / 100))
+    ctx.order.tax = order_total.round(2)
+  end
+end

data/spec/sample/tax/looks_up_tax_percentage_action.rb

@@ -1,27 +1,28 @@
-class LooksUpTaxPercentageAction
-  extend FunctionalLightService::Action
-  expects :order
-  promises :tax_percentage
-
-  executed do |ctx|
-    tax_ranges = TaxRange.for_region(ctx.order.region)
-    ctx.tax_percentage = 0
-
-    next ctx if object_is_nil?(tax_ranges, ctx, 'The tax ranges were not found')
-
-    ctx.tax_percentage = tax_ranges.for_total(ctx.order.total)
-
-    error_message = 'The tax percentage was not found'
-    next ctx if object_is_nil?(ctx.tax_percentage, ctx, error_message)
-  end
-
-  def self.object_is_nil?(object, ctx, message)
-    if object.nil?
-      ctx.fail!(message)
-      return true
-    end
-
-    false
-  end
-  private_class_method :object_is_nil?
-end
+class LooksUpTaxPercentageAction
+  extend FunctionalLightService::Action
+
+  expects :order
+  promises :tax_percentage
+
+  executed do |ctx|
+    tax_ranges = TaxRange.for_region(ctx.order.region)
+    ctx.tax_percentage = 0
+
+    next ctx if object_is_nil?(tax_ranges, ctx, 'The tax ranges were not found')
+
+    ctx.tax_percentage = tax_ranges.for_total(ctx.order.total)
+
+    error_message = 'The tax percentage was not found'
+    next ctx if object_is_nil?(ctx.tax_percentage, ctx, error_message)
+  end
+
+  def self.object_is_nil?(object, ctx, message)
+    if object.nil?
+      ctx.fail!(message)
+      return true
+    end
+
+    false
+  end
+  private_class_method :object_is_nil?
+end

data/spec/sample/tax/provides_free_shipping_action.rb

@@ -1,10 +1,11 @@
-class ProvidesFreeShippingAction
-  extend FunctionalLightService::Action
-  expects :order
-
-  executed do |context|
-    order = context.order
-
-    order.provide_free_shipping! if order.total_with_tax > 200
-  end
-end
+class ProvidesFreeShippingAction
+  extend FunctionalLightService::Action
+
+  expects :order
+
+  executed do |context|
+    order = context.order
+
+    order.provide_free_shipping! if order.total_with_tax > 200
+  end
+end

data/spec/spec_helper.rb

@@ -1,21 +1,29 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 $LOAD_PATH << File.join(File.dirname(__FILE__))
 
-require 'simplecov'
+if ENV['RUN_COVERAGE_REPORT']
+  require 'simplecov'
 
-SimpleCov.start do
-  add_filter 'vendor/'
-  add_filter %r{^/spec/}
-end
+  SimpleCov.start do
+    add_filter 'vendor/'
+    add_filter %r{^/spec/}
+  end
 
-SimpleCov.minimum_coverage_by_file 90
+  SimpleCov.minimum_coverage 98
+  SimpleCov.minimum_coverage_by_file 90
 
-require 'simplecov-cobertura'
-SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
+  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"
+
+# Le API deprecate (Maybe/Null, operatori esotici) restano testate:
+# i warning vengono silenziati globalmente e riattivati solo nelle
+# spec che li verificano
+FunctionalLightService::Deprecations.silenced = true