state_machine 0.8.0 → 0.8.1

data/test/unit/integrations/sequel_test.rb

@@ -18,14 +18,16 @@ begin
       
       protected
         # Creates a new Sequel model (and the associated table)
-        def new_model(auto_migrate = true, &block)
-          DB.create_table! :foo do
+        def new_model(create_table = :foo, &block)
+          table_name = create_table || :foo
+          
+          DB.create_table!(table_name) do
             primary_key :id
             column :state, :string
-          end if auto_migrate
-          model = Class.new(Sequel::Model(:foo)) do
+          end if create_table
+          model = Class.new(Sequel::Model(table_name)) do
             self.raise_on_save_failure = false
-            def self.name; 'SequelTest::Foo'; end
+            def self.name; "SequelTest::#{table_name.to_s.capitalize}"; end
           end
           model.plugin(:validation_class_methods) if model.respond_to?(:plugin)
           model.plugin(:hook_class_methods) if model.respond_to?(:plugin)
@@ -42,146 +44,52 @@ begin
       def test_should_not_match_if_class_does_not_inherit_from_sequel
         assert !StateMachine::Integrations::Sequel.matches?(Class.new)
       end
+      
+      def test_should_have_defaults
+        assert_equal e = {:action => :save}, StateMachine::Integrations::Sequel.defaults
+      end
     end
     
-    class MachineByDefaultTest < BaseTestCase
+    class MachineWithoutDatabaseTest < BaseTestCase
       def setup
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model)
+        @model = new_model(false)
       end
       
-      def test_should_use_save_as_action
-        assert_equal :save, @machine.action
+      def test_should_allow_machine_creation
+        assert_nothing_raised { StateMachine::Machine.new(@model) }
+      end
+    end
+    
+    class MachineUnmigratedTest < BaseTestCase
+      def setup
+        @model = new_model(false)
       end
       
-      def test_should_use_transactions
-        assert_equal true, @machine.use_transactions
+      def test_should_allow_machine_creation
+        assert_nothing_raised { StateMachine::Machine.new(@model) }
       end
     end
     
-    class MachineTest < BaseTestCase
+    class MachineByDefaultTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
-        @machine.state :parked, :first_gear
-        @machine.state :idling, :value => lambda {'idling'}
-      end
-      
-      def test_should_create_singular_with_scope
-        assert @model.respond_to?(:with_state)
-      end
-      
-      def test_should_only_include_records_with_state_in_singular_with_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [parked], @model.with_state(:parked).all
-      end
-      
-      def test_should_create_plural_with_scope
-        assert @model.respond_to?(:with_states)
-      end
-      
-      def test_should_only_include_records_with_states_in_plural_with_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [parked, idling], @model.with_states(:parked, :idling).all
-      end
-      
-      def test_should_create_singular_without_scope
-        assert @model.respond_to?(:without_state)
-      end
-      
-      def test_should_only_include_records_without_state_in_singular_without_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [parked], @model.without_state(:idling).all
-      end
-      
-      def test_should_create_plural_without_scope
-        assert @model.respond_to?(:without_states)
-      end
-      
-      def test_should_only_include_records_without_states_in_plural_without_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        first_gear = @model.create :state => 'first_gear'
-        
-        assert_equal [parked, idling], @model.without_states(:first_gear).all
-      end
-      
-      def test_should_allow_chaining_scopes_and_fitlers
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [idling], @model.without_state(:parked).filter(:state => 'idling').all
-      end
-      
-      def test_should_rollback_transaction_if_false
-        @machine.within_transaction(@model.new) do
-          @model.create
-          false
-        end
-        
-        assert_equal 0, @model.count
       end
       
-      def test_should_not_rollback_transaction_if_true
-        @machine.within_transaction(@model.new) do
-          @model.create
-          true
-        end
-        
-        assert_equal 1, @model.count
-      end
-      
-      def test_should_invalidate_using_errors
-        record = @model.new
-        record.state = 'parked'
-        
-        @machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
-        
-        assert_equal ['cannot transition via "park"'], record.errors.on(:state)
-      end
-      
-      def test_should_auto_prefix_custom_attributes_on_invalidation
-        record = @model.new
-        @machine.invalidate(record, :event, :invalid)
-        
-        assert_equal ['is invalid'], record.errors.on(:state_event)
-      end
-      
-      def test_should_clear_errors_on_reset
-        record = @model.new
-        record.state = 'parked'
-        record.errors.add(:state, 'is invalid')
-        
-        @machine.reset(record)
-        assert_nil record.errors.on(:id)
+      def test_should_use_save_as_action
+        assert_equal :save, @machine.action
       end
       
