finite_machine 0.12.1 → 0.13.0

data/spec/unit/definition_spec.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::Definition, 'definition' do
-
-  before do
-    class Engine < FiniteMachine::Definition
-      initial :neutral
-
-      event :forward, [:reverse, :neutral] => :one
-      event :shift, :one => :two
-      event :shift, :two => :one
-      event :back,  [:neutral, :one] => :reverse
-
-      on_enter :reverse do |event|
-        target.turn_reverse_lights_on
-      end
-
-      on_exit :reverse do |event|
-        target.turn_reverse_lights_off
-      end
-
-      handle FiniteMachine::InvalidStateError do |exception| end
-    end
-  end
-
-  it "creates unique instances" do
-    engine_a = Engine.new
-    engine_b = Engine.new
-    expect(engine_a).not_to be(engine_b)
-
-    expect(engine_a.current).to eq(:neutral)
-
-    engine_a.forward
-    expect(engine_a.current).to eq(:one)
-    expect(engine_b.current).to eq(:neutral)
-  end
-
-  it "allows to create standalone machine" do
-    stub_const("Car", Class.new do
-      def turn_reverse_lights_off
-        @reverse_lights = false
-      end
-
-      def turn_reverse_lights_on
-        @reverse_lights = true
-      end
-
-      def reverse_lights?
-        @reverse_lights ||= false
-      end
-    end)
-
-    car = Car.new
-    engine = Engine.new(car)
-    expect(engine.current).to eq(:neutral)
-
-    engine.forward
-    expect(engine.current).to eq(:one)
-    expect(car.reverse_lights?).to eq(false)
-
-    engine.back
-    expect(engine.current).to eq(:reverse)
-    expect(car.reverse_lights?).to eq(true)
-  end
-
-  it "supports inheritance of definitions" do
-    class GenericStateMachine < FiniteMachine::Definition
-      initial :red
-
-      event :start, :red => :green
-
-      on_enter { |event| target << 'generic' }
-    end
-
-    class SpecificStateMachine < GenericStateMachine
-      event :stop, :green => :yellow
-
-      on_enter(:yellow) { |event| target << 'specific' }
-    end
-
-    called = []
-    generic_fsm  = GenericStateMachine.new(called)
-    specific_fsm = SpecificStateMachine.new(called)
-
-    expect(generic_fsm.states).to match_array([:none, :red, :green])
-    expect(specific_fsm.states).to match_array([:none, :red, :green, :yellow])
-
-    expect(specific_fsm.current).to eq(:red)
-
-    specific_fsm.start
-    expect(specific_fsm.current).to eq(:green)
-    expect(called).to match_array(['generic'])
-
-    specific_fsm.stop
-    expect(specific_fsm.current).to eq(:yellow)
-    expect(called).to match_array(['generic', 'generic', 'specific'])
-  end
-end

data/spec/unit/event_names_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, '#events' do
-  it "retrieves all event names" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :start, :red => :green
-      event :stop,  :green => :red
-    end
-
-    expect(fsm.current).to eql(:green)
-    expect(fsm.events).to match_array([:init, :start, :stop])
-  end
-end

data/spec/unit/events_map/add_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap, '#add' do
-  it "adds transitions" do
-    transition = double(:transition)
-    events_map = described_class.new
-
-    events_map.add(:validated, transition)
-    expect(events_map[:validated]).to eq([transition])
-
-    events_map.add(:validated, transition)
-    expect(events_map[:validated]).to eq([transition, transition])
-  end
-
-  it "allows to map add operations" do
-    events_map = described_class.new
-    transition = double(:transition)
-
-    events_map.add(:go, transition).add(:start, transition)
-
-    expect(events_map.size).to eq(2)
-  end
-end

