aasm 3.0.13 → 3.0.14

data/spec/models/persistence.rb

@@ -0,0 +1,71 @@
+class Gate < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  attr_accessor :aasm_state
+
+  aasm do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end
+
+class Reader < ActiveRecord::Base
+  def aasm_read_state
+    "fi"
+  end
+  include AASM
+end
+
+class Writer < ActiveRecord::Base
+  def aasm_write_state(state)
+    "fo"
+  end
+  include AASM
+end
+
+class Transient < ActiveRecord::Base
+  def aasm_write_state_without_persistence(state)
+    "fum"
+  end
+  include AASM
+end
+
+class Simple < ActiveRecord::Base
+  include AASM
+  aasm_column :status
+  aasm_state :unknown_scope
+  aasm_state :new
+end
+
+class SimpleNewDsl < ActiveRecord::Base
+  include AASM
+  aasm :column => :status
+  aasm do
+    state :unknown_scope
+    state :new
+  end
+end
+
+class Derivate < Simple
+end
+
+class DerivateNewDsl < SimpleNewDsl
+end
+
+class Thief < ActiveRecord::Base
+  if ActiveRecord::VERSION::MAJOR >= 3
+    self.table_name = 'thieves'
+  else
+    set_table_name "thieves"
+  end
+  include AASM
+  aasm_initial_state  Proc.new { |thief| thief.skilled ? :rich : :jailed }
+  aasm_state          :rich
+  aasm_state          :jailed
+  attr_accessor :skilled, :aasm_state
+end

data/spec/spec_helpers/models_spec_helper.rb

@@ -76,91 +76,6 @@ class Argument
   end
 end
 
-class AuthMachine
-  include AASM
-
-  attr_accessor :activation_code, :activated_at, :deleted_at
-
-  aasm do
-    state :passive
-    state :pending, :initial => true, :enter => :make_activation_code
-    state :active,  :enter => :do_activate
-    state :suspended
-    state :deleted, :enter => :do_delete, :exit => :do_undelete
-    state :waiting
-
-    event :register do
-      transitions :from => :passive, :to => :pending, :guard => Proc.new {|u| u.can_register? }
-    end
-
-    event :activate do
-      transitions :from => :pending, :to => :active
-    end
-
-    event :suspend do
-      transitions :from => [:passive, :pending, :active], :to => :suspended
-    end
-
-    event :delete do
-      transitions :from => [:passive, :pending, :active, :suspended], :to => :deleted
-    end
-
-    # a dummy event that can never happen
-    event :unpassify do
-      transitions :from => :passive, :to => :active, :guard => Proc.new {|u| false }
-    end
-
-    event :unsuspend do
-      transitions :from => :suspended, :to => :active,  :guard => Proc.new {|u| u.has_activated? }
-      transitions :from => :suspended, :to => :pending, :guard => Proc.new {|u| u.has_activation_code? }
-      transitions :from => :suspended, :to => :passive
-    end
-
-    event :wait do
-      transitions :from => :suspended, :to => :waiting, :guard => :if_polite?
-    end
-  end
-
-  def initialize
-    # the AR backend uses a before_validate_on_create :aasm_ensure_initial_state
-    # lets do something similar here for testing purposes.
-    aasm_enter_initial_state
-  end
-
-  def make_activation_code
-    @activation_code = 'moo'
-  end
-
-  def do_activate
-    @activated_at = Time.now
-    @activation_code = nil
-  end
-
-  def do_delete
-    @deleted_at = Time.now
-  end
-
-  def do_undelete
-    @deleted_at = false
-  end
-
-  def can_register?
-    true
-  end
-
-  def has_activated?
-    !!@activated_at
-  end
-
-  def has_activation_code?
-    !!@activation_code
-  end
-
-  def if_polite?(phrase = nil)
-    phrase == :please
-  end
-end
-
 class ThisNameBetterNotBeInUse
   include AASM
 

data/spec/unit/aasm_spec.rb

@@ -41,7 +41,7 @@ end
 
 
 describe AASM, '- aasm_states_for_select' do
-  it "should return a select friendly array of states in the form of [['Friendly name', 'state_name']]" do
+  it "should return a select friendly array of states" do
     Foo.aasm_states_for_select.should == [['Open', 'open'], ['Closed', 'closed']]
   end
 end

