workflow_on_mongoid 0.8.0.3 → 0.8.0.4

data/test/mongoid_test.rb

@@ -0,0 +1,487 @@
+require 'test_helper'
+
+require 'mongoid'
+require 'workflow'
+require 'workflow_on_mongoid'
+
+# redefine this so it works with mongoid!
+def assert_state(title, expected_state, klass = Order)
+  puts 'mongoid assert_state'
+  o = klass.where(:title => title).first
+  assert_equal expected_state, o.send(klass.workflow_column)
+  o
+end
+
+
+class MongoidOrder
+  include Mongoid::Document
+
+  field :title
+
+  include Workflow
+  workflow do
+    state :submitted do
+      event :accept, :transitions_to => :accepted, :meta => {:doc_weight => 8} do |reviewer, args|
+      end
+    end
+    state :accepted do
+      event :ship, :transitions_to => :shipped
+    end
+    state :shipped
+  end
+end
+
+class MongoidLegacyOrder
+  include Mongoid::Document
+
+  field :title
+  field :foo_bar
+
+  include Workflow
+
+  workflow_column :foo_bar # use this legacy database column for persistence
+
+  workflow do
+    state :submitted do
+      event :accept, :transitions_to => :accepted, :meta => {:doc_weight => 8} do |reviewer, args|
+      end
+    end
+    state :accepted do
+      event :ship, :transitions_to => :shipped
+    end
+    state :shipped
+  end
+end
+
+class MongoidImage
+  include Mongoid::Document
+
+  field :title
+  field :status
+
+  include Workflow
+
+  workflow_column :status
+
+  workflow do
+    state :unconverted do
+      event :convert, :transitions_to => :converted
+    end
+    state :converted
+  end
+end
+
+class MongoidSmallImage < MongoidImage
+end
+
+class MongoidSpecialSmallImage < MongoidSmallImage
+end
+
+class MongoidTest < MongoidTestCase
+
+  def setup
+    super
+    MongoidOrder.create!(:title => 'some MongoidOrder', :workflow_state => 'accepted')
+    MongoidLegacyOrder.create!(:title => 'some MongoidOrder', :foo_bar => 'accepted')
+  end
+
+  def assert_state(title, expected_state, klass = MongoidOrder)
+    o = klass.where(:title => title).first
+    assert_equal expected_state, o.send(klass.workflow_column)
+    o
+  end
+
+  test 'immediately save the new workflow_state on state machine transition' do
+    o = assert_state 'some MongoidOrder', 'accepted'
+    assert o.ship!
+    assert_state 'some MongoidOrder', 'shipped'
+  end
+
+  test 'immediately save the new workflow_state on state machine transition with custom column name' do
+    o = assert_state 'some MongoidOrder', 'accepted', MongoidLegacyOrder
+    assert o.ship!
+    assert_state 'some MongoidOrder', 'shipped', MongoidLegacyOrder
+  end
+
+  # There was a bug where calling valid? on the record would cause it to be saved
+  # see https://github.com/bowsersenior/workflow_on_mongoid/pull/3
+  test 'does not save the record when setting initial state' do
+    new_order = MongoidOrder.new
+    assert new_order.new_record?
+
+    new_order.valid?
+    assert new_order.new_record?
+  end
+
+  test 'persist workflow_state in the db and reload' do
+    o = assert_state 'some MongoidOrder', 'accepted'
+    assert_equal :accepted, o.current_state.name
+    o.ship!
+    o.save!
+
+    assert_state 'some MongoidOrder', 'shipped'
+
+    o.reload
+    assert_equal 'shipped', o.send(:workflow_state)
+  end
+
+  test 'persist workflow_state in the db with_custom_name and reload' do
+    o = assert_state 'some MongoidOrder', 'accepted', MongoidLegacyOrder
+    assert_equal :accepted, o.current_state.name
+    o.ship!
+    o.save!
+
+    assert_state 'some MongoidOrder', 'shipped', MongoidLegacyOrder
+
+    o.reload
+    assert_equal 'shipped', o.send(:foo_bar)
+  end
+
+  test 'default workflow column should be workflow_state' do
+    o = assert_state 'some MongoidOrder', 'accepted'
+    assert_equal :workflow_state, o.class.workflow_column
+  end
+
+  test 'custom workflow column should be foo_bar' do
+    o = assert_state 'some MongoidOrder', 'accepted', MongoidLegacyOrder
+    assert_equal :foo_bar, o.class.workflow_column
+  end
+
+  test 'access workflow specification' do
+    assert_equal 3, MongoidOrder.workflow_spec.states.length
+    assert_equal ['submitted', 'accepted', 'shipped'].sort,
+      MongoidOrder.workflow_spec.state_names.map{|n| n.to_s}.sort
+  end
+
+  test 'current state object' do
+    o = assert_state 'some MongoidOrder', 'accepted'
+    assert_equal 'accepted', o.current_state.to_s
+    assert_equal 1, o.current_state.events.length
+  end
+
+  test 'on_entry and on_exit invoked' do
+    c = Class.new
+    callbacks = mock()
+    callbacks.expects(:my_on_exit_new).once
+    callbacks.expects(:my_on_entry_old).once
+    c.class_eval do
+      include Workflow
+      workflow do
+        state :new do
+          event :age, :transitions_to => :old
+        end
+        on_exit do
+          callbacks.my_on_exit_new
+        end
+        state :old
+        on_entry do
+          callbacks.my_on_entry_old
+        end
+        on_exit do
+          fail "wrong on_exit executed"
+        end
+      end
+    end
+
+    o = c.new
+    assert_equal 'new', o.current_state.to_s
+    o.age!
+  end
+
+  test 'on_transition invoked' do
+    callbacks = mock()
+    callbacks.expects(:on_tran).once # this is validated at the end
+    c = Class.new
+    c.class_eval do
+      include Workflow
+      workflow do
+        state :one do
+          event :increment, :transitions_to => :two
+        end
+        state :two
+        on_transition do |from, to, triggering_event, *event_args|
+          callbacks.on_tran
+        end
+      end
+    end
+    assert_not_nil c.workflow_spec.on_transition_proc
+    c.new.increment!
+  end
+
+  test 'access event meta information' do
+    c = Class.new
+    c.class_eval do
+      include Workflow
+      workflow do
+        state :main, :meta => {:importance => 8}
+        state :supplemental, :meta => {:importance => 1}
+      end
+    end
+    assert_equal 1, c.workflow_spec.states[:supplemental].meta[:importance]
+  end
+
+  test 'initial state' do
+    c = Class.new
+    c.class_eval do
+      include Workflow
+      workflow { state :one; state :two }
+    end
+    assert_equal 'one', c.new.current_state.to_s
+  end
+
+  test 'nil as initial state' do
+    MongoidOrder.create!(:title => 'nil state', :workflow_state => nil)
+    o = MongoidOrder.where(:title =>'nil state').first
+    assert o.submitted?, 'if workflow_state is nil, the initial state should be assumed'
+    assert !o.shipped?
+  end
+
+  test 'initial state immediately set for new objects' do
+    o = MongoidOrder.create(:title => 'new object')
+    assert_equal 'submitted', o.send(:workflow_state)
+  end
+
+  test 'question methods for state' do
+    o = assert_state 'some MongoidOrder', 'accepted'
+    assert o.accepted?
+    assert !o.shipped?
+  end
+
+  test 'correct exception for event that is not allowed in current state' do
+    o = assert_state 'some MongoidOrder', 'accepted'
+
+    assert_raise Workflow::NoTransitionAllowed do
+      o.accept!
+    end
+  end
+
+  test 'multiple events with the same name and different arguments lists from different states'
+
+  test 'implicit transition callback' do
+    args = mock()
+    args.expects(:my_tran).once # this is validated at the end
+    c = Class.new
+    c.class_eval do
+      include Workflow
+      def my_transition(args)
+        args.my_tran
+      end
+      workflow do
+        state :one do
+          event :my_transition, :transitions_to => :two
+        end
+        state :two
+      end
+    end
+    c.new.my_transition!(args)
+  end
+
+  test 'Single table inheritance (STI)' do
+    class BigMongoidOrder < MongoidOrder
+    end
+
+    bo = BigMongoidOrder.new
+    assert bo.submitted?
+    assert !bo.accepted?
+  end
+
+  test 'STI when parent changed the workflow_state column' do
+    assert_equal 'status', MongoidImage.workflow_column.to_s
+    assert_equal 'status', MongoidSmallImage.workflow_column.to_s
+    assert_equal 'status', MongoidSpecialSmallImage.workflow_column.to_s
+  end
+
+  test 'Two-level inheritance' do
+    class BigMongoidOrder < MongoidOrder
+    end
+
+    class EvenBiggerMongoidOrder < BigMongoidOrder
+    end
+
+    assert EvenBiggerMongoidOrder.new.submitted?
+  end
+
+  test 'Iheritance with workflow definition override' do
+    class BigMongoidOrder < MongoidOrder
+    end
+
+    class SpecialBigMongoidOrder < BigMongoidOrder
+      workflow do
+        state :start_big
+      end
+    end
+
+    special = SpecialBigMongoidOrder.new
+    assert_equal 'start_big', special.current_state.to_s
+  end
+
+  test 'Better error message for missing target state' do
+    class Problem
+      include Workflow
+      workflow do
+        state :initial do
+          event :solve, :transitions_to => :solved
+        end
+      end
+    end
+    assert_raise Workflow::WorkflowError do
+      Problem.new.solve!
+    end
+  end
+
+  # Intermixing of transition graph definition (states, transitions)
+  # on the one side and implementation of the actions on the other side
+  # for a bigger state machine can introduce clutter.
+  #
+  # To reduce this clutter it is now possible to use state entry- and
+  # exit- hooks defined through a naming convention. For example, if there
+  # is a state :pending, then you can hook in by defining method
+  # `def on_pending_exit(new_state, event, *args)` instead of using a
+  # block:
+  #
+  #     state :pending do
+  #       on_entry do
+  #         # your implementation here
+  #       end
+  #     end
+  #
+  # If both a function with a name according to naming convention and the
+  # on_entry/on_exit block are given, then only on_entry/on_exit block is used.
+  test 'on_entry and on_exit hooks in separate methods' do
+    c = Class.new
+    c.class_eval do
+      include Workflow
+      attr_reader :history
+      def initialize
+        @history = []
+      end
+      workflow do
+        state :new do
+          event :next, :transitions_to => :next_state
+        end
+        state :next_state
+      end
+
+      def on_next_state_entry(prior_state, event, *args)
+        @history << "on_next_state_entry #{event} #{prior_state} ->"
+      end
+
+      def on_new_exit(new_state, event, *args)
+        @history << "on_new_exit #{event} -> #{new_state}"
+      end
+    end
+
+    o = c.new
+    assert_equal 'new', o.current_state.to_s
+    assert_equal [], o.history
+    o.next!
+    assert_equal ['on_new_exit next -> next_state', 'on_next_state_entry next new ->'], o.history
+
+  end
+
+  test 'diagram generation' do
+    begin
+      $stdout = StringIO.new('', 'w')
+      Workflow::create_workflow_diagram(MongoidOrder, 'doc')
+      assert_match(/open.+\.pdf/, $stdout.string,
+        'PDF should be generate and a hint be given to the user.')
+    ensure
+      $stdout = STDOUT
+    end
+  end
+
+  test 'halt stops the transition' do
+    c = Class.new do
+      include Workflow
+      workflow do
+        state :young do
+          event :age, :transitions_to => :old
+        end
+        state :old
+      end
+
+      def age(by=1)
+        halt 'too fast' if by > 100
+      end
+    end
+
+    joe = c.new
+    assert joe.young?
+    joe.age! 120
+    assert joe.young?, 'Transition should have been halted'
+    assert_equal 'too fast', joe.halted_because
+  end
+
+  test 'halt! raises exception immediately' do
+    article_class = Class.new do
+      include Workflow
+      attr_accessor :too_far
+      workflow do
+        state :new do
+          event :reject, :transitions_to => :rejected
+        end
+        state :rejected
+      end
+
+      def reject(reason)
+        halt! 'We do not reject articles unless the reason is important' \
+          unless reason =~ /important/i
+        self.too_far = "This line should not be executed"
+      end
+    end
+
+    article = article_class.new
+    assert article.new?
+    assert_raise Workflow::TransitionHalted do
+      article.reject! 'Too funny'
+    end
+    assert_nil article.too_far
+    assert article.new?, 'Transition should have been halted'
+    article.reject! 'Important: too short'
+    assert article.rejected?, 'Transition should happen now'
+  end
+
+  # published gem doesn't have the `can_?` methods yet!
+  # test 'can fire event?' do
+  #   c = Class.new do
+  #     include Workflow
+  #     workflow do
+  #       state :newborn do
+  #         event :go_to_school, :transitions_to => :schoolboy
+  #       end
+  #       state :schoolboy do
+  #         event :go_to_college, :transitions_to => :student
+  #       end
+  #       state :student
+  #     end
+  #   end
+  #
+  #   human = c.new
+  #   assert human.can_go_to_school?
+  #   assert_equal false, human.can_go_to_college?
+  # end
+
+  test 'workflow graph generation' do
+    Dir.chdir('tmp') do
+      capture_streams do
+        Workflow::create_workflow_diagram(MongoidOrder)
+      end
+    end
+  end
+
+  test 'workflow graph generation in path with spaces' do
+    `mkdir -p '/tmp/Workflow test'`
+    capture_streams do
+      Workflow::create_workflow_diagram(MongoidOrder,  '/tmp/Workflow test')
+    end
+  end
+
+  def capture_streams
+    old_stdout = $stdout
+    $stdout = captured_stdout = StringIO.new
+    yield
+    $stdout = old_stdout
+    captured_stdout
+  end
+
+end

