davidlee-state-fu 0.0.1

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/units/binding_spec.rb

@@ -0,0 +1,145 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe StateFu::Binding do
+  include MySpecHelper
+
+  before do
+    reset!
+    make_pristine_class('Klass')
+    Klass.machine(){}
+    @obj = Klass.new()
+  end
+
+  describe "constructor" do
+    before do
+      mock( StateFu::FuSpace ).field_names() do
+        {
+          Klass => { :example => :example_field }
+        }
+      end
+    end
+
+    it "should create a new Binding given valid arguments" do
+      b = StateFu::Binding.new( Klass.machine, @obj, :example )
+      b.should be_kind_of( StateFu::Binding )
+      b.object.should      == @obj
+      b.machine.should     == Klass.machine
+      b.method_name.should == :example
+    end
+
+    it "should add any options supplied to the binding" do
+      b = StateFu::Binding.new( Klass.machine, @obj, :example,
+                                :colour => :red,
+                                :style  => [:robust, :fruity] )
+      b.options.should == { :colour => :red, :style  => [:robust, :fruity] }
+    end
+
+    describe "persister initialization" do
+      before do
+        @p = Object.new
+        class << @p
+          attr_accessor :field_name
+        end
+        @p.field_name
+      end
+
+      describe "when StateFu::Persistence.active_record_column? is true" do
+        before do
+          mock( StateFu::Persistence ).active_record_column?(Klass, :example_field).times(2) { true }
+          mock( Klass ).before_save( :state_fu!) { }
+        end
+        it "should get an ActiveRecord persister" do
+          mock( StateFu::Persistence::ActiveRecord ).new( anything, :example_field ) { @p }
+          b = StateFu::Binding.new( Klass.machine, @obj, :example )
+          b.persister.should == @p
+        end
+      end
+
+      describe "when StateFu::Persistence.active_record_column? is false" do
+        before do
+          mock( StateFu::Persistence ).active_record_column?(Klass, :example_field).times(2) { false }
+        end
+        it "should get an Attribute persister" do
+          mock( StateFu::Persistence::Attribute ).new( anything, :example_field ) { @p }
+          b = StateFu::Binding.new( Klass.machine, @obj, :example )
+          b.persister.should == @p
+        end
+      end
+    end
+  end
+
+  describe "initialization via @obj.state_fu()" do
+    it "should create a new StateFu::Binding with default method-name & field_name" do
+      b = @obj.state_fu()
+      b.should be_kind_of( StateFu::Binding )
+      b.machine.should == Klass.machine
+      b.object.should == @obj
+      b.method_name.should == :state_fu
+      b.field_name.should  == :state_fu_field
+    end
+  end
+
+  describe "a binding for the default machine with two states and an event" do
+    before do
+      reset!
+      make_pristine_class('Klass')
+      Klass.machine do
+        state :new do
+          event :age, :to => :old
+        end
+        state :old
+      end
+      @machine   = Klass.machine()
+      @object    = Klass.new()
+      @binding   = @object.state_fu()
+    end
+
+    describe ".state() / initial state" do
+      it "should default to machine.initial_state when no initial_state is explicitly defined" do
+        @machine.initial_state.name.should == :new
+        @binding.current_state.should == @machine.initial_state
+      end
+
+      it "should default to the machine's initial_state if one is set" do
+        @machine.initial_state = :fetus
+        @machine.initial_state.name.should == :fetus
+        obj = Klass.new
+        obj.state_fu.current_state.should == @machine.initial_state
+      end
+    end
+
+  end
+
+  describe "Instance methods" do
+    before do
+    end
+    describe "fireable?" do
+      describe "when called with arguments which would return a valid transition from .transition()" do
+        it "should return true"
+      end
+
+      describe "when called with arguments which would raise an InvalidTransition from .transition()" do
+        before do
+          reset!
+          make_pristine_class("Klass")
+          @machine = Klass.machine do
+            state :snoo
+            state :wizz do
+              event :ping, :to => :pong
+            end
+          end
+          @obj = Klass.new
+        end
+
+        it "should return nil" do
+          @obj.state_fu.name.should == :snoo
+          lambda { @obj.state_fu.transition(:ping) }.should raise_error( StateFu::InvalidTransition )
+          lambda { @obj.state_fu.fireable?(:ping) }.should_not raise_error( StateFu::InvalidTransition )
+          @obj.state_fu.fireable?(:ping).should == nil
+        end
+      end
+
+    end
+
+  end
+end