data/spec/unit/events_map/choice_transition_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap, '#choice_transition?' do
-  it "checks if transition has many branches" do
-    transition_a = double(:transition_a, matches?: true)
-    transition_b = double(:transition_b, matches?: true)
-
-    events_map = described_class.new
-    events_map.add(:go, transition_a)
-    events_map.add(:go, transition_b)
-
-    expect(events_map.choice_transition?(:go, :green)).to eq(true)
-  end
-
-  it "checks that transition has no branches" do
-    transition_a = double(:transition_a, matches?: false)
-    transition_b = double(:transition_b, matches?: true)
-
-    events_map = described_class.new
-    events_map.add(:go, transition_a)
-    events_map.add(:go, transition_b)
-
-    expect(events_map.choice_transition?(:go, :green)).to eq(false)
-  end
-end

data/spec/unit/events_map/clear_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap, '#clear' do
-  it "clears map events" do
-    event = double(:event)
-    events_map = described_class.new
-    events_map.add(:validated, event)
-    expect(events_map.empty?).to be(false)
-
-    events_map.clear
-    expect(events_map.empty?).to be(true)
-  end
-end

data/spec/unit/events_map/events_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap, '#events' do
-  it "has no event names" do
-    events_map = described_class.new
-    expect(events_map.events).to eq([])
-  end
-
-  it "returns all event names" do
-    events_map = described_class.new
-    transition = double(:transition)
-    events_map.add(:ready, transition)
-    events_map.add(:go, transition)
-    expect(events_map.events).to match_array([:ready, :go])
-  end
-end

data/spec/unit/events_map/inspect_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap, '#inspect' do
-  it "inspects empty events map" do
-    events_map = described_class.new
-    expect(events_map.inspect).to eq("<#FiniteMachine::EventsMap @events_map={}>")
-  end
-
-  it "inspect events map" do
-    transition = double(:transition)
-    events_map = described_class.new
-    events_map.add(:validated, transition)
-    expect(events_map.inspect).to eq("<#FiniteMachine::EventsMap @events_map=#{{validated: [transition]}}>")
-  end
-
-  it "prints events map" do
-    transition = double(:transition)
-    events_map = described_class.new
-    events_map.add(:validated, transition)
-    expect(events_map.to_s).to eq("#{{validated: [transition]}}")
-  end
-end

data/spec/unit/events_map/match_transition_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap, '#match_transition' do
-  it "matches transition without conditions" do
-    transition_a = double(:transition_a, matches?: false)
-    transition_b = double(:transition_b, matches?: true)
-    events_map = described_class.new
-
-    events_map.add(:a, transition_a)
-    events_map.add(:a, transition_b)
-
-    expect(events_map.match_transition(:a, :green)).to eq(transition_b)
-  end
-
-  it "fails to match any transition" do
-    events_map = described_class.new
-
-    expect(events_map.match_transition(:a, :green)).to eq(nil)
-  end
-
-  it "matches transition with conditions" do
-    transition_a = double(:transition_a, matches?: true)
-    transition_b = double(:transition_b, matches?: true)
-    events_map = described_class.new
-
-    events_map.add(:a, transition_a)
-    events_map.add(:a, transition_b)
-
-    allow(transition_a).to receive(:check_conditions).and_return(false)
-    allow(transition_b).to receive(:check_conditions).and_return(true)
-
-    expect(events_map.match_transition_with(:a, :green, 'Piotr')).to eq(transition_b)
-    expect(transition_a).to have_received(:check_conditions).with('Piotr')
-  end
-end

