aasm 4.0.8 → 4.5.2

data/spec/unit/persistence/sequel_persistence_multiple_spec.rb

@@ -0,0 +1,153 @@
+describe 'sequel' do
+  begin
+    require 'sequel'
+    require 'logger'
+    require 'spec_helper'
+
+    Dir[File.dirname(__FILE__) + "/../../models/sequel/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      @model = SequelMultiple
+    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(:left).current_state).to eq(:alpha)
+      end
+
+      it "should save the initial state" do
+        model.save
+        expect(model.status).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(:left).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(:left).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(:left).current_state).to be_nil
+      end
+
+      it "should not change the state if state is not loaded" do
+        model.release
+        model.save
+        model.class.select(:id).first.save
+        model.reload
+        expect(model.aasm(:left).current_state).to eq(:beta)
+      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(:left).states).to eq(@model.aasm(:left).states)
+      end
+
+      it "should have the same events as its parent class" do
+        expect(Class.new(@model).aasm(:left).events).to eq(@model.aasm(:left).events)
+      end
+
+      it "should have the same column as its parent even for the new dsl" do
+        expect(@model.aasm(:left).attribute_name).to eq(:status)
+        expect(Class.new(@model).aasm(:left).attribute_name).to eq(:status)
+      end
+    end
+
+    describe 'initial states' do
+      it 'should support conditions' do
+        @model.aasm(:left) do
+          initial_state lambda{ |m| m.default }
+        end
+
+        expect(@model.new(:default => :beta).aasm(:left).current_state).to eq(:beta)
+        expect(@model.new(:default => :gamma).aasm(:left).current_state).to eq(:gamma)
+      end
+    end
+
+    describe "complex example" do
+      it "works" do
+        record = ComplexSequelExample.new
+        expect(record.aasm(:left).current_state).to eql :one
+        expect(record.left).to be_nil
+        expect(record.aasm(:right).current_state).to eql :alpha
+        expect(record.right).to be_nil
+
+        record.save
+        expect_aasm_states record, :one, :alpha
+        record.reload
+        expect_aasm_states record, :one, :alpha
+
+        record.increment!
+        expect_aasm_states record, :two, :alpha
+        record.reload
+        expect_aasm_states record, :two, :alpha
+
+        record.level_up!
+        expect_aasm_states record, :two, :beta
+        record.reload
+        expect_aasm_states record, :two, :beta
+
+        record.increment!
+        expect { record.increment! }.to raise_error(AASM::InvalidTransition)
+        expect_aasm_states record, :three, :beta
+        record.reload
+        expect_aasm_states record, :three, :beta
+
+        record.level_up!
+        expect_aasm_states record, :three, :gamma
+        record.reload
+        expect_aasm_states record, :three, :gamma
+
+        record.level_down # without saving
+        expect_aasm_states record, :three, :beta
+        record.reload
+        expect_aasm_states record, :three, :gamma
+
+        record.level_down # without saving
+        expect_aasm_states record, :three, :beta
+        record.reset!
+        expect_aasm_states record, :one, :beta
+      end
+
+      def expect_aasm_states(record, left_state, right_state)
+        expect(record.aasm(:left).current_state).to eql left_state.to_sym
+        expect(record.left).to eql left_state.to_s
+        expect(record.aasm(:right).current_state).to eql right_state.to_sym
+        expect(record.right).to eql right_state.to_s
+      end
+    end
+
+  rescue LoadError
+    puts "------------------------------------------------------------------------"
+    puts "Not running Sequel multiple-specs because sequel gem is not installed!!!"
+    puts "------------------------------------------------------------------------"
+  end
+end

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -1,33 +1,15 @@
-
 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
+    Dir[File.dirname(__FILE__) + "/../../models/sequel/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    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
+    before(:all) do
+      @model = SequelSimple
     end
 
     describe "instance methods" do
@@ -43,6 +25,11 @@ describe 'sequel' do
         expect(model.aasm.current_state).to eq(:alpha)
       end
 
+      it "should save the initial state" do
+        model.save
+        expect(model.status).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)
@@ -60,6 +47,14 @@ describe 'sequel' do
         expect(model.aasm.current_state).to be_nil
       end
 
+      it "should not change the state if state is not loaded" do
+        model.release
+        model.save
+        model.class.select(:id).first.save
+        model.reload
+        expect(model.aasm.current_state).to eq(:beta)
+      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?
@@ -98,6 +93,8 @@ describe 'sequel' do
     end
 
   rescue LoadError
+    puts "------------------------------------------------------------------------"
     puts "Not running Sequel specs because sequel gem is not installed!!!"
