aasm 4.0.3 → 4.1.0

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -30,15 +30,15 @@ describe "instance methods" do
     let(:columns_hash) { Hash[column_name, column] }
 
     before :each do
-      gate.class.aasm.stub(:attribute_name).and_return(column_name.to_sym)
-      gate.class.stub(:columns_hash).and_return(columns_hash)
+      allow(gate.class.aasm).to receive(:attribute_name).and_return(column_name.to_sym)
+      allow(gate.class).to receive(:columns_hash).and_return(columns_hash)
     end
 
     context "when AASM column has integer type" do
       let(:column) { double(Object, type: :integer) }
 
       it "returns true" do
-        expect(subject.call).to be_true
+        expect(subject.call).to be_truthy
       end
     end
 
@@ -46,7 +46,7 @@ describe "instance methods" do
       let(:column) { double(Object, type: :string) }
 
       it "returns false" do
-        expect(subject.call).to be_false
+        expect(subject.call).to be_falsey
       end
     end
   end
@@ -55,7 +55,7 @@ describe "instance methods" do
     subject { lambda{ gate.send(:aasm_guess_enum_method) } }
 
     before :each do
-      gate.class.aasm.stub(:attribute_name).and_return(:value)
+      allow(gate.class.aasm).to receive(:attribute_name).and_return(:value)
     end
 
     it "pluralizes AASM column name" do
@@ -64,69 +64,56 @@ describe "instance methods" do
   end
 
   describe "aasm_enum" do
-    subject { lambda{ gate.send(:aasm_enum) } }
-
     context "when AASM enum setting contains an explicit enum method name" do
-      let(:enum) { :test }
-
-      before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(enum)
-      end
+      let(:with_enum) { WithEnum.new }
 
       it "returns whatever value was set in AASM config" do
-        expect(subject.call).to eq enum
+        expect(with_enum.send(:aasm_enum)).to eq :test
       end
     end
 
     context "when AASM enum setting is simply set to true" do
+      let(:with_true_enum) { WithTrueEnum.new }
       before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(true)
-        Gate.aasm.stub(:attribute_name).and_return(:value)
-        gate.stub(:aasm_guess_enum_method).and_return(:values)
+        allow(WithTrueEnum.aasm).to receive(:attribute_name).and_return(:value)
       end
 
       it "infers enum method name from pluralized column name" do
-        expect(subject.call).to eq :values
-        expect(gate).to have_received :aasm_guess_enum_method
+        expect(with_true_enum.send(:aasm_enum)).to eq :values
       end
     end
 
     context "when AASM enum setting is explicitly disabled" do
-      before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(false)
-      end
+      let(:with_false_enum) { WithFalseEnum.new }
 
       it "returns nil" do
-        expect(subject.call).to be_nil
+        expect(with_false_enum.send(:aasm_enum)).to be_nil
       end
     end
 
     context "when AASM enum setting is not enabled" do
       before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(nil)
-        Gate.aasm.stub(:attribute_name).and_return(:value)
+        allow(Gate.aasm).to receive(:attribute_name).and_return(:value)
       end
 
       context "when AASM column looks like enum" do
         before :each do
-          gate.stub(:aasm_column_looks_like_enum).and_return(true)
-          gate.stub(:aasm_guess_enum_method).and_return(:values)
+          allow(gate).to receive(:aasm_column_looks_like_enum).and_return(true)
         end
 
         it "infers enum method name from pluralized column name" do
-          expect(subject.call).to eq :values
-          expect(gate).to have_received :aasm_guess_enum_method
+          expect(gate.send(:aasm_enum)).to eq :values
         end
       end
 
       context "when AASM column doesn't look like enum'" do
         before :each do
-          gate.stub(:aasm_column_looks_like_enum)
+          allow(gate).to receive(:aasm_column_looks_like_enum)
             .and_return(false)
         end
 
         it "returns nil, as we're not using enum" do
-          expect(subject.call).to be_nil
+          expect(gate.send(:aasm_enum)).to be_nil
         end
       end
     end
@@ -139,24 +126,17 @@ describe "instance methods" do
     let(:enum) { Hash[state_sym, state_code] }
 
     before :each do
-      gate
-        .stub(:aasm_enum)
-        .and_return(enum_name)
-      gate.stub(:aasm_write_attribute)
-      gate.stub(:write_attribute)
-
-      gate
-        .class
-        .stub(enum_name)
-        .and_return(enum)
+      allow(gate).to receive(:aasm_enum).and_return(enum_name)
+      allow(gate).to receive(:aasm_write_attribute)
+      allow(gate).to receive(:write_attribute)
+
+      allow(Gate).to receive(enum_name).and_return(enum)
     end
 
     describe "aasm_write_state" do
       context "when AASM is configured to skip validations on save" do
         before :each do
-          gate
-            .stub(:aasm_skipping_validations)
-            .and_return(true)
+          allow(gate).to receive(:aasm_skipping_validations).and_return(true)
         end
 
         it "passes state code instead of state symbol to update_all" do
@@ -164,10 +144,7 @@ describe "instance methods" do
           # parameters in the middle of the chain, so we need to use
           # intermediate object instead.
           obj = double(Object, update_all: 1)
-          gate
-            .class
-            .stub(:where)
-            .and_return(obj)
+          allow(Gate).to receive(:where).and_return(obj)
 
           gate.aasm_write_state state_sym
 
