aasm 4.5.1 → 5.5.0

data/spec/unit/persistence/mongo_mapper_persistence_spec.rb

@@ -1,93 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

data/spec/unit/persistence/sequel_persistence_multiple_spec.rb

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

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -1,100 +0,0 @@
-describe 'sequel' do
-  begin
-    require 'sequel'
-    require 'logger'
-    require 'spec_helper'
-
-    Dir[File.dirname(__FILE__) + "/../../models/sequel/*.rb"].sort.each do |f|
-      require File.expand_path(f)
-    end
-
-    before(:all) do
-      @model = SequelSimple
-    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
-        allow(model).to receive(:new?).and_return(false)
-        model.status = "gamma"
-        expect(model.aasm.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.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.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.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
-
-  rescue LoadError
-    puts "------------------------------------------------------------------------"
-    puts "Not running Sequel specs because sequel gem is not installed!!!"
-    puts "------------------------------------------------------------------------"
-  end
-end

data/spec/unit/readme_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe 'testing the README examples' do
-
-  it 'Usage' do
-    class Job
-      include AASM
-
-      aasm do
-        state :sleeping, :initial => true
-        state :running
-        state :cleaning
-
-        event :run do
-          transitions :from => :sleeping, :to => :running
-        end
-
-        event :clean do
-          transitions :from => :running, :to => :cleaning
-        end
-
-        event :sleep do
-          transitions :from => [:running, :cleaning], :to => :sleeping
-        end
-      end
-    end
-
-    job = Job.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/reloading_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe 'when redefining states' do
-  let(:definer) { DoubleDefiner.new }
-
-  it "allows extending states" do
-    expect(definer).to receive(:do_enter)
-    definer.finish
-  end
-
-  it "allows extending events" do
-    expect(definer).to receive(:do_on_transition)
-    definer.finish
-  end
-end

data/spec/unit/rspec_matcher_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe 'state machine' do
-  let(:simple) { SimpleExample.new }
-  let(:multiple) { SimpleMultipleExample.new }
-
-  describe 'transition_from' do
-    it "works for simple state machines" do
-      expect(simple).to transition_from(:initialised).to(:filled_out).on_event(:fill_out)
-      expect(simple).to_not transition_from(:initialised).to(:authorised).on_event(:fill_out)
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to transition_from(:standing).to(:walking).on_event(:walk).on(:move)
-      expect(multiple).to_not transition_from(:standing).to(:running).on_event(:walk).on(:move)
-
-      expect(multiple).to transition_from(:sleeping).to(:processing).on_event(:start).on(:work)
-      expect(multiple).to_not transition_from(:sleeping).to(:sleeping).on_event(:start).on(:work)
-    end
-  end
-
-  describe 'allow_transition_to' do
-    it "works for simple state machines" do
-      expect(simple).to allow_transition_to(:filled_out)
-      expect(simple).to_not allow_transition_to(:authorised)
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to allow_transition_to(:walking).on(:move)
-      expect(multiple).to_not allow_transition_to(:standing).on(:move)
-
-      expect(multiple).to allow_transition_to(:processing).on(:work)
-      expect(multiple).to_not allow_transition_to(:sleeping).on(:work)
-    end
-  end
-
-  describe "have_state" do
-    it "works for simple state machines" do
-      expect(simple).to have_state :initialised
-      expect(simple).to_not have_state :filled_out
-      simple.fill_out
-      expect(simple).to have_state :filled_out
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to have_state(:standing).on(:move)
-      expect(multiple).to_not have_state(:walking).on(:move)
-      multiple.walk
-      expect(multiple).to have_state(:walking).on(:move)
-
-      expect(multiple).to have_state(:sleeping).on(:work)
-      expect(multiple).to_not have_state(:processing).on(:work)
-      multiple.start
-      expect(multiple).to have_state(:processing).on(:work)
-    end
-  end
-
-  describe "allow_event" do
-    it "works for simple state machines" do
-      expect(simple).to allow_event :fill_out
-      expect(simple).to_not allow_event :authorise
-      simple.fill_out
-      expect(simple).to allow_event :authorise
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to allow_event(:walk).on(:move)
-      expect(multiple).to_not allow_event(:hold).on(:move)
-      multiple.walk
-      expect(multiple).to allow_event(:hold).on(:move)
-
-      expect(multiple).to allow_event(:start).on(:work)
-      expect(multiple).to_not allow_event(:stop).on(:work)
-      multiple.start
-      expect(multiple).to allow_event(:stop).on(:work)
-    end
-  end
-
-end