davidlee-state-fu 0.0.1

data/spec/integration/class_accessor_spec.rb

@@ -0,0 +1,127 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+StateFu::FuSpace.reset!
+
+##
+##
+##
+
+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.machine()" do
+    Klass.should respond_to(:machine)
+    Klass.machine.should be_kind_of(StateFu::Machine)
+    machine = Klass.machine
+    Klass.machine.should == machine
+  end
+
+  it "should return {} given Klass.machines()" do
+    Klass.should respond_to(:machines)
+    Klass.machines.should == {}
+  end
+
+  it "should return [] given Klass.machine_names()" do
+    Klass.should respond_to(:machine_names)
+    Klass.machine_names.should == []
+  end
+
+  ##
+  ##
+  ##
+
+  describe "Having called Klass.machine() with an empty block:" do
+    before(:each) do
+      Klass.machine do
+      end
+      StateFu::DEFAULT_MACHINE.should == :state_fu
+    end
+
+    it "should return a StateFu::Machine given Klass.machine()" do
+      Klass.should respond_to(:machine)
+      Klass.machine.should_not be_nil
+      Klass.machine.should be_kind_of( StateFu::Machine )
+    end
+
+    it "should return { :state_fu => <StateFu::Machine> } given Klass.machines()" do
+      Klass.should respond_to(:machines)
+      machines = Klass.machines()
+      machines.should be_kind_of(Hash)
+      machines.should_not be_empty
+      machines.length.should == 1
+      machines.keys.should == [:state_fu]
+      machines.values.first.should be_kind_of( StateFu::Machine )
+    end
+
+    it "should returns [:state_fu] given Klass.machine_names()" do
+      Klass.should respond_to(:machine_names)
+      Klass.machine_names.should == [:state_fu]
+    end
+
+    describe "Having called Klass.machine(:two) with an empty block:" do
+      before(:each) do
+        Klass.machine(:two) do
+        end
+      end
+
+      it "should return a StateFu::Machine given Klass.machine(:two)" do
+        Klass.should respond_to(:machine)
+        Klass.machine(:two).should_not be_nil
+        Klass.machine(:two).should be_kind_of( StateFu::Machine )
+      end
+
+      it "should return a new Machine given Klass.machine(:three)" do
+        Klass.should respond_to(:machine)
+        Klass.machine(:three).should be_kind_of( StateFu::Machine )
+        three = Klass.machine(:three)
+        Klass.machine(:three).should == three
+        # StateFu::FuSpace.class_machines[Klass][:three].should == :three
+      end
+
+      it "should return { :state_fu => <StateFu::Machine>, :two => <StateFu::Machine> } given Klass.machines()" do
+        Klass.should respond_to(:machines)
+        machines = Klass.machines()
+        machines.should be_kind_of(Hash)
+        machines.should_not be_empty
+        machines.length.should == 2
+        machines.keys.should include :state_fu
+        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 [:state_fu, :two] give Klass.machine_names (unordered)" do
+        Klass.should respond_to(:machine_names)
+        Klass.machine_names.length.should == 2
+        Klass.machine_names.should include :state_fu
+        Klass.machine_names.should include :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.machine.should_not == Klass.machine
+      end
+
+      it "should know the Machine after calling Klass.machine.bind!( Child )" do
+        Child.machine.should_not == Klass.machine
+        Klass.machine.bind!( Child )
+        Child.machine.should == Klass.machine
+        Klass.machine.bind!( Child, :snoo )
+        Child.machine(:snoo).should == Klass.machine
+
+      end
+
+    end
+  end
+end

data/spec/integration/event_definition_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+describe "Adding events to a Machine outside a state block" do
+
+  include MySpecHelper
+
+  describe "When there is an empty machine" do
+    before do
+      reset!
+      make_pristine_class 'Klass'
+      Klass.machine() { }
+    end
+
+    describe "calling Klass.machine().events" do
+      it "should return []" do
+        Klass.machine().events.should == []
+      end
+    end
+
+    describe "calling event(:die){ from :dead, :to => :alive } in a Klass.machine()" do
+      before do
+        Klass.machine do
+          event :die do # arity == 0
+            from :dead, :to => :alive
+          end
+        end
+      end
+
+      it "should require a name when calling machine.event()" do
+        lambda { Klass.machine(){ event {} } }.should raise_error(ArgumentError)
+      end
+
+      it "should add 2 states to the machine called: [:dead, :alive] " do
+        Klass.machine.state_names.should == [:dead, :alive]
+        Klass.machine.states.length.should == 2
+        Klass.machine.states.each { |s| s.should be_kind_of(StateFu::State) }
+        Klass.machine.states.map(&:name).sort.should == [:alive, :dead]
+      end
+
+      describe "the <StateFu::Event> created" do
+        it "should be accessible through Klass.machine.events" do
+          Klass.machine.events.should be_kind_of(Array)
+          Klass.machine.events.length.should == 1
+          Klass.machine.events.first.should be_kind_of( StateFu::Event )
+          Klass.machine.events.first.name.should == :die
+        end
+      end
+
+    end
+
+    # arity of blocks is optional, thanks to magic fairy dust ;)
+    describe "calling event(:die){ |s| s.from :dead, :to => :alive } in a Klass.machine()" do
+      before do
+        Klass.machine do
+          event :die do |s|
+            s.from :dead, :to => :alive
+          end
+        end
+      end
+
+      it "should add 2 states to the machine called [:dead, :alive] " do
+        Klass.machine.state_names.should == [:dead, :alive]
+        Klass.machine.states.length.should == 2
+        Klass.machine.states.each { |s| s.should be_kind_of( StateFu::State ) }
+      end
+    end
+
+  end
+end
+

