davidlee-state-fu 0.3.1 → 0.10.0

data/spec/integration/transition_spec.rb

@@ -9,13 +9,47 @@ describe StateFu::Transition do
     make_pristine_class("Klass")
   end
 
+  describe "transition args / options" do
+    before do
+      make_pristine_class('Alphabet') do
+        machine do
+          connect_states :a, :b
+        end
+      end
+      @abc = Alphabet.new
+      evt  = Alphabet.machine.events[:a_to_b]
+      tgt  = Alphabet.machine.states[:b]
+      @t   = @abc.stfu.new_transition(evt, tgt,
+                                      :a, :b, 'c' => 'cat')
+    end
+
+    it "should behave like this" do
+      @t.args.should    == [:a, :b, {'c' => 'cat'}]
+      @t.options.should == {:c => 'cat'} 
+
+      @t.apply!({'d' => :e})
+      @t.options.should == {:c => 'cat', :d =>  :e} 
+      
+      @t.args.should    == [:a, :b, {'c' => 'cat'}]
+      
+      @t.args = [:A, :B]
+      @t.args.should    == [:A, :B]
+      @t.options.should == {:c => 'cat', :d => :e} 
+      
+      @t.args = [:X, :Y, {:scale => :metric }]
+      
+      @t.options.should == { :c => 'cat', :d => :e , :scale => :metric }
+      @t.args.options.should == @t.options
+    end
+  end
+
   #
   #
   #
 
   describe "A simple machine with 2 states and a single event" do
     before do
-      @machine = Klass.machine do
+      @machine = Klass.state_fu_machine do
         state :src do
           event :transfer, :to => :dest
         end
@@ -61,15 +95,14 @@ describe StateFu::Transition do
 
         it "should be live" do
           @t.should be_live
-          @t.should be_real
         end
 
         it "should not be accepted" do
           @t.should_not be_accepted
         end
 
-        it "should have a current_state of :unfired" do
-          @t.current_state.should == :unfired
+        it "should have a current_state of the origin state" do
+          @t.current_state.should == @origin
         end
 
         it "should have a current_hook of nil" do
@@ -90,7 +123,7 @@ describe StateFu::Transition do
 
         it "should change the field when persistence is via an attribute" do
           @obj.state_fu.persister.should be_kind_of( StateFu::Persistence::Attribute )
-          @obj.state_fu.persister.field_name.should == :state_fu_field
+          @obj.state_fu.persister.field_name.to_s.should == StateFu::DEFAULT_FIELD.to_s
           @obj.send( :state_fu_field ).should == "src"
           @t.fire!
           @obj.send( :state_fu_field ).should == "dest"
@@ -117,15 +150,14 @@ describe StateFu::Transition do
 
         it "should be live" do
           @t.should be_live
-          @t.should be_real
         end
 
         it "should be accepted" do
           @t.should be_accepted
         end
 
-        it "should have a current_state of :accepted" do
-          @t.current_state.should == :accepted
+        it "should have a current_state of the target state" do
+          @t.current_state.should == @target
         end
 
         it "should have a current_hook && current_hook_slot of nil" do
@@ -224,15 +256,18 @@ describe StateFu::Transition do
       end # state_fu.fire!
 
       describe "calling cycle!()" do
-        it "should raise an InvalidTransition error" do
-          lambda { @obj.state_fu.cycle!() }.should raise_error( StateFu::InvalidTransition )
+        it "should raise a TransitionNotFound error" do
+          lambda { @obj.state_fu.cycle!() }.should raise_error( StateFu::TransitionNotFound )
         end
       end # cycle!
 
       describe "calling next!()" do
         it "should change the state" do
           @obj.state_fu.state.should == @origin
-          @obj.state_fu.next!()
+          t = @obj.state_fu.transfer
+          t.should be_valid
+          @obj.state_fu.valid_transitions.length.should == 1
+          @obj.state_fu.next!
           @obj.state_fu.state.should == @target
         end
 
