aasm 3.0.26 → 3.1.0

data/spec/unit/initial_state_spec.rb

@@ -17,11 +17,11 @@ describe 'initial states' do
   let(:bar) {Bar.new}
 
   it 'should use the first state defined if no initial state is given' do
-    bar.aasm.current_state.should == :read
+    expect(bar.aasm.current_state).to eq(:read)
   end
 
   it 'should determine initial state from the Proc results' do
-    Banker.new(Banker::RICH - 1).aasm.current_state.should == :selling_bad_mortgages
-    Banker.new(Banker::RICH + 1).aasm.current_state.should == :retired
+    expect(Banker.new(Banker::RICH - 1).aasm.current_state).to eq(:selling_bad_mortgages)
+    expect(Banker.new(Banker::RICH + 1).aasm.current_state).to eq(:retired)
   end
 end

data/spec/unit/inspection_spec.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 
 describe 'inspection for common cases' do
   it 'should support the new DSL' do
-    Foo.aasm.should respond_to(:states)
-    Foo.aasm.states.should include(:open)
-    Foo.aasm.states.should include(:closed)
+    expect(Foo.aasm).to respond_to(:states)
+    expect(Foo.aasm.states).to include(:open)
+    expect(Foo.aasm.states).to include(:closed)
 
-    Foo.aasm.should respond_to(:initial_state)
-    Foo.aasm.initial_state.should == :open
+    expect(Foo.aasm).to respond_to(:initial_state)
+    expect(Foo.aasm.initial_state).to eq(:open)
 
-    Foo.aasm.should respond_to(:events)
-    Foo.aasm.events.should include(:close)
-    Foo.aasm.events.should include(:null)
+    expect(Foo.aasm).to respond_to(:events)
+    expect(Foo.aasm.events).to include(:close)
+    expect(Foo.aasm.events).to include(:null)
   end
 
   context "instance level inspection" do
@@ -20,77 +20,77 @@ describe 'inspection for common cases' do
 
     it "delivers all states" do
       states = foo.aasm.states
-      states.should include(:open)
-      states.should include(:closed)
+      expect(states).to include(:open)
+      expect(states).to include(:closed)
 
       states = foo.aasm.states(:permissible => true)
-      states.should include(:closed)
-      states.should_not include(:open)
+      expect(states).to include(:closed)
+      expect(states).not_to include(:open)
 
       foo.close
-      foo.aasm.states(:permissible => true).should be_empty
+      expect(foo.aasm.states(:permissible => true)).to be_empty
     end
 
     it "delivers all states for subclasses" do
       states = two.aasm.states
-      states.should include(:open)
-      states.should include(:closed)
-      states.should include(:foo)
+      expect(states).to include(:open)
+      expect(states).to include(:closed)
+      expect(states).to include(:foo)
 
       states = two.aasm.states(:permissible => true)
-      states.should include(:closed)
-      states.should_not include(:open)
+      expect(states).to include(:closed)
+      expect(states).not_to include(:open)
 
       two.close
-      two.aasm.states(:permissible => true).should be_empty
+      expect(two.aasm.states(:permissible => true)).to be_empty
     end
 
     it "delivers all events" do
       events = foo.aasm.events
-      events.should include(:close)
-      events.should include(:null)
+      expect(events).to include(:close)
+      expect(events).to include(:null)
       foo.close
-      foo.aasm.events.should be_empty
+      expect(foo.aasm.events).to be_empty
     end
   end
 
   it 'should list states in the order they have been defined' do
-    Conversation.aasm.states.should == [:needs_attention, :read, :closed, :awaiting_response, :junk]
+    expect(Conversation.aasm.states).to eq([:needs_attention, :read, :closed, :awaiting_response, :junk])
   end
 end
 
 describe "special cases" do
   it "should support valid a state name" do
-    Argument.aasm.states.should include(:invalid)
-    Argument.aasm.states.should include(:valid)
+    expect(Argument.aasm.states).to include(:invalid)
+    expect(Argument.aasm.states).to include(:valid)
 
     argument = Argument.new