data/test/multiple_workflows_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+unless RUBY_VERSION =~ /^1\.9/ 
+  class MultipleWorkflowsTest < ActiveRecordTestCase
+
+    test 'multiple workflows' do
+
+      ActiveRecord::Schema.define do
+        create_table :bookings do |t|
+          t.string :title, :null => false
+          t.string :workflow_state
+          t.string :workflow_type
+        end
+      end
+
+      exec "INSERT INTO bookings(title, workflow_state, workflow_type) VALUES('booking1', 'initial', 'workflow_1')"
+      exec "INSERT INTO bookings(title, workflow_state, workflow_type) VALUES('booking2', 'initial', 'workflow_2')"
+
+      class Booking < ActiveRecord::Base
+        def initialize_workflow
+          # define workflow per object instead of per class
+          case workflow_type
+          when 'workflow_1'
+            class << self
+              include Workflow
+              workflow do
+                state :initial do
+                  event :progress, :transitions_to => :last
+                end
+                state :last
+              end
+            end
+          when 'workflow_2'
+            class << self
+              include Workflow
+              workflow do
+                state :initial do
+                  event :progress, :transitions_to => :intermediate
+                end
+                state :intermediate
+                state :last
+              end
+            end
+          end
+        end
+
+        def metaclass; class << self; self; end; end
+
+        def workflow_spec
+          metaclass.workflow_spec
+        end
+
+      end
+
+      booking1 = Booking.find_by_title('booking1')
+      booking1.initialize_workflow
+
+      booking2 = Booking.find_by_title('booking2')
+      booking2.initialize_workflow
+
+      assert booking1.initial?
+      booking1.progress!
+      assert booking1.last?, 'booking1 should transition to the "last" state'
+
+      assert booking2.initial?
+      booking2.progress!
+      assert booking2.intermediate?, 'booking2 should transition to the "intermediate" state'
+
+      assert booking1.workflow_spec, 'can access the individual workflow specification'
+      assert_equal 2, booking1.workflow_spec.states.length
+      assert_equal 3, booking2.workflow_spec.states.length
+    end
+
+    class Object
+      # The hidden singleton lurks behind everyone
+      def metaclass; class << self; self; end; end
+    end
+
+  end
+end

