state-fu 0.11.1

data/spec/features/state_and_array_options_accessor_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "extending bindings and transitions with Lathe#helper" do
+
+  include MySpecHelper
+
+  before(:each) do
+    reset!
+    make_pristine_class('Klass')
+
+    @machine = Klass.state_fu_machine do
+      state :normal, :colour => 'green'
+      state :bad,    :colour => 'red'
+      event( :worsen, :colour => 'orange' ) { from :normal => :bad }
+    end
+    @obj = Klass.new
+    @binding       = @obj.state_fu
+
+  end # before
+
+  describe "accessing sprocket options" do
+    describe "state#[]" do
+      it "should return state.options[key]" do
+        @machine.states[:normal][:colour].should == 'green'
+      end
+    end
+    describe "event#[]" do
+      it "should return event.options[key]" do
+        @machine.events[:worsen][:colour].should == 'orange'
+      end
+    end
+
+    describe "state#[]=" do
+      it "should update state.options" do
+        @machine.states[:normal][:flavour] = 'lime'
+        @machine.states[:normal][:flavour].should == 'lime'
+      end
+    end
+    describe "event#[]=" do
+      it "should update event.options" do
+        @machine.events[:worsen][:flavour] = 'orange'
+        @machine.events[:worsen][:flavour].should == 'orange'
+      end
+    end
+
+  end
+end

data/spec/features/transition_boolean_comparison_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+describe "extending bindings and transitions with Lathe#helper" do
+
+  include MySpecHelper
+
+  before(:each) do
+    reset!
+    make_pristine_class('Klass')
+    Klass.class_eval do
+      attr_accessor :ok
+    end
+
+    @machine = Klass.machine do
+      chain "a -a2b-> b -b2c-> c"
+      events.each do |e|
+        e.requires :ok
+      end
+    end
+
+    @obj = Klass.new
+    @binding       = @obj.state_fu
+    @transition    = @obj.state_fu.transition(:a2b)
+  end # before
+
+  #
+  #
+
+  describe StateFu::Transition  do
+    describe "equality" do
+
+      it "should == the current_state" do
+        @transition.should == @transition.current_state
+      end
+
+      it "should != any other state" do
+        @transition.should_not == @transition.target
+      end
+
+      it "should == the current_state_name" do
+        @transition.should == @transition.current_state
+      end
+
+      it "should != any other State's name" do
+        @transition.should_not == @transition.target.name
+      end
+
+      describe "with an unaccepted transition" do
+        before do
+          # stub(@transition).accepted? { false }
+        end
+
+        it "should != true" do
+          @transition.should_not == true
+        end
+
+        it "should == false" do
+          @transition.should == false
+        end
+
+        it "should not === true" do
+          @transition.should_not === true
+        end
+
+        it "should === false" do
+          @transition.should === false
+        end
+        
+        it "should not be nil?" do
+          @transition.nil?.should be_false
+        end
+      end
+
+
+      describe "with an accepted transition" do
+        before do
+          @obj.ok = true
+          @transition.fire!
+          @transition.should be_accepted
+        end
+        it "should == true" do
+          @transition.should == true
+        end
+
+        it "should not == false" do
+          @transition.should_not == false
+        end
+
+        it "should === true" do
+          @transition.should === true
+        end
+
+        it "should not === false" do
+          @transition.should_not === false
+        end
+
+      end
+    end
+
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+begin
+  require 'rr'
+rescue LoadError => e
+  STDERR.puts "The '#{gem_name}' gem is required to run StateFu's specs. Please install it by running (as root):\ngem install #{gem_name}\n\n"
+  exit 1;
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end

data/spec/integration/active_record_persistence_spec.rb

