state_machine 1.1.2 → 1.2.0

data/test/unit/integrations/sequel_test.rb

@@ -2,9 +2,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 require 'sequel'
 require 'logger'
+require 'stringio'
 
 # Establish database connection
-DB = Sequel.connect('sqlite:///', :loggers => [Logger.new("#{File.dirname(__FILE__)}/../../sequel.log")])
+DB = Sequel.connect(RUBY_PLATFORM == 'java' ? 'jdbc:sqlite::memory:' : 'sqlite:///', :loggers => [Logger.new("#{File.dirname(__FILE__)}/../../sequel.log")])
 
 module SequelTest
   class BaseTestCase < Test::Unit::TestCase
@@ -14,10 +15,11 @@ module SequelTest
     protected
       # Creates a new Sequel model (and the associated table)
       def new_model(create_table = :foo, &block)
-        table_name = create_table || :foo
-        table_identifier = ::Sequel::SQL::Identifier.new(table_name)
+        name = create_table || :foo
+        table_name = "#{name}_#{rand(1000000)}"
+        table_identifier = Sequel::SQL::Identifier.new(table_name)
         
-        if !defined?(Sequel::VERSION) || Gem::Version.new(::Sequel::VERSION) <= Gem::Version.new('3.26.0')
+        if !defined?(Sequel::VERSION) || Gem::Version.new(Sequel::VERSION) <= Gem::Version.new('3.26.0')
           class << table_identifier
             alias_method :original_to_s, :to_s
             def to_s(*args); args.empty? ? inspect : original_to_s(*args); end
@@ -28,12 +30,16 @@ module SequelTest
           primary_key :id
           column :state, :string
         end if create_table
-        model = Class.new(Sequel::Model(DB[table_identifier])) do
+        model = Class.new(Sequel::Model) do
           self.raise_on_save_failure = false
           (class << self; self; end).class_eval do
-            define_method(:name) { "SequelTest::#{table_name.to_s.capitalize}" }
+            define_method(:name) { "SequelTest::#{name.to_s.capitalize}" }
+            define_method(:table_identifier) { table_identifier }
           end
+          
+          set_dataset(DB[table_identifier])
         end
+        model.set_dataset(DB[table_identifier])
         model.class_eval(&block) if block_given?
         model
       end
@@ -57,7 +63,7 @@ module SequelTest
     end
     
     def test_should_have_defaults
-      assert_equal e = {:action => :save}, StateMachine::Integrations::Sequel.defaults
+      assert_equal({:action => :save}, StateMachine::Integrations::Sequel.defaults)
     end
     
     def test_should_not_have_a_locale_path
@@ -122,7 +128,7 @@ module SequelTest
   
   class MachineWithStaticInitialStateTest < BaseTestCase
     def setup
-      @model = new_model do
+      @model = new_model(:vehicle) do
         attr_accessor :value
       end
       @machine = StateMachine::Machine.new(@model, :initial => :parked)
@@ -133,17 +139,6 @@ module SequelTest
       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
@@ -160,7 +155,7 @@ module SequelTest
     
     def test_should_set_attributes_prior_to_initialize_block
       state = nil
-      record = @model.new do |record|
+      @model.new do |record|
         state = record.state
       end
       
@@ -182,6 +177,7 @@ module SequelTest
       @model.class_eval do
         attr_accessor :state_during_setter
         
+        remove_method :value=
         define_method(:value=) do |value|
           self.state_during_setter = state
         end
@@ -200,6 +196,20 @@ module SequelTest
       assert_equal 'idling', record.state
     end
     
+    def test_should_persist_initial_state
+      record = @model.new
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
+    def test_should_persist_initial_state_on_dup
+      record = @model.create.dup
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
     def test_should_use_stored_values_when_loading_from_database
       @machine.state :idling
       
@@ -213,6 +223,77 @@ module SequelTest
       record = @model[@model.create(:state => nil).id]
       assert_nil record.state
     end
