state_machines-mongoid 0.0.0 → 0.1.0

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

@@ -0,0 +1,11 @@
+{ en: {
+  mongoid: {
+    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/mongoid/version.rb

@@ -0,0 +1,7 @@
+module StateMachines
+  module Integrations
+    module Mongoid
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/state_machines/state_machines-mongoid.rb

@@ -0,0 +1 @@
+require 'state_machines/integrations/mongoid'

data/state_machines-mongoid.gemspec

@@ -1,23 +1,29 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'state_machines/mongoid/version'
+require 'state_machines/integrations/mongoid/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "state_machines-mongoid"
-  spec.version       = StateMachines::Mongoid::VERSION
-  spec.authors       = ["Abdelkader Boudih"]
-  spec.email         = ["terminale@gmail.com"]
-  spec.summary       = %q{Mongoid integration for state machines}
-  spec.description   = %q{Mongoid integration for state machines gem}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.name          = 'state_machines-mongoid'
+  spec.version       = StateMachines::Integrations::Mongoid::VERSION
+  spec.authors       = ['Abdelkader Boudih', 'Aaron Pfeifer']
+  spec.email         = %w(terminale@gmail.com aaron@pluginaweek.org)
+  spec.summary       = 'Mongoid integration for state machines'
+  spec.description   = 'Mongoid integration for state machines gem'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
+  spec.required_ruby_version     = '>= 1.9.3'
+  spec.add_dependency 'state_machines-activemodel'    , '>= 0'
+  spec.add_dependency 'mongoid' , '>= 4.0.0'
+
+  spec.add_development_dependency 'bundler', '>= 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'minitest', '>= 5.4.1'
+  spec.add_development_dependency 'minitest-reporters'
 end

data/test/files/en.yml

@@ -0,0 +1,5 @@
+en:
+  mongoid:
+    errors:
+      messages:
+        invalid_transition: "cannot transition"

data/test/integration_test.rb

@@ -0,0 +1,23 @@
+require_relative 'test_helper'
+
+class IntegrationTest < BaseTestCase
+  def test_should_have_an_integration_name
+    assert_equal :mongoid, StateMachines::Integrations::Mongoid.integration_name
+  end
+
+  def test_should_match_if_class_includes_mongoid
+    assert StateMachines::Integrations::Mongoid.matches?(new_model)
+  end
+
+  def test_should_not_match_if_class_does_not_include_mongoid
+    assert !StateMachines::Integrations::Mongoid.matches?(Class.new)
+  end
+
+  def test_should_have_defaults
+    assert_equal({:action => :save}, StateMachines::Integrations::Mongoid.defaults)
+  end
+
+  def test_should_have_a_locale_path
+    refute_nil StateMachines::Integrations::Mongoid.locale_path
+  end
+end

data/test/machine_by_default_test.rb

@@ -0,0 +1,16 @@
+require_relative 'test_helper'
+
+class MachineByDefaultTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model)
+  end
+
+  def test_should_use_save_as_action
+    assert_equal :save, @machine.action
+  end
+
+  def test_should_not_use_transactions
+    assert_equal false, @machine.use_transactions
+  end
+end

data/test/machine_errors_test.rb

@@ -0,0 +1,20 @@
+require_relative 'test_helper'
+
+class MachineErrorsTest < BaseTestCase
+  def setup
+    @model = new_model
+    @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,17 @@
+require_relative 'test_helper'
+
+class MachineMultipleTest < BaseTestCase
+  def setup
+    @model = new_model do
+      field :status, :type => String
+    end
+    @state_machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @status_machine = StateMachines::Machine.new(@model, :status, :initial => :idling)
+  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_nested_action_test.rb

@@ -0,0 +1,39 @@
+require_relative 'test_helper'
+
+class MachineNestedActionTest < BaseTestCase
+  def setup
+    @callbacks = []
+
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+
+    @record = @model.new(:state => 'parked')
+  end
+
+  def test_should_allow_transition_prior_to_creation_if_skipping_action
+    record = @record
+    @model.before_create { record.ignite(false) }
+    result = @record.save
+
+    assert_equal true, result
+    assert_equal "idling", @record.state
+    @record.reload
+    assert_equal "idling", @record.state
+  end
+
+  if Mongoid::VERSION !~ /^2\.1\./
+    def test_should_allow_transition_after_creation
+      record = @record
+      @model.after_create { record.ignite }
+      result = @record.save
+
+      assert_equal true, result
+      assert_equal "idling", @record.state
+      @record.reload
+      assert_equal "idling", @record.state
+    end
+  end
+end

data/test/machine_with_aliased_attribute_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+class MachineWithAliasedAttributeTest < BaseTestCase
+  def setup
+    @model = new_model do
+      alias_attribute :vehicle_status, :state
+    end
+
+    @machine = StateMachines::Machine.new(@model, :status, :attribute => :vehicle_status)
+    @machine.state :parked
+
+    @record = @model.new
+  end
+
+  def test_should_check_custom_attribute_for_predicate
+    @record.vehicle_status = nil
+    assert !@record.status?(:parked)
+
+    @record.vehicle_status = 'parked'
+    assert @record.status?(:parked)
+  end
+end

data/test/machine_with_aliased_field_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+class MachineWithAliasedFieldTest < BaseTestCase
+  def setup
+    @model = new_model do
+      field :status, :as => :vehicle_status
+    end
+
+    @machine = StateMachines::Machine.new(@model, :vehicle_status)
+    @machine.state :parked
+
+    @record = @model.new
+  end
+
+  def test_should_check_custom_attribute_for_predicate
+    @record.vehicle_status = nil
+    assert !@record.vehicle_status?(:parked)
+
+    @record.vehicle_status = 'parked'
+    assert @record.vehicle_status?(:parked)
+  end
+end

data/test/machine_with_callbacks_test.rb

@@ -0,0 +1,167 @@
+require_relative 'test_helper'
+
+class MachineWithCallbacksTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @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_after_callbacks_if_model_callback_added_prior_to_state_machine_definition
+    model = new_model do
+      after_save { nil }
+    end
+    machine = StateMachines::Machine.new(model, :initial => :parked)
+    machine.other_states :idling
+    machine.event :ignite
+    after_called = false
+    machine.after_transition {after_called = true}
+
+    record = model.new(:state => 'parked')
+    transition = StateMachines::Transition.new(record, machine, :ignite, :parked, :idling)
+    transition.perform
+    assert_equal true, after_called
+  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
+
+  def test_should_run_in_expected_order
+    expected = [
+      :before_transition, :before_validation, :after_validation,
+      :before_save, :before_create, :after_create, :after_save,
+      :after_transition
+    ]
+
+    callbacks = []
+    @model.before_validation { callbacks << :before_validation }
+    @model.after_validation { callbacks << :after_validation }
+    @model.before_save { callbacks << :before_save }
+    @model.before_create { callbacks << :before_create }
+    @model.after_create { callbacks << :after_create }
+    @model.after_save { callbacks << :after_save }
+
+    @machine.before_transition { callbacks << :before_transition }
+    @machine.after_transition { callbacks << :after_transition }
+
+    @transition.perform
+
+    assert_equal expected, callbacks
+  end
+end

data/test/machine_with_column_state_attribute_test.rb

@@ -0,0 +1,44 @@
+require_relative 'test_helper'
+
+class MachineWithColumnStateAttributeTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @machine.other_states(:idling)
+
+    @record = @model.new
+  end
+
+  def test_should_not_override_the_column_reader
+    @record[:state] = 'parked'
+    assert_equal 'parked', @record.state
+  end
+
+  def test_should_not_override_the_column_writer
+    @record.state = 'parked'
+    assert_equal 'parked', @record[:state]
+  end
+
+  def test_should_have_an_attribute_predicate
+    assert @record.respond_to?(:state?)
+  end
+
+  def test_should_test_for_existence_on_predicate_without_parameters
+    assert @record.state?
+
+    @record.state = nil
+    assert !@record.state?
+  end
+
+  def test_should_return_false_for_predicate_if_does_not_match_current_value
+    assert !@record.state?(:idling)
+  end
+
+  def test_should_return_true_for_predicate_if_matches_current_value
+    assert @record.state?(:parked)
+  end
+
+  def test_should_raise_exception_for_predicate_if_invalid_state_specified
+    assert_raises(IndexError) { @record.state?(:invalid) }
+  end
+end