aasm 3.0.26 → 3.1.0

data/spec/unit/persistence/mongoid_persistance_spec.rb

@@ -27,15 +27,15 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
 
       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
+          expect(SimpleMongoid).to respond_to(:unknown_scope)
+          expect(SimpleMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
         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
+          expect(SimpleMongoid).to respond_to(:new)
+          expect(SimpleMongoid.new.class).to eq(SimpleMongoid)
         end
       end
 
@@ -45,20 +45,20 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
 
       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
+          expect(SimpleNewDslMongoid).to respond_to(:unknown_scope)
+          expect(SimpleNewDslMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
         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
+          expect(SimpleNewDslMongoid).to respond_to(:new)
+          expect(SimpleNewDslMongoid.new.class).to eq(SimpleNewDslMongoid)
         end
       end
 
       it "does not create scopes if requested" do
-        NoScopeMongoid.should_not respond_to(:ignored_scope)
+        expect(NoScopeMongoid).not_to respond_to(:ignored_scope)
       end
 
     end
@@ -69,12 +69,12 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       let!(:model_id) { model._id }
 
       it "should respond to method" do
-        SimpleNewDslMongoid.should respond_to(:find_in_state)
+        expect(SimpleNewDslMongoid).to respond_to(:find_in_state)
       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
+        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 raise DocumentNotFound error when given incorrect scope" do
@@ -94,17 +94,17 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       end
 
       it "should respond to method" do
-        SimpleNewDslMongoid.should respond_to(:count_in_state)
+        expect(SimpleNewDslMongoid).to respond_to(:count_in_state)
       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
+        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 zero for a scope without records persisted" do
-        SimpleNewDslMongoid.count_in_state('new').class.should == Fixnum
-        SimpleNewDslMongoid.count_in_state('new').should == 0
+        expect(SimpleNewDslMongoid.count_in_state('new').class).to eq(Fixnum)
+        expect(SimpleNewDslMongoid.count_in_state('new')).to eq(0)
       end
 
     end
@@ -117,16 +117,16 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       end
 
       it "should respond to method" do
-        SimpleNewDslMongoid.should respond_to(:with_state_scope)
+        expect(SimpleNewDslMongoid).to respond_to(:with_state_scope)
       end
 
       it "should correctly process block" do
-        SimpleNewDslMongoid.with_state_scope('unknown_scope') do
+        expect(SimpleNewDslMongoid.with_state_scope('unknown_scope') do
           SimpleNewDslMongoid.count
-        end.should == 3
-        SimpleNewDslMongoid.with_state_scope('new') do
+        end).to eq(3)
+        expect(SimpleNewDslMongoid.with_state_scope('new') do
           SimpleNewDslMongoid.count
-        end.should == 2
+        end).to eq(2)
       end
 
     end
@@ -136,12 +136,12 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       let(:simple) {SimpleNewDslMongoid.new}
 
       it "should call aasm_ensure_initial_state on validation before create" do
-        simple.should_receive(:aasm_ensure_initial_state).and_return(true)
+        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
-        simple.should_receive(:aasm_ensure_initial_state).and_return(true)
+        expect(simple).to receive(:aasm_ensure_initial_state).and_return(true)
         simple.save(:validate => false)
       end
     end

data/spec/unit/simple_example_spec.rb

@@ -20,39 +20,39 @@ describe 'state machine' do
   let(:payment) {Payment.new}
 
   it 'starts with an initial state' do
-    payment.aasm.current_state.should == :initialised
-    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

@@ -5,26 +5,26 @@ describe 'subclassing' do
 
   it 'should have the parent states' do
     Foo.aasm.states.each do |state|
-      FooTwo.aasm.states.should include(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

data/spec/unit/transition_spec.rb

@@ -4,46 +4,46 @@ describe 'transitions' do
 
   it 'should raise an exception when whiny' do
     process = ProcessWithNewDsl.new
-    lambda { process.stop! }.should raise_error(AASM::InvalidTransition)
-    process.should be_sleeping
+    expect { process.stop! }.to raise_error(AASM::InvalidTransition)
+    expect(process).to be_sleeping
   end
 
   it 'should not raise an exception when not whiny' do
     silencer = Silencer.new
-    silencer.smile!.should be_false
-    silencer.should be_silent
+    expect(silencer.smile!).to be_false
+    expect(silencer).to be_silent
   end
 
   it 'should not raise an exception when superclass not whiny' do
     sub = SubClassing.new
-    sub.smile!.should be_false
-    sub.should be_silent
+    expect(sub.smile!).to be_false
+    expect(sub).to be_silent
   end
 
   it 'should not raise an exception when from is nil even if whiny' do
     silencer = Silencer.new
-    silencer.smile_any!.should be_true
-    silencer.should be_smiling
+    expect(silencer.smile_any!).to be_true
+    expect(silencer).to be_smiling
   end
 
   it 'should call the block when success' do
     silencer = Silencer.new
     success = false
-    lambda {
+    expect {
       silencer.smile_any! do
         success = true
       end
-    }.should change { success }.to(true)
+    }.to change { success }.to(true)
   end
 
   it 'should not call the block when failure' do
     silencer = Silencer.new
     success = false
-    lambda {
+    expect {
       silencer.smile! do
         success = true
       end
-    }.should_not change { success }.to(true)
+    }.not_to change { success }.to(true)
   end
 
 end
@@ -56,9 +56,9 @@ describe AASM::Transition do
     opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
     st = AASM::Transition.new(opts)
 
-    st.from.should == opts[:from]
-    st.to.should == opts[:to]
-    st.opts.should == opts
+    expect(st.from).to eq(opts[:from])
+    expect(st.to).to eq(opts[:to])
+    expect(st.opts).to eq(opts)
   end
 
   it 'should pass equality check if from and to are the same' do
@@ -66,10 +66,10 @@ describe AASM::Transition do
     st = AASM::Transition.new(opts)
 
     obj = double('object')
-    obj.stub(:from).and_return(opts[:from])
-    obj.stub(:to).and_return(opts[:to])
+    allow(obj).to receive(:from).and_return(opts[:from])
+    allow(obj).to receive(:to).and_return(opts[:to])
 
-    st.should == obj
+    expect(st).to eq(obj)
   end
 
   it 'should fail equality check if from are not the same' do
@@ -77,10 +77,10 @@ describe AASM::Transition do
     st = AASM::Transition.new(opts)
 
     obj = double('object')
-    obj.stub(:from).and_return('blah')
-    obj.stub(:to).and_return(opts[:to])
+    allow(obj).to receive(:from).and_return('blah')
+    allow(obj).to receive(:to).and_return(opts[:to])
 
-    st.should_not == obj
+    expect(st).not_to eq(obj)
   end
 
   it 'should fail equality check if to are not the same' do
@@ -88,10 +88,10 @@ describe AASM::Transition do
     st = AASM::Transition.new(opts)
 
     obj = double('object')
-    obj.stub(:from).and_return(opts[:from])
-    obj.stub(:to).and_return('blah')
+    allow(obj).to receive(:from).and_return(opts[:from])
+    allow(obj).to receive(:to).and_return('blah')
 
-    st.should_not == obj
+    expect(st).not_to eq(obj)
   end
 end
 
@@ -100,7 +100,7 @@ describe AASM::Transition, '- when performing guard checks' do
     opts = {:from => 'foo', :to => 'bar'}
     st = AASM::Transition.new(opts)
 
-    st.perform(nil).should be_true
+    expect(st.perform(nil)).to be_true
   end
 
   it 'should call the method on the object if guard is a symbol' do
@@ -108,7 +108,7 @@ describe AASM::Transition, '- when performing guard checks' do
     st = AASM::Transition.new(opts)
 
     obj = double('object')
-    obj.should_receive(:test)
+    expect(obj).to receive(:test)
 
     st.perform(obj)
   end
@@ -118,7 +118,7 @@ describe AASM::Transition, '- when performing guard checks' do
     st = AASM::Transition.new(opts)
 
     obj = double('object')
-    obj.should_receive(:test)
+    expect(obj).to receive(:test)
 
     st.perform(obj)
   end
@@ -128,7 +128,7 @@ describe AASM::Transition, '- when performing guard checks' do
     st = AASM::Transition.new(opts)
 
     obj = double('object')
-    obj.should_receive(:test)
+    expect(obj).to receive(:test)
 
     st.perform(obj)
   end
@@ -139,9 +139,9 @@ describe AASM::Transition, '- when executing the transition with a Proc' do
     opts = {:from => 'foo', :to => 'bar', :on_transition => Proc.new {|o| o.test}}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object')
+    obj = double('object', :aasm => 'aasm')
 
-    opts[:on_transition].should_receive(:call).with(any_args)
+    expect(opts[:on_transition]).to receive(:call).with(any_args)
 
     st.execute(obj, args)
   end
@@ -150,9 +150,9 @@ describe AASM::Transition, '- when executing the transition with a Proc' do
     opts = {:from => 'foo', :to => 'bar', :on_transition => Proc.new {||}}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object')
+    obj = double('object', :aasm => 'aasm')
 
-    opts[:on_transition].should_receive(:call).with(no_args)
+    expect(opts[:on_transition]).to receive(:call).with(no_args)
 
     st.execute(obj, args)
   end
@@ -163,9 +163,9 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
     opts = {:from => 'foo', :to => 'bar', :on_transition => 'test'}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object')
+    obj = double('object', :aasm => 'aasm')
 
-    obj.should_receive(:test)
+    expect(obj).to receive(:test)
 
     st.execute(obj, args)
   end
@@ -174,9 +174,9 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
     opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object')
+    obj = double('object', :aasm => 'aasm')
 
-    obj.should_receive(:test)
+    expect(obj).to receive(:test)
 
     st.execute(obj, args)
   end
@@ -185,7 +185,7 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
     opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object')
+    obj = double('object', :aasm => 'aasm')
 
     def obj.test(args)
       "arg1: #{args[:arg1]} arg2: #{args[:arg2]}"
@@ -193,14 +193,14 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
 
     return_value = st.execute(obj, args)
 
-    return_value.should == 'arg1: 1 arg2: 2'
+    expect(return_value).to eq('arg1: 1 arg2: 2')
   end
 
   it 'should NOT pass args if the target method does NOT accept them' do
     opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object')
+    obj = double('object', :aasm => 'aasm')
 
     def obj.test
       'success'
@@ -208,7 +208,22 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
 
     return_value = st.execute(obj, args)
 
-    return_value.should == 'success'
+    expect(return_value).to eq('success')
+  end
+
+  it 'should allow accessing the from_state and the to_state' do
+    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
+    st = AASM::Transition.new(opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => AASM::InstanceBase.new('object'))
+
+    def obj.test(args)
+      "from: #{aasm.from_state} to: #{aasm.to_state}"
+    end
+
+    return_value = st.execute(obj, args)
+
+    expect(return_value).to eq('from: foo to: bar')
   end
 
 end