-      def test_should_not_override_the_column_reader
-        record = @model.new
-        record[:state] = 'parked'
-        assert_equal 'parked', record.state
+      def test_should_use_transactions
+        assert_equal true, @machine.use_transactions
       end
       
-      def test_should_not_override_the_column_writer
-        record = @model.new
-        record.state = 'parked'
-        assert_equal 'parked', record[:state]
-      end
-    end
-    
-    class MachineUnmigratedTest < BaseTestCase
-      def setup
-        @model = new_model(false)
+      def test_should_not_have_any_before_callbacks
+        assert_equal 0, @machine.callbacks[:before].size
       end
       
-      def test_should_allow_machine_creation
-        assert_nothing_raised { StateMachine::Machine.new(@model) }
+      def test_should_not_have_any_after_callbacks
+        assert_equal 0, @machine.callbacks[:after].size
       end
     end
     
@@ -198,6 +106,17 @@ begin
         assert_equal 'parked', record.state
       end
       
+      def test_should_set_initial_state_with_nil_attributes
+        @model.class_eval do
+          def set(hash)
+            super(hash || {})
+          end
+        end
+        
+        record = @model.new(nil)
+        assert_equal 'parked', record.state
+      end
+      
       def test_should_still_set_attributes
         record = @model.new(:value => 1)
         assert_equal 1, record.value
@@ -212,11 +131,6 @@ begin
         assert_equal [record], block_args
       end
       
-      def test_should_not_have_any_changed_columns
-        record = @model.new
-        assert record.changed_columns.empty?
-      end
-      
       def test_should_set_attributes_prior_to_after_initialize_hook
         state = nil
         @model.class_eval do
@@ -318,15 +232,94 @@ begin
       end
     end
     
+    class MachineWithColumnDefaultTest < BaseTestCase
+      def setup
+        @model = new_model
+        DB.alter_table :foo do
+          add_column :status, :string, :default => 'idling'
+        end
+        @model.class_eval { get_db_schema(true) }
+        
+        @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+        @record = @model.new
+      end
+      
+      def test_should_use_machine_default
+        assert_equal 'parked', @record.status
+      end
+    end
+    
+    class MachineWithConflictingPredicateTest < BaseTestCase
+      def setup
+        @model = new_model do
+          def state?(*args)
+            true
+          end
+        end
+        
+        @machine = StateMachine::Machine.new(@model)
+        @record = @model.new
+      end
+      
+      def test_should_not_define_attribute_predicate
+        assert @record.state?
+      end
+    end
+    
+    class MachineWithColumnStateAttributeTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.other_states(:idling)
+        
+        @record = @model.new
+      end
+      
+      def test_should_not_override_the_column_reader
+        record = @model.new
+        record[:state] = 'parked'
+        assert_equal 'parked', record.state
+      end
+      
+      def test_should_not_override_the_column_writer
+        record = @model.new
+        record.state = 'parked'
+        assert_equal 'parked', record[:state]
+      end
+      
+      def test_should_have_an_attribute_predicate
+        assert @record.respond_to?(:state?)
+      end
+      
+      def test_should_raise_exception_for_predicate_without_parameters
+        assert_raise(IndexError) { @record.state? }
+      end
+      
+      def test_should_return_false_for_predicate_if_does_not_match_current_value
+        assert !@record.state?(:idling)
+      end
+      
+      def test_should_return_true_for_predicate_if_matches_current_value
+        assert @record.state?(:parked)
+      end
+      
+      def test_should_raise_exception_for_predicate_if_invalid_state_specified
+        assert_raise(IndexError) { @record.state?(:invalid) }
+      end
+    end
+    
     class MachineWithNonColumnStateAttributeUndefinedTest < BaseTestCase
       def setup
         @model = new_model do
           def initialize
             # Skip attribute initialization
+            @initialized_state_machines = true
+            super
           end
         end
         
-        @machine = StateMachine::Machine.new(@model, :status, :initial => 'parked')
+        @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+        @machine.other_states(:idling)
         @record = @model.new
       end
       
@@ -349,77 +342,247 @@ begin
           attr_accessor :status
         end
         
-        @machine = StateMachine::Machine.new(@model, :status, :initial => 'parked')
+        @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+        @machine.other_states(:idling)
         @record = @model.new
       end
       
