state_machines-activerecord 0.9.0 → 0.31.0

data/test/machine_with_failed_action_test.rb

@@ -1,40 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithFailedActionTest < BaseTestCase
-  def setup
-    @model = new_model do
-      validates_inclusion_of :state, :in => %w(first_gear)
-    end
-
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-
-    @callbacks = []
-    @machine.before_transition { @callbacks << :before }
-    @machine.after_transition { @callbacks << :after }
-    @machine.after_failure { @callbacks << :after_failure }
-    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
-
-    @record = @model.new(:state => 'parked')
-    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
-  end
-
-  def test_should_not_be_successful
-    refute @result
-  end
-
-  def test_should_not_change_current_state
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_not_save_record
-    assert @record.new_record?
-  end
-
-  def test_should_run_before_callbacks_and_after_callbacks_with_failures
-    assert_equal [:before, :around_before, :after_failure], @callbacks
-  end
-end
-

data/test/machine_with_failed_after_callbacks_test.rb

@@ -1,35 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithFailedAfterCallbacksTest < BaseTestCase
-  def setup
-    @callbacks = []
-
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @machine.after_transition { @callbacks << :after_1; false }
-    @machine.after_transition { @callbacks << :after_2 }
-    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
-
-    @record = @model.new(:state => 'parked')
-    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
-  end
-
-  def test_should_be_successful
-    assert @result
-  end
-
-  def test_should_change_current_state
-    assert_equal 'idling', @record.state
-  end
-
-  def test_should_save_record
-    refute @record.new_record?
-  end
-
-  def test_should_not_run_further_after_callbacks
-    assert_equal [:around_before, :around_after, :after_1], @callbacks
-  end
-end

data/test/machine_with_failed_before_callbacks_test.rb

@@ -1,36 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithFailedBeforeCallbacksTest < BaseTestCase
-  def setup
-    @callbacks = []
-
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @machine.before_transition { @callbacks << :before_1; false }
-    @machine.before_transition { @callbacks << :before_2 }
-    @machine.after_transition { @callbacks << :after }
-    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
-
-    @record = @model.new(:state => 'parked')
-    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
-  end
-
-  def test_should_not_be_successful
-    refute @result
-  end
-
-  def test_should_not_change_current_state
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_not_run_action
-    assert @record.new_record?
-  end
-
-  def test_should_not_run_further_callbacks
-    assert_equal [:before_1], @callbacks
-  end
-end

data/test/machine_with_initialized_state_test.rb

@@ -1,41 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithInitializedStateTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :initial => :parked)
-    @machine.state :idling
-  end
-
-  def test_should_allow_nil_initial_state_when_static
-    @machine.state nil
-
-    record = @model.new(:state => nil)
-    assert_nil record.state
-  end
-
-  def test_should_allow_nil_initial_state_when_dynamic
-    @machine.state nil
-
-    @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_using_create_with
-    record = @model.create_with(state: 'idling').new
-
-    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
-end

data/test/machine_with_internationalization_test.rb

