aasm 4.11.1 → 5.2.0

data/spec/unit/subclassing_spec.rb

@@ -13,7 +13,7 @@ describe 'subclassing' do
     expect(SuperClass.aasm.states).not_to include(:foo)
   end
 
-  it "should have the same events as its parent" do
+  it 'should have the same events as its parent' do
     expect(SubClass.aasm.events).to eq(SuperClass.aasm.events)
   end
 
@@ -27,5 +27,20 @@ describe 'subclassing' do
     expect(son.aasm.current_state).to eq(:ended)
   end
 
-end
+  it 'should allow the child to modify its state machine' do
+    son = SubClass.new
+    expect(son.called_after).to eq(nil)
+    son.foo
+    expect(son.called_after).to eq(true)
+    global_callbacks = SubClass.aasm.state_machine.global_callbacks
+    expect(global_callbacks).to_not be_empty
+    expect(global_callbacks[:after_all_transitions]).to eq :after_all_event
+  end
 
+  it 'should not modify the parent state machine' do
+    super_class_event = SuperClass.aasm.events.select { |event| event.name == :foo }.first
+    expect(super_class_event.options).to be_empty
+    expect(SuperClass.aasm.state_machine.global_callbacks).to be_empty
+  end
+
+end

data/spec/unit/timestamps_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'timestamps option' do
+  it 'calls a timestamp setter based on the state name when entering a new state' do
+    object = TimestampsExample.new
+    expect { object.open }.to change { object.opened_at }.from(nil).to(instance_of(::Time))
+  end
+
+  it 'overwrites any previous timestamp if a state is entered repeatedly' do
+    object = TimestampsExample.new
+    object.opened_at = ::Time.new(2000, 1, 1)
+    expect { object.open }.to change { object.opened_at }
+  end
+
+  it 'does nothing if there is no setter matching the new state' do
+    object = TimestampsExample.new
+    expect { object.close }.not_to change { object.closed_at }
+  end
+
+  it 'can be turned off and on' do
+    object = TimestampsExample.new
+    object.class.aasm.state_machine.config.timestamps = false
+    expect { object.open }.not_to change { object.opened_at }
+    object.class.aasm.state_machine.config.timestamps = true
+    expect { object.open }.to change { object.opened_at }
+  end
+
+  it 'calls a timestamp setter when using a named state machine' do
+    object = TimestampsWithNamedMachineExample.new
+    expect { object.open }.to change { object.opened_at }.from(nil).to(instance_of(::Time))
+  end
+end

data/spec/unit/transition_spec.rb

@@ -6,7 +6,7 @@ describe 'transitions' 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.message).to eql("Event 'stop' cannot transition from 'sleeping'.")
       expect(err.object).to eql(process)
       expect(err.event_name).to eql(:stop)
     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