aasm 4.1.1 → 4.2.0

data/spec/models/simple_example.rb

@@ -0,0 +1,15 @@
+class SimpleExample
+  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

data/spec/models/state_machine_with_failed_event.rb

@@ -0,0 +1,12 @@
+class StateMachineWithFailedEvent
+  include AASM
+
+  aasm do
+    state :init, :initial => true
+    state :failed
+
+    event :failed do
+      transitions :from => :init, :to => :failed
+    end
+  end
+end

data/spec/models/sub_class.rb

@@ -0,0 +1,3 @@
+require_relative 'super_class'
+class SubClass < SuperClass
+end

data/spec/models/sub_class_with_more_states.rb

@@ -0,0 +1,7 @@
+require_relative 'super_class'
+class SubClassWithMoreStates < SuperClass
+  include AASM
+  aasm do
+    state :foo
+  end
+end

data/spec/models/super_class.rb

@@ -0,0 +1,18 @@
+class SuperClass
+  include AASM
+
+  aasm do
+    state :read
+    state :ended
+
+    event :foo do
+      transitions :to => :ended, :from => [:read]
+    end
+  end
+
+  def update_state
+    if may_foo?
+      foo!
+    end
+  end
+end

data/spec/models/{argument.rb → valid_state_name.rb}

@@ -1,4 +1,4 @@
-class Argument
+class ValidStateName
   include AASM
   aasm do
     state :invalid, :initial => true

data/spec/models/validator.rb

@@ -12,8 +12,8 @@ class Validator < ActiveRecord::Base
       transitions :to => :running, :from => :sleeping
     end
     event :sleep do
-      after_commit do
-        change_name_on_sleep
+      after_commit do |name|
+        change_name_on_sleep name
       end
       transitions :to => :sleeping, :from => :running
     end
@@ -29,8 +29,8 @@ class Validator < ActiveRecord::Base
     save!
   end
 
-  def change_name_on_sleep
-    self.name = "sleeper"
+  def change_name_on_sleep name
+    self.name = name
     save!
   end
 

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
 $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
 require 'aasm'
-
 require 'rspec'
 
 # require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
@@ -11,6 +10,7 @@ require 'rspec'
 SEQUEL_DB = defined?(JRUBY_VERSION) ? 'jdbc:sqlite::memory:' : 'sqlite:/'
 
 def load_schema
+  require 'logger'
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
   ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
   ActiveRecord::Base.establish_connection(config['sqlite3'])

data/spec/unit/api_spec.rb

@@ -1,5 +1,10 @@
 require 'spec_helper'
-require 'models/active_record/api.rb'
+require 'models/default_state.rb'
+require 'models/provided_state.rb'
+require 'models/active_record/persisted_state.rb'
+require 'models/active_record/provided_and_persisted_state.rb'
+
+load_schema
 
 describe "reading the current state" do
   it "uses the AASM default" do

data/spec/unit/complex_example_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe 'on initialization' do
-  let(:auth) {AuthMachine.new}
+  let(:auth) {ComplexExample.new}
 
   it 'should be in the pending state' do
     expect(auth.aasm.current_state).to eq(:pending)
@@ -14,7 +14,7 @@ describe 'on initialization' do
 end
 
 describe 'when being unsuspended' do
-  let(:auth) {AuthMachine.new}
+  let(:auth) {ComplexExample.new}
 
   it 'should be able to be unsuspended' do
     auth.activate!

data/spec/unit/event_naming_spec.rb

@@ -1,22 +1,9 @@
 require 'spec_helper'
 
-class SimpleStateMachine
-  include AASM
-
-  aasm do
-    state :init, :initial => true
-    state :failed
-
-    event :failed do
-      transitions :from => :init, :to => :failed
-    end
-  end
-end
-
 describe "event naming" do
-  let(:state_machine) { SimpleStateMachine.new }
+  let(:state_machine) { StateMachineWithFailedEvent.new }
 
-  it "allows an event of failed without blowing the stack" do
+  it "allows an event of failed without blowing the stack aka stack level too deep" do
     state_machine.failed
 
     expect { state_machine.failed }.to raise_error(AASM::InvalidTransition)

data/spec/unit/initial_state_spec.rb

@@ -1,27 +1,12 @@
 require 'spec_helper'
 
-class Banker
-  include AASM
-  aasm do
-    state :retired
-    state :selling_bad_mortgages
-    initial_state Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
-  end
-  RICH = 1_000_000
-  attr_accessor :balance
-  def initialize(balance = 0); self.balance = balance; end
-  def rich?; self.balance >= RICH; end
-end
-
 describe 'initial states' do
-  let(:bar) {Bar.new}
-
   it 'should use the first state defined if no initial state is given' do
