aasm 3.0.24 → 3.4.0

data/spec/unit/persistence/mongoid_persistance_spec.rb

@@ -1,131 +1,152 @@
 describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3') do
 # describe 'mongoid' do
 
-  before(:all) do
+  begin
     require 'mongoid'
     require 'logger'
     require 'spec_helper'
-    Dir[File.dirname(__FILE__) + "/../../models/mongoid/*.rb"].sort.each { |f| require File.expand_path(f) }
 
-    # if you want to see the statements while running the spec enable the following line
-    # Mongoid.logger = Logger.new(STDERR)
+    before(:all) do
+      Dir[File.dirname(__FILE__) + "/../../models/mongoid/*.rb"].sort.each { |f| require File.expand_path(f) }
 
-    DATABASE_NAME = "mongoid_#{Process.pid}"
+      # if you want to see the statements while running the spec enable the following line
+      # Mongoid.logger = Logger.new(STDERR)
 
-    Mongoid.configure do |config|
-      config.connect_to DATABASE_NAME
+      DATABASE_NAME = "mongoid_#{Process.pid}"
+
+      Mongoid.configure do |config|
+        config.connect_to DATABASE_NAME
+      end
     end
-  end
 
-  after do
-    Mongoid.purge!
-  end
+    after do
+      Mongoid.purge!
+    end
 
-  describe "named scopes with the old DSL" do
+    describe "named scopes with the old DSL" do
 
-    context "Does not already respond_to? the scope name" do
-      it "should add a scope" do
-        SimpleMongoid.should respond_to(:unknown_scope)
-        SimpleMongoid.unknown_scope.class.should == Mongoid::Criteria
+      context "Does not already respond_to? the scope name" do
+        it "should add a scope" do
+          expect(SimpleMongoid).to respond_to(:unknown_scope)
+          expect(SimpleMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
+        end
       end
-    end
 
-    context "Already respond_to? the scope name" do
-      it "should not add a scope" do
-        SimpleMongoid.should respond_to(:new)
-        SimpleMongoid.new.class.should == SimpleMongoid
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleMongoid).to respond_to(:new)
+          expect(SimpleMongoid.new.class).to eq(SimpleMongoid)
+        end
       end
+
     end
 
-  end
+    describe "named scopes with the new DSL" do
 
-  describe "named scopes with the new DSL" do
+      context "Does not already respond_to? the scope name" do
+        it "should add a scope" do
+          expect(SimpleNewDslMongoid).to respond_to(:unknown_scope)
+          expect(SimpleNewDslMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
+        end
+      end
 
-    context "Does not already respond_to? the scope name" do
-      it "should add a scope" do
-        SimpleNewDslMongoid.should respond_to(:unknown_scope)
-        SimpleNewDslMongoid.unknown_scope.class.should == Mongoid::Criteria
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleNewDslMongoid).to respond_to(:new)
+          expect(SimpleNewDslMongoid.new.class).to eq(SimpleNewDslMongoid)
+        end
       end
-    end
 
-    context "Already respond_to? the scope name" do
-      it "should not add a scope" do
-        SimpleNewDslMongoid.should respond_to(:new)
-        SimpleNewDslMongoid.new.class.should == SimpleNewDslMongoid
+      it "does not create scopes if requested" do
+        expect(NoScopeMongoid).not_to respond_to(:ignored_scope)
       end
-    end
 
-    it "does not create scopes if requested" do
-      NoScopeMongoid.should_not respond_to(:ignored_scope)
     end
 
-  end
+    describe "#find_in_state" do
 
-  describe "#find_in_state" do
+      let!(:model)    { SimpleNewDslMongoid.create!(:status => :unknown_scope) }
+      let!(:model_id) { model._id }
 
-    let!(:model)    { SimpleNewDslMongoid.create!(:status => :unknown_scope) }
-    let!(:model_id) { model._id }
+      it "should respond to method" do
+        expect(SimpleNewDslMongoid).to respond_to(:find_in_state)
+      end
 
