From 7fc628e3fcda6342a8cee0a6236987b57ac10270 Mon Sep 17 00:00:00 2001
From: rick <technoweenie@gmail.com>
Date: Fri, 27 Jun 2008 23:29:03 -0700
Subject: convert specs to tests

---
 activemodel/test/observing_test.rb | 123 +++++++++++++++++++++++++++++++++++++
 activemodel/test/test_helper.rb    |  23 +++++++
 2 files changed, 146 insertions(+)
 create mode 100644 activemodel/test/observing_test.rb
 create mode 100644 activemodel/test/test_helper.rb

(limited to 'activemodel/test')

diff --git a/activemodel/test/observing_test.rb b/activemodel/test/observing_test.rb
new file mode 100644
index 0000000000..37291ae4c6
--- /dev/null
+++ b/activemodel/test/observing_test.rb
@@ -0,0 +1,123 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ObservedModel < ActiveModel::Base
+  class Observer
+  end
+end
+
+class FooObserver < ActiveModel::Observer
+  class << self
+    public :new
+  end
+  
+  attr_accessor :stub
+
+  def on_spec(record)
+    stub.event_with(record) if stub
+  end
+end
+
+class Foo < ActiveModel::Base
+end
+
+class ObservingTest < ActiveSupport::TestCase
+  def setup
+    ObservedModel.observers.clear
+  end
+
+  test "initializes model with no cached observers" do
+    assert ObservedModel.observers.empty?, "Not empty: #{ObservedModel.observers.inspect}"
+  end
+  
+  test "stores cached observers in an array" do
+    ObservedModel.observers << :foo
+    assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}"
+  end
+  
+  test "flattens array of assigned cached observers" do
+    ObservedModel.observers = [[:foo], :bar]
+    assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}"
+    assert ObservedModel.observers.include?(:bar), ":bar not in #{ObservedModel.observers.inspect}"
+  end
+
+  uses_mocha "observer instantiation" do
+    test "instantiates observer names passed as strings" do
+      ObservedModel.observers << 'foo_observer'
+      FooObserver.expects(:instance)
+      ObservedModel.instantiate_observers
+    end
+  
+    test "instantiates observer names passed as symbols" do
+      ObservedModel.observers << :foo_observer
+      FooObserver.expects(:instance)
+      ObservedModel.instantiate_observers
+    end
+  
+    test "instantiates observer classes" do
+      ObservedModel.observers << ObservedModel::Observer
+      ObservedModel::Observer.expects(:instance)
+      ObservedModel.instantiate_observers
+    end
+  end
+  
+  test "passes observers to subclasses" do
+    FooObserver.instance
+    bar = Class.new(Foo)
+    assert_equal Foo.count_observers, bar.count_observers
+  end
+end
+  
+class ObserverTest < ActiveSupport::TestCase
+  def setup
+    ObservedModel.observers = :foo_observer
+    FooObserver.models = nil
+  end
+
+  test "guesses implicit observable model name" do
+    assert_equal 'Foo', FooObserver.observed_class_name
+  end
+
+  test "tracks implicit observable models" do
+    instance = FooObserver.new
+    assert  instance.send(:observed_classes).include?(Foo), "Foo not in #{instance.send(:observed_classes).inspect}"
+    assert !instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{instance.send(:observed_classes).inspect}"
+  end
+  
+  test "tracks explicit observed model class" do
+    old_instance = FooObserver.new
+    assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}"
+    FooObserver.observe ObservedModel
+    instance = FooObserver.new
+    assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}"
+  end
+  
+  test "tracks explicit observed model as string" do
+    old_instance = FooObserver.new
+    assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}"
+    FooObserver.observe 'observed_model'
+    instance = FooObserver.new
+    assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}"
+  end
+  
+  test "tracks explicit observed model as symbol" do
+    old_instance = FooObserver.new
+    assert !old_instance.send(:observed_classes).include?(ObservedModel), "ObservedModel in #{old_instance.send(:observed_classes).inspect}"
+    FooObserver.observe :observed_model
+    instance = FooObserver.new
+    assert instance.send(:observed_classes).include?(ObservedModel), "ObservedModel not in #{instance.send(:observed_classes).inspect}"
+  end
+  
+  test "calls existing observer event" do
+    foo = Foo.new
+    FooObserver.instance.stub = stub
+    FooObserver.instance.stub.expects(:event_with).with(foo)
+    Foo.send(:changed)
+    Foo.send(:notify_observers, :on_spec, foo)
+  end
+  
+  test "skips nonexistent observer event" do
+    foo = Foo.new
+    Foo.send(:changed)
+    Foo.send(:notify_observers, :whatever, foo)
+  end
+end
\ No newline at end of file
diff --git a/activemodel/test/test_helper.rb b/activemodel/test/test_helper.rb
new file mode 100644
index 0000000000..8e608fa0bc
--- /dev/null
+++ b/activemodel/test/test_helper.rb
@@ -0,0 +1,23 @@
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+$:.unshift File.dirname(__FILE__)
+
+require 'test/unit'
+require 'active_model'
+require 'active_support/callbacks' # needed by ActiveSupport::TestCase
+require 'active_support/test_case'
+
+def uses_gem(gem_name, test_name, version = '> 0')
+  require 'rubygems'
+  gem gem_name.to_s, version
+  require gem_name.to_s
+  yield
+rescue LoadError
+  $stderr.puts "Skipping #{test_name} tests. `gem install #{gem_name}` and try again."
+end
+
+# Wrap tests that use Mocha and skip if unavailable.
+unless defined? uses_mocha
+  def uses_mocha(test_name, &block)
+    uses_gem('mocha', test_name, '>= 0.5.5', &block)
+  end
+end
-- 
cgit v1.2.3


From b9528ad3c5379896b00772cb44faf1db0fd882d7 Mon Sep 17 00:00:00 2001
From: rick <technoweenie@gmail.com>
Date: Sat, 28 Jun 2008 00:55:02 -0700
Subject: initial statemachine machine and state classes