+      def test_should_return_false_for_predicate_if_does_not_match_current_value
+        assert !@record.status?(:idling)
+      end
+      
+      def test_should_return_true_for_predicate_if_matches_current_value
+        assert @record.status?(:parked)
+      end
+      
       def test_should_set_initial_state_on_created_object
         assert_equal 'parked', @record.status
       end
     end
     
-    class MachineWithComplexPluralizationTest < BaseTestCase
+    class MachineWithInitializedStateTest < BaseTestCase
       def setup
         @model = new_model
-        @machine = StateMachine::Machine.new(@model, :status)
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.state nil, :idling
       end
       
-      def test_should_create_singular_with_scope
-        assert @model.respond_to?(:with_status)
+      def test_should_allow_nil_initial_state_when_static
+        record = @model.new(:state => nil)
+        assert_nil record.state
       end
       
-      def test_should_create_plural_with_scope
-        assert @model.respond_to?(:with_statuses)
+      def test_should_allow_nil_initial_state_when_dynamic
+        @machine.initial_state = lambda {:parked}
+        record = @model.new(:state => nil)
+        assert_nil record.state
+      end
+      
+      def test_should_allow_different_initial_state_when_static
+        record = @model.new(:state => 'idling')
+        assert_equal 'idling', record.state
+      end
+      
+      def test_should_allow_different_initial_state_when_dynamic
+        @machine.initial_state = lambda {:parked}
+        record = @model.new(:state => 'idling')
+        assert_equal 'idling', record.state
+      end
+      
+      def test_should_use_default_state_if_protected
+        @model.class_eval do
+          self.strict_param_setting = false
+          set_restricted_columns :state
+        end
+        
+        record = @model.new(:state => 'idling')
+        assert_equal 'parked', record.state
+      end
+    end
+    
+    class MachineWithAliasedAttributeTest < BaseTestCase
+      def setup
+        @model = new_model do
+          alias_method :vehicle_status, :state
+          alias_method :vehicle_status=, :state=
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :status, :attribute => :vehicle_status)
+        @machine.state :parked
+        
+        @record = @model.new
+      end
+      
+      def test_should_add_validation_errors_to_custom_attribute
+        @record.vehicle_status = 'invalid'
+        
+        assert !@record.valid?
+        assert_equal ['is invalid'], @record.errors.on(:vehicle_status)
+        
+        @record.vehicle_status = 'parked'
+        assert @record.valid?
+      end
+    end
+    
+    class MachineWithLoopbackTest < BaseTestCase
+      def setup
+        @model = new_model do
+          # Simulate timestamps plugin
+          define_method(:before_update) do
+            changed_columns = self.changed_columns.dup
+            
+            super()
+            self.updated_at = Time.now if changed_columns.any?
+          end
+        end
+        
+        DB.alter_table :foo do
+          add_column :updated_at, :datetime
+        end
+        @model.class_eval { get_db_schema(true) }
+        
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.event :park
+        
+        @record = @model.create(:updated_at => Time.now - 1)
+        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+        
+        @timestamp = @record.updated_at
+        @transition.perform
+      end
+      
+      def test_should_update_record
+        assert_not_equal @timestamp, @record.updated_at
       end
     end
     
-    class MachineWithOwnerSubclassTest < BaseTestCase
+    class MachineWithDirtyAttributesTest < BaseTestCase
       def setup
         @model = new_model
-        @machine = StateMachine::Machine.new(@model, :state)
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.event :ignite
+        @machine.state :idling
         
-        @subclass = Class.new(@model)
-        @subclass_machine = @subclass.state_machine(:state) {}
-        @subclass_machine.state :parked, :idling, :first_gear
+        @record = @model.create
+        
+        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+        @transition.perform(false)
       end
       
-      def test_should_only_include_records_with_subclass_states_in_with_scope
-        parked = @subclass.create :state => 'parked'
-        idling = @subclass.create :state => 'idling'
+      def test_should_include_state_in_changed_attributes
+        assert_equal [:state], @record.changed_columns
+      end
+    end
+    
+    class MachineWithDirtyAttributesDuringLoopbackTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.event :park
         
-        assert_equal [parked, idling], @subclass.with_states(:parked, :idling).all
+        @record = @model.create
+        
+        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+        @transition.perform(false)
       end
       