-    argument.invalid?.should be_true
-    argument.aasm.current_state.should == :invalid
+    expect(argument.invalid?).to be_true
+    expect(argument.aasm.current_state).to eq(:invalid)
 
     argument.valid!
-    argument.valid?.should be_true
-    argument.aasm.current_state.should == :valid
+    expect(argument.valid?).to be_true
+    expect(argument.aasm.current_state).to eq(:valid)
   end
 end
 
 describe 'aasm.states_for_select' do
   it "should return a select friendly array of states" do
-    Foo.aasm.should respond_to(:states_for_select)
-    Foo.aasm.states_for_select.should == [['Open', 'open'], ['Closed', 'closed']]
+    expect(Foo.aasm).to respond_to(:states_for_select)
+    expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed']])
   end
 end
 
 describe 'aasm.from_states_for_state' do
   it "should return all from states for a state" do
-    AuthMachine.aasm.should respond_to(:from_states_for_state)
+    expect(AuthMachine.aasm).to respond_to(:from_states_for_state)
     froms = AuthMachine.aasm.from_states_for_state(:active)
-    [:pending, :passive, :suspended].each {|from| froms.should include(from)}
+    [:pending, :passive, :suspended].each {|from| expect(froms).to include(from)}
   end
 
   it "should return from states for a state for a particular transition only" do
     froms = AuthMachine.aasm.from_states_for_state(:active, :transition => :unsuspend)
-    [:suspended].each {|from| froms.should include(from)}
+    [:suspended].each {|from| expect(froms).to include(from)}
   end
 end
 
@@ -98,7 +98,7 @@ describe 'permissible events' do
   let(:foo) {Foo.new}
 
   it 'work' do
-    foo.aasm.permissible_events.should include(:close)
-    foo.aasm.permissible_events.should_not include(:null)
+    expect(foo.aasm.permissible_events).to include(:close)
+    expect(foo.aasm.permissible_events).not_to include(:null)
   end
 end

data/spec/unit/localizer_spec.rb

@@ -31,14 +31,14 @@ describe 'localized state names' do
 
   it 'should localize' do
     state = LocalizerTestModel.aasm.states.detect {|s| s == :opened}
-    state.localized_name.should == "It's open now!"
-    state.human_name.should == "It's open now!"
+    expect(state.localized_name).to eq("It's open now!")
+    expect(state.human_name).to eq("It's open now!")
   end
 
   it 'should use fallback' do
     state = LocalizerTestModel.aasm.states.detect {|s| s == :closed}
-    state.localized_name.should == 'Closed'
-    state.human_name.should == 'Closed'
+    expect(state.localized_name).to eq('Closed')
+    expect(state.human_name).to eq('Closed')
   end
 end
 
@@ -58,21 +58,21 @@ describe AASM::Localizer, "new style" do
 
   context 'aasm.human_state' do
     it 'should return translated state value' do
-      foo_opened.aasm.human_state.should == "It's open now!"
+      expect(foo_opened.aasm.human_state).to eq("It's open now!")
     end
 
     it 'should return humanized value if not localized' do
-      foo_closed.aasm.human_state.should == "Closed"
+      expect(foo_closed.aasm.human_state).to eq("Closed")
     end
   end
 
   context 'aasm_human_event_name' do
     it 'should return translated event name' do
-      LocalizerTestModel.aasm_human_event_name(:close).should == "Let's close it!"
+      expect(LocalizerTestModel.aasm_human_event_name(:close)).to eq("Let's close it!")
     end
 
     it 'should return humanized event name' do
-      LocalizerTestModel.aasm_human_event_name(:open).should == "Open"
+      expect(LocalizerTestModel.aasm_human_event_name(:open)).to eq("Open")
     end
   end
 end
@@ -93,21 +93,21 @@ describe AASM::Localizer, "deprecated style" do
 
   context 'aasm.human_state' do
     it 'should return translated state value' do
-      foo_opened.aasm.human_state.should == "It's open now!"
+      expect(foo_opened.aasm.human_state).to eq("It's open now!")
     end
 
     it 'should return humanized value if not localized' do
