golem_statemachine 0.9

data/test/problematic_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+require 'ruby-debug'
+
+# Tests specifically designed to address bugs/problems discovered along the way.
+class ProblematicTest < Test::Unit::TestCase
+
+  def setup
+    @klass = Class.new
+    @klass.instance_eval do
+      include Golem
+    end
+  end
+
+  def test_fire_event_for_multiple_statemachines
+    
+    @klass.instance_eval do
+      define_statemachine(:engine) do
+        initial_state :stopped
+        state :stopped do
+          on :start, :to => :idle
+        end
+        state :idle do
+          on :start, :to => :running
+        end
+      end
+      define_statemachine(:fan) do
+        initial_state :stopped
+        state :stopped do
+          on :start, :to => :spinning
+        end
+      end
+    end
+
+    widget = @klass.new
+    
+    assert_equal :stopped, widget.engine_state
+    assert_equal :stopped, widget.fan_state
+
+    widget.start
+    
+    assert_equal :idle, widget.engine_state
+    assert_equal :spinning, widget.fan_state
+
+    assert_nothing_raised do
+      # :fan will raise Golem::ImpossibleEvent, but :engine can proceed, so nothing is raised
+      widget.start!
+    end
+
+    assert_equal :running, widget.engine_state
+    assert_equal :spinning, widget.fan_state
+
+    assert !widget.start
+
+    assert_raise(Golem::ImpossibleEvent) do
+      # neither :fan nor :engine can proceed
+      widget.start!
+    end
+
+    assert !widget.start
+  end
+
+  def test_fire_entry_action_on_initial_state
+    @klass.instance_eval do
+      class_eval do
+        attr_accessor :off
+      end
+      
+      define_statemachine(:engine) do
+        initial_state :stopped
+        state :stopped do
+          enter do |engine|
+            engine.off = true
+          end
+          on :start, :to => :idle
+        end
+        state :idle do
+          enter do |engine|
+            engine.off = false
+          end
+          on :start, :to => :running
+        end
+      end
+    end
+
+    widget = @klass.new
+
+    assert_equal :stopped, widget.engine_state
+    assert_equal true, widget.off
+
+    widget.start!
+
+    assert_equal false, widget.off
+  end
+end
+

data/test/seminar_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+require File.dirname(__FILE__)+'/../examples/seminar'
+
+# Test the seminar.rb example.
+class SeminarTest < Test::Unit::TestCase
+
+  def setup
+    @seminar = Seminar.new
+    Seminar.output = File.open("#{self.class.name}_#{self.method_name}.log", 'w')
+  end
+
+  def test_initial_status
+    assert_equal :proposed, @seminar.statemachine.initial_state
+  end
+
+  def test_open_for_enrollment
+    @seminar.max_class_size = 3
+
+    @seminar.schedule
+    @seminar.open
+
+    assert_equal :open_for_enrollment, @seminar.status
+
+    @seminar.enroll_student("socrates")
+    @seminar.enroll_student("plato")
+
+    assert_equal :open_for_enrollment, @seminar.status
+
+    @seminar.drop_student("socrates")
+
+    assert_equal :open_for_enrollment, @seminar.status
+    assert_equal ["plato"], @seminar.students
+
+    @seminar.enroll_student("aristotle")
+    @seminar.enroll_student("socrates")
+
+    assert_equal :full, @seminar.status
+
+    @seminar.drop_student("plato")
+
+    assert_equal :open_for_enrollment, @seminar.status
+    assert_equal ["aristotle", "socrates"], @seminar.students
+
+    @seminar.enroll_student("zeno")
+
+    assert_equal :full, @seminar.status
+
+    @seminar.cancel
+
+    assert_equal :cancelled, @seminar.status
+    @seminar.students.each do |student|
+      assert @seminar.notifications_sent.include?("#{student}: the seminar has been cancelled")
+    end
+  end
+
+  def test_full
+    @seminar.max_class_size = 3
+
+    @seminar.schedule
+    @seminar.open
+    
+    @seminar.enroll_student("socrates")
+    @seminar.enroll_student("plato")
+    @seminar.enroll_student("aristotle")
+
+    assert_equal :full, @seminar.status
+
+    @seminar.enroll_student("zeno")
+    
+    assert_equal :full, @seminar.status
+    assert_equal ["socrates", "plato", "aristotle"], @seminar.students
+    assert_equal ["zeno"], @seminar.waiting_list
+
+    @seminar.enroll_student("sofia")
+
+    assert_equal :full, @seminar.status
+    assert_equal ["socrates", "plato", "aristotle"], @seminar.students
+    assert_equal ["zeno", "sofia"], @seminar.waiting_list
+
+    @seminar.drop_student("socrates")
+
+    assert_equal :full, @seminar.status
+    assert_equal ["plato", "aristotle", "zeno"], @seminar.students
+    assert_equal ["sofia"], @seminar.waiting_list
+
+    @seminar.drop_student("aristotle")
+
+    assert_equal :full, @seminar.status
+    assert_equal ["plato", "zeno", "sofia"], @seminar.students
+    assert_equal [], @seminar.waiting_list
+
+    @seminar.enroll_student("dennett")
+
+    assert_equal :full, @seminar.status
+    assert_equal ["plato", "zeno", "sofia"], @seminar.students
+    assert_equal ["dennett"], @seminar.waiting_list
+
+    @seminar.cancel
+
+    assert_equal :cancelled, @seminar.status
+    (@seminar.students + @seminar.waiting_list).each do |student|
+      assert @seminar.notifications_sent.include?("#{student}: the seminar has been cancelled")
+    end
+  end
+end
+

