state_machines-activemodel 0.0.2 → 0.0.3

data/lib/state_machines/integrations/active_model/locale.rb

@@ -1,11 +1,11 @@
-{:en => {
-  :activemodel => {
-    :errors => {
-      :messages => {
-        :invalid => StateMachines::Machine.default_messages[:invalid],
-        :invalid_event => StateMachines::Machine.default_messages[:invalid_event] % ['%{state}'],
-        :invalid_transition => StateMachines::Machine.default_messages[:invalid_transition] % ['%{event}']
+{ en: {
+  activemodel: {
+    errors: {
+      messages: {
+        invalid: StateMachines::Machine.default_messages[:invalid],
+        invalid_event: StateMachines::Machine.default_messages[:invalid_event] % ['%{state}'],
+        invalid_transition: StateMachines::Machine.default_messages[:invalid_transition] % ['%{event}']
       }
     }
   }
-}}
+} }

data/lib/state_machines/integrations/{version.rb → active_model/version.rb}

@@ -1,7 +1,7 @@
 module StateMachines
   module Integrations
     module ActiveModel
-      VERSION = '0.0.2'
+      VERSION = '0.0.3'
     end
   end
 end

data/state_machines-activemodel.gemspec

@@ -1,27 +1,28 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'state_machines/integrations/version'
+require 'state_machines/integrations/active_model/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'state_machines-activemodel'
   spec.version       = StateMachines::Integrations::ActiveModel::VERSION
   spec.authors       = ['Abdelkader Boudih', 'Aaron Pfeifer']
-  spec.email         = ['terminale@gmail.com']
-  spec.summary       = %q(ActiveModel integration for State Machines)
-  spec.description   = %q(Adds support for creating state machines for attributes on ActiveModel)
-  spec.homepage      = 'https://github.com/seuros/state_machines-activemodel'
+  spec.email         = %w(terminale@gmail.com aaron@pluginaweek.org)
+  spec.summary       = 'ActiveModel integration for State Machines'
+  spec.description   = 'Adds support for creating state machines for attributes on ActiveModel'
+  spec.homepage      = 'https://github.com/state-machines/state_machines-activemodel'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.test_files    = spec.files.grep(/^spec\//)
+  spec.test_files    = spec.files.grep(/^test\//)
   spec.require_paths = ['lib']
   spec.required_ruby_version     = '>= 1.9.3'
-  spec.add_dependency 'state_machines'    , '>= 0'
-  spec.add_dependency 'activemodel' , '>= 3.2'
+  spec.add_dependency 'state_machines', '~> 0.1.0'
+  spec.add_dependency 'activemodel', '~> 4.1'
 
   spec.add_development_dependency 'bundler', '>= 1.6'
   spec.add_development_dependency 'rake', '>= 10'
   spec.add_development_dependency 'appraisal', '>= 1'
-  spec.add_development_dependency 'rspec' , '3.0.0.beta2'
+  spec.add_development_dependency 'minitest', '~> 5.4'
+  spec.add_development_dependency 'minitest-reporters'
 end

data/{spec/support → test/files}/en.yml

@@ -2,4 +2,4 @@ en:
   activemodel:
     errors:
       messages:
-        invalid_transition: "cannot %{event}"
+        invalid_transition: "cannot %{event}"

data/test/integration_test.rb

@@ -0,0 +1,23 @@
+require_relative 'test_helper'
+
+class IntegrationTest < BaseTestCase
+  def test_should_be_registred
+    assert_includes StateMachines::Integrations.list, StateMachines::Integrations::ActiveModel
+  end
+
+  def test_should_have_an_integration_name
+    assert_equal :active_model, StateMachines::Integrations::ActiveModel.integration_name
+  end
+
+  def test_should_match_if_class_includes_validations_feature
+    assert StateMachines::Integrations::ActiveModel.matches?(new_model { include ActiveModel::Validations })
+  end
+
+  def test_should_not_match_if_class_does_not_include_active_model_features
+    refute StateMachines::Integrations::ActiveModel.matches?(new_model)
+  end
+
+  def test_should_have_no_defaults
+    assert_equal({}, StateMachines::Integrations::ActiveModel.defaults)
+  end
+end

data/test/machine_by_default_test.rb

@@ -0,0 +1,24 @@
+require_relative 'test_helper'
+
+class MachineByDefaultTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, integration: :active_model)
+  end
+
+  def test_should_not_have_action
+    assert_nil @machine.action
+  end
+
+  def test_should_use_transactions
+    assert_equal true, @machine.use_transactions
+  end
+
+  def test_should_not_have_any_before_callbacks
+    assert_equal 0, @machine.callbacks[:before].size
+  end
+
+  def test_should_not_have_any_after_callbacks
+    assert_equal 0, @machine.callbacks[:after].size
+  end
+end

data/test/machine_errors_test.rb

@@ -0,0 +1,19 @@
+require_relative 'test_helper'
+
+class MachineErrorsTest < BaseTestCase
+  def setup
+    @model = new_model { include ActiveModel::Validations }
+    @machine = StateMachines::Machine.new(@model)
+    @record = @model.new
+  end
+
+  def test_should_be_able_to_describe_current_errors
+    @record.errors.add(:id, 'cannot be blank')
+    @record.errors.add(:state, 'is invalid')
+    assert_equal ['Id cannot be blank', 'State is invalid'], @machine.errors_for(@record).split(', ').sort
+  end
+
+  def test_should_describe_as_halted_with_no_errors
+    assert_equal 'Transition halted', @machine.errors_for(@record)
+  end
+end

data/test/machine_multiple_test.rb

@@ -0,0 +1,18 @@
+require_relative 'test_helper'
+
+class MachineMultipleTest < BaseTestCase
+  def setup
+    @model = new_model do
+      model_attribute :status
+    end
+
+    @state_machine = StateMachines::Machine.new(@model, initial: :parked, integration: :active_model)
+    @status_machine = StateMachines::Machine.new(@model, :status, initial: :idling, integration: :active_model)
+  end
+
+  def test_should_should_initialize_each_state
+    record = @model.new
+    assert_equal 'parked', record.state
+    assert_equal 'idling', record.status
+  end
+end

data/test/machine_with_callbacks_test.rb

@@ -0,0 +1,130 @@
+require_relative 'test_helper'
+
+class MachineWithCallbacksTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, initial: :parked, integration: :active_model)
+    @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_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
+end

data/test/machine_with_dirty_attribute_and_custom_attributes_during_loopback_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Dirty
+      model_attribute :status
+      define_attribute_methods [:status]
+    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
+  end
+
+  def test_should_not_include_state_in_changed_attributes
+    assert_equal [], @record.changed
+  end
+
+  def test_should_not_track_attribute_changes
+    assert_equal nil, @record.changes['status']
+  end
+end

data/test/machine_with_dirty_attribute_and_state_events_test.rb

@@ -0,0 +1,23 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Dirty
+      define_attribute_methods [:state]
+    end
+    @machine = StateMachines::Machine.new(@model, action: :save, 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_equal nil, @record.changes['state']
+  end
+end

data/test/machine_with_dirty_attributes_and_custom_attribute_test.rb

@@ -0,0 +1,34 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Dirty
+      model_attribute :status
+      define_attribute_methods [:status]
+    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
+  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
+
+    assert_equal %w(parked idling), @record.changes['status']
+  end
+end

data/test/machine_with_dirty_attributes_during_loopback_test.rb

@@ -0,0 +1,49 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributesDuringLoopbackTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Dirty
+      define_attribute_methods [:state]
+    end
+    @machine = StateMachines::Machine.new(@model, initial: :parked)
+    @machine.event :park
+
+    @record = @model.create
+
+    @transition = StateMachines::Transition.new(@record, @machine, :park, :parked, :parked)
+    @transition.perform
+  end
+
+  def test_should_not_include_state_in_changed_attributes
+    assert_equal [], @record.changed
+  end
+
+  def test_should_not_track_attribute_changes
+    assert_equal nil, @record.changes['state']
+  end
+end
+class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Dirty
+      model_attribute :status
+      define_attribute_methods [:status]
+    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
+  end
+
+  def test_should_not_include_state_in_changed_attributes
+    assert_equal [], @record.changed
+  end
+
+  def test_should_not_track_attribute_changes
+    assert_equal nil, @record.changes['status']
+  end
+end

data/test/machine_with_dirty_attributes_test.rb

@@ -0,0 +1,33 @@
+require_relative 'test_helper'
+
+class MachineWithDirtyAttributesTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Dirty
+      define_attribute_methods [:state]
+    end
+    @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
+  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
+
+    assert_equal %w(parked idling), @record.changes['state']
+  end
+end