-      foo_closed.aasm.human_state.should == "Closed"
+      expect(foo_closed.aasm.human_state).to eq("Closed")
     end
   end
 
   context 'aasm_human_event_name' do
     it 'should return translated event name' do
-      LocalizerTestModel.aasm_human_event_name(:close).should == "Let's close it!"
+      expect(LocalizerTestModel.aasm_human_event_name(:close)).to eq("Let's close it!")
     end
 
     it 'should return humanized event name' do
-      LocalizerTestModel.aasm_human_event_name(:open).should == "Open"
+      expect(LocalizerTestModel.aasm_human_event_name(:open)).to eq("Open")
     end
   end
 end

data/spec/unit/new_dsl_spec.rb

@@ -5,8 +5,8 @@ describe "the new dsl" do
   let(:process) {ProcessWithNewDsl.new}
 
   it 'should not conflict with other event or state methods' do
-    lambda {ProcessWithNewDsl.state}.should raise_error(RuntimeError, "wrong state method")
-    lambda {ProcessWithNewDsl.event}.should raise_error(RuntimeError, "wrong event method")
+    expect {ProcessWithNewDsl.state}.to raise_error(RuntimeError, "wrong state method")
+    expect {ProcessWithNewDsl.event}.to raise_error(RuntimeError, "wrong event method")
   end
 
 end

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -9,8 +9,8 @@ load_schema
 
 shared_examples_for "aasm model" do
   it "should include persistence mixins" do
-    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence)
-    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
+    expect(klass.included_modules).to be_include(AASM::Persistence::ActiveRecordPersistence)
+    expect(klass.included_modules).to be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
   end
 end
 
@@ -18,45 +18,45 @@ describe "instance methods" do
   let(:gate) {Gate.new}
 
   it "should respond to aasm persistence methods" do
-    gate.should respond_to(:aasm_read_state)
-    gate.should respond_to(:aasm_write_state)
-    gate.should respond_to(:aasm_write_state_without_persistence)
+    expect(gate).to respond_to(:aasm_read_state)
+    expect(gate).to respond_to(:aasm_write_state)
+    expect(gate).to respond_to(:aasm_write_state_without_persistence)
   end
 
   it "should return the initial state when new and the aasm field is nil" do
-    gate.aasm.current_state.should == :opened
+    expect(gate.aasm.current_state).to eq(:opened)
   end
 
   it "should return the aasm column when new and the aasm field is not nil" do
     gate.aasm_state = "closed"
-    gate.aasm.current_state.should == :closed
+    expect(gate.aasm.current_state).to eq(:closed)
   end
 
   it "should return the aasm column when not new and the aasm_column is not nil" do
-    gate.stub(:new_record?).and_return(false)
+    allow(gate).to receive(:new_record?).and_return(false)
     gate.aasm_state = "state"
-    gate.aasm.current_state.should == :state
+    expect(gate.aasm.current_state).to eq(:state)
   end
 
   it "should allow a nil state" do
-    gate.stub(:new_record?).and_return(false)
+    allow(gate).to receive(:new_record?).and_return(false)
     gate.aasm_state = nil
-    gate.aasm.current_state.should be_nil
+    expect(gate.aasm.current_state).to be_nil
   end
 
   it "should call aasm_ensure_initial_state on validation before create" do
-    gate.should_receive(:aasm_ensure_initial_state).and_return(true)
+    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
     gate.valid?
   end
 
   it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-    gate.should_receive(:aasm_ensure_initial_state).and_return(true)
+    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
     gate.save(:validate => false)
   end
 
   it "should not call aasm_ensure_initial_state on validation before update" do
-    gate.stub(:new_record?).and_return(false)
-    gate.should_not_receive(:aasm_ensure_initial_state)
+    allow(gate).to receive(:new_record?).and_return(false)
+    expect(gate).not_to receive(:aasm_ensure_initial_state)
     gate.valid?
   end
 