-      def test_should_only_include_records_without_subclass_states_in_without_scope
-        parked = @subclass.create :state => 'parked'
-        idling = @subclass.create :state => 'idling'
-        first_gear = @subclass.create :state => 'first_gear'
+      def test_should_include_state_in_changed_attributes
+        assert_equal [:state], @record.changed_columns
+      end
+    end
+    
+    class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
+      def setup
+        @model = new_model
+        DB.alter_table :foo do
+          add_column :status, :string, :default => 'idling'
+        end
+        @model.class_eval { get_db_schema(true) }
         
-        assert_equal [parked, idling], @subclass.without_states(:first_gear).all
+        @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+        @machine.event :ignite
+        @machine.state :idling
+        
+        @record = @model.create
+        
+        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+        @transition.perform(false)
+      end
+      
+      def test_should_include_state_in_changed_attributes
+        assert_equal [:status], @record.changed_columns
+      end
+    end
+    
+    class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
+      def setup
+        @model = new_model
+        DB.alter_table :foo do
+          add_column :status, :string, :default => 'idling'
+        end
+        @model.class_eval { get_db_schema(true) }
+        
+        @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+        @machine.event :park
+        
+        @record = @model.create
+        
+        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+        @transition.perform(false)
+      end
+      
+      def test_should_include_state_in_changed_attributes
+        assert_equal [:status], @record.changed_columns
+      end
+    end
+    
+    class MachineWithoutTransactionsTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :use_transactions => false)
+      end
+      
+      def test_should_not_rollback_transaction_if_false
+        @machine.within_transaction(@model.new) do
+          @model.create
+          false
+        end
+        
+        assert_equal 1, @model.count
+      end
+      
+      def test_should_not_rollback_transaction_if_true
+        @machine.within_transaction(@model.new) do
+          @model.create
+          true
+        end
+        
+        assert_equal 1, @model.count
       end
     end
     
-    class MachineWithCustomAttributeTest < BaseTestCase
+    class MachineWithTransactionsTest < BaseTestCase
       def setup
-        @model = new_model do
-          alias_method :vehicle_status, :state
-          alias_method :vehicle_status=, :state=
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :use_transactions => true)
+      end
+      
+      def test_should_rollback_transaction_if_false
+        @machine.within_transaction(@model.new) do
+          @model.create
+          false
         end
         
-        @machine = StateMachine::Machine.new(@model, :status, :attribute => :vehicle_status)
-        @machine.state :parked
-        
-        @record = @model.new
+        assert_equal 0, @model.count
       end
       
-      def test_should_add_validation_errors_to_custom_attribute
-        @record.vehicle_status = 'invalid'
-        
-        assert !@record.valid?
-        assert_equal ['is invalid'], @record.errors.on(:vehicle_status)
+      def test_should_not_rollback_transaction_if_true
+        @machine.within_transaction(@model.new) do
+          @model.create
+          true
+        end
         
-        @record.vehicle_status = 'parked'
-        assert @record.valid?
+        assert_equal 1, @model.count
       end
     end
     
@@ -429,6 +592,7 @@ begin
         @machine = StateMachine::Machine.new(@model)
         @machine.state :parked, :idling
         @machine.event :ignite
+        
         @record = @model.new(:state => 'parked')
         @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
       end
@@ -515,43 +679,133 @@ begin
       end
     end
     
-    class MachineWithLoopbackTest < BaseTestCase
+    class MachineWithFailedBeforeCallbacksTest < BaseTestCase
       def setup
-        changed_columns = nil
+        before_count = 0
+        after_count = 0
         
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model)
+        @machine.state :parked, :idling
+        @machine.event :ignite
+        @machine.before_transition(lambda {before_count += 1; false})
+        @machine.before_transition(lambda {before_count += 1})
+        @machine.after_transition(lambda {after_count += 1})
+        
+        @record = @model.new(:state => 'parked')
+        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+        @result = @transition.perform
+        
+        @before_count = before_count
+        @after_count = after_count
+      end
+      
+      def test_should_not_be_successful
+        assert !@result
+      end
+      
+      def test_should_not_change_current_state
+        assert_equal 'parked', @record.state
+      end
+      
+      def test_should_not_run_action
+        assert @record.new?
+      end
+      
+      def test_should_not_run_further_before_callbacks
+        assert_equal 1, @before_count
+      end
+      
+      def test_should_not_run_after_callbacks
+        assert_equal 0, @after_count
+      end
+    end
+    
+    class MachineWithFailedActionTest < BaseTestCase
+      def setup
         @model = new_model do
