Updated to svn tags/tracks-1.6

vendor/plugins/acts_as_state_machine/test/acts_as_state_machine_test.rb

@@ -0,0 +1,224 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+include ScottBarron::Acts::StateMachine
+
+class ActsAsStateMachineTest < Test::Unit::TestCase
+  fixtures :conversations
+  
+  def test_no_initial_value_raises_exception
+    assert_raise(NoInitialState) {
+      Person.acts_as_state_machine({})
+    }
+  end
+  
+  def test_initial_state_value
+    assert_equal :needs_attention, Conversation.initial_state
+  end
+  
+  def test_column_was_set
+    assert_equal 'state_machine', Conversation.state_column
+  end
+  
+  def test_initial_state
+    c = Conversation.create
+    assert_equal :needs_attention, c.current_state
+    assert c.needs_attention?
+  end
+  
+  def test_states_were_set
+    [:needs_attention, :read, :closed, :awaiting_response, :junk].each do |s|
+      assert Conversation.states.include?(s)
+    end
+  end
+  
+  def test_event_methods_created
+    c = Conversation.create
+    %w(new_message! view! reply! close! junk! unjunk!).each do |event|
+      assert c.respond_to?(event)
+    end
+  end
+
+  def test_query_methods_created
+    c = Conversation.create
+    %w(needs_attention? read? closed? awaiting_response? junk?).each do |event|
+      assert c.respond_to?(event)
+    end
+  end
+  
+  def test_transition_table
+    tt = Conversation.transition_table
+    
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :read, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :closed, :to => :needs_attention))
+    assert tt[:new_message].include?(SupportingClasses::StateTransition.new(:from => :awaiting_response, :to => :needs_attention))
+  end
+
+  def test_next_state_for_event
+    c = Conversation.create
+    assert_equal :read, c.next_state_for_event(:view)
+  end
+  
+  def test_change_state
+    c = Conversation.create
+    c.view!
+    assert c.read?
+  end
+  
+  def test_can_go_from_read_to_closed_because_guard_passes
+    c = Conversation.create
+    c.can_close = true
+    c.view!
+    c.reply!
+    c.close!
+    assert_equal :closed, c.current_state
+  end
+  
+  def test_cannot_go_from_read_to_closed_because_of_guard
+    c = Conversation.create
+    c.can_close = false
+    c.view!
+    c.reply!
+    c.close!
+    assert_equal :read, c.current_state
+  end
+
+  def test_ignore_invalid_events
+    c = Conversation.create
+    c.view!
+    c.junk!
+
+    # This is the invalid event
+    c.new_message!
+    assert_equal :junk, c.current_state
+  end
+
+  def test_entry_action_executed
+    c = Conversation.create
+    c.read_enter = false
+    c.view!
+    assert c.read_enter
+  end
+
+  def test_after_actions_executed
+    c = Conversation.create
+
+    c.read_after_first = false
+    c.read_after_second = false
+    c.closed_after = false
+
+    c.view!
+    assert c.read_after_first
+    assert c.read_after_second
+
+    c.can_close = true
+    c.close!
+
+    assert c.closed_after
+    assert_equal :closed, c.current_state
+  end
+
+  def test_after_actions_not_run_on_loopback_transition
+    c = Conversation.create
+
+    c.view!
+    c.read_after_first = false
+    c.read_after_second = false
+    c.view!
+
+    assert !c.read_after_first
+    assert !c.read_after_second
+
+    c.can_close = true
+
+    c.close!
+    c.closed_after = false
+    c.close!
+
+    assert !c.closed_after
+  end
+
+  def test_exit_action_executed
+    c = Conversation.create
+    c.read_exit = false
+    c.view!
+    c.junk!
+    assert c.read_exit
+  end
+  
+  def test_entry_and_exit_not_run_on_loopback_transition
+    c = Conversation.create
+    c.view!
+    c.read_enter = false
+    c.read_exit  = false
+    c.view!
+    assert !c.read_enter
+    assert !c.read_exit
+  end
+
+  def test_entry_and_after_actions_called_for_initial_state
+    c = Conversation.create
+    assert c.needs_attention_enter
+    assert c.needs_attention_after
+  end
+  
+  def test_run_transition_action_is_private
+    c = Conversation.create
+    assert_raise(NoMethodError) { c.run_transition_action :foo }
+  end
+  
+  def test_find_all_in_state
+    cs = Conversation.find_in_state(:all, :read)
+    
+    assert_equal 2, cs.size
+  end
+  
+  def test_find_first_in_state
+    c = Conversation.find_in_state(:first, :read)
+    
+    assert_equal conversations(:first).id, c.id
+  end
+  
+  def test_find_all_in_state_with_conditions
+    cs = Conversation.find_in_state(:all, :read, :conditions => ['subject = ?', conversations(:second).subject])
+    
+    assert_equal 1, cs.size
+    assert_equal conversations(:second).id, cs.first.id
+  end
+  
+  def test_find_first_in_state_with_conditions
+    c = Conversation.find_in_state(:first, :read, :conditions => ['subject = ?', conversations(:second).subject])
+    assert_equal conversations(:second).id, c.id
+  end
+  
+  def test_count_in_state
+    cnt0 = Conversation.count(['state_machine = ?', 'read'])
+    cnt  = Conversation.count_in_state(:read)
+    
+    assert_equal cnt0, cnt
+  end
+  
+  def test_count_in_state_with_conditions
+    cnt0 = Conversation.count(['state_machine = ? AND subject = ?', 'read', 'Foo'])
+    cnt  = Conversation.count_in_state(:read, ['subject = ?', 'Foo'])
+    
+    assert_equal cnt0, cnt
+  end
+  
+  def test_find_in_invalid_state_raises_exception
+    assert_raise(InvalidState) {
+      Conversation.find_in_state(:all, :dead)
+    }
+  end
+  
+  def test_count_in_invalid_state_raises_exception
+    assert_raise(InvalidState) {
+      Conversation.count_in_state(:dead)
+    }
+  end
+
+  def test_can_access_events_via_event_table
+    event = Conversation.event_table[:junk]
+    assert_equal :junk, event.name
+    assert_equal "finished", event.opts[:note]
+  end
+end