data/spec/integration/ex_machine_for_accounts_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+describe "A simple Machine definition" do
+
+  include MySpecHelper
+
+  describe "When there is a machine describing user logins" do
+    before(:all) do
+      reset!
+      make_pristine_class 'Klass'
+
+      # TODO
+      #
+      # Method proxy:
+      # @obj.om.helpers[:method_name] => proc
+      # look for methods first on obj
+      # then in on the helper
+      # before raising a method_missing error.
+      #
+      # when executing methods from the helper,
+      # use method(mname) to convert them into something
+      # we can instance_eval in the context of our machinist instance :)
+      #
+      # maybe. or maybe that's just sick.
+
+      # @machine_spec = lambda do
+        Klass.machine( :method_proxy => true ) do
+
+          states :new, :active, :limbo, :expired, :deleted
+
+          event :confirm do
+            from :new, :to => :confirmed, :auto => true do
+              needs :email_confirmation
+            end
+          end
+
+          state :confirmed do
+            on_entry :send_welcome_email
+          end
+
+          event :login, :from => [:confirmed, :active], :to => :active do
+            execute :handle_login do
+              halt_unless :password_correct?
+              halt_if     :dodgy_user_agent?
+              obj.generate_new_cookie!
+            end
+          end
+
+          state :active do
+            on_entry :popup_banner_ads_everywhere
+          end
+
+          event :delete do
+            from :ALL, :except => :deleted
+            to :deleted
+            after do
+              obj.destroy!
+            end
+          end
+
+          states :ALL do
+            accepted(:save!)
+          end
+
+        end
+      end # machine
+    # end # before
+
+    # it "parsing it should not throw an error"
+      # @machine_spec.should_not raise_error()
+      # @machine_spec.call()
+
+
+  end # describe_1
+end

data/spec/integration/example_01_document_spec.rb

@@ -0,0 +1,127 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require 'activerecord'
+
+describe "Document" do
+  include MySpecHelper
+  before do
+    reset!
+    prepare_active_record do
+      def self.up
+        create_table :documents do |t|
+          t.string :name
+          t.string :author
+          t.string :status_field
+        end
+      end
+    end
+    make_pristine_class('Document', ActiveRecord::Base )
+    Document.class_eval do
+      include StateFu
+
+      attr_accessor :author
+
+      def update_rss
+        # puts "new feed!"
+      end
+
+      machine( :status ) do
+        state :draft do
+          event :publish, :to => :published
+        end
+
+        state :published do
+          on_entry :update_rss
+          requires :author
+        end
+
+        event :delete, :from => :ALL, :to => :deleted do
+          execute :destroy
+        end
+
+        events do
+          after :save!
+        end
+      end
+    end
+
+    @doc = Document.new
+    # @doc.status
+    end
+
+  describe "a new document with no attributes" do
+
+    it "should have a status.name of :draft" do
+      @doc.status.name.should == :draft
+    end
+
+    it "should have no author" do
+      @doc.author.should be_nil
+    end
+
+    it "should raise a RequirementError when publish! is called" do
+      lambda { @doc.status.publish! }.should raise_error( StateFu::RequirementError )
+      begin
+        @doc.status.publish!
+      rescue StateFu::RequirementError => e
+        e.message.should =~ /[:author]/
+      end
+    end
+  end
+
+  describe "a new document with an author" do
+    before do
+      @doc.author = "Susan"
+    end
+
+    it "should have a status.name of :draft" do
+      @doc.status.name.should == :draft
+    end
+
+    it "should have an author" do
+      @doc.author.should_not be_nil
+    end
+
+    it "should not raise an error when publish! is called" do
+      @doc.status.evaluate_requirement(:author).should == "Susan"
+      lambda { @doc.status.publish! }.should_not raise_error( )
+    end
+
+    it "should call update_rss when publish! is called" do
+      mock( @doc ).update_rss() {}
+      @doc.status.publish!
+    end
+
+    it "should have the state name :published after .publish! is called" do
+      @doc.status.publish!
+      @doc.status.current_state_name.should == :published
+    end
+
+    describe "status_field attribute" do
+      it "should be private in ruby 1.8 and 1.9"
+
+      it "should be defined before state_fu is called" do
+        @doc.send( :status_field ).should == 'draft'
+      end
+
+      it "should have an initial value of 'draft'" do
+        @doc.instance_eval { status_field }.should == "draft"
+      end
+
+      it "should be set to 'published' after publish! is called successfully" do
+        @doc.status.publish!
+        @doc.instance_eval { status_field }.should == "published"
+      end
+    end  # status_field
+  end # with author
+
+  describe "delete!" do
+
+    it "should execute destroy()" do
+      mock( @doc ).destroy() {}
+      @doc.status.delete!
+    end
+
+  end
+
+end

