state_machines-activerecord 0.9.0 → 0.40.0

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

data/test/machine_with_static_initial_state_test.rb

@@ -1,167 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithStaticInitialStateTest < BaseTestCase
-  def setup
-    @model = new_model(:vehicle) do
-      attr_accessor :value
-    end
-    @machine = StateMachines::Machine.new(@model, :initial => :parked)
-  end
-
-  def test_should_set_initial_state_on_created_object
-    record = @model.new
-    assert_equal 'parked', record.state
-  end
-
-  def test_should_set_initial_state_with_nil_attributes
-    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
-  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_before_setting_attributes
-    @model.class_eval do
-      attr_accessor :state_during_setter
-
-      remove_method :value=
-      define_method(:value=) do |value|
-        self.state_during_setter = state
-      end
-    end
-    record = @model.new
-    record.value = 1
-    assert_equal 'parked', 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
-
-  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
-    MachineWithStaticInitialStateTest.const_set('Vehicle', @model)
-
-    owner_model = new_model(:owner) do
-      has_many :vehicles, :class_name => 'MachineWithStaticInitialStateTest::Vehicle'
-    end
-    MachineWithStaticInitialStateTest.const_set('Owner', owner_model)
-
-    owner = owner_model.create
-    @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
-    MachineWithStaticInitialStateTest.const_set('Vehicle', @model)
-
-    owner_model = new_model(:owner) do
-      has_one :vehicle, :class_name => 'MachineWithStaticInitialStateTest::Vehicle'
-    end
-    MachineWithStaticInitialStateTest.const_set('Owner', owner_model)
-
-    owner = owner_model.create
-    @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
-
-    MachineWithStaticInitialStateTest.const_set('Vehicle', @model)
-
-    driver_model = new_model(:driver) do
-      connection.add_column table_name, :vehicle_id, :integer
-
-      belongs_to :vehicle, :class_name => 'MachineWithStaticInitialStateTest::Vehicle'
-    end
-
-    MachineWithStaticInitialStateTest.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
-    MachineWithStaticInitialStateTest.class_eval do
-      remove_const('Vehicle') if defined?(MachineWithStaticInitialStateTest::Vehicle)
-      remove_const('Owner') if defined?(MachineWithStaticInitialStateTest::Owner)
-      remove_const('Driver') if defined?(MachineWithStaticInitialStateTest::Driver)
-    end
-
-    clear_active_support_dependencies
-    super
-  end
-end
-

data/test/machine_with_transactions_test.rb

@@ -1,26 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithTransactionsTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :use_transactions => true)
-  end
-
-  def test_should_rollback_transaction_if_false
-    @machine.within_transaction(@model.new) do
-      @model.create
-      false
-    end
-
-    assert_equal 0, @model.count
-  end
-
-  def test_should_not_rollback_transaction_if_true
-    @machine.within_transaction(@model.new) do
-      @model.create
-      true
-    end
-
-    assert_equal 1, @model.count
-  end
-end

data/test/machine_with_validations_and_custom_attribute_test.rb

@@ -1,21 +0,0 @@
-require_relative 'test_helper'
-
-class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model, :status, :attribute => :state)
-    @machine.state :parked
-
-    @record = @model.new
-  end
-
-  def test_should_add_validation_errors_to_custom_attribute
-    @record.state = 'invalid'
-
-    refute @record.valid?
-    assert_equal ['State is invalid'], @record.errors.full_messages
-
-    @record.state = 'parked'
-    assert @record.valid?
-  end
-end