state_machine 1.1.2 → 1.2.0

data/test/unit/integrations/active_record_test.rb

@@ -18,8 +18,14 @@ rescue LoadError
   end
 end
 
+require 'active_record/version'
+if ActiveRecord::VERSION::MAJOR >= 4
+  require 'rails/observers/activerecord/active_record'
+  require 'active_record/mass_assignment_security'
+end
+
 # Establish database connection
-ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => ':memory:'})
+ActiveRecord::Base.establish_connection('adapter' => RUBY_PLATFORM == 'java' ? 'jdbcsqlite3' : 'sqlite3', 'database' => ':memory:')
 ActiveRecord::Base.logger = Logger.new("#{File.dirname(__FILE__)}/../../active_record.log")
 
 module ActiveRecordTest
@@ -30,14 +36,15 @@ module ActiveRecordTest
     protected
       # Creates a new ActiveRecord model (and the associated table)
       def new_model(create_table = :foo, &block)
-        table_name = create_table || :foo
+        name = create_table || :foo
+        table_name = "#{name}_#{rand(1000000)}"
         
         model = Class.new(ActiveRecord::Base) do
-          connection.create_table(table_name, :force => true) {|t| t.string(:state)} if create_table
           self.table_name = table_name.to_s
+          connection.create_table(table_name, :force => true) {|t| t.string(:state)} if create_table
           
           (class << self; self; end).class_eval do
-            define_method(:name) { "ActiveRecordTest::#{table_name.to_s.capitalize}" }
+            define_method(:name) { "ActiveRecordTest::#{name.to_s.capitalize}" }
           end
         end
         model.class_eval(&block) if block_given?
@@ -86,7 +93,7 @@ module ActiveRecordTest
     end
     
     def test_should_have_defaults
-      assert_equal e = {:action => :save}, StateMachine::Integrations::ActiveRecord.defaults
+      assert_equal({:action => :save}, StateMachine::Integrations::ActiveRecord.defaults)
     end
     
     def test_should_have_a_locale_path
@@ -101,6 +108,10 @@ module ActiveRecordTest
         def self.connection
           raise ActiveRecord::ConnectionNotEstablished
         end
+        
+        def self.connected?
+          false
+        end
       end
     end
     
@@ -114,7 +125,7 @@ module ActiveRecordTest
       @model = new_model(false)
       
       # Drop the table so that it definitely doesn't exist
-      @model.connection.drop_table(:foo) if @model.table_exists?
+      @model.connection.drop_table(@model.table_name) if @model.table_exists?
     end
     
     def test_should_allow_machine_creation
@@ -159,7 +170,7 @@ module ActiveRecordTest
   
   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)
@@ -191,7 +202,7 @@ module ActiveRecordTest
     
     def test_should_set_attributes_prior_to_initialize_block
       state = nil
-      record = @model.new do |record|
+      @model.new do |record|
         state = record.state
       end
       
@@ -200,7 +211,7 @@ module ActiveRecordTest
     
     def test_should_set_attributes_prior_to_after_initialize_hook
       state = nil
-      @model.class_eval {define_method(:after_initialize) {}} if ::ActiveRecord::VERSION::MAJOR <= 2
+      @model.class_eval {define_method(:after_initialize) {}} if ActiveRecord::VERSION::MAJOR <= 2
       @model.after_initialize do |record|
         state = record.state
       end
@@ -212,6 +223,7 @@ module ActiveRecordTest
       @model.class_eval do
         attr_accessor :state_during_setter
         
+        remove_method :value=
         define_method(:value=) do |value|
           self.state_during_setter = state
         end
@@ -230,6 +242,22 @@ module ActiveRecordTest
       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
+    
+    unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+      def test_should_persist_initial_state_on_dup
+        record = @model.create.dup
+        record.save
+        record.reload
+        assert_equal 'parked', record.state
+      end
+    end
+    
     def test_should_use_stored_values_when_loading_from_database
       @machine.state :idling
       
@@ -243,6 +271,68 @@ module ActiveRecordTest
       record = @model.find(@model.create(:state => nil).id)
       assert_nil record.state
     end
