finite_machine 0.11.3 → 0.12.0

data/spec/unit/initial_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, 'initial' do
 
@@ -15,23 +13,19 @@ RSpec.describe FiniteMachine, 'initial' do
   }
 
   it "defaults initial state to :none" do
-    fsm = FiniteMachine.define do
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+    fsm = FiniteMachine.new do
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:none)
   end
 
   it "requires initial state transition from :none" do
-    fsm = FiniteMachine.define do
-      events {
-        event :init, :none   => :green
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+    fsm = FiniteMachine.new do
+      event :init, :none   => :green
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:none)
@@ -41,40 +35,33 @@ RSpec.describe FiniteMachine, 'initial' do
 
   it "allows to specify inital state" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-      callbacks {
-        on_exit :none   do |event| called << 'on_exit_none' end
-        on_enter :green do |event| called << 'on_enter_green' end
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
+
+      on_exit :none   do |event| called << 'on_exit_none' end
+      on_enter :green do |event| called << 'on_enter_green' end
     end
     expect(fsm.current).to eql(:green)
     expect(called).to be_empty
   end
 
   it "allows to specify initial state through parameter" do
-    fsm = FiniteMachine.define initial: :green do
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+    fsm = FiniteMachine.new initial: :green do
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
     expect(fsm.current).to eql(:green)
   end
 
   it "allows to specify deferred inital state" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, defer: true
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:none)
@@ -84,25 +71,21 @@ RSpec.describe FiniteMachine, 'initial' do
 
   it "raises error when specyfying initial without state name" do
     expect {
-      FiniteMachine.define do
+      FiniteMachine.new do
         initial defer: true
 
-        events {
-          event :slow, :green  => :yellow
-          event :stop, :yellow => :red
-        }
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
       end
     }.to raise_error(FiniteMachine::MissingInitialStateError)
   end
 
   it "allows to specify inital start event" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, event: :start
 
-      events {
-        event :slow, :green  => :none
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :none
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:green)
@@ -113,13 +96,11 @@ RSpec.describe FiniteMachine, 'initial' do
   end
 
   it "allows to specify deferred inital start event" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, event: :start, defer: true
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:none)
@@ -129,24 +110,21 @@ RSpec.describe FiniteMachine, 'initial' do
 
   it "evaluates initial state" do
     logger = DummyLogger.new
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial logger.level
 
