aasm 4.0.8 → 4.5.2

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -1,19 +1,15 @@
 require 'active_record'
-require 'logger'
 require 'spec_helper'
+Dir[File.dirname(__FILE__) + "/../../models/active_record/*.rb"].sort.each do |f|
+  require File.expand_path(f)
+end
 
 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
-  it "should include persistence mixins" do
-    expect(klass.included_modules).to be_include(AASM::Persistence::ActiveRecordPersistence)
-    expect(klass.included_modules).to be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
-  end
-end
-
 describe "instance methods" do
   let(:gate) {Gate.new}
 
@@ -160,7 +156,7 @@ describe "instance methods" do
 
           gate.aasm_write_state state_sym
 
-          expect(gate).to have_received(:aasm_write_attribute).with(state_sym)
+          expect(gate).to have_received(:aasm_write_attribute).with(state_sym, :default)
           expect(gate).to_not have_received :write_attribute
         end
       end
@@ -170,7 +166,7 @@ describe "instance methods" do
       it "delegates state update to the helper method" do
         gate.aasm_write_state_without_persistence state_sym
 
-        expect(gate).to have_received(:aasm_write_attribute).with(state_sym)
+        expect(gate).to have_received(:aasm_write_attribute).with(state_sym, :default)
         expect(gate).to_not have_received :write_attribute
       end
     end
@@ -210,7 +206,7 @@ describe "instance methods" do
     end
 
     it "generates attribute value using a helper method" do
-      expect(gate).to have_received(:aasm_raw_attribute_value).with(sym)
+      expect(gate).to have_received(:aasm_raw_attribute_value).with(sym, :default)
     end
 
     it "writes attribute to the model" do
@@ -303,6 +299,18 @@ describe "named scopes with the new DSL" do
     expect(NoScope).not_to respond_to(:pending)
   end
 
+  context "result of scope" do
+    let!(:dsl1) { SimpleNewDsl.create!(status: :new) }
+    let!(:dsl2) { SimpleNewDsl.create!(status: :unknown_scope) }
+
+    after do
+      SimpleNewDsl.destroy_all
+    end
+
+    it "created scope works as where(name: :scope_name)" do
+      expect(SimpleNewDsl.unknown_scope).to contain_exactly(dsl2)
+    end
+  end
 end # scopes
 
 describe "direct assignment" do
@@ -321,6 +329,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
@@ -413,7 +439,7 @@ describe 'transitions with persistence' do
 
       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
+        AASM::StateMachine[Transactor][:default].config.requires_new_transaction = false
 
         expect(transactor).to be_sleeping
         expect(worker.status).to eq('sleeping')
@@ -431,9 +457,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
@@ -493,3 +524,29 @@ describe "invalid states with persistence" do
   end
 
 end
+
+describe 'basic example with two state machines' do
+  let(:example) { BasicActiveRecordTwoStateMachinesExample.new }
+
+  it 'should initialise properly' do
+    expect(example.aasm(:search).current_state).to eql :initialised
+    expect(example.aasm(:sync).current_state).to eql :unsynced
+  end
+end
+
+describe 'testing the README examples' do
+  it 'Usage' do
+    job = ReadmeJob.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/persistence/mongo_mapper_persistence_multiple_spec.rb