@@ -242,23 +277,23 @@ describe StateFu::Transition do
         end
 
         it "should define any methods declared in a block given to .transition" do
-          trans = @obj.state_fu.next! do
+          trans = @obj.state_fu.next_transition do
             def snoo
               return [self]
             end
           end
           trans.should be_kind_of( StateFu::Transition )
-          trans.should respond_to(:snoo)
+          # trans.should respond_to(:snoo)
           trans.snoo.should == [trans]
         end
 
         it "should raise an error when there is no next state" do
-          Klass.machine(:noop) {}
-          lambda { @obj.noop.next! }.should raise_error( StateFu::InvalidTransition )
+          Klass.state_fu_machine(:noop) {}
+          lambda { @obj.noop.next! }.should raise_error( StateFu::TransitionNotFound )
         end
         it "should raise an error when there is more than one next state" do
-          Klass.machine(:toomany) { event( :go, :from => :one, :to => [:a,:b,:c] ) }
-          lambda { @obj.toomany.next! }.should raise_error( StateFu::InvalidTransition )
+          Klass.state_fu_machine(:toomany) { event( :go, :from => :one, :to => [:a,:b,:c] ) }
+          lambda { @obj.toomany.next! }.should raise_error( StateFu::TransitionNotFound )
         end
       end # next!
 
@@ -268,25 +303,25 @@ describe StateFu::Transition do
         end
 
         describe "calling transition( :transfer, :a, :b, :c => :d )" do
-          it "should set args to [:a, :b] and options to :c => :d on the transition" do
+          it "should set args and options on the transition" do
             t = @obj.state_fu.transition( :transfer, *@args )
-            t.args.should    == [ :a, :b ]
+            t.args.should    == [ :a, :b, {:c => :d} ]
             t.options.should == { :c => :d }
           end
         end
 
         describe "calling fire!( :transfer, :a, :b, :c => :d )" do
-          it "should set args to [:a, :b] and options to :c => :d on the transition" do
+          it "should set args and options on the transition" do
             t = @obj.state_fu.fire!( :transfer, *@args )
-            t.args.should    == [ :a, :b ]
+            t.args.should    == [ :a, :b, {:c =>:d} ]
             t.options.should == { :c => :d }
           end
         end
 
         describe "calling next!( :a, :b, :c => :d )" do
-          it "should set args to [:a, :b] and options to :c => :d on the transition" do
+          it "should set args and options on the transition" do
             t = @obj.state_fu.next!( *@args )
-            t.args.should    == [ :a, :b ]
+            t.args.should    == [ :a, :b, {:c => :d}]
             t.options.should == { :c => :d }
           end
         end
@@ -301,7 +336,7 @@ describe StateFu::Transition do
   describe "A simple machine with 1 state and an event cycling at the same state" do
 
     before do
-      @machine = Klass.machine do
+      @machine = Klass.state_fu_machine do
         state :state_fuega do
           event :transfer, :to => :state_fuega
         end
@@ -320,8 +355,8 @@ describe StateFu::Transition do
         end
 
         it "should pass args / options to the transition" do
-          t = @obj.state_fu.cycle!( :a, :b , { :c => :d } )
-          t.args.should    == [ :a, :b ]
+          t = @obj.state_fu.cycle!( nil, :a, :b , { :c => :d } )
+          t.args.should    == [ :a, :b, { :c => :d } ]
           t.options.should == { :c => :d }
         end
 
@@ -347,7 +382,7 @@ describe StateFu::Transition do
   describe "A simple machine with 3 states and an event to & from multiple states" do
 
     before do
-      @machine = Klass.machine do
+      @machine = Klass.state_fu_machine do
         states :a, :b
         states :x, :y
 
@@ -377,23 +412,23 @@ describe StateFu::Transition do
 
     describe "state_fu instance methods" do
       describe "state_fu.transition" do