---
 activemodel/test/observing_test.rb             |   6 +-
 activemodel/test/state_machine/machine_test.rb |  28 +++
 activemodel/test/state_machine/state_test.rb   |  73 ++++++
 activemodel/test/state_machine_test.rb         | 335 +++++++++++++++++++++++++
 activemodel/test/test_helper.rb                |  18 +-
 5 files changed, 456 insertions(+), 4 deletions(-)
 create mode 100644 activemodel/test/state_machine/machine_test.rb
 create mode 100644 activemodel/test/state_machine/state_test.rb
 create mode 100644 activemodel/test/state_machine_test.rb

(limited to 'activemodel/test')

diff --git a/activemodel/test/observing_test.rb b/activemodel/test/observing_test.rb
index 37291ae4c6..6e124de52f 100644
--- a/activemodel/test/observing_test.rb
+++ b/activemodel/test/observing_test.rb
@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
 
 class ObservedModel < ActiveModel::Base
   class Observer
@@ -20,7 +20,7 @@ end
 class Foo < ActiveModel::Base
 end
 
-class ObservingTest < ActiveSupport::TestCase
+class ObservingTest < ActiveModel::TestCase
   def setup
     ObservedModel.observers.clear
   end
@@ -67,7 +67,7 @@ class ObservingTest < ActiveSupport::TestCase
   end
 end
   
-class ObserverTest < ActiveSupport::TestCase
+class ObserverTest < ActiveModel::TestCase
   def setup
     ObservedModel.observers = :foo_observer
     FooObserver.models = nil