+    
+    def test_should_use_stored_values_when_loading_for_many_association
+      @machine.state :idling
+      
+      DB.alter_table(@model.table_identifier) do
+        add_column :owner_id, :integer
+      end
+      @model.class_eval { get_db_schema(true) }
+      SequelTest.const_set('Vehicle', @model)
+      
+      owner_model = new_model(:owner) do
+        one_to_many :vehicles, :class_name => 'SequelTest::Vehicle'
+      end
+      SequelTest.const_set('Owner', owner_model)
+      
+      owner = owner_model.create
+      record = @model.create(:state => 'idling', :owner_id => owner.id)
+      assert_equal 'idling', owner.vehicles[0].state
+    end
+    
+    if defined?(Sequel::VERSION) && Gem::Version.new(Sequel::VERSION) >= Gem::Version.new('3.10.0')
+      def test_should_use_stored_values_when_loading_for_one_association
+        @machine.state :idling
+        
+        DB.alter_table(@model.table_identifier) do
+          add_column :owner_id, :integer
+        end
+        @model.class_eval { get_db_schema(true) }
+        SequelTest.const_set('Vehicle', @model)
+        
+        owner_model = new_model(:owner) do
+          one_to_one :vehicle, :class_name => 'SequelTest::Vehicle'
+        end
+        SequelTest.const_set('Owner', owner_model)
+        
+        owner = owner_model.create
+        record = @model.create(:state => 'idling', :owner_id => owner.id)
+        owner.reload
+        assert_equal 'idling', owner.vehicle.state
+      end
+    end
+    
+    def test_should_use_stored_values_when_loading_for_belongs_to_association
+      @machine.state :idling
+      
+      SequelTest.const_set('Vehicle', @model)
+      
+      driver_model = new_model(:driver) do
+        DB.alter_table(table_identifier) do
+          add_column :vehicle_id, :integer
+        end
+        get_db_schema(true)
+        
+        many_to_one :vehicle, :class_name => 'SequelTest::Vehicle'
+      end
+
+      SequelTest.const_set('Driver', driver_model)
+      
+      record = @model.create(:state => 'idling')
+      driver = driver_model.create(:vehicle_id => record.id)
+      assert_equal 'idling', driver.vehicle.state
+    end
+    
+    def teardown
+      SequelTest.class_eval do
+        remove_const('Vehicle') if defined?(SequelTest::Vehicle)
+        remove_const('Owner') if defined?(SequelTest::Owner)
+        remove_const('Driver') if defined?(SequelTest::Driver)
+      end
+      super
+    end
   end
   
   class MachineWithDynamicInitialStateTest < BaseTestCase
@@ -250,7 +331,7 @@ module SequelTest
     
     def test_should_set_attributes_prior_to_initialize_block
       state = nil
-      record = @model.new do |record|
+      @model.new do |record|
         state = record.state
       end
       
@@ -272,6 +353,7 @@ module SequelTest
       @model.class_eval do
         attr_accessor :state_during_setter
         
+        remove_method :value=
         define_method(:value=) do |value|
           self.state_during_setter = state || 'nil'
         end
@@ -290,6 +372,20 @@ module SequelTest
       assert_equal 'idling', record.state
     end
     
+    def test_should_persist_initial_state
+      record = @model.new
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
+    def test_should_persist_initial_state_on_dup
+      record = @model.create.dup
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
     def test_should_use_stored_values_when_loading_from_database
       @machine.state :idling
       
@@ -317,13 +413,19 @@ module SequelTest
     end
   end
   
-  class MachineWithColumnDefaultTest < BaseTestCase
+  class MachineWithSameColumnDefaultTest < BaseTestCase
     def setup
-      @model = new_model
-      DB.alter_table :foo do
-        add_column :status, :string, :default => 'idling'
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model(false)
+      DB.create_table!(@model.table_identifier) do
+        primary_key :id
+        column :status, :string, :default => 'parked'
+      end
+      @model.class_eval do
+        set_dataset(DB[table_identifier])
+        get_db_schema(true)
       end
-      @model.class_eval { get_db_schema(true) }
       
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
       @record = @model.new
@@ -332,6 +434,77 @@ module SequelTest
     def test_should_use_machine_default
       assert_equal 'parked', @record.status
     end