data/spec/units/event_spec.rb

@@ -0,0 +1,232 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+describe StateFu::Event do
+  include MySpecHelper
+  before do
+    @machine = Object.new
+  end
+
+  describe "Instance methods" do
+    before do
+      @name         = :germinate
+      @options      = {:speed => :slow}
+      @event        = StateFu::Event.new( @machine, @name, @options )
+      @state_a      = StateFu::State.new( @machine,:a )
+      @state_b      = StateFu::State.new( @machine,:b )
+      @initial      = Object.new
+      @final        = Object.new
+      @start        = Object.new
+      @end          = Object.new
+    end
+
+
+    describe "Instance methods" do
+      describe "setting origin / target" do
+
+        describe "target" do
+          it "should be nil if targets is nil" do
+            stub( @event ).targets() { nil }
+            @event.target.should == nil
+          end
+
+          it "should be nil if targets has more than one state" do
+            stub( @event ).targets() { [@state_a, @state_b] }
+            @event.target.should == nil
+          end
+
+          it "should be the sole state if targets is set and there is only one" do
+            stub( @event ).targets() { [@state_a] }
+            @event.target.should == @state_a
+          end
+        end
+
+        describe 'origins=' do
+          it "should call get_states_list_by_name with its argument" do
+            mock( @machine ).find_or_create_states_by_name( :initial ) { }
+            @event.origins= :initial
+          end
+
+          it "should set @origin to the result" do
+            mock( @machine ).find_or_create_states_by_name( :initial ) { :result }
+            @event.origins= :initial
+            @event.origins.should == :result
+          end
+
+        end
+
+        describe 'targets=' do
+          it "should call get_states_list_by_name with its argument" do
+            mock( @machine ).find_or_create_states_by_name( :initial ) { }
+            @event.targets= :initial
+          end
+
+          it "should set @target to the result" do
+            mock( @machine ).find_or_create_states_by_name( :initial ) { :result }
+            @event.targets= :initial
+            @event.targets.should == :result
+          end
+        end
+
+        describe "lathe" do
+          before do
+            @lathe = @event.lathe()
+          end
+
+          it "should return a StateFu::Lathe" do
+            @lathe.should be_kind_of( StateFu::Lathe )
+          end
+
+          it "should have the event's machine" do
+            @lathe.machine.should == @event.machine()
+          end
+
+          it "should have the event as the sprocket" do
+            @lathe.sprocket.should == @event
+          end
+
+        end
+
+        describe '.from()' do
+          describe "given @event.from :initial, :to => :final" do
+            describe "setting attributes" do
+              before do
+                stub( @machine ).find_or_create_states_by_name( anything ) { |*a| raise(a.inspect) }
+                stub( @machine ).find_or_create_states_by_name( :initial ) { [@initial] }
+                stub( @machine ).find_or_create_states_by_name( :final   ) { [@final]   }
+              end
+
+              it "should call @machine.find_or_create_states_by_name() with :initial and :final" do
+                @event.from :initial, :to => :final
+              end
+
+              it "should set @event.origin to the returned array of origin states" do
+                @event.from :initial, :to => :final
+                @event.origins.should == [@initial]
+              end
+
+              it "should set @event.target to the returned array of target states" do
+                @event.from :initial, :to => :final
+                @event.targets.should == [@final]
+              end
+            end
+          end
+
+          describe "given @event.from <Array>, :to => <Array>" do
+            it "should call @machine.find_or_create_states_by_name() with both arrays" do
+              stub( @machine ).find_or_create_states_by_name(:initial, :start) do
+                [@initial, @start]
+              end
+              stub( @machine ).find_or_create_states_by_name(:final, :end) do
+                [@final, @end]
+              end
+
+              @event.from( [:initial, :start], :to => [:final, :end] )
+            end
+          end
+
+          describe "given @event.from :ALL, :to => :ALL" do
+            it "should set origins and targets to @machine.states" do
+              stub( @machine ).states() { [:all, :of, :them ] }
+              stub( @machine ).find_or_create_states_by_name(anything) do |x|
+                x
+              end
+              @event.from( :ALL, :to => :ALL )
+              @event.origins.should == [:all, :of, :them ]
+              @event.targets.should == [:all, :of, :them ]
+            end
+          end
+
+        end
+
+        describe '.to()' do
+          describe "given :final" do
+            it "should set @event.target to machine.find_or_create_states_by_name( :final )" do
+              mock( @machine ).find_or_create_states_by_name(:final) { [@final] }
+              @event.to :final
+              @event.targets.should == [@final]
+            end
+          end
+        end
+
+      end
+
+      describe 'origin_names' do
+        it "should return an array of state names in origin when origin is not nil" do
+          mock( @machine ).find_or_create_states_by_name(:initial) { [@initial] }
+          mock( @machine ).find_or_create_states_by_name(:final) { [@final] }
+          @event.from :initial, :to => :final
+          @event.origin.should == @initial
+          mock( @initial ).to_sym().times(any_times) { :initial }
+          @event.origin_names.should == [:initial]
+        end
+
+        it "should return nil when origin is nil" do
+          mock( @event ).origins().times(any_times) { nil }
+          @event.origin_names.should == nil
+        end
+
+      end
+
+      describe 'target_names' do
+        it "should return an array of state names in target when target is not nil" do
+          mock( @event ).targets.times( any_times ) { [@final] }
+          mock( @final ).to_sym { :final }
+          @event.target_names.should == [:final]
+        end
+
+        it "should return nil when target is nil" do
+          mock( @event ).targets().times(any_times) { nil }
+          @event.target_names.should == nil
+        end
+      end
+
+      describe 'to?' do
+        it "should return true given a symbol which is the name of a state in @target" do
+          mock( @event ).targets.times(any_times) {  [StateFu::State.new(@machine,:a)] }
+          @event.to?( :a ).should == true
+        end
+
+        it "should return false given a symbol which is not the name of a state in @target" do
+          mock( @event ).targets.times(any_times) {  [StateFu::State.new(@machine,:a)] }
+          @event.to?( :b ).should == false
+        end
+      end
+
+      describe 'from?' do
+        it "should return true given a symbol which is the name of a state in @origin" do
+          mock( @event ).origins.times(any_times) {  [StateFu::State.new(@machine,:a)] }
+          @event.from?( :a ).should == true
+        end
+
+        it "should return false given a symbol which is not the name of a state in @origin" do
+          mock( @event ).origins().times(any_times) {  [StateFu::State.new(@machine,:a)] }
+          @event.from?( :b ).should == false
+        end
+      end
+
+      describe 'complete?' do
+        it "should be false if either origin / target are nil" do
+          @event.complete?.should == false
+        end
+
+        it "should be true when origin / target are both not nil" do
+          mock( @event ).origins { [:a] }
+          mock( @event ).targets { [:b] }
+          @event.complete?.should == true
+        end
+
+        it "should be false when either origin / target are nil" do
+          mock( @event ).origins { [:a] }
+          mock( @event ).targets { nil  }
+          @event.complete?.should == false
+        end
+
+      end
+
+    end # describe instance methods
+  end   # describe StateFu::Event
+end