-        it "should raise an ArgumentError unless a valid targets state is supplied or can be inferred" do
+        it "should raise StateFu::UnknownTarget unless a valid targets state is supplied or can be inferred" do
           lambda do
             @obj.state_fu.transition( :go )
-          end.should raise_error( ArgumentError )
+          end.should raise_error( StateFu::UnknownTarget )
 
           lambda do
             @obj.state_fu.transition( [:go, nil] )
-          end.should raise_error( ArgumentError )
+          end.should raise_error( StateFu::UnknownTarget )
 
           lambda do
             @obj.state_fu.transition( [:go, :awol] )
-          end.should raise_error( ArgumentError )
+          end.should raise_error( StateFu::UnknownTarget )
 
           lambda do
             @obj.state_fu.transition( [:go, :x] )
             @obj.state_fu.transition( [:go, :y] )
-          end.should_not raise_error( ArgumentError )
+          end.should_not raise_error( StateFu::UnknownTarget )
         end
 
         it "should return a transition with the specified destination" do
@@ -409,30 +444,30 @@ describe StateFu::Transition do
       end  # state_fu.transition
 
       describe "state_fu.fire!" do
-        it "should raise an ArgumentError unless a valid targets state is supplied" do
+        it "should raise an StateFu::UnknownTarget unless a valid targets state is supplied" do
           lambda do
             @obj.state_fu.fire!( :go )
-          end.should raise_error( ArgumentError )
+          end.should raise_error( StateFu::UnknownTarget )
 
           lambda do
             @obj.state_fu.fire!( [ :go, :awol ] )
-          end.should raise_error( ArgumentError )
+          end.should raise_error( StateFu::UnknownTarget )
         end
       end # state_fu.fire!
 
       describe "state_fu.next!" do
-        it "should raise an ArgumentError" do
+        it "should raise an StateFu::TransitionNotFound" do
           lambda do
             @obj.state_fu.next!
-          end.should raise_error( StateFu::InvalidTransition )
+          end.should raise_error( StateFu::TransitionNotFound )
         end
       end # next!
 
       describe "state_fu.cycle!" do
-        it "should raise an ArgumentError" do
+        it "should raise StateFu::TransitionNotFound" do
           lambda do
             @obj.state_fu.cycle!
-          end.should raise_error( StateFu::InvalidTransition )
+          end.should raise_error( StateFu::TransitionNotFound )
         end
       end # cycle!
 
@@ -441,7 +476,26 @@ describe StateFu::Transition do
 
   describe "A simple machine w/ 2 states, 1 event and named hooks " do
     before do
-      @machine = Klass.machine do
+      Klass.class_eval do
+        attr_reader :calls
+
+        def called name
+          (@calls ||= [])<< name
+        end
+
+        def before_go  ; called :before_go  end
+        def after_go   ; called :after_go   end
+        def execute_go ; called :execute_go end
+        def entering_a ; called :entering_a end
+        def accepted_a ; called :accepted_a end
+        def exiting_a  ; called :exiting_a  end
+        def entering_b ; called :entering_b end
+        def accepted_b ; called :accepted_b end
+        def exiting_b  ; called :exiting_b  end
+
+      end
+
+      @machine = Klass.state_fu_machine do
 
         state :a do
           on_exit( :exiting_a )
@@ -515,32 +569,16 @@ describe StateFu::Transition do
     describe "fire! calling hooks" do
       before do
         @t      = @obj.state_fu.transition( :go )
-        stub( @obj ).before_go(@t)  { @called << :before_go  }
-        stub( @obj ).exiting_a(@t)  { @called << :exiting_a  }
-        stub( @obj ).execute_go(@t) { @called << :execute_go }
-        stub( @obj ).entering_b(@t) { @called << :entering_b }
-        stub( @obj ).after_go(@t)   { @called << :after_go   }
-        stub( @obj ).accepted_b(@t) { @called << :accepted_b }
-        @called = []
-        [ :before_go,
-          :exiting_a,
-          :execute_go,
-          :entering_b,
-          :after_go,
-          :accepted_b ].each do |method_name|
-          set_method_arity( @obj, method_name, 1 )
-        end
       end
 
       it "should update the object's state after state:entering and before event:after" do
         @binding  = @obj.state_fu