@@ -0,0 +1,202 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe "an ActiveRecord model with StateFu included:" do
+
+  include MySpecHelper
+
+  before(:each) do
+    reset!
+    prepare_active_record() do
+      def self.up
+        create_table :example_records do |t|
+          t.string :name,           :null => false
+          t.string :state_fu_field, :null => false
+          t.string :description
+          t.string :status
+          t.timestamps
+        end
+      end
+    end
+
+    # class ExampleRecord < ActiveRecord::Base
+    make_pristine_class( 'ExampleRecord', ActiveRecord::Base )
+    ExampleRecord.class_eval do
+      validates_presence_of :name
+    end
+    # end class ExampleRecord
+  end
+
+  it "should be a subclass of ActiveRecord::Base" do
+    ExampleRecord.superclass.should == ActiveRecord::Base
+  end
+
+  describe "when the ActiveRecord model has no table yet (eg before migrations)" do
+    before do
+      make_pristine_class('TableMissingClass', ActiveRecord::Base )
+      TableMissingClass.class_eval do
+        state_fu_machine() { }
+      end
+    end
+
+    it "should not raise an error when the persister is instantiated" do
+      lambda { TableMissingClass.columns }.should raise_error
+      lambda { TableMissingClass.state_fu_machine }.should_not raise_error
+    end
+
+  end
+  describe "when the default machine is defined with no field_name specified" do
+    before do
+      ExampleRecord.class_eval do
+        state_fu_machine do
+                              state :initial do
+            event( :change, :to => :final ) { after :save! }
+          end
+        end
+      end
+      @ex = ExampleRecord.new( :name => "exemplar" )
+    end # before
+
+    it "should have an active_record string column 'state_fu_field' " do
+      col = ExampleRecord.columns.detect {|c| c.name == "state_fu_field" }
+      col.type.should == :string
+    end
+
+    describe "calling :save! via an event's after hook" do
+      it "should save the record with the new state persisted via the DB" do
+        @ex.change!
+        @ex.state_fu.name.should == :final
+        @ex.state_fu_field.should == 'final'
+        @ex.reload
+        @ex.state_fu_field.should == 'final'
+        @ex.state_fu.name.should == :final
+      end
+    end
+
+    describe "StateFu::Persistence.active_record_column?" do
+      it "should return true for ExampleRecord, :state_fu_field" do
+        StateFu::Persistence.active_record_column?( ExampleRecord, :state_fu_field ).should == true
+      end
+
+      it "should return true for ExampleRecord, :status" do
+        StateFu::Persistence.active_record_column?( ExampleRecord, :status ).should == true
+      end
+
+      it "should return false for ExampleRecord, :not_a_column" do
+        StateFu::Persistence.active_record_column?( ExampleRecord, :not_a_column ).should == false
+      end
+      it "should not clobber activerecord accessors" do
+        @ex.noodle! rescue nil
+        #        lambda { @ex.description }.should_not raise_error()
+        @ex.description.should be_nil
+        @ex.description= 'foo'
+        @ex.description.should == 'foo'
+      end
+
+      it "should have an active_record string column 'state_fu_field' " do
+        col = ExampleRecord.columns.detect {|c| c.name == "state_fu_field" }
+        col.type.should == :string
+      end
+    end
+
+    it "should have an active_record persister with the default field_name 'state_fu_field' " do
+      @ex.state_fu
+      @ex.state_fu.should be_kind_of( StateFu::Binding )
+      @ex.state_fu.persister.should be_kind_of( StateFu::Persistence::ActiveRecord )
+      @ex.state_fu.persister.field_name.should == :state_fu_field
+    end
+
+
+    # this ensures state_fu initializes the field before create to
+    # satisfy the not null constraint
+    describe "automagic state_fu! before_save filter and validations" do
+
+      it "should call state_fu! before a record is created" do
+        @ex.should be_new_record
+        mock.proxy( @ex ).state_fu!.at_least( 1 ) { }
+        @ex.save!
+      end
+
+      it "should call state_fu! before a record is updated" do
+        @ex.should be_new_record
+        mock.proxy( @ex ).state_fu!.at_least( 1 ) { }
+        @ex.save!
+      end
+
+      it "should fail to save if state_fu! does not instantiate the binding before create" do
+        mock( @ex ).state_fu!.at_least( 1 ) { }
+        lambda { @ex.save! }.should raise_error( ActiveRecord::StatementInvalid )
+        @ex.state_fu_field.should == nil
+      end
+
+      it "should create a record given only a name, with the field set to the initial state" do
+        ex = ExampleRecord.new( :name => "exemplar" )
+        ex.should be_valid
+        ex.state_fu_field.should == nil
+        ex.save!
+        ex.should_not be_new_record
+        ex.state_fu_field.should == 'initial'
+        ex.state_fu.state.name.should == :initial
+      end
+
+      it "should update the field after a transition is completed" do
+        ex = ExampleRecord.create!( :name => "exemplar" )
+        ex.state_fu.state.name.should == :initial
+        ex.state_fu_field.should == 'initial'
+        t = ex.state_fu.change!
+        t.should be_accepted
+        ex.state_fu.state.name.should == :final
+        ex.state_fu_field.should == 'final'
+        ex.attributes['state_fu_field'].should == 'final'
+        ex.save!
+      end
+
+      describe "a saved record whose state is not the default" do
+        before do
+          @r = ExampleRecord.create!( :name => "exemplar" )
+          @r.change!
+          @r.state_fu_field.should == 'final'
+          @r.save!
+        end
+
+        it "should be reconstituted with the correct state" do
+          r = ExampleRecord.find( @r.id )
+          r.state_fu.should be_kind_of( StateFu::Binding )
+          r.state_fu.current_state.should be_kind_of( StateFu::State )
+          r.state_fu.current_state.should == ExampleRecord.state_fu_machine.states[:final]
+        end
+      end # saved record after transition
+
+      describe "when a second machine named :status is defined with :field_name => 'status' " do
+        before do
+          ExampleRecord.state_fu_machine(:status, :field_name => 'status') do
+            event( :go, :from => :initial, :to => :final )
+          end
+          @ex = ExampleRecord.new()
+        end
+
+        it "should have a binding for .status" do
+          @ex.status.should be_kind_of( StateFu::Binding )
+        end
+
+        it "should have an ActiveRecord persister with the field_name :status" do
+          @ex.status.persister.should be_kind_of( StateFu::Persistence::ActiveRecord )
+          @ex.status.persister.field_name.should == :status
+        end
+
+        it "should have a value of nil for the status field before state_fu is called" do
+          @ex.read_attribute('status').should be_nil
+        end
+
+        it "should have the ActiveRecord setter method .status=" do
+          @ex.status= 'damp'
+          @ex.read_attribute(:status).should == 'damp'
+        end
+
+        it "should raise StateFu::InvalidState if the status field is set to a bad value and .status is called" do
+          @ex.status= 'damp'
+          lambda { @ex.status }.should raise_error( StateFu::InvalidStateName )
+        end
+      end
+    end # second machine
+  end   # with before_create filter
+end     # default machine