data/spec/integration/example_02_string_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe String do
+  include MySpecHelper
+  before do
+    reset!
+    String.class_eval do
+      include StateFu
+
+      def sanitize_for_shell!
+        gsub!(/([\\\t\| &`<>)('"])/) { |s| '\\' << s }
+      end
+
+      def dirty?
+        shell.name == :dirty
+      end
+
+      def clean?
+        shell.name == :clean
+      end
+
+      def shell_escape!
+        shell.escape!
+      end
+
+      def shell_escape
+        klone = clone
+        begin
+          klone.shell.escape!
+        rescue StateFu::InvalidTransition
+        end
+        klone
+      end
+
+      machine (:shell) do
+        event(:escape, :from => {:dirty => :clean}) do
+          execute :sanitize_for_shell!
+        end
+      end
+    end # String
+    @str = "; nohup 'rm -rf /opt' &"
+  end # before
+
+  it "should initially be dirty" do
+    @str.dirty?.should be_true
+  end
+
+  it "should call sanitize_for_shell! when shell.escape! is called, and be clean afterwards " do
+    @str.should be_dirty
+    @str.should_not be_clean
+    mock( @str ).sanitize_for_shell! {}
+    @str.shell.escape!
+    @str.should_not be_dirty
+    @str.should be_clean
+  end
+
+  it "should raise an InvalidTransition if shell.escape! is called more than once" do
+    @str.shell.escape!
+    @str.shell.state_name.should == :clean
+
+    lambda { @str.shell.escape! }.should raise_error( StateFu::InvalidTransition )
+  end
+
+  it "should modify the string when shell.escape is called" do
+    original             = @str.dup
+    original.should     == @str
+    @str.shell.escape!
+    original.should_not == @str
+  end
+
+  it "should modify the string when shell.escape! is called" do
+    original             = @str.dup
+    original.should     == @str
+    @str.shell.escape!
+    original.should_not == @str
+  end
+
+  it "should not modify the original string when shell_escape() is called" do
+    original             = @str.dup
+    original.should     == @str
+    clean_copy           = @str.shell_escape()
+    clean_copy.should be_clean
+    @str.should be_dirty
+    original.should     == @str
+  end
+
+end

data/spec/integration/instance_accessor_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+StateFu::FuSpace.reset!
+
+##
+##
+##
+
+describe "An instance of Klass with StateFu included:" do
+  include MySpecHelper
+  before(:each) do
+    make_pristine_class 'Klass'
+    @k = Klass.new()
+  end
+
+  describe "when no machine is defined" do
+    it "should return nil given .state_fu()" do
+      @k.state_fu().should be_nil
+    end
+
+    it "should return {} given .bindings()" do
+      @k.bindings().should == {}
+    end
+
+    it "should return [] given .state_fu!()" do
+      @k.state_fu!.should == []
+    end
+  end # no machine
+
+  describe "when an empty machine is defined for the class with the default name:" do
+    before(:each) do
+      Klass.machine() {}
+      StateFu::DEFAULT_MACHINE.should == :state_fu
+    end
+
+    it "should return a StateFu::Binding given .state_fu()" do
+      @k.state_fu().should be_kind_of( StateFu::Binding )
+    end
+
+    describe "before a binding is instantiated by calling .state_fu() or .state_fu!" do
+      it "should return {} given .bindings()" do
+        @k.bindings().should == {}
+      end
+    end
+
+    describe "after a binding is instantiated with .state_fu()" do
+      before do
+        @k.state_fu()
+      end
+
+      it "should return { :state_fu => <StateFu::Binding>} given .bindings()" do
+        @k.bindings().length.should == 1
+        @k.bindings().keys.should == [:state_fu]
+        @k.bindings().values.first.should be_kind_of( StateFu::Binding )
+      end
+    end
+
+    describe "after .state_fu!()" do
+      it "should return { :state_fu => <StateFu::Binding>} given .bindings()" do
+        @k.state_fu!()
+        @k.bindings().length.should == 1
+        @k.bindings().keys.should == [:state_fu]
+        @k.bindings().values.first.should be_kind_of( StateFu::Binding )
+      end
+    end
+
+    it "should return [<StateFu::Binding>] given .state_fu!()" do
+      @k.state_fu!.length.should == 1
+      @k.state_fu!.first.should be_kind_of( StateFu::Binding )
+    end
+
+    describe "when there is an empty machine called :two for the class" do
+      before(:each) do
+        Klass.machine(:two) {}
+      end
+
+      it "should return the same Binding given .state_fu() and .state_fu(:state_fu)" do
+        @k.state_fu().should be_kind_of( StateFu::Binding )
+        @k.state_fu().should == @k.state_fu(:state_fu)
+      end
+
+      it "should return a StateFu::Binding for the machine called :two given .state_fu(:two)" do
+        @k.state_fu(:two).should be_kind_of( StateFu::Binding )
+        @k.state_fu(:two).should_not == @k.state_fu(:state_fu)
+        @k.state_fu(:two).machine.should == Klass.machine(:two)
+      end
+
+      it "should return nil when .state_fu() is called with the name of a machine which doesn't exist" do
+        @k.state_fu(:hibiscus).should be_nil
+      end
+
+      it "should return an array of the two StateFu::Bindings given .state_fu!" do
+        @k.state_fu!.should be_kind_of( Array )
+        @k.state_fu!.length.should == 2
+        @k.state_fu!.each { |m| m.should be_kind_of( StateFu::Binding ) }
+        @k.state_fu!.map(&:method_name).sort_by(&:to_s).should == [:state_fu, :two]
+      end
+    end
+  end
+end

data/spec/integration/machine_duplication_spec.rb

@@ -0,0 +1,95 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+describe "Copying / cloning a Machine" do
+
+  include MySpecHelper
+
+  describe "a shallow copy" do
+    before do
+      reset!
+      make_pristine_class("Klass")
+      @original = Klass.machine do
+        state :a do
+          event :goto_b, :to => :b
+        end
+      end
+      @copy = @original.clone
+    end
+
+    it "should update any event in the original when it's changed in the copy" do
+      @original.events[:goto_b].should == @copy.events[:goto_b]
+      @copy.lathe do
+        event :goto_b do |e|
+          e.options[:wibble] = :updated
+        end
+      end
+      @copy.    events[:goto_b].options[:wibble].should == :updated
+      @original.events[:goto_b].options[:wibble].should == :updated
+    end
+
+    it "should update any state in the original when it's changed in the copy" do
+      @original.states[:a].should == @copy.states[:a]
+      @copy.lathe do
+        state :a do |s|
+          s.options[:wibble] = :updated
+        end
+      end
+      @copy.    states[:a].options[:wibble].should == :updated
+      @original.states[:a].options[:wibble].should == :updated
+    end
+
+    it "should update the original with any changes to options"
+    it "should update the original with any changes to helpers"
+    it "should update the original with any changes to named_procs"
+    it "should update the original with any changes to requirement_messages"
+
+  end # shallow
+
+  describe "a deep copy" do
+    before do
+      reset!
+      make_pristine_class("Klass")
+      @original = Klass.machine do
+        state :a do
+          event :goto_b, :to => :b
+        end
+      end
+      @copy = @original.deep_clone
+    end
+
+    it "should NOT update any event in the original when it's changed in the copy" do
+      pending
+      @original.events[:goto_b].should == @copy.events[:goto_b]
+      @copy.lathe do
+        event :goto_b do |e|
+          e.options[:wibble] = :updated
+        end
+      end
+      @copy.    events[:goto_b].options[:wibble].should == :updated
+      @original.events[:goto_b].options[:wibble].should == nil
+    end
+
+    it "should NOT update any state in the original when it's changed in the copy" do
+      pending
+      @original.states[:a].should == @copy.states[:a]
+      @copy.lathe do
+        state :a do |s|
+          s.options[:wibble] = :updated
+        end
+      end
+      @copy.    states[:a].options[:wibble].should == :updated
+      @original.states[:a].options[:wibble].should == nil
+    end
+
+    it "should NOT update the original with any changes to options"
+    it "should NOT update the original with any changes to helpers"
+    it "should NOT update the original with any changes to named_procs"
+    it "should NOT update the original with any changes to requirement_messages"
+
+  end # deep
+
+end