+    
+    def test_should_use_stored_values_when_loading_for_many_association
+      @machine.state :idling
+      
+      @model.connection.add_column @model.table_name, :owner_id, :integer
+      @model.reset_column_information
+      ActiveRecordTest.const_set('Vehicle', @model)
+      
+      owner_model = new_model(:owner) do
+        has_many :vehicles, :class_name => 'ActiveRecordTest::Vehicle'
+      end
+      ActiveRecordTest.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
+    
+    def test_should_use_stored_values_when_loading_for_one_association
+      @machine.state :idling
+      
+      @model.connection.add_column @model.table_name, :owner_id, :integer
+      @model.reset_column_information
+      ActiveRecordTest.const_set('Vehicle', @model)
+      
+      owner_model = new_model(:owner) do
+        has_one :vehicle, :class_name => 'ActiveRecordTest::Vehicle'
+      end
+      ActiveRecordTest.const_set('Owner', owner_model)
+      
+      owner = owner_model.create
+      record = @model.create(:state => 'idling', :owner_id => owner.id)
+      assert_equal 'idling', owner.vehicle.state
+    end
+    
+    def test_should_use_stored_values_when_loading_for_belongs_to_association
+      @machine.state :idling
+      
+      ActiveRecordTest.const_set('Vehicle', @model)
+      
+      driver_model = new_model(:driver) do
+        connection.add_column table_name, :vehicle_id, :integer
+        
+        belongs_to :vehicle, :class_name => 'ActiveRecordTest::Vehicle'
+      end
+
+      ActiveRecordTest.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
+      ActiveRecordTest.class_eval do
+        remove_const('Vehicle') if defined?(ActiveRecordTest::Vehicle)
+        remove_const('Owner') if defined?(ActiveRecordTest::Owner)
+        remove_const('Driver') if defined?(ActiveRecordTest::Driver)
+      end
+      ActiveSupport::Dependencies.clear if defined?(ActiveSupport::Dependencies)
+      super
+    end
   end
   
   class MachineWithDynamicInitialStateTest < BaseTestCase
@@ -275,7 +365,7 @@ module ActiveRecordTest
     
     def test_should_set_attributes_prior_to_initialize_block
       state = nil
-      record = @model.new do |record|
+      @model.new do |record|
         state = record.state
       end
       
@@ -284,7 +374,7 @@ module ActiveRecordTest
     
     def test_should_set_attributes_prior_to_after_initialize_hook
       state = nil
-      @model.class_eval {define_method(:after_initialize) {}} if ::ActiveRecord::VERSION::MAJOR <= 2
+      @model.class_eval {define_method(:after_initialize) {}} if ActiveRecord::VERSION::MAJOR <= 2
       @model.after_initialize do |record|
         state = record.state
       end
@@ -296,6 +386,7 @@ module ActiveRecordTest
       @model.class_eval do
         attr_accessor :state_during_setter
         
+        remove_method :value=
         define_method(:value=) do |value|
           self.state_during_setter = state || 'nil'
         end
@@ -314,6 +405,22 @@ module ActiveRecordTest
       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
+    
+    unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+      def test_should_persist_initial_state_on_dup
+        record = @model.create.dup
+        record.save
+        record.reload
+        assert_equal 'parked', record.state
+      end
+    end
+    
     def test_should_use_stored_values_when_loading_from_database
       @machine.state :idling
       
@@ -341,10 +448,12 @@ module ActiveRecordTest
     end
   end
   
-  class MachineWithColumnDefaultTest < BaseTestCase
+  class MachineWithSameColumnDefaultTest < BaseTestCase
     def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
       @model = new_model do
-        connection.add_column :foo, :status, :string, :default => 'idling'
+        connection.add_column table_name, :status, :string, :default => 'parked'
       end
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
       @record = @model.new
@@ -353,6 +462,66 @@ module ActiveRecordTest
     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
+      super
+    end
+  end
+  
+  class MachineWithDifferentColumnDefaultTest < BaseTestCase
+    def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model do
+        connection.add_column table_name, :status, :string, :default => 'idling'
+      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 ActiveRecordTest::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
+      super
+    end
+  end
+  
+  class MachineWithDifferentIntegerColumnDefaultTest < BaseTestCase
+    def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model do
+        connection.add_column table_name, :status, :integer, :default => 0
+      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 ActiveRecordTest::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
+      super
+    end
   end
   
   class MachineWithConflictingPredicateTest < BaseTestCase
@@ -384,18 +553,19 @@ module ActiveRecordTest
       @machine = StateMachine::Machine.new(@model)
       @machine.state :state
       
-      assert_match /^Instance method "state\?" is already defined in ActiveRecordTest::Foo, use generic helper instead.*\n$/, $stderr.string
+      assert_match(/^Instance method "state\?" is already defined in ActiveRecordTest::Foo, use generic helper instead.*\n$/, $stderr.string)
     end
     
     def test_should_output_warning_with_same_machine_attribute
       @machine = StateMachine::Machine.new(@model, :public_state, :attribute => :state)
       @machine.state :state
       
