aasm 4.2.0 → 4.3.0

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,34 +1,15 @@
-
 describe 'sequel' do
   begin
     require 'sequel'
     require 'logger'
     require 'spec_helper'
 
-    before(:all) do
-      db = Sequel.connect(SEQUEL_DB)
-
-      # 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
@@ -112,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/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/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/transition_spec.rb

@@ -53,13 +53,13 @@ describe 'transitions' do
 
 end
 
-describe 'blocks' do
-end
-
 describe AASM::Core::Transition do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
   it 'should set from, to, and opts attr readers' do
     opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     expect(st.from).to eq(opts[:from])
     expect(st.to).to eq(opts[:to])
@@ -71,7 +71,7 @@ describe AASM::Core::Transition do
     st = AASM::Core::Transition.allocate
     expect(st).to receive(:warn).with('[DEPRECATION] :on_transition is deprecated, use :after instead')
 
-    st.send :initialize, opts do
+    st.send :initialize, event, opts do
       guard :gg
       on_transition :after_callback
     end
@@ -81,7 +81,7 @@ describe AASM::Core::Transition do
 
   it 'should set after and guard from dsl' do
     opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(opts) do
+    st = AASM::Core::Transition.new(event, opts) do
       guard :gg
       after :after_callback
     end
@@ -92,7 +92,7 @@ describe AASM::Core::Transition do
 
   it 'should pass equality check if from and to are the same' do
     opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     allow(obj).to receive(:from).and_return(opts[:from])
@@ -103,7 +103,7 @@ describe AASM::Core::Transition do
 
   it 'should fail equality check if from are not the same' do
     opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     allow(obj).to receive(:from).and_return('blah')
@@ -114,7 +114,7 @@ describe AASM::Core::Transition do
 
   it 'should fail equality check if to are not the same' do
     opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     allow(obj).to receive(:from).and_return(opts[:from])
@@ -125,16 +125,19 @@ describe AASM::Core::Transition do
 end
 
 describe AASM::Core::Transition, '- when performing guard checks' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
   it 'should return true of there is no guard' do
     opts = {:from => 'foo', :to => 'bar'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     expect(st.allowed?(nil)).to be_truthy
   end
 
   it 'should call the method on the object if guard is a symbol' do
     opts = {:from => 'foo', :to => 'bar', :guard => :test}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     expect(obj).to receive(:test)
@@ -144,7 +147,7 @@ describe AASM::Core::Transition, '- when performing guard checks' do
 
   it 'should call the method on the object if unless is a symbol' do
     opts = {:from => 'foo', :to => 'bar', :unless => :test}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     expect(obj).to receive(:test)
@@ -154,7 +157,7 @@ describe AASM::Core::Transition, '- when performing guard checks' do
 
   it 'should call the method on the object if guard is a string' do
     opts = {:from => 'foo', :to => 'bar', :guard => 'test'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     expect(obj).to receive(:test)
@@ -164,7 +167,7 @@ describe AASM::Core::Transition, '- when performing guard checks' do
 
   it 'should call the method on the object if unless is a string' do
     opts = {:from => 'foo', :to => 'bar', :unless => 'test'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     expect(obj).to receive(:test)
@@ -174,7 +177,7 @@ describe AASM::Core::Transition, '- when performing guard checks' do
 
   it 'should call the proc passing the object if the guard is a proc' do
     opts = {:from => 'foo', :to => 'bar', :guard => Proc.new { test }}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
 
     obj = double('object')
     expect(obj).to receive(:test)
@@ -184,9 +187,12 @@ describe AASM::Core::Transition, '- when performing guard checks' do
 end
 
 describe AASM::Core::Transition, '- when executing the transition with a Proc' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
   it 'should call a Proc on the object with args' do
     opts = {:from => 'foo', :to => 'bar', :after => Proc.new {|a| test(a) }}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
@@ -202,7 +208,7 @@ describe AASM::Core::Transition, '- when executing the transition with a Proc' d
     prc = Proc.new { prc_object = self }
 
     opts = {:from => 'foo', :to => 'bar', :after => prc }
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
@@ -212,9 +218,12 @@ describe AASM::Core::Transition, '- when executing the transition with a Proc' d
 end
 
 describe AASM::Core::Transition, '- when executing the transition with an :after method call' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
   it 'should accept a String for the method name' do
     opts = {:from => 'foo', :to => 'bar', :after => 'test'}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
@@ -225,7 +234,7 @@ describe AASM::Core::Transition, '- when executing the transition with an :after
 
   it 'should accept a Symbol for the method name' do
     opts = {:from => 'foo', :to => 'bar', :after => :test}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
@@ -236,7 +245,7 @@ describe AASM::Core::Transition, '- when executing the transition with an :after
 
   it 'should pass args if the target method accepts them' do
     opts = {:from => 'foo', :to => 'bar', :after => :test}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
@@ -251,7 +260,7 @@ describe AASM::Core::Transition, '- when executing the transition with an :after
 
   it 'should NOT pass args if the target method does NOT accept them' do
     opts = {:from => 'foo', :to => 'bar', :after => :test}
-    st = AASM::Core::Transition.new(opts)
+    st = AASM::Core::Transition.new(event, opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
@@ -266,7 +275,7 @@ describe AASM::Core::Transition, '- when executing the transition with an :after
 
   it 'should allow accessing the from_state and the to_state' do
     opts = {:from => 'foo', :to => 'bar', :after => :test}
-    transition = AASM::Core::Transition.new(opts)
+    transition = AASM::Core::Transition.new(event, opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => AASM::InstanceBase.new('object'))