data/spec/unit/callbacks_new_dsl_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'callbacks for the new DSL' do
+  before(:each) do
+    @callback = CallbackNewDsl.new
+  end
+
+  it "should get close callbacks" do
+    @callback.should_receive(:before).once.ordered
+    @callback.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    @callback.should_receive(:before_enter_closed).once.ordered
+    @callback.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+    @callback.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
+    @callback.should_receive(:after_enter_closed).once.ordered
+    @callback.should_receive(:after).once.ordered
+
+    @callback.close!
+  end
+
+  it "should get open callbacks" do
+    @callback.close!
+
+    @callback.should_receive(:before).once.ordered
+    @callback.should_receive(:before_exit_closed).once.ordered                # these should be before the state changes
+    @callback.should_receive(:before_enter_open).once.ordered
+    @callback.should_receive(:aasm_write_state).once.ordered.and_return(true) # this is when the state changes
+    @callback.should_receive(:after_exit_closed).once.ordered                 # these should be after the state changes
+    @callback.should_receive(:after_enter_open).once.ordered
+    @callback.should_receive(:after).once.ordered
+
+    @callback.open!
+  end
+end

data/spec/unit/callbacks_old_dsl_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'callbacks for the old DSL' do
+  before(:each) do
+    @callback = CallbackOldDsl.new
+  end
+
+  it "should get close callbacks" do
+    @callback.should_receive(:before).once.ordered
+    @callback.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    @callback.should_receive(:before_enter_closed).once.ordered
+    @callback.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+    @callback.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
+    @callback.should_receive(:after_enter_closed).once.ordered
+    @callback.should_receive(:after).once.ordered
+
+    @callback.close!
+  end
+
+  it "should get open callbacks" do
+    @callback.close!
+
+    @callback.should_receive(:before).once.ordered
+    @callback.should_receive(:before_exit_closed).once.ordered                # these should be before the state changes
+    @callback.should_receive(:before_enter_open).once.ordered
+    @callback.should_receive(:aasm_write_state).once.ordered.and_return(true) # this is when the state changes
+    @callback.should_receive(:after_exit_closed).once.ordered                 # these should be after the state changes
+    @callback.should_receive(:after_enter_open).once.ordered
+    @callback.should_receive(:after).once.ordered
+
+    @callback.open!
+  end
+end

data/spec/unit/complex_example_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe 'AuthMachine on initialization' do
+  let(:auth) {AuthMachine.new}
+
+  it 'should be in the pending state' do
+    auth.aasm_current_state.should == :pending
+  end
+
+  it 'should have an activation code' do
+    auth.has_activation_code?.should be_true
+    auth.activation_code.should_not be_nil
+  end
+end
+
+describe 'AuthMachine when being unsuspended' do
+  let(:auth) {AuthMachine.new}
+
+  it 'should be able to be unsuspended' do
+    auth.activate!
+    auth.suspend!
+    auth.may_unsuspend?.should be_true
+  end
+
+  it 'should not be able to be unsuspended into active' do
+    auth.suspend!
+    auth.may_unsuspend?(:active).should_not be_true
+  end
+
+  it 'should be able to be unsuspended into active if polite' do
+    auth.suspend!
+    auth.may_wait?(:waiting, :please).should be_true
+    auth.wait!(nil, :please)
+  end
+
+  it 'should not be able to be unsuspended into active if not polite' do
+    auth.suspend!
+    auth.may_wait?(:waiting).should_not be_true
+    auth.may_wait?(:waiting, :rude).should_not be_true
+    lambda {auth.wait!(nil, :rude)}.should raise_error(AASM::InvalidTransition)
+    lambda {auth.wait!}.should raise_error(AASM::InvalidTransition)
+  end
+
+  it 'should not be able to be unpassified' do
+    auth.activate!
+    auth.suspend!
+    auth.unsuspend!
+
+    auth.may_unpassify?.should_not be_true
+    lambda {auth.unpassify!}.should raise_error(AASM::InvalidTransition)
+  end
+
+  it 'should be active if previously activated' do
+    auth.activate!
+    auth.suspend!
+    auth.unsuspend!
+
+    auth.aasm_current_state.should == :active
+  end
+
+  it 'should be pending if not previously activated, but an activation code is present' do
+    auth.suspend!
+    auth.unsuspend!
+
+    auth.aasm_current_state.should == :pending
+  end
+
+  it 'should be passive if not previously activated and there is no activation code' do
+    auth.activation_code = nil
+    auth.suspend!
+    auth.unsuspend!
+
+    auth.aasm_current_state.should == :passive
+  end
+end

data/spec/unit/event_spec.rb

@@ -1,25 +1,21 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 
-describe AASM::SupportingClasses::Event do
-  before(:each) do
-    @name = :close_order
-    @success = :success_callback
-  end
+describe 'adding an event' do
 
   def new_event
