finite_machine 0.11.2 → 0.14.0

data/spec/unit/initial_spec.rb

@@ -1,222 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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.define do
-      events {
-        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
-      }
-    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.define 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
-      }
-    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
-      }
-    end
-    expect(fsm.current).to eql(:green)
-  end
-
-  it "allows to specify deferred inital state" do
-    fsm = FiniteMachine.define do
-      initial :green, defer: true
-
-      events {
-        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.define do
-        initial defer: true
-
-        events {
-          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
-      initial :green, event: :start
-
-      events {
-        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.define do
-      initial :green, event: :start, defer: true
-
-      events {
-        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.define do
-      initial logger.level
-
-      events {
-        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
-      initial 1
-      events {
-        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.define do
-      initial :green
-
-      events {
-        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.define do
-      initial :green, defer: true
-
-      events {
-        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.define do
-      initial :green, silent: false
-
-      events {
-        event :slow, :green => :yellow
-      }
-      callbacks {
-        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.define do
-      initial :green, silent: false, defer: true
-
-      events {
-        event :slow, :green => :yellow
-      }
-      callbacks {
-        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,17 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, '#inspect' do
-  it "print useful information about state machine" do
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        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}\]>$/)
-  end
-end

data/spec/unit/is_spec.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'is?' do
-
-  it "allows to check if state is reachable" do
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        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.define do
-      initial :green
-
-      events {
-        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,30 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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.define log_transitions: true do
-      initial :green
-
-      events {
-        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,38 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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/respond_to_spec.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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
-
-      events {
-        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

data/spec/unit/state_parser/inspect_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::StateParser, "#inspect" do
-  let(:object) { described_class }
-
-  subject(:parser) { object.new(attrs) }
-
-  describe '#inspect' do
-    let(:attrs) { { green: :yellow } }
-
-    it "inspects parser" do
-      expect(parser.inspect).to eq("<#FiniteMachine::StateParser @attrs=green:yellow>")
-    end
-  end
-
-  describe '#to_s' do
-    let(:attrs) { { green: :yellow } }
-
-    it "prints parser attributes" do
-      expect(parser.to_s).to eq(attrs.to_s)
-    end
-  end
-end

data/spec/unit/state_parser/parse_spec.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::StateParser, '#parse' do
-  let(:object) { described_class }
-
-  subject(:parser) { object.new(attrs) }
-
-  context 'when no attributes' do
-    let(:attrs) { { } }
-
-    it "raises error for no transitions" do
-      expect {
-        parser.parse
-      }.to raise_error(FiniteMachine::NotEnoughTransitionsError)
-    end
-  end
-
-  context 'when :from and :to keys' do
-    let(:attrs) { { from: :green, to: :yellow }}
-
-    it "removes :from and :to keys" do
-      expect(parser.parse).to eq({green: :yellow})
-    end
-  end
-
-  context 'when only :from key' do
-    let(:attrs) { { from: :green }}
-
-    it "adds to state as copy of from" do
-      expect(parser.parse).to eq({green: :green})
-    end
-  end
-
-  context 'when only :to key' do
-    let(:attrs) { { to: :green }}
-
-    it "inserts :any from state" do
-      expect(parser.parse).to eq({any: :green})
-    end
-  end
-
-  context 'when attribuets as hash' do
-    let(:attrs) { { green: :yellow } }
-
-    it "copies attributes over" do
-      expect(parser.parse).to eq({green: :yellow})
-    end
-  end
-
-  context 'when array of from states' do
-    let(:attrs) { { [:green, :red] => :yellow } }
-
-    it "extracts states" do
-      expect(parser.parse).to include({red: :yellow, green: :yellow})
-    end
-  end
-end