-    it "should respond to method" do
-      SimpleNewDslMongoid.should respond_to(:find_in_state)
-    end
+      it "should find the model when given the correct scope and model id" do
+        expect(SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope').class).to eq(SimpleNewDslMongoid)
+        expect(SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope')).to eq(model)
+      end
 
-    it "should find the model when given the correct scope and model id" do
-      SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope').class.should == SimpleNewDslMongoid
-      SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope').should == model
-    end
+      it "should raise DocumentNotFound error when given incorrect scope" do
+        expect {SimpleNewDslMongoid.find_in_state(model_id, 'new')}.to raise_error Mongoid::Errors::DocumentNotFound
+      end
 
-    it "should raise DocumentNotFound error when given incorrect scope" do
-      expect {SimpleNewDslMongoid.find_in_state(model_id, 'new')}.to raise_error Mongoid::Errors::DocumentNotFound
-    end
+      it "should raise DocumentNotFound error when given incorrect model id" do
+        expect {SimpleNewDslMongoid.find_in_state('bad_id', 'unknown_scope')}.to raise_error Mongoid::Errors::DocumentNotFound
+      end
 
-    it "should raise DocumentNotFound error when given incorrect model id" do
-      expect {SimpleNewDslMongoid.find_in_state('bad_id', 'unknown_scope')}.to raise_error Mongoid::Errors::DocumentNotFound
     end
 
-  end
+    describe "#count_in_state" do
 
-  describe "#count_in_state" do
+      before do
+        3.times { SimpleNewDslMongoid.create!(:status => :unknown_scope) }
+      end
 
-    before do
-      3.times { SimpleNewDslMongoid.create!(:status => :unknown_scope) }
-    end
+      it "should respond to method" do
+        expect(SimpleNewDslMongoid).to respond_to(:count_in_state)
+      end
 
-    it "should respond to method" do
-      SimpleNewDslMongoid.should respond_to(:count_in_state)
-    end
+      it "should return n for a scope with n records persisted" do
+        expect(SimpleNewDslMongoid.count_in_state('unknown_scope').class).to eq(Fixnum)
+        expect(SimpleNewDslMongoid.count_in_state('unknown_scope')).to eq(3)
+      end
 
-    it "should return n for a scope with n records persisted" do
-      SimpleNewDslMongoid.count_in_state('unknown_scope').class.should == Fixnum
-      SimpleNewDslMongoid.count_in_state('unknown_scope').should == 3
-    end
+      it "should return zero for a scope without records persisted" do
+        expect(SimpleNewDslMongoid.count_in_state('new').class).to eq(Fixnum)
+        expect(SimpleNewDslMongoid.count_in_state('new')).to eq(0)
+      end
 
-    it "should return zero for a scope without records persisted" do
-      SimpleNewDslMongoid.count_in_state('new').class.should == Fixnum
-      SimpleNewDslMongoid.count_in_state('new').should == 0
     end
 
-  end
+    describe "#with_state_scope" do
 
-  describe "#with_state_scope" do
+      before do
+        3.times { SimpleNewDslMongoid.create!(:status => :unknown_scope) }
+        2.times { SimpleNewDslMongoid.create!(:status => :new) }
+      end
 
-    before do
-      3.times { SimpleNewDslMongoid.create!(:status => :unknown_scope) }
-      2.times { SimpleNewDslMongoid.create!(:status => :new) }
-    end
+      it "should respond to method" do
+        expect(SimpleNewDslMongoid).to respond_to(:with_state_scope)
+      end
+
+      it "should correctly process block" do
+        expect(SimpleNewDslMongoid.with_state_scope('unknown_scope') do
+          SimpleNewDslMongoid.count
+        end).to eq(3)
+        expect(SimpleNewDslMongoid.with_state_scope('new') do
+          SimpleNewDslMongoid.count
+        end).to eq(2)
+      end
 
-    it "should respond to method" do
-      SimpleNewDslMongoid.should respond_to(:with_state_scope)
     end
 
-    it "should correctly process block" do
-      SimpleNewDslMongoid.with_state_scope('unknown_scope') do
-        SimpleNewDslMongoid.count
-      end.should == 3
-      SimpleNewDslMongoid.with_state_scope('new') do
-        SimpleNewDslMongoid.count
-      end.should == 2
+
+    describe "instance methods" do
+      let(:simple) {SimpleNewDslMongoid.new}
+
+      it "should call aasm_ensure_initial_state on validation before create" do
+        expect(simple).to receive(:aasm_ensure_initial_state).and_return(true)
+        simple.valid?
+      end
+
+      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
+        expect(simple).to receive(:aasm_ensure_initial_state).and_return(true)
+        simple.save(:validate => false)
+      end
     end
 
+  rescue LoadError
+    puts "Not running Mongoid specs because mongoid gem is not installed!!!"
   end
 end

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -0,0 +1,103 @@
+
+describe 'sequel' do
+  begin
+    require 'sequel'
+    require 'logger'
+    require 'spec_helper'
+
+    before(:all) do
+      db = Sequel.sqlite
+      # if you want to see the statements while running the spec enable the following line
+      # db.loggers << Logger.new($stderr)
+      db.create_table(:models) do
+        primary_key :id
+        String :status
+      end
+
+      @model = Class.new(Sequel::Model(db)) do
+        set_dataset(:models)
+        attr_accessor :default
+        include AASM
+        aasm :column => :status
+        aasm do
+          state :alpha, :initial => true
+          state :beta
+          state :gamma
+          event :release do
+            transitions :from => [:alpha, :beta, :gamma], :to => :beta
+          end
+        end
+      end
+    end
+
+    describe "instance methods" do
+      let(:model) {@model.new}
+
+      it "should respond to aasm persistence methods" do
+        expect(model).to respond_to(:aasm_read_state)
+        expect(model).to respond_to(:aasm_write_state)
+        expect(model).to respond_to(:aasm_write_state_without_persistence)
+      end
+
+      it "should return the initial state when new and the aasm field is nil" do
+        expect(model.aasm.current_state).to eq(:alpha)
+      end
+
+      it "should return the aasm column when new and the aasm field is not nil" do
+        model.status = "beta"
+        expect(model.aasm.current_state).to eq(:beta)
+      end
+
+      it "should return the aasm column when not new and the aasm_column is not nil" do
+        allow(model).to receive(:new?).and_return(false)
+        model.status = "gamma"
+        expect(model.aasm.current_state).to eq(:gamma)
+      end
+
+      it "should allow a nil state" do
+        allow(model).to receive(:new?).and_return(false)
+        model.status = nil
+        expect(model.aasm.current_state).to be_nil
+      end
+
+      it "should call aasm_ensure_initial_state on validation before create" do
+        expect(model).to receive(:aasm_ensure_initial_state).and_return(true)
+        model.valid?
+      end
+
+      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
+        expect(model).to receive(:aasm_ensure_initial_state).and_return(true)
+        model.save(:validate => false)
+      end
+    end
+
+    describe 'subclasses' do
+      it "should have the same states as its parent class" do
+        expect(Class.new(@model).aasm.states).to eq(@model.aasm.states)
+      end
+
+      it "should have the same events as its parent class" do
+        expect(Class.new(@model).aasm.events).to eq(@model.aasm.events)
+      end
+
+      it "should have the same column as its parent even for the new dsl" do
+        expect(@model.aasm_column).to eq(:status)
+        expect(Class.new(@model).aasm_column).to eq(:status)
+      end
+    end
+
+    describe 'initial states' do
+      it 'should support conditions' do
+        @model.aasm do
+          initial_state lambda{ |m| m.default }
+        end
+
+        expect(@model.new(:default => :beta).aasm.current_state).to eq(:beta)
+        expect(@model.new(:default => :gamma).aasm.current_state).to eq(:gamma)
+      end
+    end
+
+  rescue LoadError
+    puts "Not running Sequel specs because sequel gem is not installed!!!"
+  end
+end

data/spec/unit/reloading_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'callbacks for the new DSL' do
+  let(:definer) { DoubleDefiner.new }
+
+  it "allows extending states" do
+    expect(definer).to receive(:do_enter)
+    definer.finish
+  end
+
+  it "allows extending events" do
+    expect(definer).to receive(:do_on_transition)
+    definer.finish
+  end
+end

data/spec/unit/simple_example_spec.rb

@@ -20,40 +20,39 @@ describe 'state machine' do
   let(:payment) {Payment.new}
 
   it 'starts with an initial state' do
-    payment.aasm_current_state.should == :initialised
-    # payment.aasm.current_state.should == :initialised # not yet supported
-    payment.should respond_to(:initialised?)
-    payment.should be_initialised
+    expect(payment.aasm.current_state).to eq(:initialised)
+    expect(payment).to respond_to(:initialised?)
+    expect(payment).to be_initialised
   end
 
   it 'allows transitions to other states' do
-    payment.should respond_to(:fill_out)
-    payment.should respond_to(:fill_out!)
+    expect(payment).to respond_to(:fill_out)
+    expect(payment).to respond_to(:fill_out!)
     payment.fill_out!
-    payment.should respond_to(:filled_out?)
-    payment.should be_filled_out
+    expect(payment).to respond_to(:filled_out?)
+    expect(payment).to be_filled_out
 
-    payment.should respond_to(:authorise)
-    payment.should respond_to(:authorise!)
+    expect(payment).to respond_to(:authorise)
+    expect(payment).to respond_to(:authorise!)
     payment.authorise
-    payment.should respond_to(:authorised?)
-    payment.should be_authorised
+    expect(payment).to respond_to(:authorised?)
+    expect(payment).to be_authorised
   end
 
   it 'denies transitions to other states' do
-    lambda {payment.authorise}.should raise_error(AASM::InvalidTransition)
-    lambda {payment.authorise!}.should raise_error(AASM::InvalidTransition)
+    expect {payment.authorise}.to raise_error(AASM::InvalidTransition)
+    expect {payment.authorise!}.to raise_error(AASM::InvalidTransition)
     payment.fill_out
-    lambda {payment.fill_out}.should raise_error(AASM::InvalidTransition)
-    lambda {payment.fill_out!}.should raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out!}.to raise_error(AASM::InvalidTransition)
     payment.authorise
-    lambda {payment.fill_out}.should raise_error(AASM::InvalidTransition)
-    lambda {payment.fill_out!}.should raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out!}.to raise_error(AASM::InvalidTransition)
   end
 
   it 'defines constants for each state name' do