data/spec/unit/events_map/move_to_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap, '#move_to' do
-  it "moves to state by matching individual transition" do
-    transition_a = double(:transition_a, matches?: false)
-    transition_b = double(:transition_b, matches?: true)
-
-    events_map = described_class.new
-    events_map.add(:go, transition_a)
-    events_map.add(:go, transition_b)
-
-    allow(transition_b).to receive(:to_state).with(:yellow).and_return(:red)
-
-    expect(events_map.move_to(:go, :yellow)).to eq(:red)
-    expect(transition_b).to have_received(:to_state).with(:yellow)
-  end
-
-  it "moves to state by matching choice transition" do
-    transition_a = double(:transition_a, matches?: true)
-    transition_b = double(:transition_b, matches?: true)
-
-    events_map = described_class.new
-    events_map.add(:go, transition_a)
-    events_map.add(:go, transition_b)
-
-    allow(transition_a).to receive(:check_conditions).and_return(false)
-    allow(transition_b).to receive(:check_conditions).and_return(true)
-
-    allow(transition_b).to receive(:to_state).with(:green).and_return(:red)
-
-    expect(events_map.move_to(:go, :green)).to eq(:red)
-    expect(transition_b).to have_received(:to_state).with(:green)
-  end
-
-  it "moves to from state if no transition available" do
-    transition_a = double(:transition_a, matches?: false)
-    transition_b = double(:transition_b, matches?: false)
-
-    events_map = described_class.new
-    events_map.add(:go, transition_a)
-    events_map.add(:go, transition_b)
-
-    expect(events_map.move_to(:go, :green)).to eq(:green)
-  end
-end

data/spec/unit/events_map/states_for_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::EventsMap do
-  it "finds current states for event name" do
-    transition = spy(:transition, states: {:red => :yellow, :yellow => :green})
-    events_map = described_class.new
-    events_map.add(:start, transition)
-
-    expect(events_map.states_for(:start)).to eq([:red, :yellow])
-  end
-
-  it "fails to find any states for event name" do
-    events_map = described_class.new
-
-    expect(events_map.states_for(:start)).to eq([])
-  end
-end

data/spec/unit/events_spec.rb

