state-fu 0.11.1

data/spec/units/binding_spec.rb

@@ -0,0 +1,192 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe StateFu::Binding do
+  include MySpecHelper
+
+  describe "instance methods" do
+  end
+
+  #
+  # class methods
+  #
+
+  describe "class methods" do
+  end
+
+
+  #
+  #
+  #
+
+
+
+  #
+  #
+  #
+
+  before do
+    reset!
+    make_pristine_class('Klass')
+    Klass.state_fu_machine(){}
+    @obj = Klass.new()
+  end
+
+  describe "constructor" do
+    before do
+      mock(Klass).state_fu_field_names.at_most(1) do
+        { :example => :example_field }
+      end
+    end
+
+    it "should create a new Binding given valid arguments" do
+      b = StateFu::Binding.new( Klass.state_fu_machine, @obj, :example )
+      b.should be_kind_of( StateFu::Binding )
+      b.object.should      == @obj
+      b.machine.should     == Klass.state_fu_machine
+      b.method_name.should == :example
+    end
+
+    it "should add any options supplied to the binding" do
+      b = StateFu::Binding.new( Klass.state_fu_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(1) { true }
+          mock( Klass ).before_create( :state_fu!) { }
+        end
+        it "should get an ActiveRecord persister" do
+          mock( StateFu::Persistence::ActiveRecord ).new( anything, :example_field ) { @p }
+          b = StateFu::Binding.new( Klass.state_fu_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) { false }
+        end
+        it "should get an Attribute persister" do
+          mock( StateFu::Persistence::Attribute ).new( anything, :example_field ) { @p }
+          b = StateFu::Binding.new( Klass.state_fu_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.state_fu_machine
+      b.object.should       == @obj
+      b.method_name.should       == StateFu::DEFAULT
+      b.field_name.to_sym.should == StateFu::DEFAULT_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.state_fu_machine do
+        state :new do
+          event :age, :to => :old
+        end
+        state :old
+      end
+      @machine   = Klass.state_fu_machine()
+      @object    = Klass.new()
+      @binding   = @object.state_fu()
+    end
+
+    describe "==" do
+      it "should be == :new" do
+        @binding.should == :new
+      end
+    end
+
+    describe ".state and .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 "can_transition?" do
+      before do
+        reset!
+        make_pristine_class("Klass")
+        Klass.class_eval do
+          def tissue?(*args); "o_O"; end
+        end
+        @machine = Klass.state_fu_machine do
+          state :snoo do
+            event :fire, :to => :wizz do
+              requires :tissue?
+            end
+          end
+          state :wizz do
+            event :not_fireable, :to => :pong
+          end
+        end
+        @obj = Klass.new
+      end
+
+      describe "when called with arguments which would return a valid transition from .transition()" do
+        it "should return true" do
+          @obj.state_fu.can_transition?(:fire).should == true
+        end
+      end
+
+      describe "when called with arguments which would raise an IllegalTransition from .transition()" do
+        it "should return nil" do
+          @obj.state_fu.name.should == :snoo
+          lambda { @obj.state_fu.can_transition?(:not_fire) }.should_not raise_error( StateFu::IllegalTransition )
+          @obj.state_fu.can_transition?(:not_fire).should == nil
+        end
+      end
+
+      describe "when called with additional arguments after the destination event/state" do
+
+        # This would make very little sense to someone trying to understand how to use the library.
+        it "should pass the arguments to any requirements to determine transition availability" do
+          pending
+          t = nil
+          mock(@obj).tissue?(anything) do
+            # current_transition.should be_kind_of(StateFu::Transition)
+            t << current_transition
+          end #{|tr| tr.args.should == [:a,:b] }
+          @obj.state_fu.can_fire?(:a, :b)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/units/event_spec.rb

@@ -0,0 +1,214 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+describe StateFu::Event do
+  include MySpecHelper
+  before do
+    @machine = Object.new
+    stub(@machine).tools() { [].extend( StateFu::ToolArray ) }
+  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.state_or_event.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 nil 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 == nil
+        end
+      end
+
+    end # describe instance methods
+  end   # describe StateFu::Event
+end

data/spec/units/exceptions_spec.rb

@@ -0,0 +1,82 @@
+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
+      pending
+      e = StateFu::TransitionHalted.new( @transition )
+      e.should be_kind_of( StateFu::TransitionHalted )
+    end
+
+    it "should allow a custom message" do
+      pending
+      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
+      pending
+      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
+      pending
+      e = StateFu::TransitionHalted.new( @transition )
+      e.transition.should == @transition
+    end
+  end
+end
+
+describe StateFu::IllegalTransition do
+  before do
+    @binding = Object.new
+    @origin  = Object.new
+    @event   = Object.new
+    @target  = Object.new
+  end
+
+  describe "constructor" do
+    it "should create an IllegalTransition given a binding, event, origin & target" do
+      pending
+      e = StateFu::IllegalTransition.new( @binding, @event, @origin, @target )
+      e.should be_kind_of( StateFu::IllegalTransition )
+      e.message.should == StateFu::IllegalTransition::DEFAULT_MESSAGE
+    end
+
+    it "should allow a custom message" do
+      pending
+      msg = 'helo'
+      e = StateFu::IllegalTransition.new( @binding, @event, @origin, @target, msg )
+      e.should be_kind_of( StateFu::IllegalTransition )
+      e.message.should == msg
+    end
+
+    it "should allow access to the binding, event, origin, and target" do
+      pending
+      e = StateFu::IllegalTransition.new( @binding, @event, @origin, @target )
+      e.binding.should == @binding
+      e.event.should   == @event
+      e.origin.should  == @origin
+      e.target.should  == @target
+    end
+  end
+end