finite_machine 0.11.2 → 0.14.0

data/spec/unit/handlers_spec.rb

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'handlers' do
-
-  before(:each) {
-    stub_const("DummyLogger", Class.new do
-      attr_reader :result
-
-      def log_error(exception)
-        @result = "log_error(#{exception})"
-      end
-
-      def raise_error
-        raise FiniteMachine::TransitionError
-      end
-    end)
-  }
-
-  it "allows to customise error handling" do
-    called = []
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-
-      handlers {
-        handle FiniteMachine::InvalidStateError do |exception|
-          called << 'invalidstate'
-        end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    expect(fsm.current).to eql(:green)
-    expect(called).to eql([
-      'invalidstate'
-    ])
-  end
-
-  it 'allows for :with to be symbol' do
-    logger = DummyLogger.new
-    fsm = FiniteMachine.define do
-      initial :green
-
-      target logger
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-
-      handlers {
-        handle FiniteMachine::InvalidStateError, with: :log_error
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    expect(fsm.current).to eql(:green)
-    expect(logger.result).to eql('log_error(FiniteMachine::InvalidStateError)')
-  end
-
-  it 'allows for error type as string' do
-    logger = DummyLogger.new
-    called = []
-    fsm = FiniteMachine.define do
-      initial :green
-
-      target logger
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-
-      callbacks {
-        on_enter_yellow do |event|
-          raise_error
-        end
-      }
-      handlers {
-        handle 'InvalidStateError' do |exception|
-          called << 'invalid_state_error'
-        end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    expect(fsm.current).to eql(:green)
-    expect(called).to eql(['invalid_state_error'])
-  end
-
-  it 'allows for empty block handler' do
-    called = []
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-
-      handlers {
-        handle FiniteMachine::InvalidStateError do
-          called << 'invalidstate'
-        end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    expect(fsm.current).to eql(:green)
-    expect(called).to eql([
-      'invalidstate'
-    ])
-  end
-
-  it 'requires error handler' do
-    expect { FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green => :yellow
-      }
-
-      handlers {
-        handle 'UnknownErrorType'
-      }
-    end }.to raise_error(ArgumentError, /error handler/)
-  end
-
-  it 'checks handler class to be Exception' do
-    expect { FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green => :yellow
-      }
-
-      handlers {
-        handle Object do end
-      }
-    end }.to raise_error(ArgumentError, /Object isn't an Exception/)
-  end
-end

data/spec/unit/hook_event/build_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::HookEvent, '#build' do
-  it "builds action event" do
-    hook_event = FiniteMachine::HookEvent::Before.build(:green, :go, :red)
-    expect(hook_event.name).to eq(:go)
-  end
-
-  it "builds state event" do
-    hook_event = FiniteMachine::HookEvent::Enter.build(:green, :go, :red)
-    expect(hook_event.name).to eq(:green)
-  end
-end

data/spec/unit/hook_event/eql_spec.rb

@@ -1,36 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::HookEvent, 'eql?' do
-  let(:name)       { :green }
-  let(:event_name) { :go }
-  let(:object)     { described_class }
-
-  subject(:hook) { object.new(name, event_name, name) }
-
-  context 'with the same object' do
-   let(:other) { hook }
-
-    it "equals" do
-      expect(hook).to eql(other)
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { hook.dup }
-
-    it "equals" do
-      expect(hook).to eql(other)
-    end
-  end
-
-  context "with an object having different name" do
-    let(:other_name) { :red }
-    let(:other) { object.new(other_name, event_name, other_name) }
-
-    it "doesn't equal" do
-      expect(hook).not_to eql(other)
-    end
-  end
-end

data/spec/unit/hook_event/infer_default_name_spec.rb

@@ -1,13 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe FiniteMachine::HookEvent, '#infer_default_name' do
-  it "infers default name for state" do
-    hook_event = described_class::Enter
-    expect(described_class.infer_default_name(hook_event)).to eq(:any)
-  end
-
-  it "infers default name for event" do
-    hook_event = described_class::Before
-    expect(described_class.infer_default_name(hook_event)).to eq(:any_event)
-  end
-end

data/spec/unit/hook_event/initialize_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::HookEvent, '#new' do
-  it "reads event name" do
-    hook_event = described_class.new(:green, :go, :green)
-    expect(hook_event.name).to eql(:green)
-  end
-
-  it "reads event type" do
-    hook_event = described_class.new(:green, :go, :green)
-    expect(hook_event.type).to eql(FiniteMachine::HookEvent)
-  end
-
-  it "reads the from state" do
-    hook_event = described_class.new(:green, :go, :red)
-    expect(hook_event.from).to eql(:red)
-  end
-
-  it "freezes object" do
-    hook_event = described_class.new(:green, :go, :green)
-    expect { hook_event.name = :red }.to raise_error(RuntimeError)
-  end
-end

data/spec/unit/hook_event/notify_spec.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::HookEvent, '.notify' do
-  it "emits event on the subscriber" do
-    subscriber = spy(:subscriber)
-    hook_event = described_class.new(:green, :go, :red)
-
-    hook_event.notify(subscriber, 1, 2)
-
-    expect(subscriber).to have_received(:emit).with(hook_event, 1, 2)
-  end
-end

data/spec/unit/hooks/call_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Hooks, '#call' do
-  let(:object) { described_class }
-
-  subject(:hooks) { object.new }
-
-  it "adds and removes a single hook" do
-    expect(hooks).to be_empty
-
-    yielded = []
-    event_type = FiniteMachine::HookEvent::Before
-    hook = -> { }
-    hooks.register(event_type, :foo, hook)
-
-    hooks.call(event_type, :foo) do |callback|
-      yielded << callback
-    end
-
-    expect(yielded).to eq([hook])
-  end
-end

data/spec/unit/hooks/clear_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe FiniteMachine::Hooks, '#clear' do
-  it "clears all registered hooks" do
-    hooks = described_class.new
-
-    event_type = FiniteMachine::HookEvent::Before
-    hook = -> { }
-    hooks.register(event_type, :foo, hook)
-    hooks.register(event_type, :bar, hook)
-
-    expect(hooks.empty?).to eq(false)
-    hooks.clear
-    expect(hooks.empty?).to eq(true)
-  end
-end

data/spec/unit/hooks/inspect_spec.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Hooks, '#inspect' do
-  subject(:hooks) { described_class.new }
-
-  it "displays name and transitions" do
-    hook = -> { }
-    event = FiniteMachine::HookEvent::Enter
-    collection = {event => {yellow: [hook]}}
-    hooks.register(event, :yellow, hook)
-
-    expect(hooks.inspect).to eql("<#FiniteMachine::Hooks:0x#{hooks.object_id.to_s(16)} @collection=#{collection}>")
-    expect(hooks.to_s).to eql(hooks.inspect)
-  end
-end

data/spec/unit/hooks/register_spec.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Hooks, '#register' do
-  let(:object) { described_class }
-
-  subject(:hooks) { object.new }
-
-  it "adds and removes a single hook" do
-    expect(hooks).to be_empty
-
-    event_type = FiniteMachine::HookEvent::Before
-    hook = -> { }
-
-    hooks.register(event_type, :foo, hook)
-    expect(hooks.collection).to eq({event_type => {foo: [hook]}})
-
-    hooks.unregister(event_type, :foo, hook)
-    expect(hooks.collection).to eq({event_type => {foo: []}})
-  end
-end

data/spec/unit/if_unless_spec.rb

@@ -1,353 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, ':if, :unless' do
-  before(:each) {
-    stub_const("Car", Class.new do
-      attr_accessor :engine_on
-
-      def turn_engine_on
-        @engine_on = true
-      end
-
-      def turn_engine_off
-        @engine_on = false
-      end
-
-      def engine_on?
-        !!@engine_on
-      end
-    end)
-
-    stub_const("Bug", Class.new do
-      def pending?
-        false
-      end
-    end)
-  }
-
-  it "passes context to conditionals" do
-    called = []
-    fsm = FiniteMachine.define do
-      initial :red
-
-      events {
-        event :go, :red => :green,
-              if: proc { |context| called << "cond_red_green(#{context})"; true}
-        event :stop, from: :any do
-          choice :red,
-                 if: proc { |context| called << "cond_any_red(#{context})"; true }
-        end
-      }
-    end
-
-    expect(fsm.current).to eq(:red)
-
-    fsm.go
-    expect(fsm.current).to eq(:green)
-    expect(called).to eq(["cond_red_green(#{fsm})"])
-
-    fsm.stop
-    expect(fsm.current).to eq(:red)
-    expect(called).to match_array([
-      "cond_red_green(#{fsm})",
-      "cond_any_red(#{fsm})"
-    ])
-  end
-
-  it "passes context & arguments to conditionals" do
-    called = []
-    fsm = FiniteMachine.define do
-      initial :red
-
-      events {
-        event :go,  :red => :green,
-              if: proc { |_, a| called << "cond_red_green(#{a})"; true }
-        event :stop, from: :any do
-          choice :red,
-                 if: proc { |_, b| called << "cond_any_red(#{b})"; true }
-        end
-      }
-    end
-
-    expect(fsm.current).to eq(:red)
-
-    fsm.go(:foo)
-    expect(fsm.current).to eq(:green)
-    expect(called).to eq(["cond_red_green(foo)"])
-
-    fsm.stop(:bar)
-    expect(fsm.current).to eq(:red)
-    expect(called).to match_array([
-      "cond_red_green(foo)",
-      "cond_any_red(bar)"
-    ])
-  end
-
-  it "allows to cancel event with :if option" do
-    called = []
-
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green => :yellow, if: -> { return false }
-        event :stop, :yellow => :red
-      }
-
-      callbacks {
-        # generic callbacks
-        on_enter      do |event| called << 'on_enter' end
-        on_transition do |event| called << 'on_transition' end
-        on_exit       do |event| called << 'on_exit' end
-
-        # state callbacks
-        on_enter :green do |event| called << 'on_enter_green' end
-        on_enter :yellow do |event| called << "on_enter_yellow" end
-
-        on_transition :green  do |event| called << 'on_transition_green' end
-        on_transition :yellow do |event| called << "on_transition_yellow" end
-
-        on_exit :green  do |event| called << 'on_exit_green' end
-        on_exit :yellow do |event| called << "on_exit_yellow" end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    called = []
-    fsm.slow
-    expect(fsm.current).to eql(:green)
-    expect(called).to eql([])
-  end
-
-  it "allows to cancel event with :unless option" do
-    called = []
-
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green => :yellow, unless: -> { true }
-        event :stop, :yellow => :red
-      }
-
-      callbacks {
-        # generic callbacks
-        on_enter      do |event| called << 'on_enter' end
-        on_transition do |event| called << 'on_transition' end
-        on_exit       do |event| called << 'on_exit' end
-
-        # state callbacks
-        on_enter :green do |event| called << 'on_enter_green' end
-        on_enter :yellow do |event| called << "on_enter_yellow" end
-
-        on_transition :green  do |event| called << 'on_transition_green' end
-        on_transition :yellow do |event| called << "on_transition_yellow" end
-
-        on_exit :green  do |event| called << 'on_exit_green' end
-        on_exit :yellow do |event| called << "on_exit_yellow" end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    called = []
-    fsm.slow
-    expect(fsm.current).to eql(:green)
-    expect(called).to eql([])
-  end
-
-  it "allows to combine conditionals" do
-    conditions = []
-
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green => :yellow,
-          if: [ -> { conditions << 'first_if'; return true },
-                -> { conditions << 'second_if'; return true}],
-          unless: -> { conditions << 'first_unless'; return true }
-        event :stop, :yellow => :red
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(fsm.current).to eql(:green)
-    expect(conditions).to eql([
-      'first_if',
-      'second_if',
-      'first_unless'
-    ])
-  end
-
-  context 'when proc' do
-    it "specifies :if and :unless" do
-      car = Car.new
-
-      fsm = FiniteMachine.define do
-        initial :neutral
-
-        target car
-
-        events {
-          event :start, :neutral => :one, if: proc {|_car| _car.engine_on? }
-          event :shift, :one => :two
-        }
-      end
-      car.turn_engine_off
-      expect(car.engine_on?).to be false
-      expect(fsm.current).to eql(:neutral)
-      fsm.start
-      expect(fsm.current).to eql(:neutral)
-
-      car.turn_engine_on
-      expect(car.engine_on?).to be true
-      expect(fsm.current).to eql(:neutral)
-      fsm.start
-      expect(fsm.current).to eql(:one)
-    end
-
-    it "passes arguments to the scope" do
-      car = Car.new
-
-      fsm = FiniteMachine.define do
-        initial :neutral
-
-        target car
-
-        events {
-          event :start, :neutral => :one, if: proc { |_car, state|
-            _car.engine_on = state
-            _car.engine_on?
-          }
-          event :shift, :one => :two
-        }
-      end
-      fsm.start(false)
-      expect(fsm.current).to eql(:neutral)
-      fsm.start(true)
-      expect(fsm.current).to eql(:one)
-    end
-  end
-
-  context 'when symbol' do
-    it "specifies :if and :unless" do
-      car = Car.new
-
-      fsm = FiniteMachine.define do
-        initial :neutral
-
-        target car
-
-        events {
-          event :start, :neutral => :one, if: :engine_on?
-          event :shift, :one => :two
-        }
-      end
-      car.turn_engine_off
-      expect(car.engine_on?).to be false
-      expect(fsm.current).to eql(:neutral)
-      fsm.start
-      expect(fsm.current).to eql(:neutral)
-
-      car.turn_engine_on
-      expect(car.engine_on?).to be true
-      expect(fsm.current).to eql(:neutral)
-      fsm.start
-      expect(fsm.current).to eql(:one)
-    end
-  end
-
-  context 'when string' do
-    it "specifies :if and :unless" do
-      car = Car.new
-
-      fsm = FiniteMachine.define do
-        initial :neutral
-
-        target car
-
-        events {
-          event :start, :neutral => :one, if: "engine_on?"
-          event :shift, :one => :two
-        }
-      end
-      car.turn_engine_off
-      expect(car.engine_on?).to be false
-      expect(fsm.current).to eql(:neutral)
-      fsm.start
-      expect(fsm.current).to eql(:neutral)
-
-      car.turn_engine_on
-      expect(car.engine_on?).to be true
-      expect(fsm.current).to eql(:neutral)
-      fsm.start
-      expect(fsm.current).to eql(:one)
-    end
-  end
-
-  context 'when same event name' do
-    it "preservers conditions for the same named event" do
-      bug = Bug.new
-      fsm = FiniteMachine.define do
-        initial :initial
-
-        target bug
-
-        events {
-          event :bump, :initial => :low
-          event :bump, :low     => :medium, if: :pending?
-          event :bump, :medium  => :high
-        }
-      end
-      expect(fsm.current).to eq(:initial)
-      fsm.bump
-      expect(fsm.current).to eq(:low)
-      fsm.bump
-      expect(fsm.current).to eq(:low)
-    end
-
-    it "allows for static choice based on branching condition" do
-      fsm = FiniteMachine.define do
-        initial :company_form
-
-        events {
-          event :next, :company_form => :agreement_form, if: -> { false }
-          event :next, :company_form => :promo_form,     if: -> { false }
-          event :next, :company_form => :official_form,  if: -> { true }
-        }
-      end
-      expect(fsm.current).to eq(:company_form)
-      fsm.next
-      expect(fsm.current).to eq(:official_form)
-    end
-
-    it "allows for dynamic choice based on branching condition" do
-      fsm = FiniteMachine.define do
-        initial :company_form
-
-        events {
-          event :next, :company_form => :agreement_form, if: proc { |_, a| a < 1 }
-          event :next, :company_form => :promo_form,     if: proc { |_, a| a == 1 }
-          event :next, :company_form => :official_form,  if: proc { |_, a| a > 1 }
-        }
-      end
-      expect(fsm.current).to eq(:company_form)
-
-      fsm.next(0)
-      expect(fsm.current).to eq(:agreement_form)
-      fsm.restore!(:company_form)
-      expect(fsm.current).to eq(:company_form)
-
-      fsm.next(1)
-      expect(fsm.current).to eq(:promo_form)
-      fsm.restore!(:company_form)
-      expect(fsm.current).to eq(:company_form)
-
-      fsm.next(2)
-      expect(fsm.current).to eq(:official_form)
-    end
-  end
-end