diff --git a/activemodel/test/state_machine/machine_test.rb b/activemodel/test/state_machine/machine_test.rb
new file mode 100644
index 0000000000..34a4b384ce
--- /dev/null
+++ b/activemodel/test/state_machine/machine_test.rb
@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+class MachineTestSubject
+  include ActiveModel::StateMachine
+
+  state_machine do
+  end
+
+  state_machine :initial => :foo do
+  end
+
+  state_machine :extra, :initial => :bar do
+  end
+end
+
+class StateMachineMachineTest < ActiveModel::TestCase
+  test "allows reuse of existing machines" do
+    assert_equal 2, MachineTestSubject.state_machines.size
+  end
+
+  test "sets #initial_state from :initial option" do
+    assert_equal :bar, MachineTestSubject.state_machine(:extra).initial_state
+  end
+
+  test "accesses non-default state machine" do
+    assert_kind_of ActiveModel::StateMachine::Machine, MachineTestSubject.state_machine(:extra)
+  end
+end
\ No newline at end of file
diff --git a/activemodel/test/state_machine/state_test.rb b/activemodel/test/state_machine/state_test.rb
new file mode 100644
index 0000000000..444435d271
--- /dev/null
+++ b/activemodel/test/state_machine/state_test.rb
@@ -0,0 +1,73 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+class StateTestSubject
+  include ActiveModel::StateMachine
+
+  state_machine do
+  end
+end
+
+class StateTest < ActiveModel::TestCase
+  def setup
+    @name    = :astate
+    @options = { :crazy_custom_key => 'key' }
+    @machine = StateTestSubject.state_machine
+  end
+
+  def new_state(options={})
+    ActiveModel::StateMachine::State.new(options.delete(:machine) || @machine, @name, @options.merge(options))
+  end
+
+  test 'sets the name' do
+    assert_equal :astate, new_state.name
+  end
+
+  test 'sets the display_name from name' do
+    assert_equal "Astate", new_state.display_name
+  end
+
+  test 'sets the display_name from options' do
+    assert_equal "A State", new_state(:display => "A State").display_name
+  end
+  
+  test 'sets the options and expose them as options' do
+    assert_equal @options, new_state.options
+  end
+
+  test 'equals a symbol of the same name' do
+    assert_equal new_state, :astate
+  end
+
+  test 'equals a State of the same name' do
+    assert_equal new_state, new_state
+  end
+
+  uses_mocha 'state actions' do
+    test 'should send a message to the record for an action if the action is present as a symbol' do
+      state = new_state(:entering => :foo)
+
+      record = stub
+      record.expects(:foo)
+
+      state.call_action(:entering, record)
+    end
+
+    test 'should send a message to the record for an action if the action is present as a string' do
+      state = new_state(:entering => 'foo')
+
+      record = stub
+      record.expects(:foo)
+
+      state.call_action(:entering, record)
+    end
+
+    test 'should call a proc, passing in the record for an action if the action is present' do
+      state = new_state(:entering => Proc.new {|r| r.foobar})
+
+      record = stub
+      record.expects(:foobar)
+    
+      state.call_action(:entering, record)
+    end
+  end
+end
\ No newline at end of file
diff --git a/activemodel/test/state_machine_test.rb b/activemodel/test/state_machine_test.rb
new file mode 100644
index 0000000000..e906744c77
--- /dev/null
+++ b/activemodel/test/state_machine_test.rb
@@ -0,0 +1,335 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class StateMachineSubject
+  include ActiveModel::StateMachine
+
+  state_machine do
+    state :open,   :exit => :exit
+    state :closed, :enter => :enter
+    
+    #event :close, :success => :success_callback do
+    #  transitions :to => :closed, :from => [:open]
+    #end
+    #
+    #event :null do
+    #  transitions :to => :closed, :from => [:open], :guard => :always_false
+    #end
+  end
+
+  state_machine :bar do
+    state :read
+    state :ended
+
+    #event :foo do
+    #  transitions :to => :ended, :from => [:read]
+    #end
+  end
+
+  def always_false
+    false
+  end
+ 
+  def success_callback
+  end
+ 
+  def enter
+  end
+  def exit
+  end
+end
+
+class StateMachineSubjectSubclass < StateMachineSubject
+end
+
+class StateMachineClassLevelTest < ActiveModel::TestCase
+  test 'defines a class level #state_machine method on its including class' do
+    assert StateMachineSubject.respond_to?(:state_machine)
+  end
+
+  test 'defines a class level #state_machines method on its including class' do
+    assert StateMachineSubject.respond_to?(:state_machines)
+  end
+
+  test 'class level #state_machine returns machine instance' do
+    assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machine
+  end
+
+  test 'class level #state_machine returns machine instance with given name' do
+    assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machine(:default)
+  end
+
+  test 'class level #state_machines returns hash of machine instances' do
+    assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machines[:default]
+  end
+
+  test "should return a select friendly array of states in the form of [['Friendly name', 'state_name']]" do
+    assert_equal [['Open', 'open'], ['Closed', 'closed']], StateMachineSubject.state_machine.states_for_select
+  end
+end
+
+class StateMachineInstanceLevelTest < ActiveModel::TestCase
+  def setup
+    @foo = StateMachineSubject.new
+  end
+ 
+  test 'defines an accessor for the current state' do
+    assert @foo.respond_to?(:current_state)
+  end
+ 
+  test 'defines a state querying instance method on including class' do
+    assert @foo.respond_to?(:open?)
+  end
+ 
+  #test 'should define an event! inance method' do
+  #  assert @foo.respond_to?(:close!)
+  #end
+end
+ 
+class StateMachineInitialStatesTest < ActiveModel::TestCase
+  def setup
+    @foo = StateMachineSubject.new
+  end
+ 
+  test 'should set the initial state' do
+    assert_equal :open, @foo.current_state
+  end
+ 
+  #test '#open? should be initially true' do
+  #  @foo.open?.should be_true
+  #end
+  #
+  #test '#closed? should be initially false' do
+  #  @foo.closed?.should be_false
+  #end
+ 
+  test 'should use the first state defined if no initial state is given' do
+    assert_equal :read, @foo.current_state(:bar)
+  end
+end
+# 
+#describe AASM, '- event firing with persistence' do
+#  it 'should fire the Event' do
+#    foo = Foo.new
+# 
+#    Foo.aasm_events[:close].should_receive(:fire).with(foo)
+#    foo.close!
+#  end
+# 
+#  it 'should update the current state' do
+#    foo = Foo.new
+#    foo.close!
+# 
+#    foo.aasm_current_state.should == :closed
+#  end
+# 
+#  it 'should call the success callback if one was provided' do
+#    foo = Foo.new
+# 
+#    foo.should_receive(:success_callback)
+# 
+#    foo.close!
+#  end
+# 
+#  it 'should attempt to persist if aasm_write_state is defined' do
+#    foo = Foo.new
+#    
+#    def foo.aasm_write_state
+#    end
+# 
+#    foo.should_receive(:aasm_write_state)
+# 
+#    foo.close!
+#  end
+#end
+# 
+#describe AASM, '- event firing without persistence' do
+#  it 'should fire the Event' do
+#    foo = Foo.new
+# 
+#    Foo.aasm_events[:close].should_receive(:fire).with(foo)
+#    foo.close
+#  end
+# 
+#  it 'should update the current state' do
+#    foo = Foo.new
+#    foo.close
+# 
+#    foo.aasm_current_state.should == :closed
+#  end
+# 
+#  it 'should attempt to persist if aasm_write_state is defined' do
+#    foo = Foo.new
+#    
+#    def foo.aasm_write_state
+#    end
+# 
+#    foo.should_receive(:aasm_write_state_without_persistence)
+# 
+#    foo.close
+#  end
+#end
+# 
+#describe AASM, '- persistence' do
+#  it 'should read the state if it has not been set and aasm_read_state is defined' do
+#    foo = Foo.new
+#    def foo.aasm_read_state
+#    end
+# 
+#    foo.should_receive(:aasm_read_state)
+# 
+#    foo.aasm_current_state
+#  end
+#end
+# 
+#describe AASM, '- getting events for a state' do
+#  it '#aasm_events_for_current_state should use current state' do
+#    foo = Foo.new
+#    foo.should_receive(:aasm_current_state)
+#    foo.aasm_events_for_current_state
+#  end
+# 
+#  it '#aasm_events_for_current_state should use aasm_events_for_state' do
+#    foo = Foo.new
+#    foo.stub!(:aasm_current_state).and_return(:foo)
+#    foo.should_receive(:aasm_events_for_state).with(:foo)
+#    foo.aasm_events_for_current_state
+#  end
+#end
+# 
+#describe AASM, '- event callbacks' do
+#  it 'should call aasm_event_fired if defined and successful for bang fire' do
+#    foo = Foo.new
+#    def foo.aasm_event_fired(from, to)
+#    end
+# 
+#    foo.should_receive(:aasm_event_fired)
+# 
+#    foo.close!
+#  end
+# 
+#    it 'should call aasm_event_fired if defined and successful for non-bang fire' do
+#    foo = Foo.new
+#    def foo.aasm_event_fired(from, to)
+#    end
+# 
+#    foo.should_receive(:aasm_event_fired)
+# 
+#    foo.close
+#  end
+# 
+#  it 'should call aasm_event_failed if defined and transition failed for bang fire' do
+#    foo = Foo.new
+#    def foo.aasm_event_failed(event)
+#    end
+# 
+#    foo.should_receive(:aasm_event_failed)
+# 
+#    foo.null!
+#  end
+# 
+#  it 'should call aasm_event_failed if defined and transition failed for non-bang fire' do
+#    foo = Foo.new
+#    def foo.aasm_event_failed(event)
+#    end
+# 
+#    foo.should_receive(:aasm_event_failed)
+# 
+#    foo.null
+#  end
+#end
+# 
+#describe AASM, '- state actions' do
+#  it "should call enter when entering state" do
+#    foo = Foo.new
+#    foo.should_receive(:enter)
+# 
+#    foo.close
+#  end
+# 
+#  it "should call exit when exiting state" do
+#    foo = Foo.new
+#    foo.should_receive(:exit)
+# 
+#    foo.close
+#  end
+#end
+# 
+# 
+class StateMachineInheritanceTest < ActiveModel::TestCase
+  test "should have the same states as it's parent" do
+    assert_equal StateMachineSubject.state_machine.states, StateMachineSubjectSubclass.state_machine.states
+  end
+ 
+  #test "should have the same events as it's parent" do
+  #  StateMachineSubjectSubclass.aasm_events.should == Bar.aasm_events
+  #end
+end
+# 
+# 
+#class ChetanPatil
+#  include AASM
+#  aasm_initial_state :sleeping
+#  aasm_state :sleeping
+#  aasm_state :showering
+#  aasm_state :working
+#  aasm_state :dating
+# 
+#  aasm_event :wakeup do
+#    transitions :from => :sleeping, :to => [:showering, :working]
+#  end
+# 
+#  aasm_event :dress do
+#    transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
+#    transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
+#  end
+# 
+#  def wear_clothes(shirt_color, trouser_type)
+#  end
+#end
+# 
+# 
+#describe ChetanPatil do
+#  it 'should transition to specified next state (sleeping to showering)' do
+#    cp = ChetanPatil.new
+#    cp.wakeup! :showering
+#    
+#    cp.aasm_current_state.should == :showering
+#  end
+# 
+#  it 'should transition to specified next state (sleeping to working)' do
+#    cp = ChetanPatil.new
+#    cp.wakeup! :working
+# 
+#    cp.aasm_current_state.should == :working
+#  end
+# 
+#  it 'should transition to default (first or showering) state' do
+#    cp = ChetanPatil.new
+#    cp.wakeup!
+# 
+#    cp.aasm_current_state.should == :showering
+#  end
+# 
+#  it 'should transition to default state when on_transition invoked' do
+#    cp = ChetanPatil.new
+#    cp.dress!(nil, 'purple', 'dressy')
+# 
+#    cp.aasm_current_state.should == :working
+#  end
+# 
+#  it 'should call on_transition method with args' do
+#    cp = ChetanPatil.new
+#    cp.wakeup! :showering
+# 
+#    cp.should_receive(:wear_clothes).with('blue', 'jeans')
+#    cp.dress! :working, 'blue', 'jeans'
+#  end
+# 
+#  it 'should call on_transition proc' do
+#    cp = ChetanPatil.new
+#    cp.wakeup! :showering
+# 
+#    cp.should_receive(:wear_clothes).with('purple', 'slacks')
+#    cp.dress!(:dating, 'purple', 'slacks')
+#  end
+#end
\ No newline at end of file
diff --git a/activemodel/test/test_helper.rb b/activemodel/test/test_helper.rb
index 8e608fa0bc..ccf93280ec 100644
--- a/activemodel/test/test_helper.rb
+++ b/activemodel/test/test_helper.rb
@@ -3,7 +3,8 @@ $:.unshift File.dirname(__FILE__)
 
 require 'test/unit'
 require 'active_model'