data/test/readme_example.rb

@@ -0,0 +1,37 @@
+require 'workflow'
+class Article
+  include Workflow
+  workflow do
+    state :new do
+      event :submit, :transitions_to => :awaiting_review
+    end
+    state :awaiting_review do
+      event :review, :transitions_to => :being_reviewed
+    end
+    state :being_reviewed do
+      event :accept, :transitions_to => :accepted
+      event :reject, :transitions_to => :rejected
+    end
+    state :accepted
+    state :rejected
+  end
+end
+
+article = Article.new
+article.accepted? # => false
+article.new? # => true
+article.submit!
+article.review!
+
+puts article.current_state # => being_reviewed
+
+
+class Article
+  def reject
+    puts "send email to the author here explaining the reason for the rejection"
+  end
+end
+
+article.reject! # will cause a state transition, would persist the new
+  # state (if inherited from ActiveRecord), and invoke the callback -
+  # send email to the author.

data/test/test_helper.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'test/unit'
+require 'active_record'
+require 'workflow_on_mongoid'
+
+class << Test::Unit::TestCase
+  def test(name, &block)
+    test_name = :"test_#{name.gsub(' ','_')}"
+    raise ArgumentError, "#{test_name} is already defined" if self.instance_methods.include? test_name.to_s
+    if block
+      define_method test_name, &block
+    else
+      puts "PENDING: #{name}"
+    end
+  end
+end
+
+class ActiveRecordTestCase < Test::Unit::TestCase
+  def exec(sql)
+    ActiveRecord::Base.connection.execute sql
+  end
+
+  def setup
+    ActiveRecord::Base.establish_connection(
+      :adapter => "sqlite3",
+      :database  => ":memory:" #"tmp/test"
+    )
+
+    # eliminate ActiveRecord warning. TODO: delete as soon as ActiveRecord is fixed
+    ActiveRecord::Base.connection.reconnect!
+  end
+
+  def teardown
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  def default_test
+  end
+end
+
+require 'mongoid'
+class MongoidTestCase < Test::Unit::TestCase
+  Mongoid.configure do |config|
+    config.master = Mongo::Connection.new('127.0.0.1', 27017).db("workflow_on_mongoid")
+  end
+
+  def teardown
+    Mongoid.master.collections.select do |collection|
+      collection.name !~ /system/
+    end.each(&:drop)    
+  end
+  
+  def default_test; end
+end