-    Payment::STATE_INITIALISED.should eq(:initialised)
-    Payment::STATE_FILLED_OUT.should eq(:filled_out)
-    Payment::STATE_AUTHORISED.should eq(:authorised)
+    expect(Payment::STATE_INITIALISED).to eq(:initialised)
+    expect(Payment::STATE_FILLED_OUT).to eq(:filled_out)
+    expect(Payment::STATE_AUTHORISED).to eq(:authorised)
   end
 end

data/spec/unit/state_spec.rb

@@ -12,34 +12,34 @@ describe AASM::State do
 
   it 'should set the name' do
     state = new_state
-    state.name.should == :astate
+    expect(state.name).to eq(:astate)
   end
 
   it 'should set the display_name from name' do
-    new_state.display_name.should == 'Astate'
+    expect(new_state.display_name).to eq('Astate')
   end
 
   it 'should set the display_name from options' do
-    new_state(:display => "A State").display_name.should == 'A State'
+    expect(new_state(:display => "A State").display_name).to eq('A State')
   end
 
   it 'should set the options and expose them as options' do
-    new_state.options.should == @options
+    expect(new_state.options).to eq(@options)
   end
 
   it 'should be equal to a symbol of the same name' do
-    new_state.should == :astate
+    expect(new_state).to eq(:astate)
   end
 
   it 'should be equal to a State of the same name' do