-require 'active_support/callbacks' # needed by ActiveSupport::TestCase
+require 'active_model/state_machine'
+require 'active_support/callbacks' # needed by ActiveModel::TestCase
 require 'active_support/test_case'
 
 def uses_gem(gem_name, test_name, version = '> 0')
@@ -21,3 +22,18 @@ unless defined? uses_mocha
     uses_gem('mocha', test_name, '>= 0.5.5', &block)
   end
 end
+
+begin
+  require 'rubygems'
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+end
+
+ActiveSupport::TestCase.send :include, ActiveSupport::Testing::Default
+
+module ActiveModel
+  class TestCase < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Default
+  end
+end
\ No newline at end of file
-- 
cgit v1.2.3


From 74cb05698684f237a7eb91afadec0020d8910c70 Mon Sep 17 00:00:00 2001
From: rick <technoweenie@gmail.com>
Date: Sat, 28 Jun 2008 09:19:44 -0700
Subject: add basic events and transitions.  still more tests to convert

---
 activemodel/test/state_machine/event_test.rb       |  51 +++++++
 activemodel/test/state_machine/machine_test.rb     |  13 ++
 activemodel/test/state_machine/state_test.rb       |   5 +-
 .../test/state_machine/state_transition_test.rb    |  88 +++++++++++
 activemodel/test/state_machine_test.rb             | 166 ++++++++++-----------
 5 files changed, 233 insertions(+), 90 deletions(-)
 create mode 100644 activemodel/test/state_machine/event_test.rb
 create mode 100644 activemodel/test/state_machine/state_transition_test.rb

(limited to 'activemodel/test')

diff --git a/activemodel/test/state_machine/event_test.rb b/activemodel/test/state_machine/event_test.rb
new file mode 100644
index 0000000000..01f3464cf2
--- /dev/null
+++ b/activemodel/test/state_machine/event_test.rb
@@ -0,0 +1,51 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+class EventTest < ActiveModel::TestCase
+  def setup
+    @name = :close_order
+    @success = :success_callback
+  end
+
+  def new_event
+    @event = ActiveModel::StateMachine::Event.new(@name, {:success => @success}) do
+      transitions :to => :closed, :from => [:open, :received]
+    end
+  end
+
+  test 'should set the name' do
+    assert_equal @name, new_event.name
+  end
+
+  test 'should set the success option' do
+    assert new_event.success?
+  end
+
+  uses_mocha 'StateTransition creation' do
+    test 'should create StateTransitions' do
+      ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :open)
+      ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :received)
+      new_event
+    end
+  end
+end
+
+class EventBeingFiredTest < ActiveModel::TestCase
+  test 'should raise an AASM::InvalidTransition error if the transitions are empty' do
+    event = ActiveModel::StateMachine::Event.new(:event)
+
+    assert_raises ActiveModel::StateMachine::InvalidTransition do
+      event.fire(nil)
+    end
+  end
+
+  test 'should return the state of the first matching transition it finds' do
+    event = ActiveModel::StateMachine::Event.new(:event) do
+      transitions :to => :closed, :from => [:open, :received]
+    end
+
+    obj = stub
+    obj.stubs(:current_state).returns(:open)
+
+    assert_equal :closed, event.fire(obj)
+  end
+end
diff --git a/activemodel/test/state_machine/machine_test.rb b/activemodel/test/state_machine/machine_test.rb
index 34a4b384ce..64dea42b1f 100644
--- a/activemodel/test/state_machine/machine_test.rb
+++ b/activemodel/test/state_machine/machine_test.rb
@@ -4,9 +4,18 @@ class MachineTestSubject
   include ActiveModel::StateMachine
 
   state_machine do
+    state :open
+    state :closed
   end
 
   state_machine :initial => :foo do
+    event :shutdown do
+      transitions :from => :open, :to => :closed
+    end
+
+    event :timeout do
+      transitions :from => :open, :to => :closed
+    end
   end
 
   state_machine :extra, :initial => :bar do
@@ -25,4 +34,8 @@ class StateMachineMachineTest < ActiveModel::TestCase
   test "accesses non-default state machine" do
     assert_kind_of ActiveModel::StateMachine::Machine, MachineTestSubject.state_machine(:extra)
   end
+
+  test "finds events for given state" do
+    assert_equal [:shutdown, :timeout], MachineTestSubject.state_machine.events_for(:open)
+  end
 end
