state_machines-activerecord 0.0.1

data/test/machine_with_scopes_and_joins_test.rb

@@ -0,0 +1,37 @@
+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
+    ActiveSupport::Dependencies.clear
+  end
+end

data/test/machine_with_scopes_and_owner_subclass_test.rb

@@ -0,0 +1,27 @@
+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'
+    first_gear = @subclass.create :state => 'first_gear'
+
+    assert_equal [parked, idling], @subclass.without_states(:first_gear).all
+  end
+end

data/test/machine_with_scopes_test.rb

@@ -0,0 +1,70 @@
+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'
+    idling = @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'
+    first_gear = @model.create :state => 'first_gear'
+
+    assert_equal [parked, idling], @model.without_states(:first_gear).all
+  end
+
+  def test_should_allow_chaining_scopes
+    parked = @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

@@ -0,0 +1,30 @@
+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_presence_of :seatbelt
+    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

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

@@ -0,0 +1,166 @@
+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
+    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
+    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
+    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
+
+    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
+    ActiveSupport::Dependencies.clear
+    super
+  end
+end
+

data/test/machine_with_transactions_test.rb

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

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

data/test/machine_with_validations_test.rb

@@ -0,0 +1,47 @@
+require_relative 'test_helper'
+
+class MachineWithValidationsTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model)
+    @machine.state :parked
+
+    @record = @model.new
+  end
+
+  def test_should_invalidate_using_errors
+    I18n.backend = I18n::Backend::Simple.new
+    @record.state = 'parked'
+
+    @machine.invalidate(@record, :state, :invalid_transition, [[:event, 'park']])
+    assert_equal ['State cannot transition via "park"'], @record.errors.full_messages
+  end
+
+  def test_should_auto_prefix_custom_attributes_on_invalidation
+    @machine.invalidate(@record, :event, :invalid)
+
+    assert_equal ['State event is invalid'], @record.errors.full_messages
+  end
+
+  def test_should_clear_errors_on_reset
+    @record.state = 'parked'
+    @record.errors.add(:state, 'is invalid')
+
+    @machine.reset(@record)
+    assert_equal [], @record.errors.full_messages
+  end
+
+  def test_should_be_valid_if_state_is_known
+    @record.state = 'parked'
+
+    assert @record.valid?
+  end
+
+  def test_should_not_be_valid_if_state_is_unknown
+    @record.state = 'invalid'
+
+    refute @record.valid?
+    assert_equal ['State is invalid'], @record.errors.full_messages
+  end
+end
+