-    @event = AASM::SupportingClasses::Event.new(@name, {:success => @success}) do
+    @event = AASM::SupportingClasses::Event.new(:close_order, {:success => :success_callback}) do
       transitions :to => :closed, :from => [:open, :received]
     end
   end
 
   it 'should set the name' do
     new_event
-    @event.name.should == @name
+    @event.name.should == :close_order
   end
 
   it 'should set the success option' do
     new_event
-    @event.success.should == @success
+    @event.success.should == :success_callback
   end
 
   it 'should create StateTransitions' do
@@ -29,7 +25,31 @@ describe AASM::SupportingClasses::Event do
   end
 end
 
-describe AASM::SupportingClasses::Event, 'when firing an event' do
+describe 'transition inspection' do
+  before do
+    @event = AASM::SupportingClasses::Event.new(:run) do
+      transitions :to => :running, :from => :sleeping
+    end
+  end
+
+  it 'should support inspecting transitions from states' do
+    @event.transitions_from_state(:sleeping).map(&:to).should == [:running]
+    @event.transitions_from_state?(:sleeping).should be_true
+
+    @event.transitions_from_state(:cleaning).map(&:to).should == []
+    @event.transitions_from_state?(:cleaning).should be_false
+  end
+
+  it 'should support inspecting transitions to states' do
+    @event.transitions_to_state(:running).map(&:from).should == [:sleeping]
+    @event.transitions_to_state?(:running).should be_true
+
+    @event.transitions_to_state(:cleaning).map(&:to).should == []
+    @event.transitions_to_state?(:cleaning).should be_false
+  end
+end
+
+describe 'firing an event' do
   it 'should return nil if the transitions are empty' do
     obj = mock('object')
     obj.stub!(:aasm_current_state)
@@ -49,7 +69,6 @@ describe AASM::SupportingClasses::Event, 'when firing an event' do
     event.fire(obj).should == :closed
   end
 
-
   it 'should call the guard with the params passed in' do
     event = AASM::SupportingClasses::Event.new(:event) do
       transitions :to => :closed, :from => [:open, :received], :guard => :guard_fn
@@ -64,7 +83,7 @@ describe AASM::SupportingClasses::Event, 'when firing an event' do
 
 end
 