-    expect(bar.aasm.current_state).to eq(:read)
+    expect(NoInitialState.new.aasm.current_state).to eq(:read)
   end
 
   it 'should determine initial state from the Proc results' do
-    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)
+    expect(InitialStateProc.new(InitialStateProc::RICH - 1).aasm.current_state).to eq(:selling_bad_mortgages)
+    expect(InitialStateProc.new(InitialStateProc::RICH + 1).aasm.current_state).to eq(:retired)
   end
 end

data/spec/unit/inspection_spec.rb

@@ -62,11 +62,11 @@ describe 'inspection for common cases' do
 end
 
 describe "special cases" do
-  it "should support valid a state name" do
-    expect(Argument.aasm.states).to include(:invalid)
-    expect(Argument.aasm.states).to include(:valid)
+  it "should support valid as state name" do
+    expect(ValidStateName.aasm.states).to include(:invalid)
+    expect(ValidStateName.aasm.states).to include(:valid)
 
-    argument = Argument.new
+    argument = ValidStateName.new
     expect(argument.invalid?).to be_truthy
     expect(argument.aasm.current_state).to eq(:invalid)
 
@@ -85,13 +85,13 @@ end
 
 describe 'aasm.from_states_for_state' do
   it "should return all from states for a state" do
-    expect(AuthMachine.aasm).to respond_to(:from_states_for_state)
-    froms = AuthMachine.aasm.from_states_for_state(:active)
+    expect(ComplexExample.aasm).to respond_to(:from_states_for_state)
+    froms = ComplexExample.aasm.from_states_for_state(:active)
     [: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)
+    froms = ComplexExample.aasm.from_states_for_state(:active, :transition => :unsuspend)
     [:suspended].each {|from| expect(froms).to include(from)}
   end
 end

data/spec/unit/localizer_spec.rb

@@ -1,48 +1,10 @@
 require 'spec_helper'
 require 'active_record'
-require 'logger'
 require 'i18n'
 
 I18n.enforce_available_locales = false
 load_schema
 
-class LocalizerTestModel < ActiveRecord::Base
-  include AASM
-
-  attr_accessor :aasm_state
-
-  aasm do
-    state :opened, :initial => true
-    state :closed
-    event :close
-    event :open
-  end
-end
-
-describe 'localized state names' do
-  before(:all) do
-    I18n.load_path << 'spec/en.yml'
-    I18n.default_locale = :en
-    I18n.reload!
-  end
-
-  after(:all) do
-    I18n.load_path.clear
-  end
-
-  it 'should localize' do
-    state = LocalizerTestModel.aasm.states.detect {|s| s == :opened}
-    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}
-    expect(state.localized_name).to eq('Closed')
-    expect(state.human_name).to eq('Closed')
-  end
-end
-
 describe AASM::Localizer, "new style" do
   before(:all) do
     I18n.load_path << 'spec/en.yml'

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -1,10 +1,10 @@
 require 'active_record'
-require 'logger'
 require 'spec_helper'
-
+Dir[File.dirname(__FILE__) + "/../../models/active_record/*.rb"].sort.each { |f| require File.expand_path(f) }
 load_schema
 
 # if you want to see the statements while running the spec enable the following line
+# require 'logger'
 # ActiveRecord::Base.logger = Logger.new(STDERR)
 
 shared_examples_for "aasm model" do
@@ -321,6 +321,24 @@ describe "direct assignment" do
     expect {obj.aasm_state = :running}.to raise_error(AASM::NoDirectAssignmentError)
     expect(obj.aasm_state.to_sym).to eql :pending
   end
+
+  it 'can be turned off and on again' do
+    obj = NoDirectAssignment.create
+    expect(obj.aasm_state.to_sym).to eql :pending
+
+    expect {obj.aasm_state = :running}.to raise_error(AASM::NoDirectAssignmentError)
+    expect(obj.aasm_state.to_sym).to eql :pending
+
+    # allow it temporarily
+    NoDirectAssignment.aasm.state_machine.config.no_direct_assignment = false
+    obj.aasm_state = :pending
+    expect(obj.aasm_state.to_sym).to eql :pending
+
+    # and forbid it again
+    NoDirectAssignment.aasm.state_machine.config.no_direct_assignment = true
+    expect {obj.aasm_state = :running}.to raise_error(AASM::NoDirectAssignmentError)
+    expect(obj.aasm_state.to_sym).to eql :pending
+  end
 end # direct assignment
 
 describe 'initial states' do
@@ -436,7 +454,7 @@ describe 'transitions with persistence' do
         expect(validator).to be_running
         expect(validator.name).to eq("name changed")
 
-        validator.sleep!
+        validator.sleep!("sleeper")
         expect(validator).to be_sleeping
         expect(validator.name).to eq("sleeper")
       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/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