-          # Simulate timestamps plugin
-          define_method(:before_update) do
-            changed_columns = self.changed_columns.dup
-            
-            super()
-            self.updated_at = Time.now if changed_columns.any?
+          validates_each :state do |object, attribute, value|
+            object.errors[attribute] << 'is invalid' unless %w(first_gear).include?(value)
           end
         end
         
-        DB.alter_table :foo do
-          add_column :updated_at, :datetime
-        end
-        @model.class_eval { get_db_schema(true) }
+        @machine = StateMachine::Machine.new(@model)
+        @machine.state :parked, :idling
+        @machine.event :ignite
         
-        @machine = StateMachine::Machine.new(@model, :initial => :parked)
-        @machine.event :park
+        before_transition_called = false
+        after_transition_called = false
+        after_transition_with_failures_called = false
+        @machine.before_transition(lambda {before_transition_called = true})
+        @machine.after_transition(lambda {after_transition_called = true})
+        @machine.after_transition(lambda {after_transition_with_failures_called = true}, :include_failures => true)
         
-        @record = @model.create(:updated_at => Time.now - 1)
-        @timestamp = @record.updated_at
+        @record = @model.new(:state => 'parked')
+        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+        @result = @transition.perform
         
-        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
-        @transition.perform
+        @before_transition_called = before_transition_called
+        @after_transition_called = after_transition_called
+        @after_transition_with_failures_called = after_transition_with_failures_called
+      end
+      
+      def test_should_not_be_successful
+        assert !@result
+      end
+      
+      def test_should_not_change_current_state
+        assert_equal 'parked', @record.state
+      end
+      
+      def test_should_not_save_record
+        assert @record.new?
+      end
+      
+      def test_should_run_before_callback
+        assert @before_transition_called
+      end
+      
+      def test_should_not_run_after_callback_if_not_including_failures
+        assert !@after_transition_called
+      end
+      
+      def test_should_run_after_callback_if_including_failures
+        assert @after_transition_with_failures_called
+      end
+    end
+    
+    class MachineWithFailedAfterCallbacksTest < BaseTestCase
+       def setup
+        after_count = 0
+        
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model)
+        @machine.state :parked, :idling
+        @machine.event :ignite
+        @machine.after_transition(lambda {after_count += 1; false})
+        @machine.after_transition(lambda {after_count += 1})
+        
+        @record = @model.new(:state => 'parked')
+        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+        @result = @transition.perform
         
-        @changed_columns = changed_columns
+        @after_count = after_count
       end
       
-      def test_should_include_state_in_changed_columns
-        assert_equal [:state], @changed_columns
+      def test_should_be_successful
+        assert @result
       end
       
-      def test_should_update_record
-        assert_not_equal @timestamp, @record.updated_at
+      def test_should_change_current_state
+        assert_equal 'idling', @record.state
+      end
+      
+      def test_should_save_record
+        assert !@record.new?
+      end
+      
+      def test_should_not_run_further_after_callbacks
+        assert_equal 1, @after_count
       end
     end
     
@@ -564,6 +818,27 @@ begin
         @record = @model.new
       end
       
+      def test_should_invalidate_using_errors
+        @record.state = 'parked'
+        
+        @machine.invalidate(@record, :state, :invalid_transition, [[:event, :park]])
+        assert_equal ['cannot transition via "park"'], @record.errors.on(:state)
+      end
+      
+      def test_should_auto_prefix_custom_attributes_on_invalidation
+        @machine.invalidate(@record, :event, :invalid)
+        
+        assert_equal ['is invalid'], @record.errors.on(:state_event)
+      end
+      
+      def test_should_clear_errors_on_reset
+        @record.state = 'parked'
+        @record.errors.add(:state, 'is invalid')
+        
+        @machine.reset(@record)
+        assert_nil @record.errors.on(:id)
+      end
+      
       def test_should_be_valid_if_state_is_known
         @record.state = 'parked'
         
@@ -578,6 +853,30 @@ begin
       end
     end
     
+    class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
+      def setup
+        @model = new_model do
+          alias_method :status, :state
+          alias_method :status=, :state=
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :status, :attribute => :state)
+        @machine.state :parked
+        
+        @record = @model.new
+      end
+      
+      def test_should_add_validation_errors_to_custom_attribute
+        @record.state = 'invalid'
+        
+        assert !@record.valid?
+        assert_equal ['state is invalid'], @record.errors.full_messages
+        
+        @record.state = 'parked'
+        assert @record.valid?
+      end
+    end
+    
     class MachineWithStateDrivenValidationsTest < BaseTestCase
       def setup
         @model = new_model do
