aasm 4.2.0 → 4.3.0

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -1,19 +1,15 @@
 require 'active_record'
 require 'spec_helper'
-Dir[File.dirname(__FILE__) + "/../../models/active_record/*.rb"].sort.each { |f| require File.expand_path(f) }
+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
@@ -431,7 +427,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')
@@ -516,3 +512,12 @@ 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

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_persistance_spec.rb → mongo_mapper_persistence_spec.rb}

@@ -4,9 +4,11 @@ describe 'mongo_mapper' do
     require 'logger'
     require 'spec_helper'
 
-    before(:all) do
-      Dir[File.dirname(__FILE__) + "/../../models/mongo_mapper/*.rb"].sort.each { |f| require File.expand_path(f) }
+    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}"
@@ -64,52 +66,6 @@ describe 'mongo_mapper' do
 
     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}
@@ -130,6 +86,8 @@ describe 'mongo_mapper' do
     end
 
   rescue LoadError
-    puts "Not running MongoMapper specs because mongo_mapper gem is not installed!!!"
+    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