finite_machine 0.12.1 → 0.13.0

data/spec/unit/state_parser/parse_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::StateParser, '#parse' do
-  let(:object) { described_class }
-
-  context 'when no attributes' do
-    let(:attrs) { { } }
-
-    it "raises error for no transitions" do
-      expect {
-        object.parse(attrs)
-      }.to raise_error(FiniteMachine::NotEnoughTransitionsError,
-                       /please provide state transitions/)
-    end
-  end
-
-  context 'when :from and :to keys' do
-    let(:attrs) { { from: :green, to: :yellow }}
-
-    it "removes :from and :to keys" do
-      expect(object.parse(attrs)).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(object.parse(attrs)).to eq({green: :green})
-    end
-  end
-
-  context 'when only :to key' do
-    let(:attrs) { { to: :green }}
-
-    it "inserts :any from state" do
-      expect(object.parse(attrs)).to eq({FiniteMachine::ANY_STATE => :green})
-    end
-  end
-
-  context 'when attribuets as hash' do
-    let(:attrs) { { green: :yellow } }
-
-    it "copies attributes over" do
-      expect(object.parse(attrs)).to eq({green: :yellow})
-    end
-  end
-
-  context 'when array of from states' do
-    let(:attrs) { { [:green, :red] => :yellow } }
-
-    it "extracts states" do
-      expect(object.parse(attrs)).to include({red: :yellow, green: :yellow})
-    end
-  end
-end

data/spec/unit/states_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, '#states' do
-  it "retrieves all available states" 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.states).to match_array([:none, :green, :yellow, :red])
-  end
-
-  it "retrieves all unique states for choice transition" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      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,40 +0,0 @@
-# frozen_string_literal: true
-
-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 @@
-# frozen_string_literal: true
-
-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
-        @engine ||= FiniteMachine.new(self) do
-          initial :neutral
-
-          event :forward, [:reverse, :neutral] => :one
-          event :shift, :one => :two
-          event :shift, :two => :one
-          event :back,  [:neutral, :one] => :reverse
-
-          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.new do
-      initial :green
-
-      event :slow, :green => :yellow
-
-      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.new do
-      initial :green
-
-      event :slow,  :green  => :yellow
-      event :stop,  :yellow => :red
-      event :ready, :red    => :yellow
-      event :go,    :yellow => :green
-
-      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 ||= []
-
-        @engine ||= FiniteMachine.new(self) do
-          initial :neutral
-
-          event :forward, [:reverse, :neutral] => :one
-          event :shift, :one => :two
-          event :shift, :two => :one
-          event :back,  [:neutral, :one] => :reverse
-
-          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.new(context) do
-      initial :green
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-
-      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.new(car) do
-      initial :unsaved
-
-      event :validate, :unsaved => :valid
-      event :save, :valid => :saved
-
-      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
-
-  it "handles targets responding to :to_hash message" do
-    stub_const("Serializer", Class.new do
-      def initialize(data)
-        @data = data
-      end
-
-      def write(new_data)
-        @data.merge!(new_data)
-      end
-
-      def to_hash
-        @data
-      end
-      alias to_h to_hash
-    end)
-
-    model = Serializer.new({a: 1, b: 2})
-
-    fsm = FiniteMachine.new(model) do
-      initial :a
-
-      event :serialize, :a => :b
-
-      on_after :serialize do |event|
-        target.write(c: 3)
-      end
-    end
-
-    fsm.serialize
-
-    expect(model.to_h).to include({a: 1, b: 2, c: 3})
-  end
-end

data/spec/unit/terminated_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, '#terminated?' do
-
-  it "allows to specify terminal state" do
-    fsm = FiniteMachine.new do
-      initial :green
-      terminal :red
-
-      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.new terminal: :red do
-      initial :green
-
-      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.new do
-      initial :green
-
-      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.new do
-      initial :open
-
-      terminal :close, :canceled, :faulty
-
-      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,55 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::Transition, '#check_conditions' do
-  it "verifies all conditions pass" do
-    context = double(:context)
-    exec_conditions = 0
-    ok_condition = -> { exec_conditions += 1; return true }
-    fail_condition = -> { exec_conditions += 1; return false }
-
-    transition = described_class.new(context, :event_name,
-                                     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
-    context = double(:context)
-    exec_conditions = 0
-    ok_condition = -> { exec_conditions += 1; return true }
-    fail_condition = -> { exec_conditions += 1; return false }
-
-    transition = described_class.new(context, :event_name,
-                                     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
-    context = double(:context)
-    condition = -> (_, arg) { arg == 1 }
-
-    transition = described_class.new(context, :event_name,
-                                     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)
-    context = Car.new
-    condition = -> (car) { car.engine_on? }
-
-    transition = described_class.new(context, :event_name, if: condition)
-
-    expect(transition.check_conditions).to eql(true)
-  end
-end