-        mock( @obj ).entering_b( @t ) { @binding.state.name.should == :a }
-        mock( @obj ).after_go(@t)     { @binding.state.name.should == :b }
-        mock( @obj ).accepted_b(@t)   { @binding.state.name.should == :b }
+        pending
         @t.fire!
       end
 
       it "should be accepted after state:entering and before event:after" do
+        pending
         mock( @obj ).entering_b( @t ) { @t.should_not be_accepted }
         mock( @obj ).after_go(@t)     { @t.should be_accepted }
         mock( @obj ).accepted_b(@t)   { @t.should be_accepted }
@@ -548,6 +586,7 @@ describe StateFu::Transition do
       end
 
       it "should call the method for each hook on @obj in order, with the transition" do
+        pending
         mock( @obj ).before_go(@t)  { @called << :before_go  }
         mock( @obj ).exiting_a(@t)  { @called << :exiting_a  }
         mock( @obj ).execute_go(@t) { @called << :execute_go }
@@ -561,10 +600,10 @@ describe StateFu::Transition do
       describe "adding an anonymous hook for event.hooks[:execute]" do
         before do
           called = @called # get us a ref for the closure
-          Klass.machine do
+          Klass.state_fu_machine do
             event( :go ) do
               execute do |ctx|
-                called << :execute_proc
+                called( :execute_proc )
               end
             end
           end
@@ -575,18 +614,19 @@ describe StateFu::Transition do
           @event.hooks[:execute].first.class.should == Symbol
           @event.hooks[:execute].last.class.should  == Proc
           @t.fire!()
-          @called.should == [ :before_go,
-                              :exiting_a,
-                              :execute_go,
-                              :execute_proc,
-                              :entering_b,
-                              :after_go,
-                              :accepted_b ]
+          @obj.calls.should == [ :before_go,
+                                 :exiting_a,
+                                 :execute_go,
+                                 :execute_proc,
+                                 :entering_b,
+                                 :after_go,
+                                 :accepted_b ]
         end
 
         it "should be replace the previous proc for a slot if redefined" do
+          pending
           called = @called # get us a ref for the closure
-          Klass.machine do
+          Klass.state_fu_machine do
             event( :go ) do
               execute do |ctx|
                 called << :execute_proc_2
@@ -612,8 +652,9 @@ describe StateFu::Transition do
       describe "adding a named hook with a block" do
         describe "with arity of -1/0" do
           it "should call the block in the context of the transition" do
+            pending
             called = @called # get us a ref for the closure
-            Klass.machine do
+            Klass.state_fu_machine do
               event( :go ) do
                 execute(:named_execute) do
                   raise self.class.inspect unless self.is_a?( StateFu::Transition )
@@ -634,8 +675,9 @@ describe StateFu::Transition do
 
         describe "with arity of 1" do
           it "should call the proc in the context of the object, passing the transition as the argument" do
+            pending
             called = @called # get us a ref for the closure
-            Klass.machine do
+            Klass.state_fu_machine do
               event( :go ) do
                 execute(:named_execute) do |ctx|
                   raise ctx.class.inspect unless ctx.is_a?( StateFu::Transition )
@@ -659,10 +701,10 @@ describe StateFu::Transition do
       describe "halting the transition during the execute hook" do
 
         before do
-          Klass.machine do
+          Klass.state_fu_machine do
             event( :go ) do
-              execute do |ctx|
-                ctx.halt!("stop")
+              execute do 
+                halt!("stop")
               end
             end
           end
@@ -675,9 +717,9 @@ describe StateFu::Transition do
           @t.should be_kind_of( StateFu::Transition )
           @t.should be_halted
           @t.should_not be_accepted