@@ -64,36 +64,36 @@ end
 
 describe 'subclasses' do
   it "should have the same states as its parent class" do
-    DerivateNewDsl.aasm.states.should == SimpleNewDsl.aasm.states
+    expect(DerivateNewDsl.aasm.states).to eq(SimpleNewDsl.aasm.states)
   end
 
   it "should have the same events as its parent class" do
-    DerivateNewDsl.aasm.events.should == SimpleNewDsl.aasm.events
+    expect(DerivateNewDsl.aasm.events).to eq(SimpleNewDsl.aasm.events)
   end
 
   it "should have the same column as its parent even for the new dsl" do
-    SimpleNewDsl.aasm_column.should == :status
-    DerivateNewDsl.aasm_column.should == :status
+    expect(SimpleNewDsl.aasm_column).to eq(:status)
+    expect(DerivateNewDsl.aasm_column).to eq(:status)
   end
 end
 
 describe "named scopes with the new DSL" do
   context "Does not already respond_to? the scope name" do
     it "should add a scope" do
-      SimpleNewDsl.should respond_to(:unknown_scope)
-      SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation).should be_true
+      expect(SimpleNewDsl).to respond_to(:unknown_scope)
+      expect(SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation)).to be_true
     end
   end
 
   context "Already respond_to? the scope name" do
     it "should not add a scope" do
-      SimpleNewDsl.should respond_to(:new)
-      SimpleNewDsl.new.class.should == SimpleNewDsl
+      expect(SimpleNewDsl).to respond_to(:new)
+      expect(SimpleNewDsl.new.class).to eq(SimpleNewDsl)
     end
   end
 
   it "does not create scopes if requested" do
-    NoScope.should_not respond_to(:ignored_scope)
+    expect(NoScope).not_to respond_to(:ignored_scope)
   end
 
 end
@@ -101,8 +101,8 @@ end
 describe 'initial states' do
 
   it 'should support conditions' do
-    Thief.new(:skilled => true).aasm.current_state.should == :rich
-    Thief.new(:skilled => false).aasm.current_state.should == :jailed
+    expect(Thief.new(:skilled => true).aasm.current_state).to eq(:rich)
+    expect(Thief.new(:skilled => false).aasm.current_state).to eq(:jailed)
   end
 end
 
@@ -110,54 +110,54 @@ describe 'transitions with persistence' do
 
   it "should work for valid models" do
     valid_object = Validator.create(:name => 'name')
-    valid_object.should be_sleeping
+    expect(valid_object).to be_sleeping
     valid_object.status = :running
-    valid_object.should be_running
+    expect(valid_object).to be_running
   end
 
   it 'should not store states for invalid models' do
     validator = Validator.create(:name => 'name')
-    validator.should be_valid
-    validator.should be_sleeping
+    expect(validator).to be_valid
+    expect(validator).to be_sleeping
 
     validator.name = nil
-    validator.should_not be_valid
-    validator.run!.should be_false
-    validator.should be_sleeping
+    expect(validator).not_to be_valid
+    expect(validator.run!).to be_false
+    expect(validator).to be_sleeping
 
     validator.reload
-    validator.should_not be_running
-    validator.should be_sleeping
+    expect(validator).not_to be_running
+    expect(validator).to be_sleeping
 
     validator.name = 'another name'
-    validator.should be_valid
-    validator.run!.should be_true
-    validator.should be_running
+    expect(validator).to be_valid
+    expect(validator.run!).to be_true
+    expect(validator).to be_running
 
     validator.reload
-    validator.should be_running
-    validator.should_not be_sleeping
+    expect(validator).to be_running
+    expect(validator).not_to be_sleeping
   end
 
   it 'should store states for invalid models if configured' do
     persistor = InvalidPersistor.create(:name => 'name')
-    persistor.should be_valid
-    persistor.should be_sleeping
+    expect(persistor).to be_valid
+    expect(persistor).to be_sleeping
 
     persistor.name = nil
