aasm 3.0.24 → 3.1.1

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 if not installed!!!"
   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