finite_machine 0.11.2 → 0.14.0

data/spec/unit/states_spec.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'states' do
-  it "retrieves all available states" 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.states).to match_array([:none, :green, :yellow, :red])
-  end
-
-  it "retrieves all unique states for choice transition" do
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :next, from: :green do
-          choice :yellow, if: -> { false }
-          choice :red,    if: -> { true }
-        end
-      }
-    end
-    expect(fsm.states).to match_array([:none, :green, :yellow, :red])
-  end
-end

data/spec/unit/subscribers_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Subscribers do
-  let(:listener) { double }
-
-  it "checks if any subscribers exist" do
-    subscribers = described_class.new
-    expect(subscribers.empty?).to eq(true)
-    subscribers.subscribe(listener)
-    expect(subscribers.empty?).to eq(false)
-  end
-
-  it "allows to subscribe multiple listeners" do
-    subscribers = described_class.new
-    subscribers.subscribe(listener, listener)
-    expect(subscribers.size).to eq(2)
-  end
-
-  it "returns index for the subscriber" do
-    subscribers = described_class.new
-    subscribers.subscribe(listener)
-    expect(subscribers.index(listener)).to eql(0)
-  end
-
-  it "visits all subscribed listeners for the event" do
-    subscribers = described_class.new
-    subscribers.subscribe(listener)
-    event = spy(:event)
-    subscribers.visit(event)
-    expect(event).to have_received(:notify).with(listener)
-  end
-
-  it "resets the subscribers" do
-    subscribers = described_class.new
-    subscribers.subscribe(listener)
-    expect(subscribers.empty?).to eq(false)
-    subscribers.reset
-    expect(subscribers.empty?).to eq(true)
-  end
-end

data/spec/unit/target_spec.rb