-    new_state.should == new_state
+    expect(new_state).to eq(new_state)
   end
 
   it 'should send a message to the record for an action if the action is present as a symbol' do
     state = new_state(:entering => :foo)
 
     record = double('record')
-    record.should_receive(:foo)
+    expect(record).to receive(:foo)
 
     state.fire_callbacks(:entering, record)
   end
@@ -48,7 +48,7 @@ describe AASM::State do
     state = new_state(:entering => 'foo')
 
     record = double('record')
-    record.should_receive(:foo)
+    expect(record).to receive(:foo)
 
     state.fire_callbacks(:entering, record)
   end
@@ -57,10 +57,10 @@ describe AASM::State do
     state = new_state(:entering => [:a, :b, "c", lambda {|r| r.foobar }])
 
     record = double('record')
-    record.should_receive(:a)
-    record.should_receive(:b)
-    record.should_receive(:c)
-    record.should_receive(:foobar)
+    expect(record).to receive(:a)
+    expect(record).to receive(:b)
+    expect(record).to receive(:c)
+    expect(record).to receive(:foobar)
 
     state.fire_callbacks(:entering, record)
   end
@@ -69,9 +69,9 @@ describe AASM::State do
     state = new_state(:entering => [:a, :b, :c])
 
     record = double('record')
-    record.should_receive(:a)
-    record.should_receive(:b).and_throw(:halt_aasm_chain)
-    record.should_not_receive(:c)
+    expect(record).to receive(:a)
+    expect(record).to receive(:b).and_throw(:halt_aasm_chain)
+    expect(record).not_to receive(:c)
 
     state.fire_callbacks(:entering, record)
   end
@@ -80,7 +80,7 @@ describe AASM::State do
     state = new_state(:entering => Proc.new {|r| r.foobar})
 
     record = double('record')
-    record.should_receive(:foobar)
+    expect(record).to receive(:foobar)
 
     state.fire_callbacks(:entering, record)
   end

data/spec/unit/subclassing_spec.rb

@@ -4,28 +4,28 @@ describe 'subclassing' do
   let(:son) {Son.new}
 
   it 'should have the parent states' do
-    Foo.aasm_states.each do |state|
-      FooTwo.aasm_states.should include(state)
+    Foo.aasm.states.each do |state|
+      expect(FooTwo.aasm.states).to include(state)
     end
-    Baz.aasm_states.should == Bar.aasm_states
+    expect(Baz.aasm.states).to eq(Bar.aasm.states)
   end
 
   it 'should not add the child states to the parent machine' do
-    Foo.aasm_states.should_not include(:foo)
+    expect(Foo.aasm.states).not_to include(:foo)
   end
 
   it "should have the same events as its parent" do
-    Baz.aasm_events.should == Bar.aasm_events
+    expect(Baz.aasm.events).to eq(Bar.aasm.events)
   end
 
   it 'should know how to respond to `may_add_details?`' do
-    son.may_add_details?.should be_true
+    expect(son.may_add_details?).to be_true
   end
 
   it 'should not break if I call Son#update_state' do
     son.update_state
-    son.aasm_current_state.should == :pending_details_confirmation
+    expect(son.aasm.current_state).to eq(:pending_details_confirmation)
   end
-  
+
 end