-describe AASM::SupportingClasses::Event, 'when executing the success callback' do
+describe 'executing the success callback' do
 
   it "should send the success callback if it's a symbol" do
     ThisNameBetterNotBeInUse.instance_eval {

data/spec/unit/inspection_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'inspecting AASM' do
+  it 'should support listing all states in the order they have been defined' do
+    Conversation.aasm_states.should == [:needs_attention, :read, :closed, :awaiting_response, :junk]
+  end
+end

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -0,0 +1,228 @@
+require 'rubygems'
+require 'active_record'
+require 'logger'
+require 'spec_helper'
+
+load_schema
+
+# if you want to see the statements while running the spec enable the following line
+# ActiveRecord::Base.logger = Logger.new(STDERR)
+
+shared_examples_for "aasm model" do
+  it "should include persistence mixins" do
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence)
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
+  end
+end
+
+describe "class methods for classes without own read or write state" do
+  let(:klass) {Gate}
+  it_should_behave_like "aasm model"
+  it "should include all persistence mixins" do
+    klass.included_modules.should be_include(AASM::Persistence::ReadState)
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+  end
+end
+
+describe "class methods for classes with own read state" do
+  let(:klass) {Reader}
+  it_should_behave_like "aasm model"
+  it "should include all persistence mixins but read state" do
+    klass.included_modules.should_not be_include(AASM::Persistence::ReadState)
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+  end
+end
+
+describe "class methods for classes with own write state" do
+  let(:klass) {Writer}
+  it_should_behave_like "aasm model"
+  it "should include include all persistence mixins but write state" do
+    klass.included_modules.should be_include(AASM::Persistence::ReadState)
+    klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+  end
+end
+
+describe "class methods for classes without persistence" do
+  let(:klass) {Transient}
+  it_should_behave_like "aasm model"
+  it "should include all mixins but persistence" do
+    klass.included_modules.should be_include(AASM::Persistence::ReadState)
+    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+  end
+end
+
+describe "instance methods" do
+  let(:gate) {Gate.new}
+
+  it "should respond to aasm states" do
+    gate.should respond_to(:aasm_read_state)
+    gate.should respond_to(:aasm_write_state)
+    gate.should respond_to(:aasm_write_state_without_persistence)
+  end
+
+  it "should return the initial state when new and the aasm field is nil" do
+    gate.aasm_current_state.should == :opened
+  end
+
+  it "should return the aasm column when new and the aasm field is not nil" do
+    gate.aasm_state = "closed"
+    gate.aasm_current_state.should == :closed
+  end
+
+  it "should return the aasm column when not new and the aasm_column is not nil" do
+    gate.stub!(:new_record?).and_return(false)
+    gate.aasm_state = "state"
+    gate.aasm_current_state.should == :state
+  end
+
+  it "should allow a nil state" do
+    gate.stub!(:new_record?).and_return(false)
+    gate.aasm_state = nil
+    gate.aasm_current_state.should be_nil
+  end
+
+  it "should have aasm_ensure_initial_state" do
+    gate.send :aasm_ensure_initial_state
+  end
+
+  it "should call aasm_ensure_initial_state on validation before create" do
+    gate.should_receive(:aasm_ensure_initial_state).and_return(true)
+    gate.valid?
+  end
+
+  it "should call aasm_ensure_initial_state on validation before create" do
+    gate.stub!(:new_record?).and_return(false)
+    gate.should_not_receive(:aasm_ensure_initial_state)
+    gate.valid?
+  end
+
+end
+
+describe 'subclasses' do
+  it "should have the same states as its parent class" do
+    Derivate.aasm_states.should == Simple.aasm_states
+  end
+
+  it "should have the same events as its parent class" do
+    Derivate.aasm_events.should == Simple.aasm_events
+  end
+
+  it "should have the same column as its parent class" do
+    Derivate.aasm_column.should == :status
+  end
+
+  it "should have the same column as its parent even for the new dsl" do
+    SimpleNewDsl.aasm_column.should == :status
+    DerivateNewDsl.aasm_column.should == :status
+  end
+end
+
+describe "named scopes with the old DSL" do
+
+  context "Does not already respond_to? the scope name" do
+    it "should add a scope" do
+      Simple.should respond_to(:unknown_scope)
+      Simple.unknown_scope.class.should == ActiveRecord::Relation
+    end
+  end
+
+  context "Already respond_to? the scope name" do
+    it "should not add a scope" do
+      Simple.should respond_to(:new)
+      Simple.new.class.should == Simple
+    end
+  end
+
+end
+
+describe "named scopes with the new DSL" do
+
+  context "Does not already respond_to? the scope name" do
+    it "should add a scope" do
+      SimpleNewDsl.should respond_to(:unknown_scope)
+      SimpleNewDsl.unknown_scope.class.should == ActiveRecord::Relation
+    end
+  end
+
+  context "Already respond_to? the scope name" do
+    it "should not add a scope" do
+      SimpleNewDsl.should respond_to(:new)
+      SimpleNewDsl.new.class.should == SimpleNewDsl
+    end
+  end
+
+end
+
+describe 'initial states' do
+
+  it 'should support conditions' do
+    Thief.new(:skilled => true).aasm_current_state.should == :rich
+    Thief.new(:skilled => false).aasm_current_state.should == :jailed
+  end
+end
+
+describe 'transitions with persistence' do
+
+  it 'should not store states for invalid models' do
+    validator = Validator.create(:name => 'name')
+    validator.should be_valid
+    validator.should be_sleeping
+
+    validator.name = nil
+    validator.should_not be_valid
+    validator.run!.should be_false
+    validator.should be_sleeping
+
+    validator.reload
+    validator.should_not be_running
+    validator.should be_sleeping
+
+    validator.name = 'another name'
+    validator.should be_valid
+    validator.run!.should be_true
+    validator.should be_running
+
+    validator.reload
+    validator.should be_running
+    validator.should_not be_sleeping
+  end
+
+  it 'should store states for invalid models if configured' do
+    persistor = InvalidPersistor.create(:name => 'name')
+    persistor.should be_valid
+    persistor.should be_sleeping
+
+    persistor.name = nil
+    persistor.should_not be_valid
+    persistor.run!.should be_true
+    persistor.should be_running
+
+    persistor = InvalidPersistor.find(persistor.id)
+    persistor.valid?
+    persistor.should be_valid
+    persistor.should be_running
+    persistor.should_not be_sleeping
+
+    persistor.reload
+    persistor.should be_running
+    persistor.should_not be_sleeping
+  end
+
+  describe 'transactions' do
+    it 'should rollback all changes' do
+      worker = Worker.create!(:name => 'worker', :status => 'sleeping')
+      transactor = Transactor.create!(:name => 'transactor', :worker => worker)
+      transactor.should be_sleeping
+      worker.status.should == 'sleeping'
+
+      lambda {transactor.run!}.should raise_error(StandardError, 'failed on purpose')
+      transactor.should be_running
+      worker.reload.status.should == 'sleeping'
+    end
+  end
+
+end