data/spec/units/exceptions_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe StateFu::RequirementError do
+
+  describe "constructor" do
+    before do
+      @transition = Object.new()
+    end
+
+  end
+end
+
+describe StateFu::TransitionHalted do
+
+  describe "constructor" do
+    before do
+      @transition = Object.new()
+    end
+
+    it "should create a TransitionHalted given a transition" do
+      e = StateFu::TransitionHalted.new( @transition )
+      e.should be_kind_of( StateFu::TransitionHalted )
+    end
+
+    it "should allow a custom message" do
+      msg = 'helo'
+      e = StateFu::TransitionHalted.new( @transition, msg )
+      e.should be_kind_of( StateFu::TransitionHalted )
+      e.message.should == msg
+    end
+
+    it "should allow a message to be omitted" do
+      e = StateFu::TransitionHalted.new( @transition )
+      e.should be_kind_of( StateFu::TransitionHalted )
+      e.message.should == StateFu::TransitionHalted::DEFAULT_MESSAGE
+    end
+
+    it "should allow access to the transition" do
+      e = StateFu::TransitionHalted.new( @transition )
+      e.transition.should == @transition
+    end
+  end
+end
+
+describe StateFu::InvalidTransition do
+  before do
+    @binding = Object.new
+    @origin  = Object.new
+    @event   = Object.new
+    @target  = Object.new
+  end
+
+  describe "constructor" do
+    it "should create an InvalidTransition given a binding, event, origin & target" do
+      e = StateFu::InvalidTransition.new( @binding, @event, @origin, @target )
+      e.should be_kind_of( StateFu::InvalidTransition )
+      e.message.should == StateFu::InvalidTransition::DEFAULT_MESSAGE
+    end
+
+    it "should allow a custom message" do
+      msg = 'helo'
+      e = StateFu::InvalidTransition.new( @binding, @event, @origin, @target, msg )
+      e.should be_kind_of( StateFu::InvalidTransition )
+      e.message.should == msg
+    end
+
+    it "should allow access to the binding, event, origin, and target" do
+      e = StateFu::InvalidTransition.new( @binding, @event, @origin, @target )
+      e.binding.should == @binding
+      e.event.should   == @event
+      e.origin.should  == @origin
+      e.target.should  == @target
+    end
+  end
+end