+    
+    def test_should_not_generate_a_warning
+      assert_no_match(/have defined a different default/, $stderr.string)
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+    end
+  end
+  
+  class MachineWithDifferentColumnDefaultTest < BaseTestCase
+    def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model(false)
+      DB.create_table!(@model.table_identifier) do
+        primary_key :id
+        column :status, :string, :default => 'idling'
+      end
+      @model.class_eval do
+        set_dataset(DB[table_identifier])
+        get_db_schema(true)
+      end
+      
+      @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+      @record = @model.new
+    end
+    
+    def test_should_use_machine_default
+      assert_equal 'parked', @record.status
+    end
+    
+    def test_should_generate_a_warning
+      assert_match(/Both SequelTest::Foo and its :status machine have defined a different default for "status". Use only one or the other for defining defaults to avoid unexpected behaviors\./, $stderr.string)
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+    end
+  end
+  
+  class MachineWithDifferentIntegerColumnDefaultTest < BaseTestCase
+    def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model(false)
+      DB.create_table!(@model.table_identifier) do
+        primary_key :id
+        column :status, :integer, :default => 0
+      end
+      @model.class_eval do
+        set_dataset(DB[table_identifier])
+        get_db_schema(true)
+      end
+      
+      @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+      @machine.state :parked, :value => 1
+      @record = @model.new
+    end
+    
+    def test_should_use_machine_default
+      assert_equal 1, @record.status
+    end
+    
+    def test_should_generate_a_warning
+      assert_match(/Both SequelTest::Foo and its :status machine have defined a different default for "status". Use only one or the other for defining defaults to avoid unexpected behaviors\./, $stderr.string)
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+    end
   end
   
   class MachineWithConflictingPredicateTest < BaseTestCase
@@ -377,8 +550,7 @@ module SequelTest
     end
     
     def test_should_raise_exception_for_predicate_without_parameters
-      exception = assert_raise(ArgumentError) { @record.state? }
-      assert_equal 'wrong number of arguments (1 for 2)', exception.message
+      assert_raise(ArgumentError) { @record.state? }
     end
     
     def test_should_return_false_for_predicate_if_does_not_match_current_value
@@ -492,8 +664,8 @@ module SequelTest
   class MachineMultipleTest < BaseTestCase
     def setup
       @model = new_model
-      DB.alter_table :foo do
-        add_column :status, :string, :default => 'idling'
+      DB.alter_table(@model.table_identifier) do
+        add_column :status, :string
       end
       @model.class_eval { get_db_schema(true) }
       
@@ -544,7 +716,7 @@ module SequelTest
         end
       end
       
-      DB.alter_table :foo do
+      DB.alter_table(@model.table_identifier) do
         add_column :updated_at, :datetime
       end
       @model.class_eval { get_db_schema(true) }
@@ -607,8 +779,8 @@ module SequelTest
   class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
     def setup
       @model = new_model
-      DB.alter_table :foo do
-        add_column :status, :string, :default => 'idling'
+      DB.alter_table(@model.table_identifier) do
+        add_column :status, :string
       end
       @model.class_eval { get_db_schema(true) }
       
@@ -630,8 +802,8 @@ module SequelTest
   class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
     def setup
       @model = new_model
-      DB.alter_table :foo do
-        add_column :status, :string, :default => 'idling'
+      DB.alter_table(@model.table_identifier) do
+        add_column :status, :string
       end
       @model.class_eval { get_db_schema(true) }
       
@@ -790,12 +962,22 @@ module SequelTest
     
     def test_should_run_around_callbacks
       before_called = false
-      after_called = [false]
-      @machine.around_transition {|block| before_called = true; block.call; after_called[0] = true}
+      after_called = false
+      ensure_called = 0
+      @machine.around_transition do |block|
+        before_called = true
+        begin
+          block.call
+        ensure
+          ensure_called += 1
+        end
+        after_called = true
+      end
       
       @transition.perform
       assert before_called
-      assert after_called[0]
+      assert after_called
+      assert_equal ensure_called, 1
     end
     
     def test_should_run_around_callbacks_with_the_context_of_the_record
@@ -830,6 +1012,33 @@ module SequelTest
       
       assert_equal [1, 2, 3], @record.callback_result
     end