-      assert_match /^Instance method "state\?" is already defined in ActiveRecordTest::Foo, use generic helper instead.*\n$/, $stderr.string
+      assert_match(/^Instance method "state\?" is already defined in ActiveRecordTest::Foo, use generic helper instead.*\n$/, $stderr.string)
     end
     
     def teardown
       $stderr = @original_stderr
+      super
     end
   end
   
@@ -545,6 +715,7 @@ module ActiveRecordTest
     
     def teardown
       $stderr = @original_stderr
+      super
     end
   end
   
@@ -594,7 +765,7 @@ module ActiveRecordTest
   class MachineMultipleTest < BaseTestCase
     def setup
       @model = new_model do
-        connection.add_column :foo, :status, :string
+        connection.add_column table_name, :status, :string
       end
       @state_machine = StateMachine::Machine.new(@model, :initial => :parked)
       @status_machine = StateMachine::Machine.new(@model, :status, :initial => :idling)
@@ -610,7 +781,7 @@ module ActiveRecordTest
   class MachineWithLoopbackTest < BaseTestCase
     def setup
       @model = new_model do
-        connection.add_column :foo, :updated_at, :datetime
+        connection.add_column table_name, :updated_at, :datetime
       end
       
       @machine = StateMachine::Machine.new(@model, :initial => :parked)
@@ -693,7 +864,7 @@ module ActiveRecordTest
     class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
       def setup
         @model = new_model do
-          connection.add_column :foo, :status, :string, :default => 'idling'
+          connection.add_column table_name, :status, :string
         end
         @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
         @machine.event :ignite
@@ -724,7 +895,7 @@ module ActiveRecordTest
     class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
       def setup
         @model = new_model do
-          connection.add_column :foo, :status, :string, :default => 'idling'
+          connection.add_column table_name, :status, :string
         end
         @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
         @machine.event :park
@@ -910,11 +1081,21 @@ module ActiveRecordTest
     def test_should_run_around_callbacks
       before_called = false
       after_called = false
-      @machine.around_transition {|block| before_called = true; block.call; after_called = true}
+      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
+      assert_equal ensure_called, 1
     end
     
     def test_should_include_transition_states_in_known_states
@@ -947,6 +1128,33 @@ module ActiveRecordTest
       
       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
@@ -984,6 +1192,42 @@ module ActiveRecordTest
     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_equal true, result
+      assert_equal "idling", @record.state
+      @record.reload
+      assert_equal "idling", @record.state
+    end
+    
+    def test_should_allow_transition_after_creation
+      record = @record
+      @model.after_create { record.ignite }
+      result = @record.save
+      
+      assert_equal true, result
+      assert_equal "idling", @record.state
+      @record.reload
+      assert_equal "idling", @record.state
+    end
+  end
+  
   class MachineWithFailedActionTest < BaseTestCase
     def setup
       @model = new_model do
@@ -1023,7 +1267,7 @@ module ActiveRecordTest
   end
   
   class MachineWithFailedAfterCallbacksTest < BaseTestCase
-     def setup
+    def setup
       @callbacks = []
       
       @model = new_model
@@ -1103,10 +1347,7 @@ module ActiveRecordTest
   
   class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
     def setup
-      @model = new_model do
-        alias_attribute :status, :state
-      end
-      
+      @model = new_model
       @machine = StateMachine::Machine.new(@model, :status, :attribute => :state)
       @machine.state :parked
       
@@ -1212,7 +1453,11 @@ module ActiveRecordTest
       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
     
@@ -1259,7 +1504,11 @@ module ActiveRecordTest
       ran_callback = false
       @machine.around_transition {|block| block.call; ran_callback = true }
       
-      @record.valid?
+      begin
+        @record.valid?
+      rescue ArgumentError
+        raise if StateMachine::Transition.pause_supported?
+      end
       assert !ran_callback
     end
     
@@ -1426,6 +1675,89 @@ module ActiveRecordTest
       
       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) { @record.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) { @record.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 ActiveRecord::Rollback }
