aasm 4.0.8 → 4.2.0

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,6 +12,9 @@ class Validator < ActiveRecord::Base
       transitions :to => :running, :from => :sleeping
     end
     event :sleep do
+      after_commit do |name|
+        change_name_on_sleep name
+      end
       transitions :to => :sleeping, :from => :running
     end
     event :fail do
@@ -26,6 +29,11 @@ class Validator < ActiveRecord::Base
     save!
   end
 
+  def change_name_on_sleep name
+    self.name = name
+    save!
+  end
+
   def fail
     raise StandardError.new('failed on purpose')
   end

data/spec/spec_helper.rb

@@ -1,17 +1,16 @@
 $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 'coveralls'
-Coveralls.wear!
-
 # require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
 # require 'ruby-debug/completion'
 # require 'pry'
 
+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/callbacks_spec.rb

@@ -145,7 +145,7 @@ describe 'callbacks for the new DSL' do
 
     cb.reset_data
     cb.close!(:arg1, :arg2)
-    expect(cb.data).to eql 'before(:arg1,:arg2) before_exit_open transition_proc(:arg1,:arg2) before_enter_closed aasm_write_state after_exit_open after_enter_closed after(:arg1,:arg2)'
+    expect(cb.data).to eql 'before(:arg1,:arg2) before_exit_open(:arg1,:arg2) transition_proc(:arg1,:arg2) before_enter_closed(:arg1,:arg2) aasm_write_state after_exit_open(:arg1,:arg2) after_enter_closed(:arg1,:arg2) after(:arg1,:arg2)'
   end
 
   it "should call the callbacks given the to-state as argument" 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
@@ -431,9 +449,14 @@ describe 'transitions with persistence' do
       it "should fire :after_commit if transaction was successful" do
         validator = Validator.create(:name => 'name')
         expect(validator).to be_sleeping
+
         validator.run!
         expect(validator).to be_running
-        expect(validator.name).not_to eq("name")
+        expect(validator.name).to eq("name changed")
+
+        validator.sleep!("sleeper")
+        expect(validator).to be_sleeping
+        expect(validator.name).to eq("sleeper")
       end
 
       it "should not fire :after_commit if transaction failed" do

data/spec/unit/persistence/mongo_mapper_persistance_spec.rb

