spec/unit/events_spec.rb in finite_machine-0.11.3 vs spec/unit/events_spec.rb in finite_machine-0.12.0
- old
+ new
@@ -1,67 +1,47 @@
-# encoding: utf-8
+# frozen_string_literal: true
-require 'spec_helper'
-
RSpec.describe FiniteMachine, 'events' do
-
it "allows for hash rocket syntax to describe transition" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :slow, :green => :yellow
- event :stop, :yellow => :red
- }
+ 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 to add event without events scope" do
- fsm = FiniteMachine.define do
- initial :green
-
- event :slow, :green => :yellow
- event :stop, :yellow => :red
- end
-
- expect(fsm.current).to eql(:green)
- end
-
it "allows for (:from | :to) key pairs to describe transition" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :slow, from: :green, to: :yellow
- event :stop, from: :yellow, to: :red
- }
+ 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.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- 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
- }
+ 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
@@ -74,21 +54,19 @@
expect(fsm.cannot?(:noop)).to be true
expect(fsm.cannot?(:slow)).to be true
end
- it "permits event from any state with :any 'from'" do
- fsm = FiniteMachine.define do
+ it "permits event from any state using :from" do
+ fsm = FiniteMachine.new do
initial :green
- events {
- 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, to: :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
@@ -110,19 +88,17 @@
fsm.run
expect(fsm.current).to eql(:green)
end
it "permits event from any state for hash syntax" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :red
- events {
- event :start, :red => :yellow
- event :run, :yellow => :green
- event :stop, :green => :red
- event :go, :any => :green
- }
+ 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
@@ -133,20 +109,18 @@
fsm.go
expect(fsm.current).to eql(:green)
end
it "permits event from any state without 'from'" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- 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
- }
+ 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
@@ -169,20 +143,17 @@
expect(fsm.current).to eql(:green)
end
it "doesn't raise error on invalid transition for non-dangerous version" do
called = []
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :stop, from: :yellow, to: :red
- }
- callbacks {
- on_before :stop do |event| called << 'on_before_stop' end
- on_after :stop do |event| called << 'on_before_stop' end
- }
+ 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)
@@ -190,41 +161,35 @@
end
context 'for non-dangerous version' do
it "doesn't raise error on invalid transition and fires callbacks" do
called = []
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :stop, from: :yellow, to: :red
- }
- callbacks {
- on_before :stop do |event| called << 'on_before_stop' end
- on_after :stop do |event| called << 'on_before_stop' end
- }
+ 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.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :slow, from: :green, to: :yellow
- event :stop, from: :yellow, to: :red, silent: true
- }
- callbacks {
- on_before :stop do |event| called << 'on_before_stop' end
- on_after :stop do |event| called << 'on_before_stop' end
- }
+ 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([])
@@ -232,40 +197,34 @@
end
context 'for dangerous version' do
it "raises error on invalid transition without callbacks" do
called = []
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :start, :red => :yellow, silent: true
- }
- callbacks {
- on_before :start do |event| called << 'on_before_start' end
- on_after :start do |event| called << 'on_after_start' end
- }
+ 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.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :start, :red => :yellow
- }
- callbacks {
- on_before :start do |event| called << 'on_before_start' end
- on_after :start do |event| called << 'on_after_start' end
- }
+ 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'/)
@@ -274,19 +233,17 @@
end
end
context 'when multiple from states' do
it "allows for array from key" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :slow, :green => :yellow
- event :stop, [:green, :yellow] => :red
- event :ready, :red => :yellow
- event :go, [:yellow, :red] => :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
@@ -302,19 +259,17 @@
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.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :slow, :green => :yellow
- event :stop, :green => :red, :yellow => :red
- event :ready, :red => :yellow
- event :go, :yellow => :green, :red => :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
@@ -331,19 +286,17 @@
fsm.go; expect(fsm.current).to eql(:green)
end
end
it "groups events with the same name" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :green
- events {
- event :stop, :green => :yellow
- event :stop, :yellow => :red
- event :stop, :red => :pink
- event :cycle, [:yellow, :red, :pink] => :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
@@ -357,40 +310,34 @@
fsm.stop
expect(fsm.current).to eql(:yellow)
end
it "groups transitions under one event name" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :initial
- events {
- event :bump, :initial => :low,
- :low => :medium,
- :medium => :high
- }
+ 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.define do
+ fsm = FiniteMachine.new do
initial :neutral
- events {
- event :start, :neutral => :engine_on
- event :drive, :engine_on => :running, if: -> { return false }
- event :stop, :any => :neutral
- }
+ event :start, :neutral => :engine_on
+ event :drive, :engine_on => :running, if: -> { return false }
+ event :stop, any_state => :neutral
- callbacks {
- on_before(:drive) { FiniteMachine::CANCELLED }
- on_after(:stop) { }
- }
+ 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)
@@ -399,23 +346,19 @@
end
it "allows for self transition events" do
digits = []
callbacks = []
- phone = FiniteMachine.define do
+ phone = FiniteMachine.new do
initial :on_hook
- events {
- event :digit, :on_hook => :dialing
- event :digit, :dialing => :dialing
- event :off_hook, :dialing => :alerting
- }
+ event :digit, :on_hook => :dialing
+ event :digit, :dialing => :dialing
+ event :off_hook, :dialing => :alerting
- callbacks {
- on_before_digit { |event, digit| digits << digit}
- on_before_off_hook { |event| callbacks << "dialing #{digits.join}" }
- }
+ 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)
@@ -427,27 +370,15 @@
expect(phone.current).to eq(:alerting)
expect(digits).to match_array(digits)
expect(callbacks).to match_array(["dialing 911"])
end
- it "detects dangerous event names" do
- expect {
- FiniteMachine.define do
- events {
- event :trigger, :a => :b
- }
- end
- }.to raise_error(FiniteMachine::AlreadyDefinedError)
- end
-
it "executes event block" do
- fsm = FiniteMachine.define do
+ fsm = FiniteMachine.new do
initial :red
- events {
- event :start, :red => :green
- event :stop, :green => :red
- }
+ event :start, :red => :green
+ event :stop, :green => :red
end
expect(fsm.current).to eq(:red)
called = []
fsm.start do |from, to|