aasm 2.1.1 → 5.2.0

data/spec/unit/persistence/dynamoid_persistence_multiple_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+if defined?(Dynamoid)
+  describe 'dynamoid' do
+
+    Dir[File.dirname(__FILE__) + "/../../models/dynamoid/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      @model = DynamoidMultiple
+    end
+
+    describe "instance methods" do
+      let(:model) {@model.new}
+
+      it "should respond to aasm persistence methods" do
+        expect(model).to respond_to(:aasm_read_state)
+        expect(model).to respond_to(:aasm_write_state)
+        expect(model).to respond_to(:aasm_write_state_without_persistence)
+      end
+
+      it "should return the initial state when new and the aasm field is nil" do
+        expect(model.aasm(:left).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(:left).current_state).to eq(:beta)
+      end
+
+      it "should return the aasm column when not new and the aasm_column is not nil" do
+        model.save
+        model.status = "gamma"
+        expect(model.aasm(:left).current_state).to eq(:gamma)
+      end
+
+      it "should allow a nil state" do
+        model.save
+        model.status = nil
+        expect(model.aasm(:left).current_state).to be_nil
+      end
+
+      it "should not change the state if state is not loaded" do
+        model.release
+        model.save
+        model.reload
+        expect(model.aasm(:left).current_state).to eq(:beta)
+      end
+    end
+
+    describe 'subclasses' do
+      it "should have the same states as its parent class" do
+        expect(Class.new(@model).aasm(:left).states).to eq(@model.aasm(:left).states)
+      end
+
+      it "should have the same events as its parent class" do
+        expect(Class.new(@model).aasm(:left).events).to eq(@model.aasm(:left).events)
+      end
+
+      it "should have the same column as its parent even for the new dsl" do
+        expect(@model.aasm(:left).attribute_name).to eq(:status)
+        expect(Class.new(@model).aasm(:left).attribute_name).to eq(:status)
+      end
+    end
+
+    describe 'initial states' do
+      it 'should support conditions' do
+        @model.aasm(:left) do
+          initial_state lambda{ |m| m.default }
+        end
+
+        expect(@model.new(:default => :beta).aasm(:left).current_state).to eq(:beta)
+        expect(@model.new(:default => :gamma).aasm(:left).current_state).to eq(:gamma)
+      end
+    end
+
+    describe "complex example" do
+      it "works" do
+        record = ComplexDynamoidExample.new
+        expect(record.aasm(:left).current_state).to eql :one
+        expect(record.aasm(:right).current_state).to eql :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
+
+  end
+end

data/spec/unit/persistence/dynamoid_persistence_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+if defined?(Dynamoid)
+  describe 'dynamoid' do
+
+    Dir[File.dirname(__FILE__) + "/../../models/dynamoid/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      @model = DynamoidSimple
+    end
+
+    describe "instance methods" do
+      let(:model) {@model.new}
+
+      it "should respond to aasm persistence methods" do
+        expect(model).to respond_to(:aasm_read_state)
+        expect(model).to respond_to(:aasm_write_state)
+        expect(model).to respond_to(:aasm_write_state_without_persistence)
+      end
+
+      it "should return the initial state when new and the aasm field is nil" 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)
+      end
+
+      it "should return the aasm column when not new and the aasm_column is not nil" do
+        model.save
+        model.status = "gamma"
+        expect(model.aasm.current_state).to eq(:gamma)
+      end
+
+      it "should allow a nil state" do
+        model.save
+        model.status = nil
+        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.reload
+        expect(model.aasm.current_state).to eq(:beta)
+      end
+    end
+
+    describe 'subclasses' do
+      it "should have the same states as its parent class" do
+        expect(Class.new(@model).aasm.states).to eq(@model.aasm.states)
+      end
+
+      it "should have the same events as its parent class" do
+        expect(Class.new(@model).aasm.events).to eq(@model.aasm.events)
+      end
+
+      it "should have the same column as its parent even for the new dsl" do
+        expect(@model.aasm.attribute_name).to eq(:status)
+        expect(Class.new(@model).aasm.attribute_name).to eq(:status)
+      end
+    end
+
+    describe 'initial states' do
+      it 'should support conditions' do
+        @model.aasm do
+          initial_state lambda{ |m| m.default }
+        end
+
+        expect(@model.new(:default => :beta).aasm.current_state).to eq(:beta)
+        expect(@model.new(:default => :gamma).aasm.current_state).to eq(:gamma)
+      end
+    end
+
+  end
+end

data/spec/unit/persistence/mongoid_persistence_multiple_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+if defined?(Mongoid::Document)
+  describe 'mongoid' do
+
+    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)
+    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 for each state" do
+          expect(SimpleMongoidMultiple).to respond_to(:unknown_scope)
+          expect(SimpleMongoidMultiple).to respond_to(:another_unknown_scope)
+
+          expect(SimpleMongoidMultiple.unknown_scope.class).to eq(Mongoid::Criteria)
+          expect(SimpleMongoidMultiple.another_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 'transitions with persistence' do
+
+      it "should work for valid models" do
+        valid_object = MultipleValidatorMongoid.create(:name => 'name')
+        expect(valid_object).to be_sleeping
+        valid_object.status = :running
+        expect(valid_object).to be_running
+      end
+
+      it 'should not store states for invalid models' do
+        validator = MultipleValidatorMongoid.create(:name => 'name')
+        expect(validator).to be_valid
+        expect(validator).to be_sleeping
+
+        validator.name = nil
+        expect(validator).not_to be_valid
+        expect { validator.run! }.to raise_error(Mongoid::Errors::Validations)
+        expect(validator).to be_sleeping
+
+        validator.reload
+        expect(validator).not_to be_running
+        expect(validator).to be_sleeping
+
+        validator.name = 'another name'
+        expect(validator).to be_valid
+        expect(validator.run!).to be_truthy
+        expect(validator).to be_running
+
+        validator.reload
+        expect(validator).to be_running
+        expect(validator).not_to be_sleeping
+      end
+
+      it 'should not store states for invalid models silently if configured' do
+        validator = MultipleSilentPersistorMongoid.create(:name => 'name')
+        expect(validator).to be_valid
+        expect(validator).to be_sleeping
+
+        validator.name = nil
+        expect(validator).not_to be_valid
+        expect(validator.run!).to be_falsey
+        expect(validator).to be_sleeping
+
+        validator.reload
+        expect(validator).not_to be_running
+        expect(validator).to be_sleeping
+
+        validator.name = 'another name'
+        expect(validator).to be_valid
+        expect(validator.run!).to be_truthy
+        expect(validator).to be_running
+
+        validator.reload
+        expect(validator).to be_running
+        expect(validator).not_to be_sleeping
+      end
+
+      it 'should store states for invalid models if configured' do
+        persistor = MultipleInvalidPersistorMongoid.create(:name => 'name')
+        expect(persistor).to be_valid
+        expect(persistor).to be_sleeping
+
+        persistor.name = nil
+        expect(persistor).not_to be_valid
+        expect(persistor.run!).to be_truthy
+        expect(persistor).to be_running
+
+        persistor = MultipleInvalidPersistorMongoid.find(persistor.id)
+        persistor.valid?
+        expect(persistor).to be_valid
+        expect(persistor).to be_running
+        expect(persistor).not_to be_sleeping
+
+        persistor.reload
+        expect(persistor).to be_running
+        expect(persistor).not_to be_sleeping
+      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
+
+  end
+end

data/spec/unit/persistence/mongoid_persistence_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+if defined?(Mongoid::Document)
+  describe 'mongoid' do
+
+    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)
+    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 for each state" do
+          expect(SimpleMongoid).to respond_to(:unknown_scope)
+          expect(SimpleMongoid).to respond_to(:another_unknown_scope)
+
+          expect(SimpleMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
+          expect(SimpleMongoid.another_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
+
+    describe "relations object" do
+
+      it "should load relations object ids" do
+        parent  =  Parent.create
+        child_1 = Child.create(parent_id: parent.id)
+        child_2 = Child.create(parent_id: parent.id)
+        expect(parent.child_ids).to eql [child_1.id, child_2.id]
+      end
+
+    end
+
+    describe 'transitions with persistence' do
+
+      it 'should work for valid models' do
+        valid_object = ValidatorMongoid.create(:name => 'name')
+        expect(valid_object).to be_sleeping
+        valid_object.status = :running
+        expect(valid_object).to be_running
+      end
+
+      it 'should not store states for invalid models' do
+        validator = ValidatorMongoid.create(:name => 'name')
+        expect(validator).to be_valid
+        expect(validator).to be_sleeping
+
+        validator.name = nil
+        expect(validator).not_to be_valid
+        expect { validator.run! }.to raise_error(Mongoid::Errors::Validations)
+        expect(validator).to be_sleeping
+
+        validator.reload
+        expect(validator).not_to be_running
+        expect(validator).to be_sleeping
+
+        validator.name = 'another name'
+        expect(validator).to be_valid
+        expect(validator.run!).to be_truthy
+        expect(validator).to be_running
+
+        validator.reload
+        expect(validator).to be_running
+        expect(validator).not_to be_sleeping
+      end
+
+      it 'should not store states for invalid models silently if configured' do
+        validator = SilentPersistorMongoid.create(:name => 'name')
+        expect(validator).to be_valid
+        expect(validator).to be_sleeping
+
+        validator.name = nil
+        expect(validator).not_to be_valid
+        expect(validator.run!).to be_falsey
+        expect(validator).to be_sleeping
+
+        validator.reload
+        expect(validator).not_to be_running
+        expect(validator).to be_sleeping
+
+        validator.name = 'another name'
+        expect(validator).to be_valid
+        expect(validator.run!).to be_truthy
+        expect(validator).to be_running
+
+        validator.reload
+        expect(validator).to be_running
+        expect(validator).not_to be_sleeping
+      end
+
+      it 'should store states for invalid models if configured' do
+        persistor = InvalidPersistorMongoid.create(:name => 'name')
+        expect(persistor).to be_valid
+        expect(persistor).to be_sleeping
+
+        persistor.name = nil
+
+        expect(persistor).not_to be_valid
+        expect(persistor.run!).to be_truthy
+        expect(persistor).to be_running
+
+        persistor = InvalidPersistorMongoid.find(persistor.id)
+
+        persistor.valid?
+        expect(persistor).to be_valid
+        expect(persistor).to be_running
+        expect(persistor).not_to be_sleeping
+
+        persistor.reload
+        expect(persistor).to be_running
+        expect(persistor).not_to be_sleeping
+      end
+    end
+
+    describe 'testing the timestamps option' do
+      let(:example) { TimestampExampleMongoid.create }
+
+      it 'should update existing timestamp fields' do
+        expect { example.open! }.to change { example.reload.opened_at }.from(nil).to(instance_of(::Time))
+      end
+
+      it 'should not fail if there is no corresponding timestamp field' do
+        expect { example.close! }.to change { example.reload.status }
+      end
+    end
+
+  end
+end