data/test/statemachine_assertions.rb

@@ -0,0 +1,79 @@
+module StatemachineAssertions
+  def assert_equal_arrays(arr1, arr2)
+    assert_equal [], arr1 - arr2, "array #{arr1} is not equal to array #{arr2}"
+  end
+
+  def assert_transition_on_event(statemachine, event, from_state, to_state)
+    from_state = statemachine.states[from_state]
+    to_state   = statemachine.states[to_state]
+    event      = statemachine.events[event]
+
+    assert_not_nil from_state
+    assert_not_nil to_state
+    assert_not_nil event
+
+    failure_msg =  "#{statemachine} does not have a transition from #{from_state.name.inspect} to #{to_state.name.inspect} on event #{event.name.inspect}"
+    failure_msg << "\n\tHas: #{from_state.transitions_on_event[event].collect{|tr| tr.to_s}.join("\n")}"
+
+
+    assert from_state.transitions_on_event[event].any?{|tr| tr.from == from_state && tr.to == to_state}, failure_msg
+  end
+
+  def assert_no_transition_on_event(statemachine, event, from_state, to_state)
+    from_state = statemachine.states[from_state]
+    to_state   = statemachine.states[to_state]
+    event      = statemachine.events[event]
+
+    assert_not_nil from_state
+    assert_not_nil to_state
+    assert_not_nil event
+
+    failure_msg =  "#{statemachine} should not have a transition from #{from_state.name.inspect} to #{to_state.name.inspect} on event #{event.name.inspect}"
+
+    assert !from_state.transitions_on_event[event].any?{|tr| tr.from == from_state && tr.to == to_state}, failure_msg
+  end
+
+  def assert_transition_on_event_has_callback(statemachine, event, from_state, to_state, callback, callback_method = nil)
+    from_state = statemachine.states[from_state]
+    to_state   = statemachine.states[to_state]
+    event      = statemachine.events[event]
+
+    assert_transition_on_event(statemachine, event, from_state, to_state)
+
+    tr = from_state.transitions_on_event[event].find{|tr| tr.to == to_state}
+
+    failure_msg =  "#{tr.to_s.inspect} does not have an #{callback.inspect} callback"
+
+    assert_not_nil tr.callbacks[callback], failure_msg
+
+    assert_equal callback_method, tr.callbacks[callback].callback if callback_method
+  end
+
+  def assert_transition_on_event_has_guard(statemachine, event, from_state, to_state, guard)
+    from_state = statemachine.states[from_state]
+    to_state   = statemachine.states[to_state]
+    event      = statemachine.events[event]
+
+    assert_transition_on_event(statemachine, event, from_state, to_state)
+
+    tr = from_state.transitions_on_event[event].find{|tr| tr.to == to_state}
+
+    failure_msg =  "#{tr.to_s.inspect} does not have #{guard.inspect} as a guard condition"
+
+    assert tr.guards.collect{|g| g.callback}.include?(guard), failure_msg
+  end
+
+  def assert_transition_on_event_does_not_have_guard(statemachine, event, from_state, to_state, guard)
+    from_state = statemachine.states[from_state]
+    to_state   = statemachine.states[to_state]
+    event      = statemachine.events[event]
+
+    assert_transition_on_event(statemachine, event, from_state, to_state)
+
+    tr = from_state.transitions_on_event[event].find{|tr| tr.to == to_state}
+
+    failure_msg =  "#{tr.to_s.inspect} should not have #{guard.inspect} as a guard condition"
+
+    assert !tr.guards.collect{|g| g.callback}.include?(guard), failure_msg
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+
+$: << File.dirname(__FILE__)+'/../lib'
+
+require 'golem'

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: golem_statemachine
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  version: "0.9"
+platform: ruby
+authors: 
+- Matt Zukowski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Adds finite state machine behaviour to Ruby classes. Meant as an alternative to acts_as_state_machine/AASM.
+email: 
+- matt@roughest.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- examples/document.rb
+- examples/monster.rb
+- examples/seminar.rb
+- examples/seminar_enrollment.rb
+- init.rb
+- install.rb
+- lib/golem.rb
+- lib/golem/dsl/decision_def.rb
+- lib/golem/dsl/event_def.rb
+- lib/golem/dsl/state_def.rb
+- lib/golem/dsl/state_machine_def.rb
+- lib/golem/dsl/transition_def.rb
+- lib/golem/model/callback.rb
+- lib/golem/model/condition.rb
+- lib/golem/model/event.rb
+- lib/golem/model/state.rb
+- lib/golem/model/state_machine.rb
+- lib/golem/model/transition.rb
+- lib/golem/util/element_collection.rb
+- tasks/golem_statemachine_tasks.rake
+- test/active_record_test.rb
+- test/dsl_test.rb
+- test/monster_test.rb
+- test/problematic_test.rb
+- test/seminar_test.rb
+- test/statemachine_assertions.rb
+- test/test.db
+- test/test_helper.rb
+- uninstall.rb
+homepage: http://github.com/zuk/golem_statemachine
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- Golem Statmeachine Docs
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README.rdoc
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Adds finite state machine behaviour to Ruby classes.
+test_files: []
+