state_machines-activerecord 0.8.0 → 0.100.0

data/test/machine_with_aliased_attribute_test.rb

@@ -1,23 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithAliasedAttributeTest < BaseTestCase
-  def setup
-    @model = new_model do
-      alias_attribute :vehicle_status, :state
-    end
-
-    @machine = StateMachines::Machine.new(@model, :status, :attribute => :vehicle_status)
-    @machine.state :parked
-
-    @record = @model.new
-  end
-
-  def test_should_check_custom_attribute_for_predicate
-    @record.vehicle_status = nil
-    refute @record.status?(:parked)
-
-    @record.vehicle_status = 'parked'
-    assert @record.status?(:parked)
-  end
-end
-

data/test/machine_with_callbacks_test.rb

@@ -1,172 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithCallbacksTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :initial => :parked)
-    @machine.other_states :idling
-    @machine.event :ignite
-
-    @record = @model.new(:state => 'parked')
-    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
-  end
-
-  def test_should_run_before_callbacks
-    called = false
-    @machine.before_transition { called = true }
-
-    @transition.perform
-    assert called
-  end
-
-  def test_should_pass_record_to_before_callbacks_with_one_argument
-    record = nil
-    @machine.before_transition { |arg| record = arg }
-
-    @transition.perform
-    assert_equal @record, record
-  end
-
-  def test_should_pass_record_and_transition_to_before_callbacks_with_multiple_arguments
-    callback_args = nil
-    @machine.before_transition { |*args| callback_args = args }
-
-    @transition.perform
-    assert_equal [@record, @transition], callback_args
-  end
-
-  def test_should_run_before_callbacks_outside_the_context_of_the_record
-    context = nil
-    @machine.before_transition { context = self }
-
-    @transition.perform
-    assert_equal self, context
-  end
-
-  def test_should_run_after_callbacks
-    called = false
-    @machine.after_transition { called = true }
-
-    @transition.perform
-    assert called
-  end
-
-  def test_should_pass_record_to_after_callbacks_with_one_argument
-    record = nil
-    @machine.after_transition { |arg| record = arg }
-
-    @transition.perform
-    assert_equal @record, record
-  end
-
-  def test_should_pass_record_and_transition_to_after_callbacks_with_multiple_arguments
-    callback_args = nil
-    @machine.after_transition { |*args| callback_args = args }
-
-    @transition.perform
-    assert_equal [@record, @transition], callback_args
-  end
-
-  def test_should_run_after_callbacks_outside_the_context_of_the_record
-    context = nil
-    @machine.after_transition { context = self }
-
-    @transition.perform
-    assert_equal self, context
-  end
-
-  def test_should_run_after_callbacks_if_model_callback_added_prior_to_state_machine_definition
-    model = new_model do
-      after_save { nil }
-    end
-    machine = StateMachines::Machine.new(model, :initial => :parked)
-    machine.other_states :idling
-    machine.event :ignite
-    after_called = false
-    machine.after_transition { after_called = true }
-
-    record = model.new(:state => 'parked')
-    transition = StateMachines::Transition.new(record, machine, :ignite, :parked, :idling)
-    transition.perform
-    assert_equal true, after_called
-  end
-
-  def test_should_run_around_callbacks
-    before_called = false
-    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
-    assert_equal ensure_called, 1
-  end
-
-  def test_should_include_transition_states_in_known_states
-    @machine.before_transition :to => :first_gear, :do => lambda {}
-
-    assert_equal [:parked, :idling, :first_gear], @machine.states.map { |state| state.name }
-  end
-
-  def test_should_allow_symbolic_callbacks
-    callback_args = nil
-
-    klass = class << @record;
-      self;
-    end
-    klass.send(:define_method, :after_ignite) do |*args|
-      callback_args = args
-    end
-
-    @machine.before_transition(:after_ignite)
-
-    @transition.perform
-    assert_equal [@transition], callback_args
-  end
-
-  def test_should_allow_string_callbacks
-    class << @record
-      attr_reader :callback_result
-    end
-
-    @machine.before_transition('@callback_result = [1, 2, 3]')
-    @transition.perform
-
-    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 }
-    @model.after_commit { callbacks << :after_commit }
-    expected << :after_commit
-
-    @machine.before_transition { callbacks << :before_transition }
-    @machine.after_transition { callbacks << :after_transition }
-
-    @transition.perform
-
-    assert_equal expected, callbacks
-  end
-end
-

data/test/machine_with_column_state_attribute_test.rb

@@ -1,44 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithColumnStateAttributeTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :initial => :parked)
-    @machine.other_states(:idling)
-
-    @record = @model.new
-  end
-
-  def test_should_not_override_the_column_reader
-    @record[:state] = 'parked'
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_not_override_the_column_writer
-    @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_test_for_existence_on_predicate_without_parameters
-    assert @record.state?
-
-    @record.state = nil
-    refute @record.state?
-  end
-
-  def test_should_return_false_for_predicate_if_does_not_match_current_value
-    refute @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_raises(IndexError) { @record.state?(:invalid) }
-  end
-end

data/test/machine_with_complex_pluralization_scopes_test.rb

@@ -1,16 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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_nil @record.changes['status']
-  end
-end

data/test/machine_with_dirty_attribute_and_state_events_test.rb

@@ -1,20 +0,0 @@
-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_nil @record.changes['state']
-  end
-end

data/test/machine_with_dirty_attributes_and_custom_attribute_test.rb

@@ -1,32 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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_nil @record.changes['state']
-  end
-end

data/test/machine_with_dirty_attributes_test.rb

@@ -1,35 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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