@@ -1,225 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, '#target' do
-  it "allows to target external object" do
-    stub_const("Car", Class.new do
-      attr_accessor :reverse_lights
-
-      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
-
-      def engine
-        context = self
-        @engine ||= FiniteMachine.define do
-          initial :neutral
-
-          target context
-
-          events {
-            event :forward, [:reverse, :neutral] => :one
-            event :shift, :one => :two
-            event :shift, :two => :one
-            event :back,  [:neutral, :one] => :reverse
-          }
-
-          callbacks {
-            on_enter :reverse do |event|
-              target.turn_reverse_lights_on
-            end
-
-            on_exit :reverse do |event|
-              target.turn_reverse_lights_off
-            end
-          }
-        end
-      end
-    end)
-    car = Car.new
-    expect(car.reverse_lights?).to be(false)
-    expect(car.engine.current).to eql(:neutral)
-    car.engine.back
-    expect(car.engine.current).to eql(:reverse)
-    expect(car.reverse_lights?).to be(true)
-    car.engine.forward
-    expect(car.engine.current).to eql(:one)
-    expect(car.reverse_lights?).to be(false)
-  end
-
-  it "propagates method call" do
-    fsm = FiniteMachine.define do
-      initial :green
-      events {
-        event :slow, :green => :yellow
-      }
-
-      callbacks {
-        on_enter_yellow do |event|
-          uknown_method
-        end
-      }
-    end
-    expect(fsm.current).to eql(:green)
-    expect { fsm.slow }.to raise_error(StandardError)
-  end
-
-  it "references machine methods inside callback" do
-    called = []
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
-
-      callbacks {
-        on_enter_yellow do |event|
-          stop(:now)
-        end
-
-        on_enter_red do |event, param|
-          called << "#{event.from} #{param}"
-        end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(fsm.current).to eql(:red)
-    expect(called).to eql(['yellow now'])
-  end
-
-  it "allows context methods take precedence over machine ones" do
-    stub_const("Car", Class.new do
-      attr_accessor :reverse_lights
-      attr_accessor :called
-
-      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
-
-      def engine
-        self.called ||= []
-        context ||= self
-        @engine ||= FiniteMachine.define do
-          initial :neutral
-
-          target context
-
-          events {
-            event :forward, [:reverse, :neutral] => :one
-            event :shift, :one => :two
-            event :shift, :two => :one
-            event :back,  [:neutral, :one] => :reverse
-          }
-
-          callbacks {
-            on_enter :reverse do |event|
-              target.called << 'on_enter_reverse'
-              target.turn_reverse_lights_on
-              forward('Piotr!')
-            end
-            on_before :forward do |event, name|
-              target.called << "on_enter_forward with #{name}"
-            end
-          }
-        end
-      end
-    end)
-
-    car = Car.new
-    expect(car.reverse_lights?).to be(false)
-    expect(car.engine.current).to eql(:neutral)
-    car.engine.back
-    expect(car.engine.current).to eql(:one)
-    expect(car.called).to eql([
-      'on_enter_reverse',
-      'on_enter_forward with Piotr!'
-    ])
-  end
-
-  it "allows to access target inside the callback" do
-    context = double(:context)
-    called = nil
-    fsm = FiniteMachine.define do
-      initial :green
-
-      target context
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-      callbacks {
-        on_enter_yellow do |event|
-          called = target
-        end
-      }
-    end
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(called).to eq(context)
-  end
-
-  it "allows to differentiate between same named methods" do
-    called = []
-    stub_const("Car", Class.new do
-      def initialize(called)
-        @called = called
-      end
-      def save
-        @called << 'car save called'
-      end
-    end)
-
-    car = Car.new(called)
-    fsm = FiniteMachine.define do
-      initial :unsaved
-
-      target car
-
-      events {
-        event :validate, :unsaved => :valid
-        event :save, :valid => :saved
-      }
-
-      callbacks {
-        on_enter :valid do |event|
-          target.save
-          save
-        end
-        on_after :save do |event|
-          called << 'event save called'
-        end
-      }
-    end
-    expect(fsm.current).to eql(:unsaved)
-    fsm.validate
-    expect(fsm.current).to eql(:saved)
-    expect(called).to eq([
-      'car save called',
-      'event save called'
-    ])
-  end
-end

data/spec/unit/terminated_spec.rb

@@ -1,95 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'terminated?' do
-
-  it "allows to specify terminal state" do
-    fsm = FiniteMachine.define do
-      initial :green
-      terminal :red
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    expect(fsm.terminated?).to be(false)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    expect(fsm.terminated?).to be(false)
-
-    fsm.stop
-    expect(fsm.current).to eql(:red)
-    expect(fsm.terminated?).to be(true)
-  end
-
-  it "allows to specify terminal state as parameter" do
-    fsm = FiniteMachine.define terminal: :red do
-      initial :green
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-    end
-    fsm.slow
-    fsm.stop
-    expect(fsm.terminated?).to be(true)
-  end
-
-  it "checks without terminal state" do
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    expect(fsm.terminated?).to be(false)
-
-    fsm.slow
-    expect(fsm.current).to eql(:yellow)
-    expect(fsm.terminated?).to be(false)
-
-    fsm.stop
-    expect(fsm.current).to eql(:red)
-    expect(fsm.terminated?).to be(false)
-  end
-
-  it "allows for multiple terminal states" do
-    fsm = FiniteMachine.define do
-      initial :open
-
-      terminal :close, :canceled, :faulty
-
-      events {
-        event :resolve, :open => :close
-        event :decline, :open => :canceled
-        event :error,   :open => :faulty
-      }
-    end
-    expect(fsm.current).to eql(:open)
-    expect(fsm.terminated?).to be(false)
-
-    fsm.resolve
-    expect(fsm.current).to eql(:close)
-    expect(fsm.terminated?).to be(true)
-
-    fsm.restore!(:open)
-    fsm.decline
-    expect(fsm.current).to eql(:canceled)
-    expect(fsm.terminated?).to be(true)
-
-    fsm.restore!(:open)
-    fsm.error
-    expect(fsm.current).to eql(:faulty)
-    expect(fsm.terminated?).to be(true)
-  end
-end

data/spec/unit/transition/check_conditions_spec.rb

@@ -1,54 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Transition, '.check_conditions' do
-  it "verifies all conditions pass" do
-    exec_conditions = 0
-    ok_condition = -> { exec_conditions += 1; return true }
-    fail_condition = -> { exec_conditions += 1; return false }
-    machine = double(:machine, target: Object.new)
-
-    transition = described_class.new(machine, if: [ok_condition, fail_condition])
-
-    expect(transition.check_conditions).to eql(false)
-    expect(exec_conditions).to eq(2)
-  end
-
-  it "verifies 'if' and 'unless' conditions" do
-    machine = double(:machine, target: Object.new)
-    exec_conditions = 0
-    ok_condition = -> { exec_conditions += 1; return true }
-    fail_condition = -> { exec_conditions += 1; return false }
-
-    transition = described_class.new(machine, if: [ok_condition], unless: [fail_condition])
-
-    expect(transition.check_conditions).to eql(true)
-    expect(exec_conditions).to eq(2)
-  end
-
-  it "verifies condition with arguments" do
-    machine = double(:machine, target: Object.new)
-    condition = lambda { |target, arg| arg == 1 }
-
-    transition = described_class.new(machine, if: [condition])
-
-    expect(transition.check_conditions(2)).to eql(false)
-    expect(transition.check_conditions(1)).to eql(true)
-  end
-
-  it "verifies condition on target" do
-    stub_const("Car", Class.new do
-      def engine_on?
-        true
-      end
-    end)
-    target = Car.new
-    machine = double(:machine, target: target)
-    condition = lambda { |car| car.engine_on? }
-
-    transition = described_class.new(machine, if: condition)
-
-    expect(transition.check_conditions).to eql(true)
-  end
-end