@@ -794,6 +1093,146 @@ begin
         assert_equal 'idling', @record.state
       end
     end
+    
+    class MachineWithScopesTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model)
+        @machine.state :parked, :first_gear
+        @machine.state :idling, :value => lambda {'idling'}
+      end
+      
+      def test_should_create_singular_with_scope
+        assert @model.respond_to?(:with_state)
+      end
+      
+      def test_should_only_include_records_with_state_in_singular_with_scope
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        
+        assert_equal [parked], @model.with_state(:parked).all
+      end
+      
+      def test_should_create_plural_with_scope
+        assert @model.respond_to?(:with_states)
+      end
+      
+      def test_should_only_include_records_with_states_in_plural_with_scope
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        
+        assert_equal [parked, idling], @model.with_states(:parked, :idling).all
+      end
+      
+      def test_should_create_singular_without_scope
+        assert @model.respond_to?(:without_state)
+      end
+      
+      def test_should_only_include_records_without_state_in_singular_without_scope
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        
+        assert_equal [parked], @model.without_state(:idling).all
+      end
+      
+      def test_should_create_plural_without_scope
+        assert @model.respond_to?(:without_states)
+      end
+      
+      def test_should_only_include_records_without_states_in_plural_without_scope
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        first_gear = @model.create :state => 'first_gear'
+        
+        assert_equal [parked, idling], @model.without_states(:first_gear).all
+      end
+      
+      def test_should_allow_chaining_scopes_and_filters
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        
+        assert_equal [idling], @model.without_state(:parked).filter(:state => 'idling').all
+      end
+    end
+    
+    class MachineWithScopesAndOwnerSubclassTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :state)
+        
+        @subclass = Class.new(@model)
+        @subclass_machine = @subclass.state_machine(:state) {}
+        @subclass_machine.state :parked, :idling, :first_gear
+      end
+      
+      def test_should_only_include_records_with_subclass_states_in_with_scope
+        parked = @subclass.create :state => 'parked'
+        idling = @subclass.create :state => 'idling'
+        
+        assert_equal [parked, idling], @subclass.with_states(:parked, :idling).all
+      end
+      
+      def test_should_only_include_records_without_subclass_states_in_without_scope
+        parked = @subclass.create :state => 'parked'
+        idling = @subclass.create :state => 'idling'
+        first_gear = @subclass.create :state => 'first_gear'
+        
+        assert_equal [parked, idling], @subclass.without_states(:first_gear).all
+      end
+    end
+    
+    class MachineWithComplexPluralizationScopesTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :status)
+      end
+      
+      def test_should_create_singular_with_scope
+        assert @model.respond_to?(:with_status)
+      end
+      
+      def test_should_create_plural_with_scope
+        assert @model.respond_to?(:with_statuses)
+      end
+    end
+    
+    class MachineWithScopesAndJoinsTest < BaseTestCase
+      def setup
+        @company = new_model(:company)
+        SequelTest.const_set('Company', @company)
+        
+        @vehicle = new_model(:vehicle) do
+          many_to_one :company, :class => SequelTest::Company
+        end
+        DB.alter_table :vehicle do
+          add_column :company_id, :integer
+        end
+        @vehicle.class_eval { get_db_schema(true) }
+        SequelTest.const_set('Vehicle', @vehicle)
+        
+        @company_machine = StateMachine::Machine.new(@company, :initial => :active)
+        @vehicle_machine = StateMachine::Machine.new(@vehicle, :initial => :parked)
+        @vehicle_machine.state :idling
+        
+        @ford = @company.create
+        @mustang = @vehicle.create(:company => @ford)
+      end
+      
+      def test_should_find_records_in_with_scope
+        assert_equal [@mustang], @vehicle.with_states(:parked).join(:company, :id => :company_id).filter(:company__state => 'active').select(:vehicle.*).all
+      end
+      
+      def test_should_find_records_in_without_scope
+        assert_equal [@mustang], @vehicle.without_states(:idling).join(:company, :id => :company_id).filter(:company__state => 'active').select(:vehicle.*).all
+      end
+      
+      def teardown
+        SequelTest.class_eval do
+          remove_const('Vehicle')
+          remove_const('Company')
+        end
+      end
+    end
   end
 rescue LoadError
   $stderr.puts "Skipping Sequel tests. `gem install sequel#{" -v #{ENV['SEQUEL_VERSION']}" if ENV['SEQUEL_VERSION']}` and try again."