+    puts "------------------------------------------------------------------------"
   end
 end

data/spec/unit/readme_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'testing the README examples' do
+
+  it 'Usage' do
+    class Job
+      include AASM
+
+      aasm do
+        state :sleeping, :initial => true
+        state :running
+        state :cleaning
+
+        event :run do
+          transitions :from => :sleeping, :to => :running
+        end
+
+        event :clean do
+          transitions :from => :running, :to => :cleaning
+        end
+
+        event :sleep do
+          transitions :from => [:running, :cleaning], :to => :sleeping
+        end
+      end
+    end
+
+    job = Job.new
+
+    expect(job.sleeping?).to eql true
+    expect(job.may_run?).to eql true
+
+    job.run
+
+    expect(job.running?).to eql true
+    expect(job.sleeping?).to eql false
+    expect(job.may_run?).to eql false
+
+    expect { job.run }.to raise_error(AASM::InvalidTransition)
+  end
+
+end

data/spec/unit/reloading_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'callbacks for the new DSL' do
+describe 'when redefining states' do
   let(:definer) { DoubleDefiner.new }
 
   it "allows extending states" do

data/spec/unit/rspec_matcher_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe 'state machine' do
+  let(:simple) { SimpleExample.new }
+  let(:multiple) { SimpleMultipleExample.new }
+
+  describe 'transition_from' do
+    it "works for simple state machines" do
+      expect(simple).to transition_from(:initialised).to(:filled_out).on_event(:fill_out)
+      expect(simple).to_not transition_from(:initialised).to(:authorised).on_event(:fill_out)
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to transition_from(:standing).to(:walking).on_event(:walk).on(:move)
+      expect(multiple).to_not transition_from(:standing).to(:running).on_event(:walk).on(:move)
+
+      expect(multiple).to transition_from(:sleeping).to(:processing).on_event(:start).on(:work)
+      expect(multiple).to_not transition_from(:sleeping).to(:sleeping).on_event(:start).on(:work)
+    end
+  end
+
+  describe 'allow_transition_to' do
+    it "works for simple state machines" do
+      expect(simple).to allow_transition_to(:filled_out)
+      expect(simple).to_not allow_transition_to(:authorised)
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to allow_transition_to(:walking).on(:move)
+      expect(multiple).to_not allow_transition_to(:standing).on(:move)
+
+      expect(multiple).to allow_transition_to(:processing).on(:work)
+      expect(multiple).to_not allow_transition_to(:sleeping).on(:work)
+    end
+  end
+
+  describe "have_state" do
+    it "works for simple state machines" do
+      expect(simple).to have_state :initialised
+      expect(simple).to_not have_state :filled_out
+      simple.fill_out
+      expect(simple).to have_state :filled_out
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to have_state(:standing).on(:move)
+      expect(multiple).to_not have_state(:walking).on(:move)
+      multiple.walk
+      expect(multiple).to have_state(:walking).on(:move)
+
+      expect(multiple).to have_state(:sleeping).on(:work)
+      expect(multiple).to_not have_state(:processing).on(:work)
+      multiple.start
+      expect(multiple).to have_state(:processing).on(:work)
+    end
+  end
+
+  describe "allow_event" do
+    it "works for simple state machines" do
+      expect(simple).to allow_event :fill_out
+      expect(simple).to_not allow_event :authorise
+      simple.fill_out
+      expect(simple).to allow_event :authorise
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to allow_event(:walk).on(:move)
+      expect(multiple).to_not allow_event(:hold).on(:move)
+      multiple.walk
+      expect(multiple).to allow_event(:hold).on(:move)
+
+      expect(multiple).to allow_event(:start).on(:work)
+      expect(multiple).to_not allow_event(:stop).on(:work)
+      multiple.start
+      expect(multiple).to allow_event(:stop).on(:work)
+    end
+  end
+
+end

data/spec/unit/simple_example_spec.rb

@@ -1,58 +1,42 @@
 require 'spec_helper'
 
-class Payment
-  include AASM
-  aasm do
-    state :initialised, :initial => true
-    state :filled_out
-    state :authorised
-
-    event :fill_out do
-      transitions :from => :initialised, :to => :filled_out
-    end
-    event :authorise do
-      transitions :from => :filled_out, :to => :authorised
-    end
-  end
-end
-
 describe 'state machine' do
-  let(:payment) {Payment.new}
+  let(:simple) { SimpleExample.new }
 
   it 'starts with an initial state' do