-          @called.should == [ :before_go,
-                              :exiting_a,
-                              :execute_go ]
+          @obj.calls.flatten.should == [ :before_go,
+                                         :exiting_a,
+                                         :execute_go ]
         end
 
         it "should have current_hook_slot set to where it halted" do
@@ -699,25 +741,31 @@ describe StateFu::Transition do
 
   describe "A binding for a machine with an event transition requirement" do
     before do
-      @machine = Klass.machine do
+      @machine = Klass.state_fu_machine do
         event( :go, :from => :a, :to => :b ) do
           requires( :ok? )
         end
 
         initial_state :a
       end
+      Klass.class_eval do
+        attr_accessor :ok
+        def ok?; ok; end
+      end
       @obj = Klass.new
       @binding = @obj.state_fu
       @event = @machine.events[:go]
       @a = @machine.states[:a]
       @b = @machine.states[:b]
+      # stub(@obj).ok? { true }
     end
 
     describe "when no block is supplied for the requirement" do
 
       it "should have an event named :go" do
         @machine.events[:go].requirements.should == [:ok?]
-        @machine.events[:go].should be_complete
+        @machine.events[:go].targets.should_not be_blank
+        @machine.events[:go].origins.should_not be_blank        
         @machine.states.map(&:name).sort_by(&:to_s).should == [:a, :b]
         @a.should be_kind_of( StateFu::State )
         @event.should be_kind_of( StateFu::Event )
@@ -728,33 +776,26 @@ describe StateFu::Transition do
         @binding.events.should_not be_empty
       end
 
-      it "should contain :go in @binding.valid_events if evt.fireable_by? is true for the binding" do
-        mock( @event ).fireable_by?( @binding ) { true }
-        @binding.valid_events.should == [@event]
-      end
-
-      it "should contain :go in @binding.valid_events if @binding.evaluate_requirement( :ok? ) is true" do
-        mock( @binding ).evaluate_requirement_with_args( :ok? ) { true }
-        @binding.current_state.should == @machine.initial_state
-        @binding.events.should == @machine.events
-        @binding.valid_events.should == [@event]
-      end
 
       it "should contain the event in @binding.valid_events if @obj.ok? is true" do
-        mock( @obj ).ok? { true }
+        # stub( @binding ).ok?() {  true }
+#        set_method_arity(@binding,:ok, 0)
+        @obj.ok = true
         @binding.current_state.should == @machine.initial_state
         @binding.events.should == @machine.events
         @binding.valid_events.should == [@event]
       end
 
       it "should not contain :go in @binding.valid_events if !@obj.ok?" do
-        mock( @obj ).ok? { false }
+        # stub( @binding ).ok?() { false }
+        @obj.ok = false
         @binding.events.should == @machine.events
         @binding.valid_events.should == []
       end
 
       it "should raise a RequirementError if requirements are not satisfied" do
-        stub( @obj ).ok? { false }
+        #stub( @binding ).ok? { false }
+        @obj.ok = false
         lambda do
           @obj.state_fu.fire!( :go )
         end.should raise_error( StateFu::RequirementError )
@@ -787,14 +828,22 @@ describe StateFu::Transition do
 
   describe "A binding for a machine with a state transition requirement" do
     before do
-      @machine = Klass.machine do
+      @machine = Klass.state_fu_machine do
         event( :go, :from => :a, :to => :b )
         state( :b ) do
           requires :entry_ok?
         end
       end
+      Klass.class_eval do
+        attr_accessor :entry_ok
+        def entry_ok?
+          entry_ok
+        end
+      end
+
       @obj = Klass.new
       @binding = @obj.state_fu
+      @obj.entry_ok = true
       @event = @machine.events[:go]
       @a = @machine.states[:a]
       @b = @machine.states[:b]
@@ -803,30 +852,20 @@ describe StateFu::Transition do
     describe "when no block is supplied for the requirement" do
 
       it "should be valid if @binding.valid_transitions' values includes the state" do