+    
+    def test_should_run_in_expected_order
+      expected = [
+        :before_transition, :before_validation, :after_validation,
+        :before_save, :before_create, :after_create, :after_save,
+        :after_transition
+      ]
+      
+      callbacks = []
+      @model.before_validation { callbacks << :before_validation }
+      @model.after_validation { callbacks << :after_validation }
+      @model.before_save { callbacks << :before_save }
+      @model.before_create { callbacks << :before_create }
+      @model.after_create { callbacks << :after_create }
+      @model.after_save { callbacks << :after_save }
+      if @model.respond_to?(:after_commit)
+        @model.after_commit { callbacks << :after_commit }
+        expected << :after_commit
+      end
+      
+      @machine.before_transition { callbacks << :before_transition }
+      @machine.after_transition { callbacks << :after_transition }
+      
+      @transition.perform
+      
+      assert_equal expected, callbacks
+    end
   end
   
   class MachineWithFailedBeforeCallbacksTest < BaseTestCase
@@ -869,12 +1078,50 @@ module SequelTest
     end
   end
   
+  class MachineNestedActionTest < BaseTestCase
+    def setup
+      @callbacks = []
+      
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.event :ignite do
+        transition :parked => :idling
+      end
+      
+      @record = @model.new(:state => 'parked')
+    end
+    
+    def test_should_allow_transition_prior_to_creation_if_skipping_action
+      record = @record
+      @model.before_create { record.ignite(false) }
+      result = @record.save
+      
+      assert result
+      assert_equal "idling", @record.state
+      @record.reload
+      assert_equal "idling", @record.state
+    end
+    
+    if !defined?(Sequel::VERSION) || !%w(2.10.0 2.11.0).include?(Sequel::VERSION)
+      def test_should_allow_transition_after_creation
+        record = @record
+        @model.after_create { record.ignite }
+        result = @record.save
+        
+        assert result
+        assert_equal "idling", @record.state
+        @record.reload
+        assert_equal "idling", @record.state
+      end
+    end
+  end
+  
   class MachineWithFailedActionTest < BaseTestCase
     def setup
       @model = new_model do
-        plugin(:validation_class_methods) if respond_to?(:plugin)
-        validates_each :state do |object, attribute, value|
-          object.errors[attribute] << 'is invalid' unless %w(first_gear).include?(value)
+        def validate
+          super
+          errors[:state] << 'is invalid' unless %w(first_gear).include?(state)
         end
       end
       
@@ -913,7 +1160,7 @@ module SequelTest
   end
   
   class MachineWithFailedAfterCallbacksTest < BaseTestCase
-     def setup
+    def setup
       callbacks = []
       
       @model = new_model
@@ -1042,7 +1289,10 @@ module SequelTest
       
       @machine = StateMachine::Machine.new(@model)
       @machine.state :first_gear do
-        validates_presence_of :seatbelt
+        def validate
+          super if defined?(super)
+          errors[:seatbelt] << 'is not present' if seatbelt.nil?
+        end
       end
       @machine.other_states :parked
     end
@@ -1104,7 +1354,11 @@ module SequelTest
       ran_callback = false
       @machine.around_transition {|block| ran_callback = true; block.call }
       
-      @record.valid?
+      begin
+        @record.valid?
+      rescue ArgumentError
+        raise if StateMachine::Transition.pause_supported?
+      end
       assert ran_callback
     end
     
@@ -1124,7 +1378,10 @@ module SequelTest
     def test_should_not_run_after_callbacks_with_failures_disabled_if_validation_fails
       @model.class_eval do
         attr_accessor :seatbelt
-        validates_presence_of :seatbelt
+        def validate
+          super
+          errors[:seatbelt] << 'is not present' if seatbelt.nil?
+        end
       end
       
       ran_callback = false
@@ -1137,7 +1394,10 @@ module SequelTest
     def test_should_run_failure_callbacks_if_validation_fails
       @model.class_eval do
         attr_accessor :seatbelt
-        validates_presence_of :seatbelt
+        def validate
+          super
+          errors[:seatbelt] << 'is not present' if seatbelt.nil?
+        end
       end
       
       ran_callback = false
@@ -1151,20 +1411,31 @@ module SequelTest
       ran_callback = [false]
       @machine.around_transition {|block| block.call; ran_callback[0] = true }
       
