switchyard 7.0.0

data/spec/action_optional_expected_keys_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe ":expects macro using defaults" do
+  context "when all expected keys are supplied" do
+    it "is expected to ignore default values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :second_number => 5,
+        :third_number => 7
+      )
+
+      expect(outcome.total).to eq 15
+    end
+  end
+
+  context "when defaults are supplied" do
+    it "is expected to use static values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :second_number => 7
+      )
+
+      expect(outcome.total).to eq 20
+    end
+
+    it "is expected to use dynamic values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :third_number => 5
+      )
+
+      expect(outcome.total).to eq 18
+    end
+
+    it "is expected to process defaults in their defined order" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :third_number => 5,
+        :first_number => 3
+      )
+
+      expect(outcome.total).to eq 18
+    end
+
+    it "is expected to use all defaults if required" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3
+      )
+
+      expect(outcome.total).to eq 23
+    end
+  end
+
+  context "when used within an organizer" do
+    it "is expected to process required defaults" do
+      outcome = TestDoubles::OrganizerWithActionsUsingDefaults.call
+
+      expect(outcome.total).to eq 20
+    end
+  end
+
+  context "when the expected key is satisfied through an alias" do
+    it "is expected to not apply the default" do
+      action = Class.new do
+        extend Switchyard::Action
+
+        expects  :greeting, :default => "hello"
+        promises :greeted
+
+        executed do |ctx|
+          ctx.greeted = ctx.greeting
+        end
+      end
+
+      organizer = Class.new do
+        extend Switchyard::Organizer
+
+        aliases :salutation => :greeting
+      end
+
+      outcome = organizer.with(:salutation => "ciao").reduce([action])
+
+      expect(outcome.greeted).to eq "ciao"
+    end
+  end
+
+  context "when defaults are misconfigured" do
+    it "is expected to raise an exception" do
+      expect do
+        # Needs to be specified in the block
+        # as error is raised at define time
+        class AddsNumbersWithIncorrectDefaults
+          extend Switchyard::Action
+
+          expects  :first,  :default => 10 # This one is fine. Other two arent
+          expects  :second, :defalut => ->(ctx) { ctx[:first] + 7 }
+          expects  :third,  :deafult => 10
+          promises :total
+
+          executed do |ctx|
+            ctx.total = ctx.first + ctx.second + ctx.third
+          end
+        end
+      end.to raise_error(Switchyard::UnusableExpectKeyDefaultError)
+    end
+  end
+end

data/spec/action_promised_keys_spec.rb

@@ -0,0 +1,126 @@
+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 Switchyard::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(Switchyard::PromisedKeysNotInContextError, exception_msg)
+    end
+
+    it "can fail the context without fulfilling its promise" do
+      module TestDoubles
+        class MakesCappuccinoAction2
+          extend Switchyard::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 Switchyard::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 Switchyard::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(Switchyard::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(Switchyard::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,97 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe Switchyard::Action do
+  let(:context) { Switchyard::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 Switchyard::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 Switchyard::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,52 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Context do
+  subject(:context) { Switchyard::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 =
+        "Switchyard::Context({}, success: true, message: '', error_code: nil, " \
+        "skip_remaining: false, skip_all_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 =
+        "Switchyard::Context({}, success: false, message: 'There was an error', " \
+        "error_code: nil, skip_remaining: false, skip_all_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 =
+        "Switchyard::Context({}, success: true, message: 'No need to process', " \
+        "error_code: nil, skip_remaining: true, skip_all_remaining: false, aliases: {})"
+
+      expect(context.inspect).to eq(inspected_context)
+    end
+
+    it 'prints skip_all_remaining' do
+      context.skip_all_remaining!('Nothing else to process')
+
+      inspected_context =
+        "Switchyard::Context({}, success: true, message: 'Nothing else to process', " \
+        "error_code: nil, skip_remaining: false, skip_all_remaining: true, aliases: {})"
+
+      expect(context.inspect).to eq(inspected_context)
+    end
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Context do
+  let(:context) { Switchyard::Context.make }
+
+  describe "can be made" do
+    context "with no arguments" do
+      subject { Switchyard::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 = Switchyard::Context.make(:one => 1)
+
+        expect(context[:one]).to eq(1)
+      end
+    end
+
+    context "with FAILURE" do
+      it "is failed" do
+        outcome = Switchyard::Result::Failure(:message => '', :error => nil)
+        context = Switchyard::Context.new({}, outcome)
+
+        expect(context).to be_failure
+      end
+    end
+  end
+
+  describe "can't be made" do
+    specify "with invalid parameters" do
+      expect { Switchyard::Context.make([]) }.to raise_error(ArgumentError)
+    end
+  end
+
+  it "can be asked for success?" do
+    outcome = Switchyard::Result::Success(:message => '', :error => nil)
+    context = Switchyard::Context.new({}, outcome)
+
+    expect(context).to be_success
+  end
+
+  it "can be asked for failure?" do
+    outcome = Switchyard::Result::Failure(:message => '', :error => nil)
+    context = Switchyard::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(Switchyard::Configuration.localization_adapter)
+      .to receive(:failure)
+      .with(:failure_reason, action_class, {})
+      .and_return("message")
+
+    context = Switchyard::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(Switchyard::Configuration.localization_adapter)
+      .to receive(:success)
+      .with(:action_passed, action_class, {})
+      .and_return("message")
+
+    context = Switchyard::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(Switchyard::FailWithRollbackError)
+  end
+
+  it "exptected outcome reader get Success and message empty and error nil" do
+    outcome = Switchyard::Result::Success(:message => "", :error => nil)
+    expect(context.outcome).to eq(outcome)
+  end
+
+  it "can contain false values" do
+    context = Switchyard::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(Switchyard::ReservedKeysInContextError, /:size conflicts/)
+    end
+
+    it "does not raise when re-defining accessors for the same key" do
+      ctx = Switchyard::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 Switchyard::Action
+
+        expects :_before_actions
+        executed { |_ctx| } # rubocop:disable Lint/EmptyBlock
+      end
+
+      expect { action.execute(:_before_actions => []) }
+        .to raise_error(Switchyard::ReservedKeysInContextError)
+    end
+
+    it "rejects :organized_by in expects/promises" do
+      action = Class.new do
+        extend Switchyard::Action
+
+        expects :organized_by
+        executed { |_ctx| } # rubocop:disable Lint/EmptyBlock
+      end
+
+      expect { action.execute(:organized_by => Object) }
+        .to raise_error(Switchyard::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 = Switchyard::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
+      Switchyard::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