aasm 2.1.1 → 5.2.0

data/spec/unit/transition_spec.rb

@@ -0,0 +1,436 @@
+require 'spec_helper'
+
+describe 'transitions' do
+
+  it 'should raise an exception when whiny' do
+    process = ProcessWithNewDsl.new
+    expect { process.stop! }.to raise_error do |err|
+      expect(err.class).to eql(AASM::InvalidTransition)
+      expect(err.message).to eql("Event 'stop' cannot transition from 'sleeping'.")
+      expect(err.object).to eql(process)
+      expect(err.event_name).to eql(:stop)
+    end
+    expect(process).to be_sleeping
+  end
+
+  it 'should not raise an exception when not whiny' do
+    silencer = Silencer.new
+    expect(silencer.smile!).to be_falsey
+    expect(silencer).to be_silent
+  end
+
+  it 'should not raise an exception when superclass not whiny' do
+    sub = SubClassing.new
+    expect(sub.smile!).to be_falsey
+    expect(sub).to be_silent
+  end
+
+  it 'should not raise an exception when from is nil even if whiny' do
+    silencer = Silencer.new
+    expect(silencer.smile_any!).to be_truthy
+    expect(silencer).to be_smiling
+  end
+
+  it 'should call the block on success' do
+    silencer = Silencer.new
+    success = false
+    expect {
+      silencer.smile_any! do
+        success = true
+      end
+    }.to change { success }.to(true)
+  end
+
+  it 'should not call the block on failure' do
+    silencer = Silencer.new
+    success = false
+    expect {
+      silencer.smile! do
+        success = true
+      end
+    }.not_to change { success }
+  end
+
+end
+
+describe AASM::Core::Transition do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
+  it 'should set from, to, and opts attr readers' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::Core::Transition.new(event, opts)
+
+    expect(st.from).to eq(opts[:from])
+    expect(st.to).to eq(opts[:to])
+    expect(st.opts).to eq(opts)
+  end
+
+  it 'should set on_transition with deprecation warning' do
+    opts = {:from => 'foo', :to => 'bar'}
+    st = AASM::Core::Transition.allocate
+    expect(st).to receive(:warn).with('[DEPRECATION] :on_transition is deprecated, use :after instead')
+
+    st.send :initialize, event, opts do
+      guard :gg
+      on_transition :after_callback
+    end
+
+    expect(st.opts[:after]).to eql [:after_callback]
+  end
+
+  it 'should set after, guard and success from dsl' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::Core::Transition.new(event, opts) do
+      guard :gg
+      after :after_callback
+      success :after_persist
+    end
+
+    expect(st.opts[:guard]).to eql ['g', :gg]
+    expect(st.opts[:after]).to eql [:after_callback] # TODO fix this bad code coupling
+    expect(st.opts[:success]).to eql [:after_persist] # TODO fix this bad code coupling
+  end
+
+  it 'should pass equality check if from and to are the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    allow(obj).to receive(:from).and_return(opts[:from])
+    allow(obj).to receive(:to).and_return(opts[:to])
+
+    expect(st).to eq(obj)
+  end
+
+  it 'should fail equality check if from are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    allow(obj).to receive(:from).and_return('blah')
+    allow(obj).to receive(:to).and_return(opts[:to])
+
+    expect(st).not_to eq(obj)
+  end
+
+  it 'should fail equality check if to are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    allow(obj).to receive(:from).and_return(opts[:from])
+    allow(obj).to receive(:to).and_return('blah')
+
+    expect(st).not_to eq(obj)
+  end
+end
+
+describe AASM::Core::Transition, '- when performing guard checks' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
+  it 'should return true of there is no guard' do
+    opts = {:from => 'foo', :to => 'bar'}
+    st = AASM::Core::Transition.new(event, opts)
+
+    expect(st.allowed?(nil)).to be_truthy
+  end
+
+  it 'should call the method on the object if guard is a symbol' do
+    opts = {:from => 'foo', :to => 'bar', :guard => :test}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    expect(st.allowed?(obj)).to be false
+  end
+
+  it 'should add the name of the failed method calls to the failures instance var' do
+    opts = {:from => 'foo', :to => 'bar', :guard => :test}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    st.allowed?(obj)
+    expect(st.failures).to eq [:test]
+  end
+
+  it 'should call the method on the object if unless is a symbol' do
+    opts = {:from => 'foo', :to => 'bar', :unless => :test}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    expect(st.allowed?(obj)).to be true
+  end
+
+  it 'should call the method on the object if guard is a string' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'test'}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    expect(st.allowed?(obj)).to be false
+  end
+
+  it 'should call the method on the object if unless is a string' do
+    opts = {:from => 'foo', :to => 'bar', :unless => 'test'}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    expect(st.allowed?(obj)).to be true
+  end
+
+  it 'should call the proc passing the object if the guard is a proc' do
+    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new { test }}
+    st = AASM::Core::Transition.new(event, opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    expect(st.allowed?(obj)).to be false
+  end
+end
+
+describe AASM::Core::Transition, '- when executing the transition with a Proc' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
+  it 'should call a Proc on the object with args' do
+    opts = {:from => 'foo', :to => 'bar', :after => Proc.new {|a| test(a) }}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    expect(obj).to receive(:test).with(args)
+
+    st.execute(obj, args)
+  end
+
+  it 'should call a Proc on the object without args' do
+    # in order to test that the Proc has been called, we make sure
+    # that after running the :after callback the prc_object is set
+    prc_object = nil
+    prc = Proc.new { prc_object = self }
+
+    opts = {:from => 'foo', :to => 'bar', :after => prc }
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    st.execute(obj, args)
+    expect(prc_object).to eql obj
+  end
+end
+
+describe AASM::Core::Transition, '- when executing the transition with an :after method call' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
+  it 'should accept a String for the method name' do
+    opts = {:from => 'foo', :to => 'bar', :after => 'test'}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    expect(obj).to receive(:test)
+
+    st.execute(obj, args)
+  end
+
+  it 'should accept a Symbol for the method name' do
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    expect(obj).to receive(:test)
+
+    st.execute(obj, args)
+  end
+
+  it 'should pass args if the target method accepts them' do
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    def obj.test(args)
+      "arg1: #{args[:arg1]} arg2: #{args[:arg2]}"
+    end
+
+    return_value = st.execute(obj, args)
+
+    expect(return_value).to eq('arg1: 1 arg2: 2')
+  end
+
+  it 'should NOT pass args if the target method does NOT accept them' do
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    def obj.test
+      'success'
+    end
+
+    return_value = st.execute(obj, args)
+
+    expect(return_value).to eq('success')
+  end
+
+  it 'should allow accessing the from_state and the to_state' do
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
+    transition = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => AASM::InstanceBase.new('object'))
+
+    def obj.test(args)
+      "from: #{aasm.from_state} to: #{aasm.to_state}"
+    end
+
+    return_value = transition.execute(obj, args)
+
+    expect(return_value).to eq('from: foo to: bar')
+  end
+
+end
+
+describe AASM::Core::Transition, '- when executing the transition with a Class' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
+  class AfterTransitionClass
+    def initialize(record)
+      @record = record
+    end
+
+    def call
+      "from: #{@record.aasm.from_state} to: #{@record.aasm.to_state}"
+    end
+  end
+
+  class AfterTransitionClassWithArgs
+    def initialize(record, args)
+      @record = record
+      @args = args
+    end
+
+    def call
+      "arg1: #{@args[:arg1]}, arg2: #{@args[:arg2]}"
+    end
+  end
+
+  class AfterTransitionClassWithoutArgs
+    def call
+      'success'
+    end
+  end
+
+  it 'passes the record to the initialize method on the class to give access to the from_state and to_state' do
+    opts = {:from => 'foo', :to => 'bar', :after => AfterTransitionClass}
+    transition = AASM::Core::Transition.new(event, opts)
+    obj = double('object', :aasm => AASM::InstanceBase.new('object'))
+
+    return_value = transition.execute(obj)
+
+    expect(return_value).to eq('from: foo to: bar')
+  end
+
+  it 'should pass args to the initialize method on the class if it accepts them' do
+    opts = {:from => 'foo', :to => 'bar', :after => AfterTransitionClassWithArgs}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    return_value = st.execute(obj, args)
+
+    expect(return_value).to eq('arg1: 1, arg2: 2')
+  end
+
+  it 'should NOT pass args if the call method of the class if it does NOT accept them' do
+    opts = {:from => 'foo', :to => 'bar', :after => AfterTransitionClassWithoutArgs}
+    st = AASM::Core::Transition.new(event, opts)
+    obj = double('object', :aasm => 'aasm')
+
+    return_value = st.execute(obj)
+
+    expect(return_value).to eq('success')
+  end
+end
+
+describe AASM::Core::Transition, '- when invoking the transition :success method call' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
+  it 'should accept a String for the method name' do
+    opts = {:from => 'foo', :to => 'bar', :success => 'test'}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    expect(obj).to receive(:test)
+
+    st.invoke_success_callbacks(obj, args)
+  end
+
+  it 'should accept a Symbol for the method name' do
+    opts = {:from => 'foo', :to => 'bar', :success => :test}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    expect(obj).to receive(:test)
+
+    st.invoke_success_callbacks(obj, args)
+  end
+
+  it 'should accept a Array for the method name' do
+    opts = {:from => 'foo', :to => 'bar', :success => [:test1, :test2]}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    expect(obj).to receive(:test1)
+    expect(obj).to receive(:test2)
+
+    st.invoke_success_callbacks(obj, args)
+  end
+
+  it 'should pass args if the target method accepts them' do
+    opts = {:from => 'foo', :to => 'bar', :success => :test}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    def obj.test(args)
+      "arg1: #{args[:arg1]} arg2: #{args[:arg2]}"
+    end
+
+    return_value = st.invoke_success_callbacks(obj, args)
+
+    expect(return_value).to eq('arg1: 1 arg2: 2')
+  end
+
+  it 'should NOT pass args if the target method does NOT accept them' do
+    opts = {:from => 'foo', :to => 'bar', :success => :test}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    def obj.test
+      'success'
+    end
+
+    return_value = st.invoke_success_callbacks(obj, args)
+
+    expect(return_value).to eq('success')
+  end
+end