@@ -0,0 +1,146 @@
+describe 'mongo_mapper' do
+  begin
+    require 'mongo_mapper'
+    require 'logger'
+    require 'spec_helper'
+
+    Dir[File.dirname(__FILE__) + "/../../models/mongo_mapper/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      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(SimpleMongoMapperMultiple).to respond_to(:unknown_scope)
+          expect(SimpleMongoMapperMultiple.unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
+          #expect(SimpleMongoMapperMultiple.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(SimpleMongoMapperMultiple).to respond_to(:next)
+          expect(SimpleMongoMapperMultiple.new.class).to eq(SimpleMongoMapperMultiple)
+        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(SimpleNewDslMongoMapperMultiple).to respond_to(:unknown_scope)
+          expect(SimpleNewDslMongoMapperMultiple.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(SimpleNewDslMongoMapperMultiple).to respond_to(:next)
+          expect(SimpleNewDslMongoMapperMultiple.new.class).to eq(SimpleNewDslMongoMapperMultiple)
+        end
+      end
+
+      it "does not create scopes if requested" do
+        expect(NoScopeMongoMapperMultiple).not_to respond_to(:ignored_scope)
+      end
+
+    end
+
+    describe "instance methods" do
+
+      let(:simple) {SimpleNewDslMongoMapperMultiple.new}
+
+      it "should call aasm_ensure_initial_state on validation before create" do
+        expect(SimpleNewDslMongoMapperMultiple.aasm(:left).initial_state).to eq(:unknown_scope)
+        expect(SimpleNewDslMongoMapperMultiple.aasm(:left).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
+
+    describe "complex example" do
+      it "works" do
+        record = ComplexMongoMapperExample.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 MongoMapper specs because mongo_mapper gem is not installed!!!"
+    puts "--------------------------------------------------------------------------"
+  end
+end

data/spec/unit/persistence/mongo_mapper_persistence_spec.rb

@@ -0,0 +1,93 @@
+describe 'mongo_mapper' do
+  begin
+    require 'mongo_mapper'
+    require 'logger'
+    require 'spec_helper'
+
+    Dir[File.dirname(__FILE__) + "/../../models/mongo_mapper/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      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 "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 "--------------------------------------------------------------------------"
+    puts "Not running MongoMapper multiple-specs because mongo_mapper gem is not installed!!!"
+    puts "--------------------------------------------------------------------------"
+  end
+end

data/spec/unit/persistence/mongoid_persistence_multiple_spec.rb

@@ -0,0 +1,127 @@
+describe 'mongoid' do
+  begin
+    require 'mongoid'
+    require 'logger'
+    require 'spec_helper'
+
+    Dir[File.dirname(__FILE__) + "/../../models/mongoid/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      # if you want to see the statements while running the spec enable the following line
+      # Mongoid.logger = Logger.new(STDERR)
+
+      Mongoid.configure do |config|
+        config.connect_to "mongoid_#{Process.pid}"
+      end
+    end
+
+    after do
+      Mongoid.purge!
+    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(SimpleMongoidMultiple).to respond_to(:unknown_scope)
+          expect(SimpleMongoidMultiple.unknown_scope.class).to eq(Mongoid::Criteria)
+        end
+      end
+
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleMongoidMultiple).to respond_to(:new)
+          expect(SimpleMongoidMultiple.new.class).to eq(SimpleMongoidMultiple)
+        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(SimpleNewDslMongoidMultiple).to respond_to(:unknown_scope)
+          expect(SimpleNewDslMongoidMultiple.unknown_scope.class).to eq(Mongoid::Criteria)
+        end
+      end
+
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleNewDslMongoidMultiple).to respond_to(:new)
+          expect(SimpleNewDslMongoidMultiple.new.class).to eq(SimpleNewDslMongoidMultiple)
+        end
+      end
+
+      it "does not create scopes if requested" do
+        expect(NoScopeMongoidMultiple).not_to respond_to(:ignored_scope)
+      end
+    end
+
+    describe "instance methods" do
+      let(:simple) {SimpleNewDslMongoidMultiple.new}
+
+      it "should initialize the aasm state on instantiation" do
+        expect(SimpleNewDslMongoidMultiple.new.status).to eql 'unknown_scope'
+        expect(SimpleNewDslMongoidMultiple.new.aasm(:left).current_state).to eql :unknown_scope
+      end
+
+    end
+
+    describe "complex example" do
+      it "works" do
+        record = ComplexMongoidExample.new
+        expect_aasm_states record, :one, :alpha
+
+        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 Mongoid multiple-specs because mongoid gem is not installed!!!"
+    puts "--------------------------------------------------------------------------"
+  end
+end

data/spec/unit/persistence/mongoid_persistence_spec.rb

@@ -0,0 +1,79 @@
+describe 'mongoid' do
+  begin
+    require 'mongoid'
+    require 'logger'
+    require 'spec_helper'
+
+    Dir[File.dirname(__FILE__) + "/../../models/mongoid/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      # if you want to see the statements while running the spec enable the following line
+      # Mongoid.logger = Logger.new(STDERR)
+
+      Mongoid.configure do |config|
+        config.connect_to "mongoid_#{Process.pid}"
+      end
+    end
+
+    after do
+      Mongoid.purge!
+    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(SimpleMongoid).to respond_to(:unknown_scope)
+          expect(SimpleMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
+        end
+      end
+
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleMongoid).to respond_to(:new)
+          expect(SimpleMongoid.new.class).to eq(SimpleMongoid)
+        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(SimpleNewDslMongoid).to respond_to(:unknown_scope)
+          expect(SimpleNewDslMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
+        end
+      end
+
+      context "Already respond_to? the scope name" do
+        it "should not add a scope" do
+          expect(SimpleNewDslMongoid).to respond_to(:new)
+          expect(SimpleNewDslMongoid.new.class).to eq(SimpleNewDslMongoid)
+        end
+      end
+
+      it "does not create scopes if requested" do
+        expect(NoScopeMongoid).not_to respond_to(:ignored_scope)
+      end
+
+    end
+
+    describe "instance methods" do
+      let(:simple) {SimpleNewDslMongoid.new}
+
+      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
+
+    end
+
+  rescue LoadError
+    puts "--------------------------------------------------------------------------"
+    puts "Not running Mongoid specs because mongoid gem is not installed!!!"
+    puts "--------------------------------------------------------------------------"
+  end
+end