state_machines-activerecord 0.0.1

data/test/machine_with_complex_pluralization_scopes_test.rb

@@ -0,0 +1,16 @@
+require_relative 'test_helper'
+
+class MachineWithComplexPluralizationScopesTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::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

data/test/machine_with_conflicting_predicate_test.rb

@@ -0,0 +1,18 @@
+require_relative 'test_helper'
+
+class MachineWithConflictingPredicateTest < BaseTestCase
+  def setup
+    @model = new_model do
+      def state?(*args)
+        true
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@model)
+    @record = @model.new
+  end
+
+  def test_should_not_define_attribute_predicate
+    assert @record.state?
+  end
+end

data/test/machine_with_conflicting_state_name_test.rb

@@ -0,0 +1,29 @@
+require_relative 'test_helper'
+require 'stringio'
+
+class MachineWithConflictingStateNameTest < BaseTestCase
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @model = new_model
+  end
+
+  def test_should_output_warning_with_same_machine_name
+    @machine = StateMachines::Machine.new(@model)
+    @machine.state :state
+
+    assert_match(/^Instance method "state\?" is already defined in Foo, use generic helper instead.*\n$/, $stderr.string)
+  end
+
+  def test_should_output_warning_with_same_machine_attribute
+    @machine = StateMachines::Machine.new(@model, :public_state, :attribute => :state)
+    @machine.state :state
+
+    assert_match(/^Instance method "state\?" is already defined in Foo, use generic helper instead.*\n$/, $stderr.string)
+  end
+
+  def teardown
+    $stderr = @original_stderr
+    super
+  end
+end

data/test/machine_with_custom_attribute_test.rb

@@ -0,0 +1,21 @@
+require_relative 'test_helper'
+require 'stringio'
+
+class MachineWithCustomAttributeTest < BaseTestCase
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :public_state, :attribute => :state)
+    @record = @model.new
+  end
+
+  def test_should_not_delegate_attribute_predicate_with_different_attribute
+    assert_raise(ArgumentError) { @record.public_state? }
+  end
+
+  def teardown
+    $stderr = @original_stderr
+    super
+  end
+end

data/test/machine_with_default_scope_test.rb

@@ -0,0 +1,18 @@
+require_relative 'test_helper'
+
+class MachineWithDefaultScopeTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @machine.state :idling
+
+    @model.class_eval do
+      default_scope { with_state(:parked, :idling) }
+    end
+  end
+
+  def test_should_set_initial_state_on_created_object
+    object = @model.new
+    assert_equal 'parked', object.state
+  end
+end

data/test/machine_with_different_column_default_test.rb

@@ -0,0 +1,27 @@
+require_relative 'test_helper'
+require 'stringio'
+
+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 = StateMachines::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 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

data/test/machine_with_different_integer_column_default_test.rb

@@ -0,0 +1,29 @@
+require_relative 'test_helper'
+require 'stringio'
+
+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 = StateMachines::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 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
+

data/test/machine_with_dirty_attribute_and_custom_attributes_during_loopback_test.rb

@@ -0,0 +1,24 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
+  def setup
+    @model = new_model do
+      connection.add_column table_name, :status, :string
+    end
+    @machine = StateMachines::Machine.new(@model, :status, :initial => :parked)
+    @machine.event :park
+
+    @record = @model.create
+
+    @transition = StateMachines::Transition.new(@record, @machine, :park, :parked, :parked)
+    @transition.perform(false)
+  end
+
+  def test_should_not_include_state_in_changed_attributes
+    assert_equal [], @record.changed
+  end
+
+  def test_should_not_track_attribute_changes
+    assert_equal nil, @record.changes['status']
+  end
+end

data/test/machine_with_dirty_attribute_and_state_events_test.rb

@@ -0,0 +1,20 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @machine.event :ignite
+
+    @record = @model.create
+    @record.state_event = 'ignite'
+  end
+
+  def test_should_not_include_state_in_changed_attributes
+    assert_equal [], @record.changed
+  end
+
+  def test_should_not_track_attribute_change
+    assert_equal nil, @record.changes['state']
+  end
+end

data/test/machine_with_dirty_attributes_and_custom_attribute_test.rb

@@ -0,0 +1,32 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
+  def setup
+    @model = new_model do
+      connection.add_column table_name, :status, :string
+    end
+    @machine = StateMachines::Machine.new(@model, :status, :initial => :parked)
+    @machine.event :ignite
+    @machine.state :idling
+
+    @record = @model.create
+
+    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
+    @transition.perform(false)
+  end
+
+  def test_should_include_state_in_changed_attributes
+    assert_equal %w(status), @record.changed
+  end
+
+  def test_should_track_attribute_change
+    assert_equal %w(parked idling), @record.changes['status']
+  end
+
+  def test_should_not_reset_changes_on_multiple_transitions
+    transition = StateMachines::Transition.new(@record, @machine, :ignite, :idling, :idling)
+    transition.perform(false)
+
+    assert_equal %w(parked idling), @record.changes['status']
+  end
+end