\ No newline at end of file
diff --git a/activemodel/test/state_machine/state_test.rb b/activemodel/test/state_machine/state_test.rb
index 444435d271..22d0d9eb93 100644
--- a/activemodel/test/state_machine/state_test.rb
+++ b/activemodel/test/state_machine/state_test.rb
@@ -10,12 +10,12 @@ end
 class StateTest < ActiveModel::TestCase
   def setup
     @name    = :astate
-    @options = { :crazy_custom_key => 'key' }
     @machine = StateTestSubject.state_machine
+    @options = { :crazy_custom_key => 'key', :machine => @machine }
   end
 
   def new_state(options={})
-    ActiveModel::StateMachine::State.new(options.delete(:machine) || @machine, @name, @options.merge(options))
+    ActiveModel::StateMachine::State.new(@name, @options.merge(options))
   end
 
   test 'sets the name' do
@@ -31,6 +31,7 @@ class StateTest < ActiveModel::TestCase
   end
   
   test 'sets the options and expose them as options' do
+    @options.delete(:machine)
     assert_equal @options, new_state.options
   end
 
diff --git a/activemodel/test/state_machine/state_transition_test.rb b/activemodel/test/state_machine/state_transition_test.rb
new file mode 100644
index 0000000000..9a9e7f60c5
--- /dev/null
+++ b/activemodel/test/state_machine/state_transition_test.rb
@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+class StateTransitionTest < ActiveModel::TestCase
+  test 'should set from, to, and opts attr readers' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = ActiveModel::StateMachine::StateTransition.new(opts)
+
+    assert_equal opts[:from], st.from
+    assert_equal opts[:to],   st.to
+    assert_equal opts,        st.options
+  end
+
+  uses_mocha 'checking ActiveModel StateMachine transitions' do
+    test 'should pass equality check if from and to are the same' do
+      opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+      st = ActiveModel::StateMachine::StateTransition.new(opts)
+
+      obj = stub
+      obj.stubs(:from).returns(opts[:from])
+      obj.stubs(:to).returns(opts[:to])
+
+      assert_equal st, obj
+    end
+
+    test 'should fail equality check if from are not the same' do
+      opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+      st = ActiveModel::StateMachine::StateTransition.new(opts)
+
+      obj = stub
+      obj.stubs(:from).returns('blah')
+      obj.stubs(:to).returns(opts[:to])
+
+      assert_not_equal st, obj
+    end
+  
+    test 'should fail equality check if to are not the same' do
+      opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+      st = ActiveModel::StateMachine::StateTransition.new(opts)
+
+      obj = stub
+      obj.stubs(:from).returns(opts[:from])
+      obj.stubs(:to).returns('blah')
+
+      assert_not_equal st, obj
+    end
+  end
+end
+
+class StateTransitionGuardCheckTest < ActiveModel::TestCase
+  test 'should return true of there is no guard' do
+    opts = {:from => 'foo', :to => 'bar'}
+      st = ActiveModel::StateMachine::StateTransition.new(opts)
+
+    assert st.perform(nil)
+  end
+
+  uses_mocha 'checking ActiveModel StateMachine transition guard checks' do
+    test 'should call the method on the object if guard is a symbol' do
+      opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
+      st = ActiveModel::StateMachine::StateTransition.new(opts)
+    
+      obj = stub
+      obj.expects(:test_guard)
+      
+      st.perform(obj)
+    end
+    
+    test 'should call the method on the object if guard is a string' do
+      opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
+      st = ActiveModel::StateMachine::StateTransition.new(opts)
+    
+      obj = stub
+      obj.expects(:test_guard)
+      
+      st.perform(obj)
+    end
+    
+    test 'should call the proc passing the object if the guard is a proc' do
+      opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
+      st = ActiveModel::StateMachine::StateTransition.new(opts)
+    
+      obj = stub
+      obj.expects(:test_guard)
+    
+      st.perform(obj)
+    end
+  end
+end
diff --git a/activemodel/test/state_machine_test.rb b/activemodel/test/state_machine_test.rb
index e906744c77..963ce84248 100644
--- a/activemodel/test/state_machine_test.rb
+++ b/activemodel/test/state_machine_test.rb
@@ -7,22 +7,22 @@ class StateMachineSubject
     state :open,   :exit => :exit
     state :closed, :enter => :enter
     
-    #event :close, :success => :success_callback do
-    #  transitions :to => :closed, :from => [:open]
-    #end
-    #
-    #event :null do
-    #  transitions :to => :closed, :from => [:open], :guard => :always_false
-    #end
+    event :close, :success => :success_callback do
+      transitions :to => :closed, :from => [:open]
+    end
+
+    event :null do
+      transitions :to => :closed, :from => [:open], :guard => :always_false
+    end
   end
 
   state_machine :bar do
     state :read
     state :ended
 
-    #event :foo do
-    #  transitions :to => :ended, :from => [:read]
-    #end
+    event :foo do
+      transitions :to => :ended, :from => [:read]
+    end
   end
 
   def always_false
@@ -80,9 +80,13 @@ class StateMachineInstanceLevelTest < ActiveModel::TestCase
     assert @foo.respond_to?(:open?)
   end
  
-  #test 'should define an event! inance method' do
-  #  assert @foo.respond_to?(:close!)
-  #end
+  test 'defines an event! instance method' do
+    assert @foo.respond_to?(:close!)
+  end
+ 
+  test 'defines an event instance method' do
+    assert @foo.respond_to?(:close)
+  end
 end
  
 class StateMachineInitialStatesTest < ActiveModel::TestCase
@@ -90,19 +94,19 @@ class StateMachineInitialStatesTest < ActiveModel::TestCase
     @foo = StateMachineSubject.new
   end
  
-  test 'should set the initial state' do
+  test 'sets the initial state' do
     assert_equal :open, @foo.current_state
   end
  
-  #test '#open? should be initially true' do
-  #  @foo.open?.should be_true
-  #end
-  #
-  #test '#closed? should be initially false' do
-  #  @foo.closed?.should be_false
-  #end
+  test '#open? should be initially true' do
+    assert @foo.open?
+  end
+  
+  test '#closed? should be initially false' do
+    assert !@foo.closed?
+  end
  
-  test 'should use the first state defined if no initial state is given' do
+  test 'uses the first state defined if no initial state is given' do
     assert_equal :read, @foo.current_state(:bar)
   end
 end
@@ -141,34 +145,36 @@ end
 #    foo.close!
 #  end
 #end