data/test/minitest_helper.rb

@@ -0,0 +1,57 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec', 'models')))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'aasm'
+require 'minitest/autorun'
+require 'aasm/minitest_spec'
+require 'pry'
+
+# require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
+# require 'ruby-debug/completion'
+# require 'pry'
+
+SEQUEL_DB = defined?(JRUBY_VERSION) ? 'jdbc:sqlite::memory:' : 'sqlite:/'
+
+def load_schema
+  require 'logger'
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+  ActiveRecord::Base.establish_connection(config['sqlite3'])
+  require File.dirname(__FILE__) + "/database.rb"
+end
+
+# Dynamoid initialization
+begin
+  require 'dynamoid'
+  require 'aws-sdk-resources'
+
+  ENV['ACCESS_KEY'] ||= 'abcd'
+  ENV['SECRET_KEY'] ||= '1234'
+
+  Aws.config.update({
+    region: 'us-west-2',
+    credentials: Aws::Credentials.new(ENV['ACCESS_KEY'], ENV['SECRET_KEY'])
+  })
+
+  Dynamoid.configure do |config|
+    config.namespace = 'dynamoid_tests'
+    config.endpoint = "http://#{ENV['DYNAMODB_HOST'] || '127.0.0.1'}:30180"
+    config.warn_on_scan = false
+  end
+
+  Dynamoid.logger.level = Logger::FATAL
+
+  class Minitest::Spec
+    before do
+      Dynamoid.adapter.list_tables.each do |table|
+        Dynamoid.adapter.delete_table(table) if table =~ /^#{Dynamoid::Config.namespace}/
+      end
+      Dynamoid.adapter.tables.clear
+    end
+  end
+rescue LoadError
+  # Without Dynamoid settings
+end
+
+# example model classes
+Dir[File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec', 'models')) + '/*.rb'].sort.each { |f| require File.expand_path(f) }

data/test/unit/minitest_matcher_test.rb

@@ -0,0 +1,80 @@
+require 'minitest_helper'
+
+class StateMachineTest < Minitest::Spec
+
+  let(:simple) { SimpleExample.new }
+  let(:multiple) { SimpleMultipleExample.new }
+
+  describe 'transition_from' do
+    it "works for simple state machines" do
+      simple.must_transition_from :initialised, to: :filled_out, on_event: :fill_out
+      simple.wont_transition_from :initialised, to: :authorised, on_event: :fill_out
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_transition_from :standing, to: :walking, on_event: :walk, on: :move
+      multiple.wont_transition_from :standing, to: :running, on_event: :walk, on: :move
+
+      multiple.must_transition_from :sleeping, to: :processing, on_event: :start, on: :work
+      multiple.wont_transition_from :sleeping, to: :sleeping, on_event: :start, on: :work
+    end
+  end
+
+  describe 'allow_transition_to' do
+    it "works for simple state machines" do
+      simple.must_allow_transition_to :filled_out
+      simple.wont_allow_transition_to :authorised
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_allow_transition_to :walking, on: :move
+      multiple.wont_allow_transition_to :standing, on: :move
+
+      multiple.must_allow_transition_to :processing, on: :work
+      multiple.wont_allow_transition_to :sleeping, on: :work
+    end
+  end
+
+  describe "have_state" do
+    it "works for simple state machines" do
+      simple.must_have_state :initialised
+      simple.wont_have_state :filled_out
+      simple.fill_out
+      simple.must_have_state :filled_out
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_have_state :standing, on: :move
+      multiple.wont_have_state :walking, on: :move
+      multiple.walk
+      multiple.must_have_state :walking, on: :move
+
+      multiple.must_have_state :sleeping, on: :work
+      multiple.wont_have_state :processing, on: :work
+      multiple.start
+      multiple.must_have_state :processing, on: :work
+    end
+  end
+
+  describe "allow_event" do
+    it "works for simple state machines" do
+      simple.must_allow_event :fill_out
+      simple.wont_allow_event :authorise
+      simple.fill_out
+      simple.must_allow_event :authorise
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_allow_event :walk, on: :move
+      multiple.wont_allow_event :hold, on: :move
+      multiple.walk
+      multiple.must_allow_event :hold, on: :move
+
+      multiple.must_allow_event :start, on: :work
+      multiple.wont_allow_event :stop, on: :work
+      multiple.start
+      multiple.must_allow_event :stop, on: :work
+    end
+  end
+
+end