-      events {
-        event :slow, :green  => :none
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :none
+      event :stop, :yellow => :red
     end
     expect(fsm.current).to eql(:pending)
   end
 
   it "doesn't care about state type" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial 1
-      events {
-        event :a, 1 => 2
-        event :b, 2 => 3
-      }
+
+      event :a, 1 => 2
+      event :b, 2 => 3
     end
     expect(fsm.current).to eql(1)
     fsm.a
@@ -156,13 +134,11 @@ RSpec.describe FiniteMachine, 'initial' do
   end
 
   it "allows to retrieve initial state" 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 eq(:green)
     expect(fsm.initial_state).to eq(:green)
@@ -172,13 +148,11 @@ RSpec.describe FiniteMachine, 'initial' do
   end
 
   it "allows to retrieve initial state for deferred" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, defer: true
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
     expect(fsm.current).to eq(:none)
     expect(fsm.initial_state).to eq(:none)
@@ -189,15 +163,12 @@ RSpec.describe FiniteMachine, 'initial' do
 
   it "allows to trigger callbacks on initial with :silent option" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, silent: false
 
-      events {
-        event :slow, :green => :yellow
-      }
-      callbacks {
-        on_enter :green do |event| called << 'on_enter_green' end
-      }
+      event :slow, :green => :yellow
+
+      on_enter :green do |event| called << 'on_enter_green' end
     end
     expect(fsm.current).to eq(:green)
     expect(called).to eq(['on_enter_green'])
@@ -205,15 +176,12 @@ RSpec.describe FiniteMachine, 'initial' do
 
   it "allows to trigger callbacks on deferred initial state" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, silent: false, defer: true
 
-      events {
-        event :slow, :green => :yellow
-      }
-      callbacks {
-        on_enter :green do |event| called << 'on_enter_green' end
-      }
+      event :slow, :green => :yellow
+
+      on_enter :green do |event| called << 'on_enter_green' end
     end
     expect(fsm.current).to eq(:none)
     fsm.init

data/spec/unit/inspect_spec.rb

@@ -1,17 +1,22 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal
 
 RSpec.describe FiniteMachine, '#inspect' do
   it "print useful information about state machine" 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.inspect).to match(/^<#FiniteMachine::StateMachine:0x#{fsm.object_id.to_s(16)} @states=\[:none, :green, :yellow, :red\], @events=\[:init, :slow, :stop\], @transitions=\[{:none=>:green}, {:green=>:yellow}, {:yellow=>:red}\]>$/)
+    inspected = fsm.inspect
+    expect(inspected).to match(/^<#FiniteMachine::StateMachine:0x#{fsm.object_id.to_s(16)} @states=\[.*\], @events=\[.*\], @transitions=\[.*\]>$/)
+
+    event_names = eval inspected[/events=\[(.*?)\]/]
+    states = eval inspected[/states=\[(.*?)\]/]
+    transitions = eval inspected[/transitions=\[(.*?)\]/]
+
+    expect(event_names).to match_array([:init, :slow, :stop])
+    expect(states).to match_array([:none, :green, :yellow, :red])
+    expect(transitions).to match_array([{:none => :green}, {:green => :yellow}, {:yellow => :red}])
   end
 end

data/spec/unit/is_spec.rb

@@ -1,19 +1,15 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'is?' do
+RSpec.describe FiniteMachine, '#is?' do
 
   it "allows to check if state is reachable" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
     end
 
     expect(fsm.current).to eql(:green)
@@ -32,15 +28,13 @@ RSpec.describe FiniteMachine, 'is?' do
   end
 
   it "defines helper methods to check current state" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
     end
     expect(fsm.current).to eql(:green)
 

data/spec/unit/log_transitions_spec.rb

@@ -1,8 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'log_transitions' do
+RSpec.describe FiniteMachine, ':log_transitions' do
   let(:output) { StringIO.new('', 'w+')}
 
   before { FiniteMachine.logger = ::Logger.new(output) }
@@ -10,13 +6,11 @@ RSpec.describe FiniteMachine, 'log_transitions' do
   after  { FiniteMachine.logger = ::Logger.new($stderr) }
 
   it "logs transitions" do
-    fsm = FiniteMachine.define log_transitions: true do
+    fsm = FiniteMachine.new log_transitions: true do
       initial :green
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
 
     fsm.slow

data/spec/unit/logger_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Logger do
   let(:message) { 'error' }

data/spec/unit/{event_queue_spec.rb → message_queue_spec.rb}

@@ -1,55 +1,62 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::MessageQueue do
-
-  subject(:event_queue) { described_class.new }
-
   it "dispatches all events" do
+    event_queue = FiniteMachine::MessageQueue.new
     event_queue.start
     called = []
     event1 = double(:event1, dispatch: called << 'event1_dispatched')
     event2 = double(:event2, dispatch: called << 'event2_dispatched')
+
     expect(event_queue.size).to be_zero
+
     event_queue << event1
     event_queue << event2
     event_queue.join(0.001)
+
     expect(called).to match_array(['event1_dispatched', 'event2_dispatched'])
+    event_queue.shutdown
   end
 
   it "logs error" do
+    event_queue = FiniteMachine::MessageQueue.new
     event_queue.start
     event = spy(:event)
     allow(event).to receive(:dispatch) { raise }
     expect(FiniteMachine::Logger).to receive(:error)
     event_queue << event
-    event_queue.join(0.01)
+    event_queue.join(0.02)
     expect(event_queue).to be_empty
   end
 
   it "notifies listeners" do
+    event_queue = FiniteMachine::MessageQueue.new
     event_queue.start
     called = []
     event1 = double(:event1, dispatch: true)
     event2 = double(:event2, dispatch: true)
     event3 = double(:event3, dispatch: true)
     event_queue.subscribe(:listener1) { |event| called << event }
-    event_queue << event1 << event2 << event3
+    event_queue << event1
+    event_queue << event2
+    event_queue << event3
     event_queue.join(0.02)
     event_queue.shutdown
     expect(called).to match_array([event1, event2, event3])
   end
 
   it "allows to shutdown event queue" do
+    event_queue = FiniteMachine::MessageQueue.new
     event_queue.start
     event1 = double(:event1, dispatch: true)
     event2 = double(:event2, dispatch: true)
     event3 = double(:event3, dispatch: true)
-    expect(event_queue.alive?).to be(true)
+    expect(event_queue.running?).to be(true)
     event_queue << event1
     event_queue << event2
     event_queue.shutdown
     event_queue << event3
+    expect(event_queue.running?).to be(false)
     event_queue.join(0.001)
-    expect(event_queue.alive?).to be(false)
   end
 end

data/spec/unit/new_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine, '.new' do
+  context 'with block' do
+    it "creates system state machine" do
+      fsm = FiniteMachine.new do
+        initial :green
+
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      end
+
+      expect(fsm.current).to eql(:green)
+
+      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)
+    end
+  end
+
+  context 'without block' do
+    it "creates state machine" do
+      called = []
+      fsm = FiniteMachine.new
+      fsm.initial(:green)
+      fsm.event(:slow, :green => :yellow)
+      fsm.event(:stop, :yellow => :red)
+      fsm.event(:ready,:red    => :yellow)
+      fsm.event(:go,   :yellow => :green)
+      fsm.on_enter(:yellow) { |event| called << 'on_enter_yellow' }
+      fsm.handle(FiniteMachine::InvalidStateError) { |exception|
+        called << 'error_handler'
+      }
+      fsm.init
+      expect(fsm.current).to eql(:green)
+      fsm.slow
+      expect(fsm.current).to eql(:yellow)
+      fsm.ready
+      expect(fsm.current).to eql(:yellow)
+      expect(called).to match_array(['on_enter_yellow', 'error_handler'])
+    end
+  end
+end