-# 
-#describe AASM, '- event firing without persistence' do
-#  it 'should fire the Event' do
-#    foo = Foo.new
-# 
-#    Foo.aasm_events[:close].should_receive(:fire).with(foo)
-#    foo.close
-#  end
-# 
-#  it 'should update the current state' do
-#    foo = Foo.new
-#    foo.close
-# 
-#    foo.aasm_current_state.should == :closed
-#  end
-# 
-#  it 'should attempt to persist if aasm_write_state is defined' do
-#    foo = Foo.new
-#    
-#    def foo.aasm_write_state
-#    end
-# 
-#    foo.should_receive(:aasm_write_state_without_persistence)
-# 
-#    foo.close
-#  end
-#end
-# 
+
+class StateMachineEventFiringWithoutPersistence < ActiveModel::TestCase
+  test 'updates the current state' do
+    subj = StateMachineSubject.new
+    assert_equal :open, subj.current_state
+    subj.close
+    assert_equal :closed, subj.current_state
+  end
+
+  uses_mocha 'StateMachineEventFiringWithoutPersistence' do
+    test 'fires the Event' do
+      subj = StateMachineSubject.new
+
+      StateMachineSubject.state_machine.events[:close].expects(:fire).with(subj)
+      subj.close
+    end
+
+    test 'should attempt to persist if aasm_write_state is defined' do
+      subj = StateMachineSubject.new
+
+      def subj.aasm_write_state
+      end
+
+      subj.expects(:aasm_write_state_without_persistence)
+
+      subj.close
+    end
+  end
+end
+ 
 #describe AASM, '- persistence' do
 #  it 'should read the state if it has not been set and aasm_read_state is defined' do
 #    foo = Foo.new
@@ -180,22 +186,7 @@ end
 #    foo.aasm_current_state
 #  end
 #end
-# 
-#describe AASM, '- getting events for a state' do
-#  it '#aasm_events_for_current_state should use current state' do
-#    foo = Foo.new
-#    foo.should_receive(:aasm_current_state)
-#    foo.aasm_events_for_current_state
-#  end
-# 
-#  it '#aasm_events_for_current_state should use aasm_events_for_state' do
-#    foo = Foo.new
-#    foo.stub!(:aasm_current_state).and_return(:foo)
-#    foo.should_receive(:aasm_events_for_state).with(:foo)
-#    foo.aasm_events_for_current_state
-#  end
-#end
-# 
+ 
 #describe AASM, '- event callbacks' do
 #  it 'should call aasm_event_fired if defined and successful for bang fire' do
 #    foo = Foo.new
@@ -237,32 +228,31 @@ end
 #    foo.null
 #  end
 #end
-# 
-#describe AASM, '- state actions' do
-#  it "should call enter when entering state" do
-#    foo = Foo.new
-#    foo.should_receive(:enter)
-# 
-#    foo.close
-#  end
-# 
-#  it "should call exit when exiting state" do
-#    foo = Foo.new
-#    foo.should_receive(:exit)
-# 
-#    foo.close
-#  end
-#end
-# 
-# 
+
+uses_mocha 'StateMachineStateActionsTest' do
+  class StateMachineStateActionsTest < ActiveModel::TestCase
+    test "calls enter when entering state" do
+      subj = StateMachineSubject.new
+      subj.expects(:enter)
+      subj.close
+    end
+
+    test "calls exit when exiting state" do
+      subj = StateMachineSubject.new
+      subj.expects(:exit)
+      subj.close
+    end
+  end
+end
+
 class StateMachineInheritanceTest < ActiveModel::TestCase
-  test "should have the same states as it's parent" do
+  test "has the same states as its parent" do
     assert_equal StateMachineSubject.state_machine.states, StateMachineSubjectSubclass.state_machine.states
   end
  
-  #test "should have the same events as it's parent" do
-  #  StateMachineSubjectSubclass.aasm_events.should == Bar.aasm_events
-  #end
+  test "has the same events as its parent" do
+    assert_equal StateMachineSubject.state_machine.events, StateMachineSubjectSubclass.state_machine.events
+  end
 end
 # 
 # 
-- 
cgit v1.2.3


From a9d9ca16c739ec39a192d29c62f760e51040fc6e Mon Sep 17 00:00:00 2001
From: rick <technoweenie@gmail.com>
Date: Sat, 28 Jun 2008 11:01:40 -0700
Subject: converted tests for more complex state transitions

---
 activemodel/test/state_machine/event_test.rb   |   6 +-
 activemodel/test/state_machine/machine_test.rb |   4 +-
 activemodel/test/state_machine_test.rb         | 222 ++++++++++++-------------
 3 files changed, 117 insertions(+), 115 deletions(-)

(limited to 'activemodel/test')

diff --git a/activemodel/test/state_machine/event_test.rb b/activemodel/test/state_machine/event_test.rb
index 01f3464cf2..7db4f8d887 100644
--- a/activemodel/test/state_machine/event_test.rb
+++ b/activemodel/test/state_machine/event_test.rb
@@ -7,7 +7,7 @@ class EventTest < ActiveModel::TestCase
   end
 
   def new_event
-    @event = ActiveModel::StateMachine::Event.new(@name, {:success => @success}) do
+    @event = ActiveModel::StateMachine::Event.new(nil, @name, {:success => @success}) do
       transitions :to => :closed, :from => [:open, :received]
     end
   end
@@ -31,7 +31,7 @@ end
 
 class EventBeingFiredTest < ActiveModel::TestCase
   test 'should raise an AASM::InvalidTransition error if the transitions are empty' do
-    event = ActiveModel::StateMachine::Event.new(:event)
+    event = ActiveModel::StateMachine::Event.new(nil, :event)
 
     assert_raises ActiveModel::StateMachine::InvalidTransition do
       event.fire(nil)
@@ -39,7 +39,7 @@ class EventBeingFiredTest < ActiveModel::TestCase
   end
 
   test 'should return the state of the first matching transition it finds' do
-    event = ActiveModel::StateMachine::Event.new(:event) do
+    event = ActiveModel::StateMachine::Event.new(nil, :event) do
       transitions :to => :closed, :from => [:open, :received]
     end
 
