aasm 2.1.1 → 2.1.3

data/spec/unit/active_record_persistence_spec.rb

@@ -0,0 +1,254 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'aasm')
+
+begin
+  require 'rubygems'
+  require 'active_record'
+
+  # A dummy class for mocking the activerecord connection class
+  class Connection
+  end
+
+  class FooBar < ActiveRecord::Base
+    include AASM
+
+    # Fake this column for testing purposes
+    attr_accessor :aasm_state
+
+    aasm_state :open
+    aasm_state :closed
+
+    aasm_event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+
+  class Fi < ActiveRecord::Base
+    def aasm_read_state
+      "fi"
+    end
+    include AASM
+  end
+
+  class Fo < ActiveRecord::Base
+    def aasm_write_state(state)
+      "fo"
+    end
+    include AASM
+  end
+
+  class Fum < ActiveRecord::Base
+    def aasm_write_state_without_persistence(state)
+      "fum"
+    end
+    include AASM
+  end
+
+  class June < ActiveRecord::Base
+    include AASM
+    aasm_column :status
+  end
+
+  class Beaver < June
+  end
+
+  class Thief < ActiveRecord::Base
+    include AASM
+    aasm_initial_state  Proc.new { |thief| thief.skilled ? :rich : :jailed }
+    aasm_state          :rich
+    aasm_state          :jailed
+    attr_accessor :skilled, :aasm_state
+  end
+
+  describe "aasm model", :shared => true do
+    it "should include AASM::Persistence::ActiveRecordPersistence" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence)
+    end
+    it "should include AASM::Persistence::ActiveRecordPersistence::InstanceMethods" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
+    end
+  end
+
+  describe FooBar, "class methods" do
+    before(:each) do
+      @klass = FooBar
+    end
+    it_should_behave_like "aasm model"
+    it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
+    end
+    it "should include AASM::Persistence::ActiveRecordPersistence::WriteState" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    end
+    it "should include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+    end
+  end
+
+  describe Fi, "class methods" do
+    before(:each) do
+      @klass = Fi
+    end
+    it_should_behave_like "aasm model"
+    it "should not include AASM::Persistence::ActiveRecordPersistence::ReadState" do
+      @klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
+    end
+    it "should include AASM::Persistence::ActiveRecordPersistence::WriteState" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    end
+    it "should include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+    end
+  end
+
+  describe Fo, "class methods" do
+    before(:each) do
+      @klass = Fo
+    end
+    it_should_behave_like "aasm model"
+    it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
+    end
+    it "should not include AASM::Persistence::ActiveRecordPersistence::WriteState" do
+      @klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    end
+    it "should include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+    end
+  end
+
+  describe Fum, "class methods" do
+    before(:each) do
+      @klass = Fum
+    end
+    it_should_behave_like "aasm model"
+    it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::ReadState)
+    end
+    it "should include AASM::Persistence::ActiveRecordPersistence::WriteState" do
+      @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::WriteState)
+    end
+    it "should not include AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence" do
+      @klass.included_modules.should_not be_include(AASM::Persistence::ActiveRecordPersistence::WriteStateWithoutPersistence)
+    end
+  end
+
+  describe FooBar, "instance methods" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBar.stub!(:connection).and_return(connection)
+    end
+
+    it "should respond to aasm read state when not previously defined" do
+      FooBar.new.should respond_to(:aasm_read_state)
+    end
+
+    it "should respond to aasm write state when not previously defined" do
+      FooBar.new.should respond_to(:aasm_write_state)
+    end
+
+    it "should respond to aasm write state without persistence when not previously defined" do
+      FooBar.new.should respond_to(:aasm_write_state_without_persistence)
+    end
+
+    it "should return the initial state when new and the aasm field is nil" do
+      FooBar.new.aasm_current_state.should == :open
+    end
+
+    it "should return the aasm column when new and the aasm field is not nil" do
+      foo = FooBar.new
+      foo.aasm_state = "closed"
+      foo.aasm_current_state.should == :closed
+    end
+
+    it "should return the aasm column when not new and the aasm_column is not nil" do
+      foo = FooBar.new
+      foo.stub!(:new_record?).and_return(false)
+      foo.aasm_state = "state"
+      foo.aasm_current_state.should == :state
+    end
+
+    it "should allow a nil state" do
+      foo = FooBar.new
+      foo.stub!(:new_record?).and_return(false)
+      foo.aasm_state = nil
+      foo.aasm_current_state.should be_nil
+    end
+
+    it "should have aasm_ensure_initial_state" do
+      foo = FooBar.new
+      foo.send :aasm_ensure_initial_state
+    end
+
+    it "should call aasm_ensure_initial_state on validation before create" do
+      foo = FooBar.new
+      foo.should_receive(:aasm_ensure_initial_state).and_return(true)
+      foo.valid?
+    end
+
+    it "should call aasm_ensure_initial_state on validation before create" do
+      foo = FooBar.new
+      foo.stub!(:new_record?).and_return(false)
+      foo.should_not_receive(:aasm_ensure_initial_state)
+      foo.valid?
+    end
+
+  end
+
+  describe 'Beavers' do
+    it "should have the same states as it's parent" do
+      Beaver.aasm_states.should == June.aasm_states
+    end
+
+    it "should have the same events as it's parent" do
+      Beaver.aasm_events.should == June.aasm_events
+    end
+
+    it "should have the same column as it's parent" do
+      Beaver.aasm_column.should == :status
+    end
+  end
+
+  describe AASM::Persistence::ActiveRecordPersistence::NamedScopeMethods do
+    class NamedScopeExample < ActiveRecord::Base
+      include AASM
+    end
+
+    context "Does not already respond_to? the scope name" do
+      it "should add a named_scope" do
+        NamedScopeExample.should_receive(:named_scope)
+        NamedScopeExample.aasm_state :unknown_scope
+      end
+    end
+
+    context "Already respond_to? the scope name" do
+      it "should not add a named_scope" do
+        NamedScopeExample.should_not_receive(:named_scope)
+        NamedScopeExample.aasm_state :new
+      end
+    end
+  end
+
+  describe 'Thieves' do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      Thief.stub!(:connection).and_return(connection)
+    end
+
+    it 'should be rich if they\'re skilled' do
+      Thief.new(:skilled => true).aasm_current_state.should == :rich
+    end
+
+    it 'should be jailed if they\'re unskilled' do
+      Thief.new(:skilled => false).aasm_current_state.should == :jailed
+    end
+  end
+
+  # TODO: figure out how to test ActiveRecord reload! without a database
+
+rescue LoadError => e
+  if e.message == "no such file to load -- active_record"
+    puts "You must install active record to run this spec.  Install with sudo gem install activerecord"
+  else
+    raise
+  end
+end