data/test/without_active_record_test.rb

@@ -0,0 +1,57 @@
+# require File.join(File.dirname(__FILE__), 'test_helper')
+
+require 'test_helper'
+
+require 'workflow'
+
+class WithoutWorkflowTest < Test::Unit::TestCase
+  class Article
+    include Workflow
+    workflow do
+      state :new do
+        event :submit, :transitions_to => :awaiting_review
+      end
+      state :awaiting_review do
+        event :review, :transitions_to => :being_reviewed
+      end
+      state :being_reviewed do
+        event :accept, :transitions_to => :accepted
+        event :reject, :transitions_to => :rejected
+      end
+      state :accepted
+      state :rejected
+    end
+  end
+
+  def test_readme_example_article
+    article = Article.new
+    assert article.new?
+  end
+
+  test 'better error message on transitions_to typo' do
+    assert_raise Workflow::WorkflowDefinitionError do
+      Class.new do
+        include Workflow
+        workflow do
+          state :new do
+            event :event1, :transitionnn => :next # missing transitions_to target
+          end
+          state :next
+        end
+      end
+    end
+  end
+
+  test 'check transition_to alias' do
+    Class.new do
+      include Workflow
+      workflow do
+        state :new do
+          event :event1, :transition_to => :next
+        end
+        state :next
+      end
+    end
+  end
+end
+