-      @record.valid?
+      begin
+        @record.valid?
+      rescue ArgumentError
+        raise if StateMachine::Transition.pause_supported?
+      end
       assert !ran_callback[0]
     end
     
     def test_should_not_run_around_callbacks_after_yield_with_failures_disabled_if_validation_fails
       @model.class_eval do
         attr_accessor :seatbelt
-        validates_presence_of :seatbelt
+        def validate
+          super
+          errors[:seatbelt] << 'is not present' if seatbelt.nil?
+        end
       end
       
       ran_callback = [false]
       @machine.around_transition {|block| block.call; ran_callback[0] = true }
       
-      @record.valid?
+      begin
+        @record.valid?
+      rescue ArgumentError
+        raise if StateMachine::Transition.pause_supported?
+      end
       assert !ran_callback[0]
     end
     
@@ -1282,29 +1553,17 @@ module SequelTest
       assert !ran_callback
     end
     
-    if defined?(Sequel::MAJOR) && Sequel::MAJOR >= 3 && Sequel::MINOR >= 7
-      def test_should_not_run_failure_callbacks_if_fails
-        @model.before_create {|record| false}
-        
-        ran_callback = false
-        @machine.after_failure { ran_callback = true }
-        
-        @record.save
-        assert !ran_callback
-      end
-    else
-      def test_should_run_failure_callbacks_if_fails
-        @model.before_create {|record| false}
-        
-        ran_callback = false
-        @machine.after_failure { ran_callback = true }
-        
-        @record.save
-        assert ran_callback
-      end
+    def test_should_run_failure_callbacks_if_fails
+      @model.before_create {|record| false}
+      
+      ran_callback = false
+      @machine.after_failure { ran_callback = true }
+      
+      @record.save
+      assert ran_callback
     end
     
-    def test_should_not_run_before_transitions_within_transaction
+    def test_should_run_before_transitions_within_transaction
       @machine.before_transition { self.class.create; raise Sequel::Error::Rollback }
       
       begin
@@ -1312,7 +1571,7 @@ module SequelTest
       rescue Sequel::Error::Rollback
       end
       
-      assert_equal 1, @model.count
+      assert_equal 0, @model.count
     end
     
     def test_should_not_run_around_callbacks_with_failures_disabled_if_fails
@@ -1333,43 +1592,111 @@ module SequelTest
       assert ran_callback[0]
     end
     
-    if defined?(Sequel::MAJOR) && (Sequel::MAJOR >= 3 || Sequel::MAJOR == 2 && Sequel::MINOR == 12)
-      def test_should_run_after_transitions_within_transaction
-        @machine.after_transition { self.class.create; raise Sequel::Error::Rollback }
+    def test_should_run_after_transitions_within_transaction
+      @machine.after_transition { self.class.create; raise Sequel::Error::Rollback }
+      
+      @record.save
+      
+      assert_equal 0, @model.count
+    end
+    
+    def test_should_run_around_transition_within_transaction
+      @machine.around_transition {|block| block.call; self.class.create; raise Sequel::Error::Rollback }
+      
+      @record.save
+      
+      assert_equal 0, @model.count
+    end
+    
+    def test_should_allow_additional_transitions_to_new_state_in_after_transitions
+      @machine.event :park do
+        transition :idling => :parked
+      end
+      
+      @machine.after_transition(:on => :ignite) { park }
+      
+      @record.save
+      assert_equal 'parked', @record.state
+      
+      @record.reload
+      assert_equal 'parked', @record.state
+    end
+    
+    def test_should_allow_additional_transitions_to_previous_state_in_after_transitions
+      @machine.event :shift_up do
+        transition :idling => :first_gear
+      end
+      
+      @machine.after_transition(:on => :ignite) { shift_up }
+      
+      @record.save
+      assert_equal 'first_gear', @record.state
+      
+      @record.reload
+      assert_equal 'first_gear', @record.state
+    end
+    
+    def test_should_return_nil_on_manual_rollback
+      @machine.before_transition { raise Sequel::Error::Rollback }
+      
+      assert_equal nil, @record.save
+    end
+  end
+  
+  if defined?(Sequel::VERSION) && Gem::Version.new(Sequel::VERSION) >= Gem::Version.new('3.4.0')
+    class MachineWithEventAttributesOnAutosaveTest < BaseTestCase
+      def setup
+        @vehicle_model = new_model(:vehicle)
+        DB.alter_table(@vehicle_model.table_identifier) do
+          add_column :owner_id, :integer
+        end
+        @vehicle_model.class_eval { get_db_schema(true) }
+        SequelTest.const_set('Vehicle', @vehicle_model)
         