-        mock( @binding ).valid_transitions{ {@event => [@b] } }
-        @binding.valid_next_states.should == [@b]
-      end
-
-      it "should be valid if state is enterable_by?( @binding)" do
-        mock( @b ).enterable_by?( @binding ) { true }
+        t = @binding.transition([@event, @b])
         @binding.valid_next_states.should == [@b]
       end
 
-      it "should not be valid if state is not enterable_by?( @binding)" do
-        mock( @b ).enterable_by?( @binding ) { false }
-        @binding.valid_next_states.should == []
-      end
-
       it "should be invalid if @obj.entry_ok? is false" do
-        mock( @obj ).entry_ok? { false }
+        #mock( @obj ).entry_ok? { false }
+        @obj.entry_ok = false
         @b.entry_requirements.should == [:entry_ok?]
-        # @binding.evaluate_requirement( :entry_ok? ).should == false
-        # @b.enterable_by?( @binding ).should == false
         @binding.valid_next_states.should == []
       end
 
       it "should be valid if @obj.entry_ok? is true" do
-        mock( @obj ).entry_ok? { true }
+        # mock( @obj ).entry_ok? { true }
+        @obj.entry_ok = true
         @binding.valid_next_states.should == [@b]
       end
 
@@ -857,7 +896,7 @@ describe StateFu::Transition do
     before do
       reset!
       make_pristine_class("Klass")
-      @machine = Klass.machine do
+      @machine = Klass.state_fu_machine do
         event(:run, :from => :start, :to => :finish ) do
           execute( :run_exec )
         end
@@ -867,43 +906,16 @@ describe StateFu::Transition do
 
     describe "a method defined on the stateful object" do
 
-     #  it "should have self as the object itself" do
-     #    called = false
-     #    Klass.class_eval do
-     #      @@obj = nil
-     #      cattr_accessor :obj
-     #
-     #      def run_exec( t )
-     #        called  = true
-     #        raise "self is #{self} not #{@@obj}" unless self == @@obj
-     #      end
-     #    end
-     #    Klass.obj = @obj
-     #    called.should == false
-     #    trans = @obj.state_fu.fire!(:run)
-     #    called.should == true
-     #  end
-
-      it "should receive a transition and be able to access the binding, etc through it" do
-        mock( @obj ).run_exec(is_a(StateFu::Transition)) do |t|
-          raise "not a transition" unless t.is_a?( StateFu::Transition )
-          raise "no binding" unless t.binding.is_a?( StateFu::Binding )
-          raise "no machine" unless t.machine.is_a?( StateFu::Machine )
-          raise "no object" unless t.object.is_a?( Klass )
-        end
-        set_method_arity( @obj, :run_exec, 1 )
-        trans = @obj.state_fu.fire!(:run)
-      end
-
       it "should be able to conditionally execute code based on whether the transition is a test" do
-        mock( @obj ).run_exec(is_a(StateFu::Transition)) do |t|
-          raise "SHOULD NOT EXECUTE" unless t.testing?
+        pending
+        testing = nil
+        @obj.__define_singleton_method(:run_exec) do
+          testing = t.testing?
         end
-        set_method_arity( @obj, :run_exec, 1 )
-        trans = @obj.state_fu.transition( :run )
-        trans.test_only = true
-        trans.fire!
-        trans.should be_accepted
+        @obj.state_fu.fire! :run do |t|
+          t.test_only = true
+        end
+        testing.should == true
       end
 
       it "should be able to call methods on the transition mixed in via machine.helper" do
@@ -932,13 +944,13 @@ describe StateFu::Transition do
       end
 
       it "should be able to access the args / options passed to fire! via transition.args" do
+        pending
         # NOTE a trailing hash gets munged into options - not args
         args = [:a, :b, { 'c' => :d }]
-        mock( @obj ).run_exec(is_a(StateFu::Transition)) do |t|
-          t.args.should == [:a, :b]
-          t.options.should == {:c => :d}
+        @obj.__define_singleton_method(:run_exec) do
+          t.args.should == [:a, :b,{'c' => :d}]
+          t.options.should == {}
         end