@@ -0,0 +1,135 @@
+describe 'mongo_mapper' do
+  begin
+    require 'mongo_mapper'
+    require 'logger'
+    require 'spec_helper'
+
+    before(:all) do
+      Dir[File.dirname(__FILE__) + "/../../models/mongo_mapper/*.rb"].sort.each { |f| require File.expand_path(f) }
+
+      config = {
+        'test' => {
+          'database' => "mongo_mapper_#{Process.pid}"
+        }
+      }
+
+      MongoMapper.setup(config, 'test') #, :logger => Logger.new(STDERR))
+    end
+
+    after do
+      # Clear Out all non-system Mongo collections between tests
+      MongoMapper.database.collections.each do |collection|
+        collection.drop unless collection.capped? || (collection.name =~ /\Asystem/)
+      end
+    end
+
+    describe "named scopes with the old DSL" do
+
+      context "Does not already respond_to? the scope name" do
+        it "should add a scope" do
+          expect(SimpleMongoMapper).to respond_to(:unknown_scope)
+          expect(SimpleMongoMapper.unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
+          #expect(SimpleMongoMapper.unknown_scope.is_a?(ActiveRecord::Relation)).to be_truthy
+        end
+      end
+
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleMongoMapper).to respond_to(:next)
+          expect(SimpleMongoMapper.new.class).to eq(SimpleMongoMapper)
+        end
+      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
+          expect(SimpleNewDslMongoMapper).to respond_to(:unknown_scope)
+          expect(SimpleNewDslMongoMapper.unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
+        end
+      end
+
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleNewDslMongoMapper).to respond_to(:next)
+          expect(SimpleNewDslMongoMapper.new.class).to eq(SimpleNewDslMongoMapper)
+        end
+      end
+
+      it "does not create scopes if requested" do
+        expect(NoScopeMongoMapper).not_to respond_to(:ignored_scope)
+      end
+
+    end
+
+    describe "#find_in_state" do
+
+      let!(:model)    { SimpleNewDslMongoMapper.create!(:status => :unknown_scope) }
+      let!(:model_id) { model._id }
+
+      it "should respond to method" do
+        expect(SimpleNewDslMongoMapper).to respond_to(:find_in_state)
+      end
+
+      it "should find the model when given the correct scope and model id" do
+        expect(SimpleNewDslMongoMapper.find_in_state(model_id, 'unknown_scope').class).to eq(SimpleNewDslMongoMapper)
+        expect(SimpleNewDslMongoMapper.find_in_state(model_id, 'unknown_scope')).to eq(model)
+      end
+
+      it "should raise DocumentNotFound error when given incorrect scope" do
+        expect {SimpleNewDslMongoMapper.find_in_state(model_id, 'next')}.to raise_error MongoMapper::DocumentNotFound
+      end
+
+      it "should raise DocumentNotFound error when given incorrect model id" do
+        expect {SimpleNewDslMongoMapper.find_in_state('bad_id', 'unknown_scope')}.to raise_error MongoMapper::DocumentNotFound
+      end
+
+    end
+
+    describe "#count_in_state" do
+
+      before do
+        3.times { SimpleNewDslMongoMapper.create!(:status => :unknown_scope) }
+      end
+
+      it "should respond to method" do
+        expect(SimpleNewDslMongoMapper).to respond_to(:count_in_state)
+      end
+
+      it "should return n for a scope with n records persisted" do
+        expect(SimpleNewDslMongoMapper.count_in_state('unknown_scope').class).to eq(Fixnum)
+        expect(SimpleNewDslMongoMapper.count_in_state('unknown_scope')).to eq(3)
+      end
+
+      it "should return zero for a scope without records persisted" do
+        expect(SimpleNewDslMongoMapper.count_in_state('next').class).to eq(Fixnum)
+        expect(SimpleNewDslMongoMapper.count_in_state('next')).to eq(0)
+      end
+
+    end
+
+    describe "instance methods" do
+
+      let(:simple) {SimpleNewDslMongoMapper.new}
+
+      it "should call aasm_ensure_initial_state on validation before create" do
+        expect(SimpleNewDslMongoMapper.aasm.initial_state).to eq(:unknown_scope)
+        expect(SimpleNewDslMongoMapper.aasm.attribute_name).to eq(:status)
+        expect(simple.status).to eq(nil)
+        simple.valid?
+        expect(simple.status).to eq('unknown_scope')
+      end
+
+      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
+        expect(simple.status).to eq(nil)
+        simple.save(:validate => false)
+        expect(simple.status).to eq('unknown_scope')
+      end
+    end
+
+  rescue LoadError
+    puts "Not running MongoMapper specs because mongo_mapper gem is not installed!!!"
+  end
+end

data/spec/unit/persistence/mongoid_persistance_spec.rb

@@ -1,6 +1,4 @@
-describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3') do
-# describe 'mongoid' do
-
+describe 'mongoid' do
   begin
     require 'mongoid'
     require 'logger'
@@ -135,15 +133,11 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
     describe "instance methods" do
       let(:simple) {SimpleNewDslMongoid.new}
 
-      it "should call aasm_ensure_initial_state on validation before create" do
-        expect(simple).to receive(:aasm_ensure_initial_state).and_return(true)
-        simple.valid?
+      it "should initialize the aasm state on instantiation" do
+        expect(SimpleNewDslMongoid.new.status).to eql 'unknown_scope'
+        expect(SimpleNewDslMongoid.new.aasm.current_state).to eql :unknown_scope
       end
 
-      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-        expect(simple).to receive(:aasm_ensure_initial_state).and_return(true)
-        simple.save(:validate => false)
-      end
     end
 
   rescue LoadError

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -6,7 +6,8 @@ describe 'sequel' do
     require 'spec_helper'
 
     before(:all) do
-      db = Sequel.sqlite
+      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
@@ -43,6 +44,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 +66,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?

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

data/spec/unit/transition_spec.rb

@@ -4,7 +4,12 @@ describe 'transitions' do
 
   it 'should raise an exception when whiny' do
     process = ProcessWithNewDsl.new
-    expect { process.stop! }.to raise_error(AASM::InvalidTransition)
+    expect { process.stop! }.to raise_error do |err|
+      expect(err.class).to eql(AASM::InvalidTransition)
+      expect(err.message).to eql("Event 'stop' cannot transition from 'sleeping'")
+      expect(err.object).to eql(process)
+      expect(err.event_name).to eql(:stop)
+    end
     expect(process).to be_sleeping
   end