vendor/plugins/acts_as_state_machine/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: state_machine.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: state_machine.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: state_machine_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: state_machine_test

vendor/plugins/acts_as_state_machine/test/fixtures/conversation.rb

@@ -0,0 +1,67 @@
+class Conversation < ActiveRecord::Base
+  attr_writer :can_close
+  attr_accessor :read_enter, :read_exit, :read_after_first, :read_after_second,
+                :closed_after, :needs_attention_enter, :needs_attention_after
+
+  acts_as_state_machine :initial => :needs_attention, :column => 'state_machine'
+
+  state :needs_attention, :enter => Proc.new { |o| o.needs_attention_enter = true },
+                          :after => Proc.new { |o| o.needs_attention_after = true }
+                          
+  state :read, :enter => :read_enter_action,
+               :exit  => Proc.new { |o| o.read_exit  = true },
+               :after => [:read_after_first_action, :read_after_second_action]
+
+  state :closed, :after => :closed_after_action
+  state :awaiting_response
+  state :junk
+
+  event :new_message do
+    transitions :to => :needs_attention,   :from => [:read, :closed, :awaiting_response]
+  end
+
+  event :view do
+    transitions :to => :read,              :from => [:needs_attention, :read]
+  end
+  
+  event :reply do
+    transitions :to => :awaiting_response, :from => [:read, :closed]
+  end
+
+  event :close do
+    transitions :to => :closed,            :from => [:read, :awaiting_response], :guard => Proc.new {|o| o.can_close?}
+    transitions :to => :read,              :from => [:read, :awaiting_response], :guard => :always_true
+  end
+
+  event :junk, :note => "finished" do
+    transitions :to => :junk,              :from => [:read, :closed, :awaiting_response]
+  end
+
+  event :unjunk do
+    transitions :to => :closed,            :from => :junk
+  end
+
+  def can_close?
+    @can_close
+  end
+
+  def read_enter_action
+    self.read_enter = true
+  end
+
+  def always_true
+    true
+  end
+
+  def read_after_first_action
+    self.read_after_first = true
+  end
+
+  def read_after_second_action
+    self.read_after_second = true
+  end
+
+  def closed_after_action
+    self.closed_after = true
+  end
+end

vendor/plugins/acts_as_state_machine/test/fixtures/conversations.yml

@@ -0,0 +1,11 @@
+first:
+  id: 1
+  state_machine: read
+  subject: This is a test
+  closed: false
+  
+second:
+  id: 2
+  state_machine: read
+  subject: Foo
+  closed: false

vendor/plugins/acts_as_state_machine/test/fixtures/person.rb

@@ -0,0 +1,2 @@
+class Person < ActiveRecord::Base
+end

vendor/plugins/acts_as_state_machine/test/schema.rb

@@ -0,0 +1,11 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :conversations, :force => true do |t|
+    t.column :state_machine, :string
+    t.column :subject,       :string
+    t.column :closed,        :boolean
+  end
+  
+  create_table :people, :force => true do |t|
+    t.column :name, :string
+  end
+end

vendor/plugins/acts_as_state_machine/test/test_helper.rb

@@ -0,0 +1,38 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+RAILS_ROOT = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_support/binding_of_caller'
+require 'active_support/breakpoint'
+require "#{File.dirname(__FILE__)}/../init"
+
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite'])
+
+load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
+
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+
+class Test::Unit::TestCase #:nodoc:
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+    end
+  end
+
+  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
+  self.use_transactional_fixtures = true
+  
+  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+end