-        set_method_arity( @obj, :run_exec, 1 )
         trans = @obj.state_fu.fire!( :run, *args )
         trans.should be_accepted
       end
@@ -946,19 +958,16 @@ describe StateFu::Transition do
 
     describe "a block passed to binding.transition" do
       it "should execute in the context of the transition initializer after it's set up" do
-        Klass.send :define_method, :run_exec, &lambda {|a| raise "!" }
-
-        mock( @obj ).run_exec(is_a(StateFu::Transition)) do |t|
+        pending
+        @obj.__define_singleton_method(:run_exec) do
           t.args.should == ['who','yo','daddy?']
           t.options.should == {:hi => :mum}
         end
-        set_method_arity( @obj, :run_exec, 1)
         trans = @obj.state_fu.transition( :run ) do
           @args    = %w/ who yo daddy? /
           @options = {:hi => :mum}
+
         end
-        @obj.method(:run_exec).should be_kind_of(Proc)
-        @obj.method(:run_exec).arity.should == 1
         trans.fire!()
       end
     end
@@ -968,9 +977,10 @@ describe StateFu::Transition do
   describe "next_transition" do
     describe "when there are multiple events but only one is fireable?" do
       before do
+        pending
         reset!
         make_pristine_class("Klass")
-        @machine = Klass.machine do
+        @machine = Klass.state_fu_machine do
           initial_state :alive do
             event :impossibility do
               to :afterlife
@@ -987,8 +997,8 @@ describe StateFu::Transition do
         @obj     = Klass.new()
         @binding = @obj.state_fu
         @binding.events.length.should == 2
-        @machine.events[:impossibility].fireable_by?( @binding ).should == false
-        @machine.events[:inevitability].fireable_by?( @binding ).should == true
+        #@machine.events[:impossibility].fireable_by?( @binding ).should == false
+        #@machine.events[:inevitability].fireable_by?( @binding ).should == true
       end
 
       describe "when the fireable? event has only one target" do
@@ -1006,7 +1016,7 @@ describe StateFu::Transition do
         before do
           reset!
           make_pristine_class("Klass")
-          @machine = Klass.machine do
+          @machine = Klass.state_fu_machine do
             initial_state :alive
 
             state :cremated
@@ -1025,13 +1035,9 @@ describe StateFu::Transition do
           @obj     = Klass.new()
           @binding = @obj.state_fu
           @machine.events[:inevitability].should be_kind_of(StateFu::Event)
-          @machine.events[:inevitability].fireable_by?( @binding ).should == true
-          @machine.states[:cremated].enterable_by?( @binding ).should == true
-          @machine.states[:buried].enterable_by?( @binding ).should == false
           @binding.valid_events.map(&:name).should == [@machine.events[:inevitability]].map(&:name)
           @binding.valid_events.should == [@machine.events[:inevitability]]
-          @binding.valid_transitions.values.flatten.map(&:name).should == [:cremated]
-          @binding.valid_transitions.values.flatten.should == [@machine.states[:cremated]]
+          @binding.valid_transitions.map(&:target).map(&:name).should == [:cremated]
         end # before
 
         it "should return a transition for the fireable event & the enterable target" do
@@ -1050,8 +1056,6 @@ describe StateFu::Transition do
               to :cremated, :buried
             end
           end
-          @machine.states[:buried].enterable_by?( @binding ).should == true
-          @machine.states[:cremated].enterable_by?( @binding ).should == true
           @obj     = Klass.new()
           @binding = @obj.state_fu
         end
@@ -1070,11 +1074,3 @@ describe StateFu::Transition do
   end
 end
 
-describe "sanity" do
-  include MySpecHelper
-  it "should be sane" do
-    x = Object.new
-    set_method_arity(x, :to_s, 2 )
-    x.method( :to_s ).arity.should == 2
-  end
-end