finite_machine 0.12.1 → 0.13.0

data/spec/unit/initial_spec.rb

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, 'initial' do
-
-  before(:each) {
-    stub_const("DummyLogger", Class.new do
-      attr_accessor :level
-
-      def initialize
-        @level = :pending
-      end
-    end)
-  }
-
-  it "defaults initial state to :none" do
-    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.new do
-      event :init, :none   => :green
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-
-    expect(fsm.current).to eql(:none)
-    fsm.init
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "allows to specify inital state" do
-    called = []
-    fsm = FiniteMachine.new do
-      initial :green
-
-      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.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.new do
-      initial :green, defer: true
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-
-    expect(fsm.current).to eql(:none)
-    fsm.init
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "raises error when specyfying initial without state name" do
-    expect {
-      FiniteMachine.new do
-        initial defer: true
-
-        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.new do
-      initial :green, event: :start
-
-      event :slow, :green  => :none
-      event :stop, :yellow => :red
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(fsm.current).to eql(:none)
-    fsm.start
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "allows to specify deferred inital start event" do
-    fsm = FiniteMachine.new do
-      initial :green, event: :start, defer: true
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-
-    expect(fsm.current).to eql(:none)
-    fsm.start
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "evaluates initial state" do
-    logger = DummyLogger.new
-    fsm = FiniteMachine.new do
-      initial logger.level
-
-      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.new do
-      initial 1
-
-      event :a, 1 => 2
-      event :b, 2 => 3
-    end
-    expect(fsm.current).to eql(1)
-    fsm.a
-    expect(fsm.current).to eql(2)
-    fsm.b
-    expect(fsm.current).to eql(3)
-  end
-
-  it "allows to retrieve initial state" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-    expect(fsm.current).to eq(:green)
-    expect(fsm.initial_state).to eq(:green)
-    fsm.slow
-    expect(fsm.current).to eq(:yellow)
-    expect(fsm.initial_state).to eq(:green)
-  end
-
-  it "allows to retrieve initial state for deferred" do
-    fsm = FiniteMachine.new do
-      initial :green, defer: true
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-    expect(fsm.current).to eq(:none)
-    expect(fsm.initial_state).to eq(:none)
-    fsm.init
-    expect(fsm.current).to eq(:green)
-    expect(fsm.initial_state).to eq(:green)
-  end
-
-  it "allows to trigger callbacks on initial with :silent option" do
-    called = []
-    fsm = FiniteMachine.new do
-      initial :green, silent: false
-
-      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'])
-  end
-
-  it "allows to trigger callbacks on deferred initial state" do
-    called = []
-    fsm = FiniteMachine.new do
-      initial :green, silent: false, defer: true
-
-      event :slow, :green => :yellow
-
-      on_enter :green do |event| called << 'on_enter_green' end
-    end
-    expect(fsm.current).to eq(:none)
-    fsm.init
-    expect(called).to eq(['on_enter_green'])
-  end
-end

data/spec/unit/inspect_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal
-
-RSpec.describe FiniteMachine, '#inspect' do
-  it "print useful information about state machine" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :slow,  :green  => :yellow
-      event :stop,  :yellow => :red
-    end
-    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,49 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, '#is?' do
-
-  it "allows to check if state is reachable" 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)
-
-    expect(fsm.is?(:green)).to be true
-    expect(fsm.is?(:yellow)).to be false
-    expect(fsm.is?([:green,  :red])).to be true
-    expect(fsm.is?([:yellow, :red])).to be false
-
-    fsm.slow
-
-    expect(fsm.is?(:green)).to be false
-    expect(fsm.is?(:yellow)).to be true
-    expect(fsm.is?([:green, :red])).to be false
-    expect(fsm.is?([:yellow, :red])).to be true
-  end
-
-  it "defines helper methods to check current state" 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)
-
-    expect(fsm.green?).to be true
-    expect(fsm.yellow?).to be false
-
-    fsm.slow
-
-    expect(fsm.green?).to be false
-    expect(fsm.yellow?).to be true
-  end
-end

data/spec/unit/log_transitions_spec.rb

@@ -1,24 +0,0 @@
-RSpec.describe FiniteMachine, ':log_transitions' do
-  let(:output) { StringIO.new('', 'w+')}
-
-  before { FiniteMachine.logger = ::Logger.new(output) }
-
-  after  { FiniteMachine.logger = ::Logger.new($stderr) }
-
-  it "logs transitions" do
-    fsm = FiniteMachine.new log_transitions: true do
-      initial :green
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-
-    fsm.slow
-    output.rewind
-    expect(output.read).to match(/Transition: @event=slow green -> yellow/)
-
-    fsm.stop(1, 2)
-    output.rewind
-    expect(output.read).to match(/Transition: @event=stop @with=\[1,2\] yellow -> red/)
-  end
-end

data/spec/unit/logger_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::Logger do
-  let(:message) { 'error' }
-  let(:log) { spy }
-
-  subject(:logger) { described_class }
-
-  before { allow(FiniteMachine).to receive(:logger) { log } }
-
-  it "debugs message call" do
-    expect(log).to receive(:debug).with(message)
-    logger.debug(message)
-  end
-
-  it "informs message call" do
-    expect(log).to receive(:info).with(message)
-    logger.info(message)
-  end
-
-  it "warns message call" do
-    expect(log).to receive(:warn).with(message)
-    logger.warn(message)
-  end
-
-  it "errors message call" do
-    expect(log).to receive(:error).with(message)
-    logger.error(message)
-  end
-
-  it "reports transition" do
-    logger.report_transition(:go, :red, :green)
-
-    expect(log).to have_received(:info).with("Transition: @event=go red -> green")
-  end
-end

data/spec/unit/message_queue_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::MessageQueue do
-  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.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
-    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.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)
-  end
-end

data/spec/unit/new_spec.rb

@@ -1,50 +0,0 @@
-# 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

data/spec/unit/respond_to_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, '#respond_to' do
-
-  subject(:fsm) {
-    stub_const("Car", Class.new do
-      def engine_on?
-        true
-      end
-    end)
-
-    FiniteMachine.new target: Car.new do
-      initial :green
-
-      event :slow,  :green  => :yellow
-    end
-  }
-
-  it "knows about event name" do
-    expect(fsm).to respond_to(:slow)
-  end
-
-  it "doesn't know about not implemented call" do
-    expect(fsm).not_to respond_to(:not_implemented)
-  end
-
-  it "knows about event callback" do
-    expect(fsm).to respond_to(:on_enter_slow)
-  end
-
-  it "doesn't know about target class methods" do
-    expect(fsm).not_to respond_to(:engine_on?)
-  end
-end