diff --git a/activemodel/test/state_machine/machine_test.rb b/activemodel/test/state_machine/machine_test.rb
index 64dea42b1f..2cdfcd9554 100644
--- a/activemodel/test/state_machine/machine_test.rb
+++ b/activemodel/test/state_machine/machine_test.rb
@@ -36,6 +36,8 @@ class StateMachineMachineTest < ActiveModel::TestCase
   end
 
   test "finds events for given state" do
-    assert_equal [:shutdown, :timeout], MachineTestSubject.state_machine.events_for(:open)
+    events = MachineTestSubject.state_machine.events_for(:open)
+    assert events.include?(:shutdown)
+    assert events.include?(:timeout)
   end
 end
\ No newline at end of file
diff --git a/activemodel/test/state_machine_test.rb b/activemodel/test/state_machine_test.rb
index 963ce84248..2f08b522d9 100644
--- a/activemodel/test/state_machine_test.rb
+++ b/activemodel/test/state_machine_test.rb
@@ -186,48 +186,50 @@ end
 #    foo.aasm_current_state
 #  end
 #end
- 
-#describe AASM, '- event callbacks' do
-#  it 'should call aasm_event_fired if defined and successful for bang fire' do
-#    foo = Foo.new
-#    def foo.aasm_event_fired(from, to)
-#    end
-# 
-#    foo.should_receive(:aasm_event_fired)
-# 
-#    foo.close!
-#  end
-# 
-#    it 'should call aasm_event_fired if defined and successful for non-bang fire' do
-#    foo = Foo.new
-#    def foo.aasm_event_fired(from, to)
-#    end
-# 
-#    foo.should_receive(:aasm_event_fired)
-# 
-#    foo.close
-#  end
-# 
-#  it 'should call aasm_event_failed if defined and transition failed for bang fire' do
-#    foo = Foo.new
-#    def foo.aasm_event_failed(event)
-#    end
-# 
-#    foo.should_receive(:aasm_event_failed)
-# 
-#    foo.null!
-#  end
-# 
-#  it 'should call aasm_event_failed if defined and transition failed for non-bang fire' do
-#    foo = Foo.new
-#    def foo.aasm_event_failed(event)
-#    end
-# 
-#    foo.should_receive(:aasm_event_failed)
-# 
-#    foo.null
-#  end
-#end
+
+uses_mocha 'StateMachineEventCallbacksTest' do
+  class StateMachineEventCallbacksTest < ActiveModel::TestCase
+    test 'should call aasm_event_fired if defined and successful for bang fire' do
+      subj = StateMachineSubject.new
+      def subj.aasm_event_fired(from, to)
+      end
+
+      subj.expects(:event_fired)
+
+      subj.close!
+    end
+
+    test 'should call aasm_event_fired if defined and successful for non-bang fire' do
+      subj = StateMachineSubject.new
+      def subj.aasm_event_fired(from, to)
+      end
+
+      subj.expects(:event_fired)
+
+      subj.close
+    end
+
+    test 'should call aasm_event_failed if defined and transition failed for bang fire' do
+      subj = StateMachineSubject.new
+      def subj.event_failed(event)
+      end
+
+      subj.expects(:event_failed)
+
+      subj.null!
+    end
+
+    test 'should call aasm_event_failed if defined and transition failed for non-bang fire' do
+      subj = StateMachineSubject.new
+      def subj.aasm_event_failed(event)
+      end
+
+      subj.expects(:event_failed)
+
+      subj.null
+    end
+  end
+end
 
 uses_mocha 'StateMachineStateActionsTest' do
   class StateMachineStateActionsTest < ActiveModel::TestCase
@@ -254,72 +256,70 @@ class StateMachineInheritanceTest < ActiveModel::TestCase
     assert_equal StateMachineSubject.state_machine.events, StateMachineSubjectSubclass.state_machine.events
   end
 end
-# 
-# 
-#class ChetanPatil
-#  include AASM
-#  aasm_initial_state :sleeping
-#  aasm_state :sleeping
-#  aasm_state :showering
-#  aasm_state :working
-#  aasm_state :dating
-# 
-#  aasm_event :wakeup do
-#    transitions :from => :sleeping, :to => [:showering, :working]
-#  end
-# 
-#  aasm_event :dress do
-#    transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
-#    transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
-#  end
-# 
-#  def wear_clothes(shirt_color, trouser_type)
-#  end
-#end
-# 
-# 
-#describe ChetanPatil do
-#  it 'should transition to specified next state (sleeping to showering)' do
-#    cp = ChetanPatil.new
-#    cp.wakeup! :showering
-#    
-#    cp.aasm_current_state.should == :showering
-#  end
-# 
-#  it 'should transition to specified next state (sleeping to working)' do
-#    cp = ChetanPatil.new
-#    cp.wakeup! :working
-# 
-#    cp.aasm_current_state.should == :working
-#  end
-# 
-#  it 'should transition to default (first or showering) state' do
-#    cp = ChetanPatil.new
-#    cp.wakeup!
-# 
-#    cp.aasm_current_state.should == :showering
-#  end
-# 
-#  it 'should transition to default state when on_transition invoked' do
-#    cp = ChetanPatil.new
-#    cp.dress!(nil, 'purple', 'dressy')
-# 
-#    cp.aasm_current_state.should == :working
-#  end
-# 
-#  it 'should call on_transition method with args' do
-#    cp = ChetanPatil.new
-#    cp.wakeup! :showering
-# 
-#    cp.should_receive(:wear_clothes).with('blue', 'jeans')
-#    cp.dress! :working, 'blue', 'jeans'
-#  end
-# 
-#  it 'should call on_transition proc' do
-#    cp = ChetanPatil.new
-#    cp.wakeup! :showering
-# 
-#    cp.should_receive(:wear_clothes).with('purple', 'slacks')
-#    cp.dress!(:dating, 'purple', 'slacks')
-#  end
-#end
\ No newline at end of file
+
+class StateMachineSubject
+  state_machine :chetan_patil, :initial => :sleeping do
+    state :sleeping
+    state :showering
+    state :working
+    state :dating
+ 
+    event :wakeup do
+      transitions :from => :sleeping, :to => [:showering, :working]
+    end
+ 
+    event :dress do
+      transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
+      transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
+    end
+  end
+ 
+  def wear_clothes(shirt_color, trouser_type)
+  end
+end
+
+class StateMachineWithComplexTransitionsTest < ActiveModel::TestCase
+  def setup
+    @subj = StateMachineSubject.new
+  end
+
+  test 'transitions to specified next state (sleeping to showering)' do
+    @subj.wakeup! :showering
+    
+    assert_equal :showering, @subj.current_state(:chetan_patil)
+  end
+ 
+  test 'transitions to specified next state (sleeping to working)' do
+    @subj.wakeup! :working
+ 
+    assert_equal :working, @subj.current_state(:chetan_patil)
+  end
+ 
+  test 'transitions to default (first or showering) state' do
+    @subj.wakeup!
+ 
+    assert_equal :showering, @subj.current_state(:chetan_patil)
+  end
+ 
+  test 'transitions to default state when on_transition invoked' do
+    @subj.dress!(nil, 'purple', 'dressy')
+ 
+    assert_equal :working, @subj.current_state(:chetan_patil)
+  end
+
+  uses_mocha "StateMachineWithComplexTransitionsTest on_transition tests" do
+    test 'calls on_transition method with args' do
+      @subj.wakeup! :showering
+ 
+      @subj.expects(:wear_clothes).with('blue', 'jeans')
+      @subj.dress! :working, 'blue', 'jeans'
+    end
+ 
+    test 'calls on_transition proc' do
+      @subj.wakeup! :showering
+ 
+      @subj.expects(:wear_clothes).with('purple', 'slacks')
+      @subj.dress!(:dating, 'purple', 'slacks')
+    end
+  end
+end
\ No newline at end of file
-- 
cgit v1.2.3