data/spec/unit/before_after_callbacks_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+class Foo2
+  include AASM
+  aasm_initial_state :open
+  aasm_state :open,
+    :before_enter => :before_enter_open,
+    :before_exit => :before_exit_open,
+    :after_enter => :after_enter_open,
+    :after_exit => :after_exit_open
+  aasm_state :closed,
+    :before_enter => :before_enter_closed,
+    :before_exit => :before_exit_closed,
+    :after_enter => :after_enter_closed,
+    :after_exit => :after_exit_closed
+
+  aasm_event :close, :before => :before, :after => :after do
+    transitions :to => :closed, :from => [:open]
+  end
+
+  aasm_event :open, :before => :before, :after => :after do
+    transitions :to => :open, :from => :closed
+  end
+
+  def before_enter_open
+  end
+  def before_exit_open
+  end
+  def after_enter_open
+  end
+  def after_exit_open
+  end
+
+  def before_enter_closed
+  end
+  def before_exit_closed
+  end
+  def after_enter_closed
+  end
+  def after_exit_closed
+  end
+
+  def before
+  end
+  def after
+  end
+end
+
+describe Foo2, '- new callbacks' do
+  before(:each) do
+    @foo = Foo2.new
+  end
+
+  it "should get close callbacks" do
+    @foo.should_receive(:before).once.ordered
+    @foo.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    @foo.should_receive(:before_enter_closed).once.ordered
+    @foo.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+    @foo.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
+    @foo.should_receive(:after_enter_closed).once.ordered
+    @foo.should_receive(:after).once.ordered
+
+    @foo.close!
+  end
+
+  it "should get open callbacks" do
+    @foo.close!
+    
+    @foo.should_receive(:before).once.ordered                                                                       
+    @foo.should_receive(:before_exit_closed).once.ordered                # these should be before the state changes
+    @foo.should_receive(:before_enter_open).once.ordered                                                            
+    @foo.should_receive(:aasm_write_state).once.ordered.and_return(true) # this is when the state changes
+    @foo.should_receive(:after_exit_closed).once.ordered                 # these should be after the state changes
+    @foo.should_receive(:after_enter_open).once.ordered
+    @foo.should_receive(:after).once.ordered
+
+    @foo.open!
+  end
+end

data/spec/unit/event_spec.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe AASM::SupportingClasses::Event do
+  before(:each) do
+    @name = :close_order
+    @success = :success_callback
+  end
+
+  def new_event
+    @event = AASM::SupportingClasses::Event.new(@name, {:success => @success}) do
+      transitions :to => :closed, :from => [:open, :received]
+    end
+  end
+
+  it 'should set the name' do
+    new_event
+    @event.name.should == @name
+  end
+
+  it 'should set the success option' do
+    new_event
+    @event.success.should == @success
+  end
+
+  it 'should create StateTransitions' do
+    AASM::SupportingClasses::StateTransition.should_receive(:new).with({:to => :closed, :from => :open})
+    AASM::SupportingClasses::StateTransition.should_receive(:new).with({:to => :closed, :from => :received})
+    new_event
+  end
+end
+
+describe AASM::SupportingClasses::Event, 'when firing an event' do
+  it 'should raise an AASM::InvalidTransition error if the transitions are empty' do
+    obj = mock('object')
+    obj.stub!(:aasm_current_state)
+
+    event = AASM::SupportingClasses::Event.new(:event)
+    lambda { event.fire(obj) }.should raise_error(AASM::InvalidTransition)
+  end
+
+  it 'should return the state of the first matching transition it finds' do
+    event = AASM::SupportingClasses::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
+end
+
+describe AASM::SupportingClasses::Event, 'when executing the success callback' do
+  class ThisNameBetterNotBeInUse
+    include AASM
+
+    aasm_state :initial
+    aasm_state :symbol
+    aasm_state :string
+    aasm_state :array
+    aasm_state :proc
+  end
+
+  it "should send the success callback 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 "should send the success callback 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 "should call each success callback 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 "should call each success callback 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 { |obj| obj.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 "should call the success callback if it's a proc" do
+    ThisNameBetterNotBeInUse.instance_eval {
+      aasm_event :with_proc, :success => lambda { |obj| obj.proc_success_callback } do
+        transitions :to => :proc, :from => [:initial]
+      end
+    }
+
+    model = ThisNameBetterNotBeInUse.new
+    model.should_receive(:proc_success_callback)
+    model.with_proc!
+  end
+end