-    expect(payment.aasm.current_state).to eq(:initialised)
-    expect(payment).to respond_to(:initialised?)
-    expect(payment).to be_initialised
+    expect(simple.aasm.current_state).to eq(:initialised)
+    expect(simple).to respond_to(:initialised?)
+    expect(simple).to be_initialised
   end
 
   it 'allows transitions to other states' do
-    expect(payment).to respond_to(:fill_out)
-    expect(payment).to respond_to(:fill_out!)
-    payment.fill_out!
-    expect(payment).to respond_to(:filled_out?)
-    expect(payment).to be_filled_out
-
-    expect(payment).to respond_to(:authorise)
-    expect(payment).to respond_to(:authorise!)
-    payment.authorise
-    expect(payment).to respond_to(:authorised?)
-    expect(payment).to be_authorised
+    expect(simple).to respond_to(:fill_out)
+    expect(simple).to respond_to(:fill_out!)
+    simple.fill_out!
+    expect(simple).to respond_to(:filled_out?)
+    expect(simple).to be_filled_out
+
+    expect(simple).to respond_to(:authorise)
+    expect(simple).to respond_to(:authorise!)
+    simple.authorise
+    expect(simple).to respond_to(:authorised?)
+    expect(simple).to be_authorised
   end
 
   it 'denies transitions to other states' do