data/test/machine_with_dirty_attributes_during_loopback_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributesDuringLoopbackTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @machine.event :park
+
+    @record = @model.create
+
+    @transition = StateMachines::Transition.new(@record, @machine, :park, :parked, :parked)
+    @transition.perform(false)
+  end
+
+  def test_should_not_include_state_in_changed_attributes
+    assert_equal [], @record.changed
+  end
+
+  def test_should_not_track_attribute_changes
+    assert_equal nil, @record.changes['state']
+  end
+end

data/test/machine_with_dirty_attributes_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributesTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @machine.event :ignite
+    @machine.state :idling
+
+    @record = @model.create
+
+    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
+    @transition.perform(false)
+  end
+
+  def test_should_include_state_in_changed_attributes
+    assert_equal %w(state), @record.changed
+  end
+
+  def test_should_track_attribute_change
+    assert_equal %w(parked idling), @record.changes['state']
+  end
+
+  def test_should_not_reset_changes_on_multiple_transitions
+    transition = StateMachines::Transition.new(@record, @machine, :ignite, :idling, :idling)
+    transition.perform(false)
+
+    assert_equal %w(parked idling), @record.changes['state']
+  end
+
+  def test_should_not_have_changes_when_loaded_from_database
+    record = @model.find(@record.id)
+    refute record.changed?
+  end
+end

data/test/machine_with_dynamic_initial_state_test.rb

@@ -0,0 +1,99 @@
+require_relative 'test_helper'
+
+class MachineWithDynamicInitialStateTest < BaseTestCase
+  def setup
+    @model = new_model do
+      attr_accessor :value
+    end
+    @machine = StateMachines::Machine.new(@model, :initial => lambda { |object| :parked })
+    @machine.state :parked
+  end
+
+  def test_should_set_initial_state_on_created_object
+    record = @model.new
+    assert_equal 'parked', record.state
+  end
+
+  def test_should_still_set_attributes
+    record = @model.new(:value => 1)
+    assert_equal 1, record.value
+  end
+
+  def test_should_still_allow_initialize_blocks
+    block_args = nil
+    record = @model.new do |*args|
+      block_args = args
+    end
+
+    assert_equal [record], block_args
+  end
+
+  def test_should_set_attributes_prior_to_initialize_block
+    state = nil
+    @model.new do |record|
+      state = record.state
+    end
+
+    assert_equal 'parked', state
+  end
+
+  def test_should_set_attributes_prior_to_after_initialize_hook
+    state = nil
+    @model.after_initialize do |record|
+      state = record.state
+    end
+    @model.new
+    assert_equal 'parked', state
+  end
+
+  def test_should_set_initial_state_after_setting_attributes
+    @model.class_eval do
+      attr_accessor :state_during_setter
+
+      remove_method :value=
+      define_method(:value=) do |value|
+        self.state_during_setter = state || 'nil'
+      end
+    end
+
+    record = @model.new(:value => 1)
+    assert_equal 'nil', record.state_during_setter
+  end
+
+  def test_should_not_set_initial_state_after_already_initialized
+    record = @model.new(:value => 1)
+    assert_equal 'parked', record.state
+
+    record.state = 'idling'
+    record.attributes = {}
+    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
+
+    record = @model.find(@model.create(:state => 'idling').id)
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_use_stored_values_when_loading_from_database_with_nil_state
+    @machine.state nil
+
+    record = @model.find(@model.create(:state => nil).id)
+    assert_nil record.state
+  end
+end

data/test/machine_with_event_attributes_on_autosave_test.rb

@@ -0,0 +1,48 @@
+require_relative 'test_helper'
+
+class MachineWithEventAttributesOnAutosaveTest < BaseTestCase
+  def setup
+    @vehicle_model = new_model(:vehicle) do
+      connection.add_column table_name, :owner_id, :integer
+    end
+    MachineWithEventAttributesOnAutosaveTest.const_set('Vehicle', @vehicle_model)
+
+    @owner_model = new_model(:owner)
+    MachineWithEventAttributesOnAutosaveTest.const_set('Owner', @owner_model)
+
+    machine = StateMachines::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 => 'MachineWithEventAttributesOnAutosaveTest::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 => 'MachineWithEventAttributesOnAutosaveTest::Vehicle', :autosave => true
+    @owner.vehicles[0].state_event = 'ignite'
+    @owner.save
+
+    @vehicle.reload
+    assert_equal 'idling', @vehicle.state
+  end
+
+  def teardown
+    MachineWithEventAttributesOnAutosaveTest.class_eval do
+      remove_const('Vehicle')
+      remove_const('Owner')
+    end
+    ActiveSupport::Dependencies.clear if defined?(ActiveSupport::Dependencies)
+    super
+  end
+end