@@ -179,7 +156,7 @@ describe "instance methods" do
       context "when AASM is not skipping validations" do
         it "delegates state update to the helper method" do
           # Let's pretend that validation is passed
-          gate.stub(:save).and_return(true)
+          allow(gate).to receive(:save).and_return(true)
 
           gate.aasm_write_state state_sym
 
@@ -210,9 +187,7 @@ describe "instance methods" do
     let(:state_sym) { :running }
 
     before :each do
-      gate
-        .stub(:aasm_enum)
-        .and_return(nil)
+      allow(gate).to receive(:aasm_enum).and_return(nil)
     end
 
     describe "aasm_raw_attribute_value" do
@@ -228,9 +203,8 @@ describe "instance methods" do
     let(:value) { 42 }
 
     before :each do
-      gate.stub(:write_attribute)
-      gate.stub(:aasm_raw_attribute_value)
-        .and_return(value)
+      allow(gate).to receive(:write_attribute)
+      allow(gate).to receive(:aasm_raw_attribute_value).and_return(value)
 
       gate.send(:aasm_write_attribute, sym)
     end
@@ -265,24 +239,36 @@ describe "instance methods" do
     expect(gate.aasm.current_state).to be_nil
   end
 
-  it "should call aasm_ensure_initial_state on validation before create" do
-    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
-    gate.valid?
-  end
+  context 'on initialization' do
+    it "should initialize the aasm state" do
+      expect(Gate.new.aasm_state).to eql 'opened'
+      expect(Gate.new.aasm.current_state).to eql :opened
+    end
 
-  it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
-    gate.save(:validate => false)
-  end
+    it "should not initialize the aasm state if it has not been loaded" do
+      # we have to create a gate in the database, for which we only want to
+      # load the id, and not the state
+      gate = Gate.create!
 
-  it "should not call aasm_ensure_initial_state on validation before update" do
-    allow(gate).to receive(:new_record?).and_return(false)
-    expect(gate).not_to receive(:aasm_ensure_initial_state)
-    gate.valid?
+      # then we just load the gate ids
+      Gate.select(:id).where(id: gate.id).first
+    end
   end
 
 end
 
+if ActiveRecord::VERSION::MAJOR < 4 && ActiveRecord::VERSION::MINOR < 2 # won't work with Rails >= 4.2
+describe "direct state column access" do
+  it "accepts false states" do
+    f = FalseState.create!
+    expect(f.aasm_state).to eql false
+    expect {
+      f.aasm.events.map(&:name)
+    }.to_not raise_error
+  end
+end
+end
+
 describe 'subclasses' do
   it "should have the same states as its parent class" do
     expect(DerivateNewDsl.aasm.states).to eq(SimpleNewDsl.aasm.states)
@@ -302,7 +288,7 @@ 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(SimpleNewDsl).to respond_to(:unknown_scope)
-      expect(SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation)).to be_true
+      expect(SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation)).to be_truthy
     end
   end
 
@@ -361,7 +347,7 @@ describe 'transitions with persistence' do
 
     validator.name = nil
     expect(validator).not_to be_valid
-    expect(validator.run!).to be_false
+    expect(validator.run!).to be_falsey
     expect(validator).to be_sleeping
 
     validator.reload
@@ -370,7 +356,7 @@ describe 'transitions with persistence' do
 
     validator.name = 'another name'
     expect(validator).to be_valid
-    expect(validator.run!).to be_true
+    expect(validator.run!).to be_truthy
     expect(validator).to be_running
 
     validator.reload
@@ -385,7 +371,7 @@ describe 'transitions with persistence' do
 
     persistor.name = nil
     expect(persistor).not_to be_valid
-    expect(persistor.run!).to be_true
+    expect(persistor.run!).to be_truthy
     expect(persistor).to be_running
 
     persistor = InvalidPersistor.find(persistor.id)
@@ -490,7 +476,7 @@ describe "invalid states with persistence" do
   it "should not store states" do
     validator = Validator.create(:name => 'name')
     validator.status = 'invalid_state'
-    expect(validator.save).to be_false
+    expect(validator.save).to be_falsey
     expect {validator.save!}.to raise_error(ActiveRecord::RecordInvalid)
 
     validator.reload
@@ -500,7 +486,7 @@ describe "invalid states with persistence" do
   it "should store invalid states if configured" do
     persistor = InvalidPersistor.create(:name => 'name')
     persistor.status = 'invalid_state'
-    expect(persistor.save).to be_true
+    expect(persistor.save).to be_truthy
 
     persistor.reload
     expect(persistor.status).to eq('invalid_state')

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

data/spec/unit/state_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe AASM::State do
+describe AASM::Core::State do
   before(:each) do
     @name    = :astate
     @options = { :crazy_custom_key => 'key' }
   end
 
   def new_state(options={})
-    AASM::State.new(@name, Conversation, @options.merge(options))
+    AASM::Core::State.new(@name, Conversation, @options.merge(options))
   end
 
   it 'should set the name' do

data/spec/unit/subclassing_spec.rb

@@ -19,7 +19,7 @@ describe 'subclassing' do
   end
 
   it 'should know how to respond to `may_add_details?`' do
-    expect(son.may_add_details?).to be_true
+    expect(son.may_add_details?).to be_truthy
   end
 
   it 'should not break if I call Son#update_state' do