+      
+      assert_equal nil, @record.save
+    end
+  end
+  
+  if ActiveRecord::VERSION::MAJOR >= 3 || ActiveRecord::VERSION::MINOR >= 3
+    class MachineWithEventAttributesOnAutosaveTest < BaseTestCase
+      def setup
+        @vehicle_model = new_model(:vehicle) do
+          connection.add_column table_name, :owner_id, :integer
+        end
+        ActiveRecordTest.const_set('Vehicle', @vehicle_model)
+        
+        @owner_model = new_model(:owner)
+        ActiveRecordTest.const_set('Owner', @owner_model)
+        
+        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_persist_has_one_autosave
+        @owner_model.has_one :vehicle, :class_name => 'ActiveRecordTest::Vehicle', :autosave => true
+        @owner.vehicle.state_event = 'ignite'
+        @owner.save
+        
+        @vehicle.reload
+        assert_equal 'idling', @vehicle.state
+      end
+      
+      def test_should_persist_has_many_autosave
+        @owner_model.has_many :vehicles, :class_name => 'ActiveRecordTest::Vehicle', :autosave => true
+        @owner.vehicles[0].state_event = 'ignite'
+        @owner.save
+        
+        @vehicle.reload
+        assert_equal 'idling', @vehicle.state
+      end
+      
+      def teardown
+        ActiveRecordTest.class_eval do
+          remove_const('Vehicle')
+          remove_const('Owner')
+        end
+        ActiveSupport::Dependencies.clear if defined?(ActiveSupport::Dependencies)
+        super
+      end
+    end
   end
   
   class MachineWithEventAttributesOnSaveBangTest < BaseTestCase
@@ -1571,7 +1903,6 @@ module ActiveRecordTest
         :before_transition
       ]
       
-      notified = false
       observer = new_observer(@model) do
         callbacks.each do |callback|
           define_method(callback) do |*args|
@@ -1586,6 +1917,31 @@ module ActiveRecordTest
       assert_equal callbacks, instance.notifications
     end
     
+    def test_should_call_no_transition_callbacks_when_observers_disabled
+      return unless ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR >= 1
+      
+      callbacks = [
+        :before_ignite,
+        :before_transition
+      ]
+      
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      @model.observers.disable(observer) do
+        @transition.perform
+      end
+      
+      assert_equal [], instance.notifications
+    end
+    
     def test_should_pass_record_and_transition_to_before_callbacks
       observer = new_observer(@model) do
         def before_transition(*args)
@@ -1625,7 +1981,7 @@ module ActiveRecordTest
     def test_should_continue_to_handle_non_state_machine_callbacks
       observer = new_observer(@model) do
         def before_save(object)
-          notifications << [:before_save, @object]
+          notifications << [:before_save, object]
         end
         
         def before_ignite(*args)
@@ -1636,7 +1992,7 @@ module ActiveRecordTest
       instance = observer.instance
       
       @transition.perform
-      assert_equal [:before_ignite, [:before_save, @object]], instance.notifications
+      assert_equal [:before_ignite, [:before_save, @record]], instance.notifications
     end
     
     def test_should_support_nil_from_states
@@ -1647,7 +2003,6 @@ module ActiveRecordTest
         :before_transition_state_from_nil
       ]
       
-      notified = false
       observer = new_observer(@model) do
         callbacks.each do |callback|
           define_method(callback) do |*args|
@@ -1671,7 +2026,6 @@ module ActiveRecordTest
         :before_transition_state_to_nil
       ]
       
-      notified = false
       observer = new_observer(@model) do
         callbacks.each do |callback|
           define_method(callback) do |*args|
@@ -1840,7 +2194,7 @@ module ActiveRecordTest
       
       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).find(:all)
       end
@@ -1941,7 +2295,7 @@ module ActiveRecordTest
         ActiveRecordTest.const_set('Company', @company)
         
         @vehicle = new_model(:vehicle) do
-          connection.add_column :vehicle, :company_id, :integer
+          connection.add_column table_name, :company_id, :integer
           belongs_to :company, :class_name => 'ActiveRecordTest::Company'
         end
         ActiveRecordTest.const_set('Vehicle', @vehicle)
@@ -1955,11 +2309,11 @@ module ActiveRecordTest
       end
       
       def test_should_find_records_in_with_scope
-        assert_equal [@mustang], @vehicle.with_states(:parked).find(:all, :include => :company, :conditions => 'company.state = "active"')
+        assert_equal [@mustang], @vehicle.with_states(:parked).find(:all, :joins => :company, :conditions => "#{@company.table_name}.state = \"active\"")
       end
       
       def test_should_find_records_in_without_scope
-        assert_equal [@mustang], @vehicle.without_states(:idling).find(:all, :include => :company, :conditions => 'company.state = "active"')
+        assert_equal [@mustang], @vehicle.without_states(:idling).find(:all, :joins => :company, :conditions => "#{@company.table_name}.state = \"active\"")
       end
       
       def teardown
@@ -1967,6 +2321,8 @@ module ActiveRecordTest
           remove_const('Vehicle')
           remove_const('Company')
         end
+        ActiveSupport::Dependencies.clear if defined?(ActiveSupport::Dependencies)
+        super
       end
     end
   else
@@ -1981,7 +2337,7 @@ module ActiveRecordTest
         @machine.state :idling
         
         @model.class_eval do
-          default_scope with_state(:parked, :idling)
+          default_scope { with_state(:parked, :idling) }
         end
       end