From c9e366e997c6f3a383cfaa6351fa847e92de7fe4 Mon Sep 17 00:00:00 2001
From: rick <technoweenie@gmail.com>
Date: Sat, 28 Jun 2008 11:33:50 -0700
Subject: all aasm tests without activerecord moved over and passing

---
 activemodel/test/state_machine/event_test.rb |  2 +-
 activemodel/test/state_machine_test.rb       | 99 ++++++++++++++--------------
 2 files changed, 50 insertions(+), 51 deletions(-)

(limited to 'activemodel/test')

diff --git a/activemodel/test/state_machine/event_test.rb b/activemodel/test/state_machine/event_test.rb
index 7db4f8d887..40b630da7c 100644
--- a/activemodel/test/state_machine/event_test.rb
+++ b/activemodel/test/state_machine/event_test.rb
@@ -17,7 +17,7 @@ class EventTest < ActiveModel::TestCase
   end
 
   test 'should set the success option' do
-    assert new_event.success?
+    assert_equal @success, new_event.success
   end
 
   uses_mocha 'StateTransition creation' do
diff --git a/activemodel/test/state_machine_test.rb b/activemodel/test/state_machine_test.rb
index 2f08b522d9..b2f0fc4ec0 100644
--- a/activemodel/test/state_machine_test.rb
+++ b/activemodel/test/state_machine_test.rb
@@ -110,41 +110,38 @@ class StateMachineInitialStatesTest < ActiveModel::TestCase
     assert_equal :read, @foo.current_state(:bar)
   end
 end
-# 
-#describe AASM, '- event firing with persistence' do
-#  it 'should fire the Event' do
-#    foo = Foo.new
-# 
-#    Foo.aasm_events[:close].should_receive(:fire).with(foo)
-#    foo.close!
-#  end
-# 
-#  it 'should update the current state' do
-#    foo = Foo.new
-#    foo.close!
-# 
-#    foo.aasm_current_state.should == :closed
-#  end
-# 
-#  it 'should call the success callback if one was provided' do
-#    foo = Foo.new
-# 
-#    foo.should_receive(:success_callback)
-# 
-#    foo.close!
-#  end
-# 
-#  it 'should attempt to persist if aasm_write_state is defined' do
-#    foo = Foo.new
-#    
-#    def foo.aasm_write_state
-#    end
-# 
-#    foo.should_receive(:aasm_write_state)
-# 
-#    foo.close!
-#  end
-#end
+ 
+class StateMachineEventFiringWithPersistenceTest < ActiveModel::TestCase
+  def setup
+    @subj = StateMachineSubject.new
+  end
+
+  test 'updates the current state' do
+    @subj.close!
+
+    assert_equal :closed, @subj.current_state
+  end
+
+  uses_mocha "StateMachineEventFiringWithPersistenceTest with callbacks" do
+    test 'fires the Event' do
+      @subj.class.state_machine.events[:close].expects(:fire).with(@subj)
+      @subj.close!
+    end
+
+    test 'calls the success callback if one was provided' do
+      @subj.expects(:success_callback)
+      @subj.close!
+    end
+
+    test 'attempts to persist if write_state is defined' do
+      def @subj.write_state
+      end
+
+      @subj.expects(:write_state)
+      @subj.close!
+    end
+  end
+end
 
 class StateMachineEventFiringWithoutPersistence < ActiveModel::TestCase
   test 'updates the current state' do
@@ -162,30 +159,32 @@ class StateMachineEventFiringWithoutPersistence < ActiveModel::TestCase
       subj.close
     end
 
-    test 'should attempt to persist if aasm_write_state is defined' do
+    test 'attempts to persist if write_state is defined' do
       subj = StateMachineSubject.new
 
-      def subj.aasm_write_state
+      def subj.write_state
       end
 
-      subj.expects(:aasm_write_state_without_persistence)
+      subj.expects(:write_state_without_persistence)
 
       subj.close
     end
   end
 end
- 
-#describe AASM, '- persistence' do
-#  it 'should read the state if it has not been set and aasm_read_state is defined' do
-#    foo = Foo.new
-#    def foo.aasm_read_state
-#    end
-# 
-#    foo.should_receive(:aasm_read_state)
-# 
-#    foo.aasm_current_state
-#  end
-#end
+
+uses_mocha 'StateMachinePersistenceTest' do
+  class StateMachinePersistenceTest < ActiveModel::TestCase
+    test 'reads the state if it has not been set and read_state is defined' do
+      subj = StateMachineSubject.new
+      def subj.read_state
+      end
+
+      subj.expects(:read_state).with(StateMachineSubject.state_machine)
+
+      subj.current_state
+    end
+  end
+end
 
 uses_mocha 'StateMachineEventCallbacksTest' do
   class StateMachineEventCallbacksTest < ActiveModel::TestCase
-- 
cgit v1.2.3