@@ -1,180 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithInternationalizationTest < BaseTestCase
-  def setup
-    I18n.backend = I18n::Backend::Simple.new
-
-    # Initialize the backend
-    StateMachines::Machine.new(new_model)
-
-    @model = new_model
-  end
-
-  def test_should_use_defaults
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:errors => {:messages => {:invalid_transition => "cannot #{interpolation_key('event')}"}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.state :parked, :idling
-    machine.event :ignite
-
-    record = @model.new(:state => 'idling')
-
-    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
-    assert_equal ['State cannot transition via "ignite"'], record.errors.full_messages
-  end
-
-  def test_should_allow_customized_error_key
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:errors => {:messages => {:bad_transition => "cannot #{interpolation_key('event')}"}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model, :messages => {:invalid_transition => :bad_transition})
-    machine.state :parked, :idling
-
-    record = @model.new(:state => 'idling')
-
-    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
-    assert_equal ['State cannot ignite'], record.errors.full_messages
-  end
-
-  def test_should_allow_customized_error_string
-    machine = StateMachines::Machine.new(@model, :messages => {:invalid_transition => "cannot #{interpolation_key('event')}"})
-    machine.state :parked, :idling
-
-    record = @model.new(:state => 'idling')
-
-    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
-    assert_equal ['State cannot ignite'], record.errors.full_messages
-  end
-
-  def test_should_allow_customized_state_key_scoped_to_class_and_machine
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:'foo' => {:state => {:states => {:parked => 'shutdown'}}}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.state :parked
-
-    assert_equal 'shutdown', machine.state(:parked).human_name
-  end
-
-  def test_should_allow_customized_state_key_scoped_to_class
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:'foo' => {:states => {:parked => 'shutdown'}}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.state :parked
-
-    assert_equal 'shutdown', machine.state(:parked).human_name
-  end
-
-  def test_should_allow_customized_state_key_scoped_to_machine
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:state => {:states => {:parked => 'shutdown'}}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.state :parked
-
-    assert_equal 'shutdown', machine.state(:parked).human_name
-  end
-
-  def test_should_allow_customized_state_key_unscoped
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:states => {:parked => 'shutdown'}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.state :parked
-
-    assert_equal 'shutdown', machine.state(:parked).human_name
-  end
-
-  def test_should_support_nil_state_key
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:states => {:nil => 'empty'}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-
-    assert_equal 'empty', machine.state(nil).human_name
-  end
-
-  def test_should_allow_customized_event_key_scoped_to_class_and_machine
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:'foo' => {:state => {:events => {:park => 'stop'}}}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.event :park
-
-    assert_equal 'stop', machine.event(:park).human_name
-  end
-
-  def test_should_allow_customized_event_key_scoped_to_class
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:'foo' => {:events => {:park => 'stop'}}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.event :park
-
-    assert_equal 'stop', machine.event(:park).human_name
-  end
-
-  def test_should_allow_customized_event_key_scoped_to_machine
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:state => {:events => {:park => 'stop'}}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.event :park
-
-    assert_equal 'stop', machine.event(:park).human_name
-  end
-
-  def test_should_allow_customized_event_key_unscoped
-    I18n.backend.store_translations(:en, {
-                                           :activerecord => {:state_machines => {:events => {:park => 'stop'}}}
-                                       })
-
-    machine = StateMachines::Machine.new(@model)
-    machine.event :park
-
-    assert_equal 'stop', machine.event(:park).human_name
-  end
-
-  def test_should_only_add_locale_once_in_load_path
-    assert_equal 1, I18n.load_path.select { |path| path =~ %r{active_record/locale\.rb$} }.length
-
-    # Create another ActiveRecord model that will trigger the i18n feature
-    new_model
-
-    assert_equal 1, I18n.load_path.select { |path| path =~ %r{active_record/locale\.rb$} }.length
-  end
-
-  def test_should_prefer_other_locales_first
-    @original_load_path = I18n.load_path
-    I18n.backend = I18n::Backend::Simple.new
-    I18n.load_path = [File.dirname(__FILE__) + '/files/en.yml']
-
-    machine = StateMachines::Machine.new(@model)
-    machine.state :parked, :idling
-    machine.event :ignite
-
-    record = @model.new(:state => 'idling')
-
-    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
-    assert_equal ['State cannot transition'], record.errors.full_messages
-  ensure
-    I18n.load_path = @original_load_path
-  end
-
-  private
-  def interpolation_key(key)
-    "%{#{key}}"
-  end
-end

data/test/machine_with_loopback_test.rb

@@ -1,22 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithLoopbackTest < BaseTestCase
-  def setup
-    @model = new_model do
-      connection.add_column table_name, :updated_at, :datetime
-    end
-
-    @machine = StateMachines::Machine.new(@model, :initial => :parked)
-    @machine.event :park
-
-    @record = @model.create(:updated_at => Time.now - 1)
-    @transition = StateMachines::Transition.new(@record, @machine, :park, :parked, :parked)
-
-    @timestamp = @record.updated_at
-    @transition.perform
-  end
-
-  def test_should_not_update_record
-    assert_equal @timestamp, @record.updated_at
-  end
-end

data/test/machine_with_non_column_state_attribute_defined_test.rb

@@ -1,29 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithNonColumnStateAttributeDefinedTest < BaseTestCase
-  def setup
-    @model = new_model do
-      attr_accessor :status
-    end
-
-    @machine = StateMachines::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
-    refute @record.status?(:idling)
-  end
-
-  def test_should_return_true_for_predicate_if_matches_current_value
-    assert @record.status?(:parked)
-  end
-
-  def test_should_raise_exception_for_predicate_if_invalid_state_specified
-    assert_raise(IndexError) { @record.status?(:invalid) }
-  end
-
-  def test_should_set_initial_state_on_created_object
-    assert_equal 'parked', @record.status
-  end
-end

data/test/machine_with_same_column_default_test.rb

@@ -1,26 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithSameColumnDefaultTest < BaseTestCase
-  def setup
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    @model = new_model do
-      connection.add_column table_name, :status, :string, :default => 'parked'
-    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_not_generate_a_warning
-    assert_no_match(/have defined a different default/, $stderr.string)
-  end
-
-  def teardown
-    $stderr = @original_stderr
-    super
-  end
-end

data/test/machine_with_same_integer_column_default_test.rb

@@ -1,30 +0,0 @@
-require_relative 'test_helper'
-require 'stringio'
-
-class MachineWithSameIntegerColumnDefaultTest < BaseTestCase
-  def setup
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    @model = new_model do
-      connection.add_column table_name, :status, :integer, :default => 1
-    end
-    @machine = StateMachines::Machine.new(@model, :status, :initial => :parked) do
-      state :parked, :value => 1
-    end
-    @record = @model.new
-  end
-
-  def test_should_use_machine_default
-    assert_equal 1, @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
-

data/test/machine_with_scopes_and_joins_test.rb

@@ -1,38 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithScopesAndJoinsTest < BaseTestCase
-  def setup
-    @company = new_model(:company)
-    MachineWithScopesAndJoinsTest.const_set('Company', @company)
-
-    @vehicle = new_model(:vehicle) do
-      connection.add_column table_name, :company_id, :integer
-      belongs_to :company, :class_name => 'MachineWithScopesAndJoinsTest::Company'
-    end
-    MachineWithScopesAndJoinsTest.const_set('Vehicle', @vehicle)
-
-    @company_machine = StateMachines::Machine.new(@company, :initial => :active)
-    @vehicle_machine = StateMachines::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).joins(:company).where("#{@company.table_name}.state = \"active\"")
-  end
-
-  def test_should_find_records_in_without_scope
-    assert_equal [@mustang], @vehicle.without_states(:idling).joins(:company).where("#{@company.table_name}.state = \"active\"")
-  end
-
-  def teardown
-    MachineWithScopesAndJoinsTest.class_eval do
-      remove_const('Vehicle')
-      remove_const('Company')
-    end
-
-    clear_active_support_dependencies
-  end
-end