data/spec/units/fu_space_spec.rb

@@ -0,0 +1,95 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+StateFu::FuSpace.reset!
+
+##
+##
+##
+describe StateFu::FuSpace do
+  include MySpecHelper
+
+  before(:each) do
+    reset!
+    make_pristine_class 'Klass'
+    @k = Klass.new()
+  end
+
+  describe "Before any Machine is defined" do
+    it "should return {} given StateFu::FuSpace.class_machines()" do
+      StateFu::FuSpace.should respond_to(:class_machines)
+      StateFu::FuSpace.class_machines.should == {}
+    end
+  end
+
+  describe "Having called Klass.machine() with an empty block:" do
+    before(:each) do
+      Klass.machine do
+      end
+      StateFu::DEFAULT_MACHINE.should == :state_fu
+    end
+
+    it "should return { Klass => { ... } } given StateFu::FuSpace.class_machines()" do
+      StateFu::FuSpace.should respond_to(:class_machines)
+      machines = StateFu::FuSpace.class_machines()
+      machines.keys.should == [Klass]
+      machines.values.first.should be_kind_of( Hash )
+    end
+
+    it "should return { :state_fu => <StateFu::Machine> } given StateFu::FuSpace.class_machines[Klass]" do
+      StateFu::FuSpace.should respond_to(:class_machines)
+      machines = StateFu::FuSpace.class_machines[Klass]
+      machines.should be_kind_of(Hash)
+      machines.should_not be_empty
+      machines.length.should == 1
+      machines.keys.should == [:state_fu]
+      machines.values.first.should be_kind_of( StateFu::Machine )
+    end
+
+    it "should return { Klass => { ... } } given StateFu::FuSpace.field_names()" do
+      StateFu::FuSpace.should respond_to(:field_names)
+      fields = StateFu::FuSpace.field_names()
+      fields.keys.should == [Klass]
+      fields.values.first.should be_kind_of( Hash )
+    end
+
+    it "should return { :state_fu => :state_fu_state } given StateFu::FuSpace.field_names[Klass]" do
+      StateFu::FuSpace.should respond_to(:field_names)
+      fields = StateFu::FuSpace.field_names[Klass]
+      fields.should be_kind_of(Hash)
+      fields.should_not be_empty
+      fields.length.should == 1
+      fields.keys.should == [:state_fu]
+      fields.values.should == [:state_fu_field]
+    end
+
+    describe "Having called Klass.machine(:two) with an empty block:" do
+      before(:each) do
+        # Klass.machine.should_not be_nil
+        Klass.machine(:two) do
+        end
+      end
+
+      it "should return { :state_fu => <StateFu::Machine>, :two => <StateFu::Machine> } given StateFu::FuSpace.class_machines()" do
+        StateFu::FuSpace.should respond_to(:class_machines)
+        machines = StateFu::FuSpace.class_machines[Klass]
+        machines.should be_kind_of(Hash)
+        machines.should_not be_empty
+        machines.length.should == 2
+        machines.keys.sort.should == [:state_fu, :two]
+        machines.values.each { |v| v.should be_kind_of( StateFu::Machine ) }
+      end
+
+      describe "Having called StateFu::FuSpace.reset!" do
+        before(:each) do
+          StateFu::FuSpace.reset!
+        end
+        it "should return {} given StateFu::FuSpace.class_machines()" do
+          StateFu::FuSpace.should respond_to(:class_machines)
+          StateFu::FuSpace.class_machines.should == {}
+        end
+      end
+
+    end
+  end
+end
+