-        @record.save
+        @owner_model = new_model(:owner) do
+          plugin :nested_attributes
+        end
+        SequelTest.const_set('Owner', @owner_model)
         
-        assert_equal 0, @model.count
+        machine = StateMachine::Machine.new(@vehicle_model)
+        machine.event :ignite do
+          transition :parked => :idling
+        end
+        
+        @owner = @owner_model.create
+        @vehicle = @vehicle_model.create(:state => 'parked', :owner_id => @owner.id)
       end
       
-      def test_should_run_around_transition_within_transaction
-        @machine.around_transition {|block| block.call; self.class.create; raise Sequel::Error::Rollback }
+      def test_should_persist_many_association
+        @owner_model.one_to_many :vehicles, :class_name => 'SequelTest::Vehicle'
+        @owner_model.nested_attributes :vehicles
         
-        @record.save
+        @owner.vehicles_attributes = [{:id => @vehicle.id, :state_event => 'ignite'}]
+        @owner.save
         
-        assert_equal 0, @model.count
+        @vehicle.reload
+        assert_equal 'idling', @vehicle.state
       end
-    else
-      def test_should_not_run_after_transitions_within_transaction
-        @machine.after_transition { self.class.create; raise Sequel::Error::Rollback }
-        
-        begin
-          @record.save
-        rescue Sequel::Error::Rollback
+      
+      if Gem::Version.new(Sequel::VERSION) >= Gem::Version.new('3.10.0')
+        def test_should_persist_one_association
+          @owner_model.one_to_one :vehicle, :class_name => 'SequelTest::Vehicle'
+          @owner_model.nested_attributes :vehicle
+          
+          @owner.vehicle_attributes = {:id => @vehicle.id, :state_event => 'ignite'}
+          @owner.save
+          
+          @vehicle.reload
+          assert_equal 'idling', @vehicle.state
         end
-        
-        assert_equal 2, @model.count
       end
       
-      def test_should_not_run_around_transition_within_transaction
-        @machine.around_transition {|block| block.call; self.class.create; raise Sequel::Error::Rollback }
-        
-        begin
-          @record.save
-        rescue Sequel::Error::Rollback
+      def teardown
+        SequelTest.class_eval do
+          remove_const('Vehicle')
+          remove_const('Owner')
         end
-        
-        assert_equal 2, @model.count
+        super
       end
     end
   end
@@ -1422,7 +1749,7 @@ module SequelTest
     
     def test_should_only_include_records_with_state_in_singular_with_scope
       parked = @model.create :state => 'parked'
-      idling = @model.create :state => 'idling'
+      @model.create :state => 'idling'
       
       assert_equal [parked], @model.with_state(:parked).all
     end
@@ -1482,7 +1809,7 @@ module SequelTest
       @machine.state :idling, :value => lambda {'idling'}
       
       parked = @model.create :state => 'parked'
-      idling = @model.create :state => 'idling'
+      @model.create :state => 'idling'
       
       assert_equal [parked], @model.with_state(:parked).all
     end
@@ -1537,7 +1864,7 @@ module SequelTest
       @vehicle = new_model(:vehicle) do
         many_to_one :company, :class => SequelTest::Company
       end
-      DB.alter_table :vehicle do
+      DB.alter_table(@vehicle.table_identifier) do
         add_column :company_id, :integer
       end
       @vehicle.class_eval { get_db_schema(true) }
@@ -1552,11 +1879,11 @@ module SequelTest
     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
+      assert_equal [@mustang], @vehicle.with_states(:parked).join(@company.table_identifier.value, :id => :company_id).filter(:"#{@company.table_identifier.value}__state" => 'active').select(@vehicle.table_identifier.value.to_sym.*).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
+      assert_equal [@mustang], @vehicle.without_states(:idling).join(@company.table_identifier.value, :id => :company_id).filter(:"#{@company.table_identifier.value}__state" => 'active').select(@vehicle.table_identifier.value.to_sym.*).all
     end
     
     def teardown