data/test/machine_with_scopes_and_owner_subclass_test.rb

@@ -1,27 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithScopesAndOwnerSubclassTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::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'
-    @subclass.create :state => 'first_gear'
-
-    assert_equal [parked, idling], @subclass.without_states(:first_gear).all
-  end
-end

data/test/machine_with_scopes_test.rb

@@ -1,70 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithScopesTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked, :first_gear
-    @machine.state :idling, :value => -> { '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'
-    @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_allow_lookup_by_string_name
-    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'
-    @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'
-    @model.create :state => 'first_gear'
-
-    assert_equal [parked, idling], @model.without_states(:first_gear).all
-  end
-
-  def test_should_allow_chaining_scopes
-    @model.create :state => 'parked'
-    idling = @model.create :state => 'idling'
-
-    assert_equal [idling], @model.without_state(:parked).with_state(:idling).all
-  end
-end
-

data/test/machine_with_state_driven_validations_test.rb

@@ -1,30 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithStateDrivenValidationsTest < BaseTestCase
-  def setup
-    @model = new_model do
-      attr_accessor :seatbelt
-    end
-
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :first_gear, :second_gear do
-      validates :seatbelt, presence: true
-    end
-    @machine.other_states :parked
-  end
-
-  def test_should_be_valid_if_validation_fails_outside_state_scope
-    record = @model.new(:state => 'parked', :seatbelt => nil)
-    assert record.valid?
-  end
-
-  def test_should_be_invalid_if_validation_fails_within_state_scope
-    record = @model.new(:state => 'first_gear', :seatbelt => nil)
-    refute record.valid?
-  end
-
-  def test_should_be_valid_if_validation_succeeds_within_state_scope
-    record = @model.new(:state => 'second_gear', :seatbelt => true)
-    assert record.valid?
-  end
-end

data/test/machine_with_states_test.rb

@@ -1,13 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithStatesTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :first_gear
-  end
-
-  def test_should_humanize_name
-    assert_equal 'first gear', @machine.state(:first_gear).human_name
-  end
-end