state_machines-mongoid 0.0.0 → 0.1.0

data/test/machine_with_failed_before_callbacks_test.rb

@@ -0,0 +1,36 @@
+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
+    assert !@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_field_test.rb

@@ -0,0 +1,16 @@
+require_relative 'test_helper'
+
+class MachineWithFieldTest < BaseTestCase
+  def setup
+    @model = new_model do
+      field :status, :type => Integer
+    end
+    StateMachines::Machine.new(@model, :status)
+  end
+
+  def test_should_not_redefine_field
+    field = @model.fields['status']
+    refute_nil field
+    assert_equal Integer, field.type
+  end
+end

data/test/machine_with_initialized_state_test.rb

@@ -0,0 +1,35 @@
+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_dynamic
+    @machine.initial_state = lambda {:parked}
+    record = silence_warnings { @model.new(:state => 'idling') }
+    assert_equal 'idling', record.state
+  end
+end

data/test/machine_with_internationalization_test.rb

@@ -0,0 +1,175 @@
+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, {
+      :mongoid => {:errors => {:messages => {:invalid_transition => 'cannot %{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, {
+      :mongoid => {:errors => {:messages => {:bad_transition => 'cannot %{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 %{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, {
+      :mongoid => {:state_machines => {:'mongoid_test/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, {
+      :mongoid => {:state_machines => {:'mongoid_test/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, {
+      :mongoid => {: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, {
+      :mongoid => {: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, {
+      :mongoid => {: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, {
+      :mongoid => {:state_machines => {:'mongoid_test/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, {
+      :mongoid => {:state_machines => {:'mongoid_test/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, {
+      :mongoid => {: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, {
+      :mongoid => {: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{mongoid/locale\.rb$}}.length
+
+    # Create another Mongoid model that will triger the i18n feature
+    new_model
+
+    assert_equal 1, I18n.load_path.select {|path| path =~ %r{mongoid/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
+
+end

data/test/machine_with_loopback_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+class MachineWithLoopbackTest < BaseTestCase
+  def setup
+    @model = new_model do
+      field :updated_at, :type => Time
+
+      before_update do |record|
+        record.updated_at = Time.now
+      end
+    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_update_record
+    refute_equal @timestamp, @record.updated_at
+  end
+end

data/test/machine_with_non_column_state_attribute_defined_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+class MachineWithNonColumnStateAttributeDefinedTest < BaseTestCase
+  def setup
+    @model = new_model do
+      def status
+        self['status']
+      end
+
+      def status=(value)
+        self['status'] = value
+      end
+    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
+    assert !@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_raises(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_non_column_state_attribute_undefined_test.rb

@@ -0,0 +1,33 @@
+require_relative 'test_helper'
+
+class MachineWithNonColumnStateAttributeUndefinedTest < BaseTestCase
+  def setup
+    @model = new_model do
+      def initialize
+        # Skip attribute initialization
+        @initialized_state_machines = true
+        super
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@model, :status, :initial => :parked)
+    @machine.other_states(:idling)
+    @record = @model.new
+  end
+
+  def test_should_define_a_new_key_for_the_attribute
+    refute_nil @model.fields['status']
+  end
+
+  def test_should_define_a_reader_attribute_for_the_attribute
+    assert @record.respond_to?(:status)
+  end
+
+  def test_should_define_a_writer_attribute_for_the_attribute
+    assert @record.respond_to?(:status=)
+  end
+
+  def test_should_define_an_attribute_predicate
+    assert @record.respond_to?(:status?)
+  end
+end

data/test/machine_with_scopes_and_owner_subclass_test.rb

@@ -0,0 +1,42 @@
+require_relative 'test_helper'
+
+class MachineWithScopesAndOwnerSubclassTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :state)
+
+    MongoidTest.const_set('Foo', @model)
+
+    # Remove the #name override so that Mongoid picks up the subclass name
+    # properly
+    class << @model; remove_method(:name); end
+    @subclass = MongoidTest.class_eval <<-end_eval
+      class SubFoo < MongoidTest::Foo
+        self
+      end
+    end_eval
+    @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).to_a
+  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).to_a
+  end
+
+  def teardown
+    MongoidTest.send(:remove_const, 'SubFoo')
+    MongoidTest.send(:remove_const, 'Foo')
+    super
+  end
+end

data/test/machine_with_scopes_test.rb

@@ -0,0 +1,69 @@
+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 => lambda {'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).to_a
+  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).to_a
+  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').to_a
+  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).to_a
+  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).to_a
+  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