@@ -1,390 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, 'events' do
-  it "allows for hash rocket syntax to describe transition" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.stop
-    expect(fsm.current).to eql(:red)
-  end
-
-  it "allows for (:from | :to) key pairs to describe transition" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :slow, from: :green, to: :yellow
-      event :stop, from: :yellow, to: :red
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.stop
-    expect(fsm.current).to eql(:red)
-  end
-
-  it "permits no-op event without 'to' transition" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :noop,  from: :green
-      event :slow,  from: :green,  to: :yellow
-      event :stop,  from: :yellow, to: :red
-      event :ready, from: :red,    to: :yellow
-      event :go,    from: :yellow, to: :green
-    end
-
-    expect(fsm.current).to eql(:green)
-
-    expect(fsm.can?(:noop)).to be true
-    expect(fsm.can?(:slow)).to be true
-
-    fsm.noop
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-
-    expect(fsm.cannot?(:noop)).to be true
-    expect(fsm.cannot?(:slow)).to be true
-  end
-
-  it "permits event from any state using :from" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :slow,  from: :green,  to: :yellow
-      event :stop,  from: :yellow, to: :red
-      event :ready, from: :red,    to: :yellow
-      event :go,    from: :yellow, to: :green
-      event :run,   from: any_state, to: :green
-    end
-
-    expect(fsm.current).to eql(:green)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.run
-    expect(fsm.current).to eql(:green)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.stop
-    expect(fsm.current).to eql(:red)
-    fsm.run
-    expect(fsm.current).to eql(:green)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.go
-    expect(fsm.current).to eql(:green)
-    fsm.run
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "permits event from any state for hash syntax" do
-    fsm = FiniteMachine.new do
-      initial :red
-
-      event :start, :red    => :yellow
-      event :run,   :yellow => :green
-      event :stop,  :green  => :red
-      event :go,    any_state => :green
-    end
-
-    expect(fsm.current).to eql(:red)
-
-    fsm.go
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    fsm.start
-    expect(fsm.current).to eql(:yellow)
-    fsm.go
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "permits event from any state without 'from'" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :slow,  from: :green,  to: :yellow
-      event :stop,  from: :yellow, to: :red
-      event :ready, from: :red,    to: :yellow
-      event :go,    from: :yellow, to: :green
-      event :run,                  to: :green
-    end
-
-    expect(fsm.current).to eql(:green)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.run
-    expect(fsm.current).to eql(:green)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.stop
-    expect(fsm.current).to eql(:red)
-    fsm.run
-    expect(fsm.current).to eql(:green)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    fsm.go
-    expect(fsm.current).to eql(:green)
-    fsm.run
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "doesn't raise error on invalid transition for non-dangerous version" do
-    called = []
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :stop, from: :yellow, to: :red
-
-      on_before :stop do |event| called << 'on_before_stop' end
-      on_after  :stop do |event| called << 'on_before_stop' end
-    end
-
-    expect(fsm.current).to eq(:green)
-    expect(fsm.stop).to eq(false)
-    expect(fsm.current).to eq(:green)
-    expect(called).to match_array(['on_before_stop'])
-  end
-
-  context 'for non-dangerous version' do
-    it "doesn't raise error on invalid transition and fires callbacks" do
-      called = []
-      fsm = FiniteMachine.new do
-        initial :green
-
-        event :stop, from: :yellow, to: :red
-
-        on_before :stop do |event| called << 'on_before_stop' end
-        on_after  :stop do |event| called << 'on_before_stop' end
-      end
-
-      expect(fsm.current).to eq(:green)
-      expect(fsm.stop).to eq(false)
-      expect(fsm.current).to eq(:green)
-      expect(called).to match_array(['on_before_stop'])
-    end
-
-    it "raises error on invalid transition for dangerous version" do
-      called = []
-      fsm = FiniteMachine.new do
-        initial :green
-
-        event :slow,  from: :green,  to: :yellow
-        event :stop,  from: :yellow, to: :red, silent: true
-
-        on_before :stop do |event| called << 'on_before_stop' end
-        on_after  :stop do |event| called << 'on_before_stop' end
-      end
-
-      expect(fsm.current).to eql(:green)
-      expect(fsm.stop).to eq(false)
-      expect(called).to match_array([])
-    end
-  end
-
-  context 'for dangerous version' do
-    it "raises error on invalid transition without callbacks" do
-      called = []
-      fsm = FiniteMachine.new do
-        initial :green
-
-        event :start, :red => :yellow, silent: true
-
-        on_before :start do |event| called << 'on_before_start' end
-        on_after  :start do |event| called << 'on_after_start' end
-      end
-
-      expect(fsm.current).to eq(:green)
-      expect { fsm.start! }.to raise_error(FiniteMachine::InvalidStateError)
-      expect(called).to eq([])
-      expect(fsm.current).to eq(:green)
-    end
-
-    it "raises error on invalid transition with callbacks fired" do
-      called = []
-      fsm = FiniteMachine.new do
-        initial :green
-
-        event :start, :red => :yellow
-
-        on_before :start do |event| called << 'on_before_start' end
-        on_after  :start do |event| called << 'on_after_start' end
-      end
-
-      expect(fsm.current).to eq(:green)
-      expect { fsm.start! }.to raise_error(FiniteMachine::InvalidStateError,
-                                           /inappropriate current state 'green'/)
-      expect(called).to eq(['on_before_start'])
-      expect(fsm.current).to eq(:green)
-    end
-  end
-
-  context 'when multiple from states' do
-    it "allows for array from key" do
-      fsm = FiniteMachine.new do
-        initial :green
-
-        event :slow,  :green            => :yellow
-        event :stop,  [:green, :yellow] => :red
-        event :ready, :red              => :yellow
-        event :go,    [:yellow, :red]   => :green
-      end
-
-      expect(fsm.current).to eql(:green)
-
-      expect(fsm.can?(:slow)).to be true
-      expect(fsm.can?(:stop)).to be true
-      expect(fsm.cannot?(:ready)).to be true
-      expect(fsm.cannot?(:go)).to be true
-
-      fsm.slow;  expect(fsm.current).to eql(:yellow)
-      fsm.stop;  expect(fsm.current).to eql(:red)
-      fsm.ready; expect(fsm.current).to eql(:yellow)
-      fsm.go;    expect(fsm.current).to eql(:green)
-
-      fsm.stop; expect(fsm.current).to eql(:red)
-      fsm.go;   expect(fsm.current).to eql(:green)
-    end
-
-    it "allows for hash of states" do
-      fsm = FiniteMachine.new do
-        initial :green
-
-        event :slow,  :green  => :yellow
-        event :stop,  :green  => :red,   :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green, :red    => :green
-      end
-
-      expect(fsm.current).to eql(:green)
-
-      expect(fsm.can?(:slow)).to be true
-      expect(fsm.can?(:stop)).to be true
-      expect(fsm.cannot?(:ready)).to be true
-      expect(fsm.cannot?(:go)).to be true
-
-      fsm.slow;  expect(fsm.current).to eql(:yellow)
-      fsm.stop;  expect(fsm.current).to eql(:red)
-      fsm.ready; expect(fsm.current).to eql(:yellow)
-      fsm.go;    expect(fsm.current).to eql(:green)
-
-      fsm.stop; expect(fsm.current).to eql(:red)
-      fsm.go;   expect(fsm.current).to eql(:green)
-    end
-  end
-
-  it "groups events with the same name" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :stop,  :green  => :yellow
-      event :stop,  :yellow => :red
-      event :stop,  :red    => :pink
-      event :cycle, [:yellow, :red, :pink] => :green
-    end
-
-    expect(fsm.current).to eql(:green)
-    expect(fsm.can?(:stop)).to be true
-    fsm.stop
-    expect(fsm.current).to eql(:yellow)
-    fsm.stop
-    expect(fsm.current).to eql(:red)
-    fsm.stop
-    expect(fsm.current).to eql(:pink)
-    fsm.cycle
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    expect(fsm.current).to eql(:yellow)
-  end
-
-  it "groups transitions under one event name" do
-    fsm = FiniteMachine.new do
-      initial :initial
-
-      event :bump, :initial => :low,
-                    :low     => :medium,
-                    :medium  => :high
-    end
-
-    expect(fsm.current).to eq(:initial)
-    fsm.bump; expect(fsm.current).to eq(:low)
-    fsm.bump; expect(fsm.current).to eq(:medium)
-    fsm.bump; expect(fsm.current).to eq(:high)
-  end
-
-  it "returns values for events" do
-    fsm = FiniteMachine.new do
-      initial :neutral
-
-      event :start,  :neutral   => :engine_on
-      event :drive,  :engine_on => :running, if: -> { return false }
-      event :stop,   any_state  => :neutral
-
-      on_before(:drive) { cancel_event }
-      on_after(:stop)   { }
-    end
-
-    expect(fsm.current).to eql(:neutral)
-    expect(fsm.start).to eql(true)
-    expect(fsm.drive).to eql(false)
-    expect(fsm.stop).to eql(true)
-    expect(fsm.stop).to eql(true)
-  end
-
-  it "allows for self transition events" do
-    digits = []
-    callbacks = []
-    phone = FiniteMachine.new do
-      initial :on_hook
-
-      event :digit,    :on_hook => :dialing
-      event :digit,    :dialing => :dialing
-      event :off_hook, :dialing => :alerting
-
-      on_before_digit { |event, digit| digits << digit}
-      on_before_off_hook { |event| callbacks << "dialing #{digits.join}" }
-    end
-
-    expect(phone.current).to eq(:on_hook)
-    phone.digit(9)
-    expect(phone.current).to eq(:dialing)
-    phone.digit(1)
-    expect(phone.current).to eq(:dialing)
-    phone.digit(1)
-    expect(phone.current).to eq(:dialing)
-    phone.off_hook
-    expect(phone.current).to eq(:alerting)
-    expect(digits).to match_array(digits)
-    expect(callbacks).to match_array(["dialing 911"])
-  end
-
-  it "executes event block" do
-    fsm = FiniteMachine.new do
-      initial :red
-
-      event :start, :red => :green
-      event :stop,  :green => :red
-    end
-
-    expect(fsm.current).to eq(:red)
-    called = []
-    fsm.start do |from, to|
-      called << "execute_start_#{from}_#{to}"
-    end
-    expect(called).to eq(['execute_start_red_green'])
-  end
-end