-    expect {payment.authorise}.to raise_error(AASM::InvalidTransition)
-    expect {payment.authorise!}.to raise_error(AASM::InvalidTransition)
-    payment.fill_out
-    expect {payment.fill_out}.to raise_error(AASM::InvalidTransition)
-    expect {payment.fill_out!}.to raise_error(AASM::InvalidTransition)
-    payment.authorise
-    expect {payment.fill_out}.to raise_error(AASM::InvalidTransition)
-    expect {payment.fill_out!}.to raise_error(AASM::InvalidTransition)
+    expect {simple.authorise}.to raise_error(AASM::InvalidTransition)
+    expect {simple.authorise!}.to raise_error(AASM::InvalidTransition)
+    simple.fill_out
+    expect {simple.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {simple.fill_out!}.to raise_error(AASM::InvalidTransition)
+    simple.authorise
+    expect {simple.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {simple.fill_out!}.to raise_error(AASM::InvalidTransition)
   end
 
   it 'defines constants for each state name' do
-    expect(Payment::STATE_INITIALISED).to eq(:initialised)
-    expect(Payment::STATE_FILLED_OUT).to eq(:filled_out)
-    expect(Payment::STATE_AUTHORISED).to eq(:authorised)
+    expect(SimpleExample::STATE_INITIALISED).to eq(:initialised)
+    expect(SimpleExample::STATE_FILLED_OUT).to eq(:filled_out)
+    expect(SimpleExample::STATE_AUTHORISED).to eq(:authorised)
   end
 end

data/spec/unit/simple_multiple_example_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe 'state machine' do
+  let(:simple) { SimpleMultipleExample.new }
+
+  it 'starts with an initial state' do
+    expect(simple.aasm(:move).current_state).to eq(:standing)
+    expect(simple).to respond_to(:standing?)
+    expect(simple).to be_standing
+
+    expect(simple.aasm(:work).current_state).to eq(:sleeping)
+    expect(simple).to respond_to(:sleeping?)
+    expect(simple).to be_sleeping
+  end
+
+  it 'allows transitions to other states' do
+    expect(simple).to respond_to(:walk)
+    expect(simple).to respond_to(:walk!)
+    simple.walk!
+    expect(simple).to respond_to(:walking?)
+    expect(simple).to be_walking
+
+    expect(simple).to respond_to(:run)
+    expect(simple).to respond_to(:run!)
+    simple.run
+    expect(simple).to respond_to(:running?)
+    expect(simple).to be_running
+
+    expect(simple).to respond_to(:start)
+    expect(simple).to respond_to(:start!)
+    simple.start
+    expect(simple).to respond_to(:processing?)
+    expect(simple).to be_processing
+  end
+
+  it 'denies transitions to other states' do
+    expect {simple.hold}.to raise_error(AASM::InvalidTransition)
+    expect {simple.hold!}.to raise_error(AASM::InvalidTransition)
+    simple.walk
+    expect {simple.walk}.to raise_error(AASM::InvalidTransition)
+    expect {simple.walk!}.to raise_error(AASM::InvalidTransition)
+    simple.run
+    expect {simple.walk}.to raise_error(AASM::InvalidTransition)
+    expect {simple.walk!}.to raise_error(AASM::InvalidTransition)
+
+    expect {simple.stop}.to raise_error(AASM::InvalidTransition)
+    expect {simple.stop!}.to raise_error(AASM::InvalidTransition)
+    simple.start
+    expect {simple.start}.to raise_error(AASM::InvalidTransition)
+    expect {simple.start!}.to raise_error(AASM::InvalidTransition)
+    simple.stop
+  end
+
+  it 'defines constants for each state name' do
+    expect(SimpleMultipleExample::STATE_STANDING).to eq(:standing)
+    expect(SimpleMultipleExample::STATE_WALKING).to eq(:walking)
+    expect(SimpleMultipleExample::STATE_RUNNING).to eq(:running)
+
+    expect(SimpleMultipleExample::STATE_SLEEPING).to eq(:sleeping)
+    expect(SimpleMultipleExample::STATE_PROCESSING).to eq(:processing)
+    expect(SimpleMultipleExample::STATE_RUNNING).to eq(:running)
+  end
+end

data/spec/unit/state_spec.rb

@@ -1,13 +1,15 @@
 require 'spec_helper'
 
 describe AASM::Core::State do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+
   before(:each) do
     @name    = :astate
     @options = { :crazy_custom_key => 'key' }
   end
 
   def new_state(options={})
-    AASM::Core::State.new(@name, Conversation, @options.merge(options))
+    AASM::Core::State.new(@name, Conversation, state_machine, @options.merge(options))
   end
 
   it 'should set the name' do

data/spec/unit/subclassing_multiple_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'subclassing with multiple state machines' do
+
+  it 'should have the parent states' do
+    SuperClassMultiple.aasm(:left).states.each do |state|
+      expect(SubClassWithMoreStatesMultiple.aasm(:left).states).to include(state)
+    end
+    expect(SubClassMultiple.aasm(:left).states).to eq(SuperClassMultiple.aasm(:left).states)
+
+    SuperClassMultiple.aasm(:right).states.each do |state|
+      expect(SubClassWithMoreStatesMultiple.aasm(:right).states).to include(state)
+    end
+    expect(SubClassMultiple.aasm(:right).states).to eq(SuperClassMultiple.aasm(:right).states)
+  end
+
+  it 'should not add the child states to the parent machine' do
+    expect(SuperClassMultiple.aasm(:left).states).not_to include(:foo)
+    expect(SuperClassMultiple.aasm(:right).states).not_to include(:archived)
+  end
+
+  it "should have the same events as its parent" do
+    expect(SubClassMultiple.aasm(:left).events).to eq(SuperClassMultiple.aasm(:left).events)
+    expect(SubClassMultiple.aasm(:right).events).to eq(SuperClassMultiple.aasm(:right).events)
+  end
+
+  it 'should know how to respond to question methods' do
+    expect(SubClassMultiple.new.may_foo?).to be_truthy
+    expect(SubClassMultiple.new.may_close?).to be_truthy
+  end
+
+  it 'should not break if I call methods from super class' do
+    son = SubClassMultiple.new
+    son.update_state
+    expect(son.aasm(:left).current_state).to eq(:ended)
+  end
+
+end
+

data/spec/unit/subclassing_spec.rb

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
 describe 'subclassing' do
-  let(:son) {Son.new}
 
   it 'should have the parent states' do
-    Foo.aasm.states.each do |state|
-      expect(FooTwo.aasm.states).to include(state)
+    SuperClass.aasm.states.each do |state|
+      expect(SubClassWithMoreStates.aasm.states).to include(state)
     end
-    expect(Baz.aasm.states).to eq(Bar.aasm.states)
+    expect(SubClass.aasm.states).to eq(SuperClass.aasm.states)
   end
 
   it 'should not add the child states to the parent machine' do
-    expect(Foo.aasm.states).not_to include(:foo)
+    expect(SuperClass.aasm.states).not_to include(:foo)
   end
 
   it "should have the same events as its parent" do
-    expect(Baz.aasm.events).to eq(Bar.aasm.events)
+    expect(SubClass.aasm.events).to eq(SuperClass.aasm.events)
   end
 
-  it 'should know how to respond to `may_add_details?`' do
-    expect(son.may_add_details?).to be_truthy
+  it 'should know how to respond to question methods' do
+    expect(SubClass.new.may_foo?).to be_truthy
   end
 
-  it 'should not break if I call Son#update_state' do
+  it 'should not break if I call methods from super class' do
+    son = SubClass.new
     son.update_state
-    expect(son.aasm.current_state).to eq(:pending_details_confirmation)
+    expect(son.aasm.current_state).to eq(:ended)
   end
 
 end