state-fu 0.11.1

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.state_fu_machine() { }
+    end
+
+    describe "calling Klass.state_fu_machine().events" do
+      it "should return []" do
+        Klass.state_fu_machine().events.should == []
+      end
+    end
+
+    describe "calling event(:die){ from :dead, :to => :alive } in a Klass.state_fu_machine()" do
+      before do
+        Klass.state_fu_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.state_fu_machine(){ event {} } }.should raise_error(ArgumentError)
+      end
+
+      it "should add 2 states to the machine called: [:dead, :alive] " do
+        Klass.state_fu_machine.state_names.should == [:dead, :alive]
+        Klass.state_fu_machine.states.length.should == 2
+        Klass.state_fu_machine.states.each { |s| s.should be_kind_of(StateFu::State) }
+        Klass.state_fu_machine.states.map(&:name).sort.should == [:alive, :dead]
+      end
+
+      describe "the <StateFu::Event> created" do
+        it "should be accessible through Klass.state_fu_machine.events" do
+          Klass.state_fu_machine.events.should be_kind_of(Array)
+          Klass.state_fu_machine.events.length.should == 1
+          Klass.state_fu_machine.events.first.should be_kind_of( StateFu::Event )
+          Klass.state_fu_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.state_fu_machine()" do
+      before do
+        Klass.state_fu_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.state_fu_machine.state_names.should == [:dead, :alive]
+        Klass.state_fu_machine.states.length.should == 2
+        Klass.state_fu_machine.states.each { |s| s.should be_kind_of( StateFu::State ) }
+      end
+    end
+
+  end
+end
+

data/spec/integration/example_01_document_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+# require 'activesupport'
+# 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
+
+      state_fu_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
+
+        states do
+          accepted :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
+      @doc.status.name.should == :draft
+      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
+      lambda { @doc.status.publish! }.should_not raise_error( )
+    end
+
+    it "should call update_rss when publish! is called" do
+      mock( @doc ).update_rss(anything) {}
+      @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
+
+      # need to think about this
+      #
+      # it "should be private in ruby 1.8 and 1.9" do
+      #   lambda { @doc.status_field }.should raise_error()
+      # end
+
+      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(anything) {}
+      @doc.status.delete!
+    end
+
+  end
+
+end

data/spec/integration/example_02_string_spec.rb

@@ -0,0 +1,88 @@
+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::IllegalTransition
+        end
+        klone
+      end
+
+      state_fu_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!(anything) {}
+    @str.shell.escape!
+    @str.should_not be_dirty
+    @str.should be_clean
+  end
+
+  it "should raise an IllegalTransition 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::IllegalTransition )
+  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,97 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+##
+##
+##
+
+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 raise an ArgumentError given .state_fu()" do
+      lambda { @k.state_fu() }.should raise_error(ArgumentError)
+    end
+
+    it "should return {} given .bindings()" do
+      @k.state_fu_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.state_fu_machine() {}
+    end
+
+    it "should return a StateFu::Binding given .state_fu()" do
+      @k.state_fu_binding.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 == [StateFu::DEFAULT]
+        @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 == [StateFu::DEFAULT]
+        @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.state_fu_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(StateFu::DEFAULT)
+      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(StateFu::DEFAULT)
+        @k.state_fu(:two).machine.should == Klass.state_fu_machine(:two)
+      end
+
+      it "should raise an ArgumentError when .state_fu() is called with the name of a machine which doesn't exist" do
+        lambda { @k.state_fu(:hibiscus) }.should raise_error(ArgumentError)
+      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 == [StateFu::DEFAULT, :two]
+      end
+    end
+  end
+end

data/spec/integration/lathe_extension_spec.rb

@@ -0,0 +1,67 @@
+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.tool" do
+
+      it "should add the arguments to the machine's collection of tools" do
+        @machine.should respond_to(:tools)
+        @machine.tools.should be_empty
+        @machine.lathe do
+          tool :bench_grinder
+        end
+        @machine.tools.should_not be_empty
+        @machine.tools.should include(:bench_grinder)
+      end
+
+      it "should extend the machine's lathe" do
+        @machine.lathe do
+          tool :bench_grinder
+          snark()
+        end
+        @machine.lathe.should respond_to( :snark )
+        @machine.lathe.snark
+      end
+
+      it "should extend the machine's lathe for state and events" do
+        @machine.lathe do
+          tool :bench_grinder
+          snark()
+          state :grinding do
+            snark()
+            event :grind do
+              snark()
+            end
+          end
+        end
+      end
+
+      it "should not extend another machine's lathe" do
+        @machine.lathe do
+          tool :bench_grinder
+          snark()
+        end
+        m2 = Klass.state_fu_machine(:two) do
+        end
+        lambda { m2.lathe.snark }.should raise_error( NoMethodError )
+      end
+
+    end # tool
+
+  end
+end