-    persistor.should_not be_valid
-    persistor.run!.should be_true
-    persistor.should be_running
+    expect(persistor).not_to be_valid
+    expect(persistor.run!).to be_true
+    expect(persistor).to be_running
 
     persistor = InvalidPersistor.find(persistor.id)
     persistor.valid?
-    persistor.should be_valid
-    persistor.should be_running
-    persistor.should_not be_sleeping
+    expect(persistor).to be_valid
+    expect(persistor).to be_running
+    expect(persistor).not_to be_sleeping
 
     persistor.reload
-    persistor.should be_running
-    persistor.should_not be_sleeping
+    expect(persistor).to be_running
+    expect(persistor).not_to be_sleeping
   end
 
   describe 'transactions' do
@@ -165,41 +165,81 @@ describe 'transitions with persistence' do
     let(:transactor) { Transactor.create!(:name => 'transactor', :worker => worker) }
 
     it 'should rollback all changes' do
-      transactor.should be_sleeping
-      worker.status.should == 'sleeping'
+      expect(transactor).to be_sleeping
+      expect(worker.status).to eq('sleeping')
 
-      lambda {transactor.run!}.should raise_error(StandardError, 'failed on purpose')
-      transactor.should be_running
-      worker.reload.status.should == 'sleeping'
+      expect {transactor.run!}.to raise_error(StandardError, 'failed on purpose')
+      expect(transactor).to be_running
+      expect(worker.reload.status).to eq('sleeping')
     end
 
-    it "should rollback all changes in nested transaction" do
-      transactor.should be_sleeping
-      worker.status.should == 'sleeping'
+    context "nested transactions" do
+      it "should rollback all changes in nested transaction" do
+        expect(transactor).to be_sleeping
+        expect(worker.status).to eq('sleeping')
 
-      Worker.transaction do
-        lambda { transactor.run! }.should raise_error(StandardError, 'failed on purpose')
+        Worker.transaction do
+          expect { transactor.run! }.to raise_error(StandardError, 'failed on purpose')
+        end
+
+        expect(transactor).to be_running
+        expect(worker.reload.status).to eq('sleeping')
       end
 
-      transactor.should be_running
-      worker.reload.status.should == 'sleeping'
+      it "should only rollback changes in the main transaction not the nested one" do
+        # change configuration to not require new transaction
+        AASM::StateMachine[Transactor].config.requires_new_transaction = false
+
+        expect(transactor).to be_sleeping
+        expect(worker.status).to eq('sleeping')
+
+        Worker.transaction do
+          expect { transactor.run! }.to raise_error(StandardError, 'failed on purpose')
+        end
+
+        expect(transactor).to be_running
+        expect(worker.reload.status).to eq('running')
+      end
     end
 
     describe "after_commit callback" do
       it "should fire :after_commit if transaction was successful" do
         validator = Validator.create(:name => 'name')
-        validator.should be_sleeping
+        expect(validator).to be_sleeping
         validator.run!
-        validator.should be_running
-        validator.name.should_not == "name"
+        expect(validator).to be_running
+        expect(validator.name).not_to eq("name")
       end
 
       it "should not fire :after_commit if transaction failed" do
         validator = Validator.create(:name => 'name')
-        lambda { validator.fail! }.should raise_error(StandardError, 'failed on purpose')
-        validator.name.should == "name"
+        expect { validator.fail! }.to raise_error(StandardError, 'failed on purpose')
+        expect(validator.name).to eq("name")
       end
 
     end
   end
 end
+
+describe "invalid states with persistence" do
+
+  it "should not store states" do
+    validator = Validator.create(:name => 'name')
+    validator.status = 'invalid_state'
+    expect(validator.save).to be_false
+    expect {validator.save!}.to raise_error(ActiveRecord::RecordInvalid)
+
+    validator.reload
+    expect(validator).to be_sleeping
+  end
+
+  it "should store invalid states if configured" do
+    persistor = InvalidPersistor.create(:name => 'name')
+    persistor.status = 'invalid_state'
+    expect(persistor.save).to be_true
+
+    persistor.reload
+    expect(persistor.status).to eq('invalid_state')
+  end
+
+end