aasm 5.0.0 → 5.5.0

data/spec/unit/persistence/no_brainer_persistence_multiple_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-if defined?(NoBrainer::Document)
-  describe 'nobrainer' do
-    Dir[File.dirname(__FILE__) + '/../../models/nobrainer/*.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
-      # NoBrainer.configure do |config|
-      #   config.logger = Logger.new(STDERR)
-      # end
-    end
-
-    after do
-      NoBrainer.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(SimpleNoBrainerMultiple).to respond_to(:unknown_scope)
-          expect(SimpleNoBrainerMultiple).to respond_to(:another_unknown_scope)
-
-          expect(SimpleNoBrainerMultiple.unknown_scope.class).to eq(NoBrainer::Criteria)
-          expect(SimpleNoBrainerMultiple.another_unknown_scope.class).to eq(NoBrainer::Criteria)
-        end
-      end
-
-      context 'Already respond_to? the scope name' do
-        it 'should not add a scope' do
-          expect(SimpleNoBrainerMultiple).to respond_to(:new)
-          expect(SimpleNoBrainerMultiple.new.class).to eq(SimpleNoBrainerMultiple)
-        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(SimpleNewDslNoBrainerMultiple).to respond_to(:unknown_scope)
-          expect(SimpleNewDslNoBrainerMultiple.unknown_scope.class).to eq(NoBrainer::Criteria)
-        end
-      end
-
-      context 'Already respond_to? the scope name' do
-        it 'should not add a scope' do
-          expect(SimpleNewDslNoBrainerMultiple).to respond_to(:new)
-          expect(SimpleNewDslNoBrainerMultiple.new.class).to eq(SimpleNewDslNoBrainerMultiple)
-        end
-      end
-
-      it 'does not create scopes if requested' do
-        expect(NoScopeNoBrainerMultiple).not_to respond_to(:ignored_scope)
-      end
-    end
-
-    describe 'instance methods' do
-      let(:simple) { SimpleNewDslNoBrainerMultiple.new }
-
-      it 'should initialize the aasm state on instantiation' do
-        expect(SimpleNewDslNoBrainerMultiple.new.status).to eql 'unknown_scope'
-        expect(SimpleNewDslNoBrainerMultiple.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 = MultipleValidatorNoBrainer.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 = MultipleValidatorNoBrainer.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(NoBrainer::Error::DocumentInvalid)
-        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 = MultipleSilentPersistorNoBrainer.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 = MultipleInvalidPersistorNoBrainer.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 = MultipleInvalidPersistorNoBrainer.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 = ComplexNoBrainerExample.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/no_brainer_persistence_spec.rb

@@ -1,158 +0,0 @@
-require 'spec_helper'
-
-if defined?(NoBrainer::Document)
-  describe 'nobrainer' do
-    Dir[File.dirname(__FILE__) + '/../../models/nobrainer/*.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
-      # NoBrainer.configure do |config|
-      #   config.logger = Logger.new(STDERR)
-      # end
-    end
-
-    after do
-      NoBrainer.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(SimpleNoBrainer).to respond_to(:unknown_scope)
-          expect(SimpleNoBrainer).to respond_to(:another_unknown_scope)
-
-          expect(SimpleNoBrainer.unknown_scope.class).to eq(NoBrainer::Criteria)
-          expect(SimpleNoBrainer.another_unknown_scope.class).to eq(NoBrainer::Criteria)
-        end
-      end
-
-      context 'Already respond_to? the scope name' do
-        it 'should not add a scope' do
-          expect(SimpleNoBrainer).to respond_to(:new)
-          expect(SimpleNoBrainer.new.class).to eq(SimpleNoBrainer)
-        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(SimpleNewDslNoBrainer).to respond_to(:unknown_scope)
-          expect(SimpleNewDslNoBrainer.unknown_scope.class).to eq(NoBrainer::Criteria)
-        end
-      end
-
-      context 'Already respond_to? the scope name' do
-        it 'should not add a scope' do
-          expect(SimpleNewDslNoBrainer).to respond_to(:new)
-          expect(SimpleNewDslNoBrainer.new.class).to eq(SimpleNewDslNoBrainer)
-        end
-      end
-
-      it 'does not create scopes if requested' do
-        expect(NoScopeNoBrainer).not_to respond_to(:ignored_scope)
-      end
-    end
-
-    describe 'instance methods' do
-      let(:simple) { SimpleNewDslNoBrainer.new }
-
-      it 'should initialize the aasm state on instantiation' do
-        expect(SimpleNewDslNoBrainer.new.status).to eql 'unknown_scope'
-        expect(SimpleNewDslNoBrainer.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.childs.pluck(:id, :status).map(&:id)).to eql [child_1.id, child_2.id]
-      end
-    end
-
-    describe 'transitions with persistence' do
-      it 'should work for valid models' do
-        valid_object = ValidatorNoBrainer.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 = ValidatorNoBrainer.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(NoBrainer::Error::DocumentInvalid)
-        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 = SilentPersistorNoBrainer.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 = InvalidPersistorNoBrainer.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 = InvalidPersistorNoBrainer.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
-  end
-end

data/spec/unit/persistence/redis_persistence_multiple_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-if defined?(Redis)
-  describe 'redis' do
-
-    Dir[File.dirname(__FILE__) + "/../../models/redis/*.rb"].sort.each do |f|
-      require File.expand_path(f)
-    end
-
-    before(:all) do
-      @model = RedisMultiple
-    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
-        expect(model.status).to eq("alpha")
-      end
-
-      it "should return the aasm column the aasm field is not nil" do
-        model.status = "beta"
-        expect(model.aasm(:left).current_state).to eq(:beta)
-      end
-
-      it "should allow a nil state" do
-        model.status = nil
-        expect(model.aasm(:left).current_state).to be_nil
-      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 "complex example" do
-      it "works" do
-        record = RedisComplexExample.new
-
-        expect(record.aasm(:left).current_state).to eql :one
-        expect(record.aasm(:right).current_state).to eql :alpha
-
-        expect_aasm_states record, :one, :alpha
-
-        record.increment!
-        expect_aasm_states record, :two, :alpha
-
-        record.level_up!
-        expect_aasm_states record, :two, :beta
-
-        record.increment!
-        expect { record.increment! }.to raise_error(AASM::InvalidTransition)
-        expect_aasm_states record, :three, :beta
-
-        record.level_up!
-        expect_aasm_states record, :three, :gamma
-      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.value.to_s).to eql left_state.to_s
-        expect(record.aasm(:right).current_state).to eql right_state.to_sym
-        expect(record.right.value.to_s).to eql right_state.to_s
-      end
-    end
-  end
-end

data/spec/unit/persistence/redis_persistence_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-if defined?(Redis::Objects)
-  describe 'redis' do
-
-    Dir[File.dirname(__FILE__) + "/../../models/redis/*.rb"].sort.each do |f|
-      require File.expand_path(f)
-    end
-
-    before(:all) do
-      @model = RedisSimple
-    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 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 allow a nil state" do
-        model.status = nil
-        expect(model.aasm.current_state).to be_nil
-        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
-  end
-end

data/spec/unit/persistence/sequel_persistence_multiple_spec.rb

@@ -1,148 +0,0 @@
-require 'spec_helper'
-
-if defined?(Sequel)
-  describe 'sequel' do
-
-    Dir[File.dirname(__FILE__) + "/../../models/sequel/*.rb"].sort.each do |f|
-      require File.expand_path(f)
-    end
-
-    before(:all) do
-      @model = Sequel::Multiple
-    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
-        allow(model).to receive(:new?).and_return(false)
-        model.status = "gamma"
-        expect(model.aasm(:left).current_state).to eq(:gamma)
-      end
-
-      it "should allow a nil state" do
-        allow(model).to receive(:new?).and_return(false)
-        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.class.select(:id).first.save
-        model.reload
-        expect(model.aasm(:left).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?
-      end
-
-      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-        expect(model).to receive(:aasm_ensure_initial_state).and_return(true)
-        model.save(:validate => false)
-      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 = Sequel::ComplexExample.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
-
-  end
-end