aasm 3.0.16 → 3.0.17

data/spec/models/foo.rb

@@ -0,0 +1,34 @@
+class Foo
+  include AASM
+  aasm do
+    state :open, :initial => true, :exit => :exit
+    state :closed, :enter => :enter
+
+    event :close, :success => :success_callback do
+      transitions :from => [:open], :to => [:closed]
+    end
+
+    event :null do
+      transitions :from => [:open], :to => :closed, :guard => :always_false
+    end
+  end
+
+  def always_false
+    false
+  end
+
+  def success_callback
+  end
+
+  def enter
+  end
+  def exit
+  end
+end
+
+class FooTwo < Foo
+  include AASM
+  aasm do
+    state :foo
+  end
+end

data/spec/models/mongoid/simple_mongoid.rb

@@ -0,0 +1,10 @@
+class SimpleMongoid
+  include Mongoid::Document
+  include AASM
+
+  field :status, type: String
+
+  aasm_column :status
+  aasm_state :unknown_scope
+  aasm_state :new
+end

data/spec/models/mongoid/{mongoid_models.rb → simple_new_dsl_mongoid.rb}

@@ -1,14 +1,3 @@
-class SimpleMongoid
-  include Mongoid::Document
-  include AASM
-
-  field :status, type: String
-
-  aasm_column :status
-  aasm_state :unknown_scope
-  aasm_state :new
-end
-
 class SimpleNewDslMongoid
   include Mongoid::Document
   include AASM
@@ -20,4 +9,4 @@ class SimpleNewDslMongoid
     state :unknown_scope
     state :new
   end
-end
+end

data/spec/models/persistence.rb

@@ -15,10 +15,11 @@ class Gate < ActiveRecord::Base
 end
 
 class Reader < ActiveRecord::Base
+  include AASM
+
   def aasm_read_state
     "fi"
   end
-  include AASM
 end
 
 class Writer < ActiveRecord::Base

data/spec/models/this_name_better_not_be_in_use.rb

@@ -0,0 +1,11 @@
+class ThisNameBetterNotBeInUse
+  include AASM
+
+  aasm do
+    state :initial
+    state :symbol
+    state :string
+    state :array
+    state :proc
+  end
+end

data/spec/schema.rb

@@ -1,6 +1,6 @@
 ActiveRecord::Schema.define(:version => 0) do
 
-  %w{gates readers writers transients simples simple_new_dsls thieves localizer_test_models}.each do |table_name|
+  %w{gates readers writers transients simples simple_new_dsls thieves localizer_test_models persisted_states provided_and_persisted_states}.each do |table_name|
     create_table table_name, :force => true do |t|
       t.string "aasm_state"
     end

data/spec/spec_helper.rb

@@ -5,8 +5,12 @@ require 'aasm'
 require 'rspec'
 require 'rspec/autorun'
 
+require 'coveralls'
+Coveralls.wear!
+
 # require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
 # require 'ruby-debug/completion'
+# require 'pry'
 
 def load_schema
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
@@ -15,5 +19,8 @@ def load_schema
   load(File.dirname(__FILE__) + "/schema.rb")
 end
 
-# Requiring custom spec helpers
+# custom spec helpers
 Dir[File.dirname(__FILE__) + "/spec_helpers/**/*.rb"].sort.each { |f| require File.expand_path(f) }
+
+# example model classes
+Dir[File.dirname(__FILE__) + "/models/*.rb"].sort.each { |f| require File.expand_path(f) }

data/spec/unit/api_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'models/active_record/api.rb'
+
+describe "reading the current state" do
+  it "uses the AASM default" do
+    DefaultState.new.aasm.current_state.should eql :alpha
+  end
+
+  it "uses the provided method" do
+    ProvidedState.new.aasm.current_state.should eql :beta
+  end
+
+  it "uses the persistence storage" do
+    PersistedState.new.aasm.current_state.should eql :alpha
+  end
+
+  it "uses the provided method even if persisted" do
+    ProvidedAndPersistedState.new.aasm.current_state.should eql :gamma
+  end
+end
+
+describe "writing and persisting the current state" do
+  it "uses the AASM default" do
+    o = DefaultState.new
+    o.release!
+    o.persisted_store.should be_nil
+  end
+
+  it "uses the provided method" do
+    o = ProvidedState.new
+    o.release!
+    o.persisted_store.should eql :beta
+  end
+
+  it "uses the persistence storage" do
+    o = PersistedState.new
+    o.release!
+    o.persisted_store.should be_nil
+  end
+
+  it "uses the provided method even if persisted" do
+    o = ProvidedAndPersistedState.new
+    o.release!
+    o.persisted_store.should eql :beta
+  end
+end
+
+describe "writing the current state without persisting it" do
+  it "uses the AASM default" do
+    o = DefaultState.new
+    o.release
+    o.transient_store.should be_nil
+  end
+
+  it "uses the provided method" do
+    o = ProvidedState.new
+    o.release
+    o.transient_store.should eql :beta
+  end
+
+  it "uses the persistence storage" do
+    o = PersistedState.new
+    o.release
+    o.transient_store.should be_nil
+  end
+
+  it "uses the provided method even if persisted" do
+    o = ProvidedAndPersistedState.new
+    o.release
+    o.transient_store.should eql :beta
+  end
+end