data/spec/integration/binding_extension_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+module BenchGrinder
+  def snark
+  end
+end
+
+describe "extending StateFu::Lathe" do
+  include MySpecHelper
+
+  describe "helpers" do
+    before do
+      reset!
+      make_pristine_class('Klass')
+      @machine = Klass.state_fu_machine() do
+        state :init
+      end
+    end # before
+
+    describe "lathe.helper" do
+      it "should add the arguments to the machine's collection of helpers" do
+        @machine.should respond_to(:helpers)
+        @machine.helpers.should be_empty
+        @machine.lathe do
+          helper :bench_grinder
+        end
+        @machine.helpers.should_not be_empty
+        @machine.helpers.should include(:bench_grinder)
+      end
+
+      it "should extend the binding with the helper's methods" do
+        @machine.lathe do
+          helper :bench_grinder
+        end
+        @machine.helpers.should include(:bench_grinder)
+        @obj = Klass.new
+        @obj.state_fu.should respond_to(:snark)
+      end
+    end
+  end
+end

data/spec/integration/class_accessor_spec.rb

@@ -0,0 +1,117 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+
+##
+##
+##
+
+describe "A pristine class Klass with StateFu included:" do
+  include MySpecHelper
+  before(:each) do
+    make_pristine_class 'Klass'
+  end
+
+  it "should return a new Machine bound to the class given Klass.state_fu_machine()" do
+    Klass.should respond_to(:state_fu_machine)
+    Klass.state_fu_machine.should be_kind_of(StateFu::Machine)
+    machine = Klass.state_fu_machine
+    Klass.state_fu_machine.should == machine
+  end
+
+  it "should return {} given Klass.state_fu_machines" do
+    Klass.should respond_to(:state_fu_machines)
+    Klass.state_fu_machines.should == {}
+  end
+
+  ##
+  ##
+  ##
+
+  describe "Having called Klass.state_fu_machine() with an empty block:" do
+    before(:each) do
+      Klass.state_fu_machine do
+      end
+    end
+
+    it "should return a StateFu::Machine given Klass.state_fu_machine()" do
+      Klass.should respond_to(:state_fu_machine)
+      Klass.state_fu_machine.should_not be_nil
+      Klass.state_fu_machine.should be_kind_of( StateFu::Machine )
+    end
+
+    it "should return { :default => <StateFu::Machine> } given Klass.state_fu_machines()" do
+      Klass.should respond_to(:state_fu_machines)
+      machines = Klass.state_fu_machines()
+      machines.should be_kind_of(Hash)
+      machines.should_not be_empty
+      machines.length.should == 1
+      machines.keys.should == [StateFu::DEFAULT]
+      machines.values.first.should be_kind_of( StateFu::Machine )
+    end
+
+    describe "Having called Klass.state_fu_machine(:two) with an empty block:" do
+      before(:each) do
+        Klass.state_fu_machine(:two) do
+        end
+      end
+
+      it "should return a StateFu::Machine given Klass.state_fu_machine(:two)" do
+        Klass.should respond_to(:state_fu_machine)
+        Klass.state_fu_machine(:two).should_not be_nil
+        Klass.state_fu_machine(:two).should be_kind_of( StateFu::Machine )
+      end
+
+      it "should return a new Machine given Klass.state_fu_machine(:three)" do
+        Klass.should respond_to(:state_fu_machine)
+        Klass.state_fu_machine(:three).should be_kind_of( StateFu::Machine )
+        three = Klass.state_fu_machine(:three)
+        Klass.state_fu_machines[:three].should == three
+        Klass.state_fu_machine(:three).should == three        
+      end
+
+      it "should return { :default => <StateFu::Machine>, :two => <StateFu::Machine> } given Klass.state_fu_machines()" do
+        Klass.should respond_to(:state_fu_machines)
+        machines = Klass.state_fu_machines()
+        machines.should be_kind_of(Hash)
+        machines.should_not be_empty
+        machines.length.should == 2
+        machines.keys.should include StateFu::DEFAULT
+        machines.keys.should include :two
+        machines.values.length.should == 2
+        machines.values.each { |v| v.should be_kind_of( StateFu::Machine ) }
+      end
+
+      it "should return [DEFAULT, :two] give Klass.state_fu_machines.keys" do
+        Klass.should respond_to(:state_fu_machines)
+        Klass.state_fu_machines.keys.should =~ [StateFu::DEFAULT, :two]
+      end
+    end
+
+    describe "An empty class Child which inherits from Klass" do
+      before() do
+        Object.send(:remove_const, 'Child' ) if Object.const_defined?( 'Child' )
+        class Child < Klass
+        end
+      end
+
+      # sorry, Lamarckism not supported
+      it "does NOT inherit it's parent class' Machines !!" do
+        Child.state_fu_machine.should_not == Klass.state_fu_machine
+      end
+
+      it "should know the Machine after calling Klass.state_fu_machine.bind!( Child )" do
+        Child.state_fu_machine.should_not == Klass.state_fu_machine
+        Klass.state_fu_machine.bind!( Child )
+        Klass.state_fu_machines.should == { StateFu::DEFAULT => Klass.state_fu_machine }
+        Child.state_fu_machine.should == Klass.state_fu_machine
+        Klass.state_fu_machine.bind!( Child, :snoo )
+        Child.state_fu_machines.should == {
+          StateFu::DEFAULT => Klass.state_fu_machine,
+          :snoo            => Klass.state_fu_machine
+        }
+        Child.state_fu_machine(:snoo).should == Klass.state_fu_machine
+      end
+
+    end
+  end
+end