data/spec/unit/callbacks_spec.rb

@@ -85,7 +85,7 @@ describe 'event callbacks' do
     end
 
     it 'should not call it for failing bang fire' do
-      @foo.stub!(:aasm_set_current_state_with_persistence).and_return(false)
+      @foo.aasm.stub!(:set_current_state_with_persistence).and_return(false)
       @foo.should_not_receive(:aasm_event_fired)
       @foo.close!
     end
@@ -108,7 +108,7 @@ describe 'event callbacks' do
     end
 
     it 'should not call it if persist fails for bang fire' do
-      @foo.stub!(:aasm_set_current_state_with_persistence).and_return(false)
+      @foo.aasm.stub!(:set_current_state_with_persistence).and_return(false)
       @foo.should_receive(:aasm_event_failed)
       @foo.close!
     end

data/spec/unit/event_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe 'adding an event' do
+  let(:event) do
+    AASM::Event.new(:close_order, {:success => :success_callback}) do
+      before :before_callback
+      after :after_callback
+      transitions :to => :closed, :from => [:open, :received]
+    end
+  end
+
+  it 'should set the name' do
+    event.name.should == :close_order
+  end
+
+  it 'should set the success callback' do
+    event.options[:success].should == :success_callback
+  end
+
+  it 'should set the after callback' do
+    event.options[:after].should == [:after_callback]
+  end
+
+  it 'should set the before callback' do
+    event.options[:before].should == [:before_callback]
+  end
+
+  it 'should create transitions' do
+    transitions = event.all_transitions
+    transitions[0].from.should == :open
+    transitions[0].to.should == :closed
+    transitions[1].from.should == :received
+    transitions[1].to.should == :closed
+  end
+end
+
+describe 'transition inspection' do
+  let(:event) do
+    AASM::Event.new(:run) do
+      transitions :to => :running, :from => :sleeping
+    end
+  end
+
+  it 'should support inspecting transitions from other 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 other 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)
+
+    event = AASM::Event.new(:event)
+    event.fire(obj).should be_nil
+  end
+
+  it 'should return the state of the first matching transition it finds' do
+    event = AASM::Event.new(:event) do
+      transitions :to => :closed, :from => [:open, :received]
+    end
+
+    obj = mock('object')
+    obj.stub!(:aasm_current_state).and_return(:open)
+
+    event.fire(obj).should == :closed
+  end
+
+  it 'should call the guard with the params passed in' do
+    event = AASM::Event.new(:event) do
+      transitions :to => :closed, :from => [:open, :received], :guard => :guard_fn
+    end
+
+    obj = mock('object')
+    obj.stub!(:aasm_current_state).and_return(:open)
+    obj.should_receive(:guard_fn).with('arg1', 'arg2').and_return(true)
+
+    event.fire(obj, nil, 'arg1', 'arg2').should == :closed
+  end
+
+end
+
+describe 'should fire callbacks' do
+  describe 'success' do
+    it "if it's a symbol" do
+      ThisNameBetterNotBeInUse.instance_eval {
+        aasm_event :with_symbol, :success => :symbol_success_callback do
+          transitions :to => :symbol, :from => [:initial]
+        end
+      }
+
+      model = ThisNameBetterNotBeInUse.new
+      model.should_receive(:symbol_success_callback)
+      model.with_symbol!
+    end
+
+    it "if it's a string" do
+      ThisNameBetterNotBeInUse.instance_eval {
+        aasm_event :with_string, :success => 'string_success_callback' do
+          transitions :to => :string, :from => [:initial]
+        end
+      }
+
+      model = ThisNameBetterNotBeInUse.new
+      model.should_receive(:string_success_callback)
+      model.with_string!
+    end
+
+    it "if passed an array of strings and/or symbols" do
+      ThisNameBetterNotBeInUse.instance_eval {
+        aasm_event :with_array, :success => [:success_callback1, 'success_callback2'] do
+          transitions :to => :array, :from => [:initial]
+        end
+      }
+
+      model = ThisNameBetterNotBeInUse.new
+      model.should_receive(:success_callback1)
+      model.should_receive(:success_callback2)
+      model.with_array!
+    end
+
+    it "if passed an array of strings and/or symbols and/or procs" do
+      ThisNameBetterNotBeInUse.instance_eval {
+        aasm_event :with_array_including_procs, :success => [:success_callback1, 'success_callback2', lambda { proc_success_callback }] do
+          transitions :to => :array, :from => [:initial]
+        end
+      }
+
+      model = ThisNameBetterNotBeInUse.new
+      model.should_receive(:success_callback1)
+      model.should_receive(:success_callback2)
+      model.should_receive(:proc_success_callback)
+      model.with_array_including_procs!
+    end
+
+    it "if it's a proc" do
+      ThisNameBetterNotBeInUse.instance_eval {
+        aasm_event :with_proc, :success => lambda { proc_success_callback } do
+          transitions :to => :proc, :from => [:initial]
+        end
+      }
+
+      model = ThisNameBetterNotBeInUse.new
+      model.should_receive(:proc_success_callback)
+      model.with_proc!
+    end
+  end
+
+  describe 'after' do
+    it "if they set different ways" do
+      ThisNameBetterNotBeInUse.instance_eval do
+        aasm_event :with_afters, :after => :do_one_thing_after do
+          after do
+            do_another_thing_after_too
+          end
+          after do
+            do_third_thing_at_last
+          end
+          transitions :to => :proc, :from => [:initial]
+        end
+      end
+
+      model = ThisNameBetterNotBeInUse.new
+      model.should_receive(:do_one_thing_after).once.ordered
+      model.should_receive(:do_another_thing_after_too).once.ordered
+      model.should_receive(:do_third_thing_at_last).once.ordered
+      model.with_afters!
+    end
+  end
+
+  describe 'before' do
+    it "if it's a proc" do
+      ThisNameBetterNotBeInUse.instance_eval do
+        aasm_event :before_as_proc do
+          before do
+            do_something_before
+          end
+          transitions :to => :proc, :from => [:initial]
+        end
+      end
+
+      model = ThisNameBetterNotBeInUse.new
+      model.should_receive(:do_something_before).once
+      model.before_as_proc!
+    end
+  end
+
+  it 'in right order' do
+    ThisNameBetterNotBeInUse.instance_eval do
+      aasm_event :in_right_order, :after => :do_something_after do
+        before do
+          do_something_before
+        end
+        transitions :to => :proc, :from => [:initial]
+      end
+    end
+
+    model = ThisNameBetterNotBeInUse.new
+    model.should_receive(:do_something_before).once.ordered
+    model.should_receive(:do_something_after).once.ordered
+    model.in_right_order!
+  end
+end
+
+describe 'parametrised events' do
+  let(:pe) {ParametrisedEvent.new}
+
+  it 'should transition to specified next state (sleeping to showering)' do
+    pe.wakeup!(:showering)
+    pe.aasm_current_state.should == :showering
+  end
+
+  it 'should transition to specified next state (sleeping to working)' do
+    pe.wakeup!(:working)
+    pe.aasm_current_state.should == :working
+  end
+
+  it 'should transition to default (first or showering) state' do
+    pe.wakeup!
+    pe.aasm_current_state.should == :showering
+  end
+
+  it 'should transition to default state when on_transition invoked' do
+    pe.dress!(nil, 'purple', 'dressy')
+    pe.aasm_current_state.should == :working
+  end
+
+  it 'should call on_transition method with args' do
+    pe.wakeup!(:showering)
+    pe.should_receive(:wear_clothes).with('blue', 'jeans')
+    pe.dress!(:working, 'blue', 'jeans')
+  end
+
+  it 'should call on_transition proc' do
+    pe.wakeup!(:showering)
+    pe.should_receive(:wear_clothes).with('purple', 'slacks')
+    pe.dress!(:dating, 'purple', 'slacks')
+  end
+
+  it 'should call on_transition with an array of methods' do
+    pe.wakeup!(:showering)
+    pe.should_receive(:condition_hair)
+    pe.should_receive(:fix_hair)
+    pe.dress!(:prettying_up)
+  end
+end
+
+describe 'event firing without persistence' do
+  it 'should attempt to persist if aasm_write_state is defined' do
+    foo = Foo.new
+    def foo.aasm_write_state; end
+    foo.should be_open
+
+    foo.should_receive(:aasm_write_state_without_persistence)
+    foo.close
+  end
+end