davidlee-state-fu 0.3.1 → 0.10.0

data/spec/BDD/plotter_spec.rb

@@ -1,115 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../helper")
-
-##
-##
-##
-
-describe StateFu::Plotter do
-  include MySpecHelper
-  before do
-    reset!
-    make_pristine_class('Klass')
-    @machine = Klass.machine(:drawme) do
-      chain 'clean -tarnish-> dirty -fester-> putrid'
-    end
-    @machine = Klass.machine(:drawme)
-  end
-
-  it "deleteme" do
-    @machine.graphviz.save_as('/tmp/1.dot')
-  end
-
-  describe "example machine" do
-    it "should have 3 states" do
-      @machine.states.length.should == 3
-    end
-
-    it "should have 2 simple events" do
-      @machine.events.length.should == 2
-      @machine.events.each{ |e| e.should be_simple }
-    end
-
-  end
-
-  describe StateFu::Plotter do
-    describe "class methods" do
-      describe ".new" do
-        it "should expect a StateFu::Machine and return a Plotter" do
-          @plotter = StateFu::Plotter.new( @machine )
-          @plotter.should be_kind_of(StateFu::Plotter)
-          @plotter.machine.should == @machine
-          lambda { StateFu::Plotter.new( "abracadabra" ) }.should raise_error(RuntimeError)
-        end
-      end
-
-      describe "a new plotter" do
-        before do
-          @plotter = StateFu::Plotter.new( @machine )
-        end
-
-        it "should have an empty hash of states" do
-          @plotter = StateFu::Plotter.new( @machine )
-          @plotter.states.should == {}
-        end
-
-      end
-    end # class methods
-
-    describe "instance methods" do
-      before do
-        @plotter = StateFu::Plotter.new( @machine )
-      end
-
-      describe ".generate" do
-
-        it "should call generate_dot!" do
-          mock( @plotter ).generate_dot!() { "dot" }
-          @plotter.generate
-        end
-
-        it "should store the result in the dot attribute" do
-          mock( @plotter).generate_dot!() { "dot" }
-          @plotter.generate
-          @plotter.dot.should == "dot"
-        end
-
-        it "should return a Vizier::Graph" # .graph
-
-        describe ".save_as(filename)" do
-          it "should save the string to a file" do
-            mock( File).open( 'filename', 'w' ).yields( @fh = Object.new() )
-            mock( @fh ).write( @plotter.output )
-            @plotter.output.save_as( 'filename' )
-          end
-        end
-        describe ".save!" do
-          it "should save the string in a tempfile and return the path" do
-            mock(@tempfile = Object.new).path {"path"}.subject
-            mock(Tempfile).new(['state_fu_graph','.dot']).yields( @fh = Object.new() ) { @tempfile }
-            mock( @fh ).write( @plotter.output )
-            @plotter.output.save!.should == 'path'
-          end
-        end
-      end
-
-      describe "output" do
-        it "should return the result of .generate" do
-          @plotter.output.should == @plotter.generate
-        end
-      end
-
-      describe "generate_dot!" do
-
-        it "should return a string" do
-          @plotter.generate_dot!.should be_kind_of(String)
-        end
-
-        it "should extend the string to respond_to save_as" do
-          @plotter.output.should respond_to(:save_as)
-        end
-      end
-
-    end
-  end
-end
-

data/spec/integration/dynamic_requirement_spec.rb

@@ -1,160 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../helper")
-
-module MySpecHelper
-  module DynamicTransitionObjectInstanceMethods
-    def method_which_expects_nothing_passed_to_it()
-      true
-    end
-
-    def method_which_requires_one_arg( t )
-      t.args.length == 1
-    end
-
-    def given_any_arg?( t = nil )
-      t.is_a?( StateFu::Transition ) && !t.args.empty?
-    end
-
-    def falsey?( t = nil )
-      t.is_a?( StateFu::Transition ) && !t.args.empty? && t.args.first == false
-    end
-
-    def truthy?( t = nil )
-      t.is_a?( StateFu::Transition ) && !t.args.empty? && t.args.first == true
-    end
-
-    def method_which_always_returns_true( t = nil )
-      true
-    end
-
-    def method_which_always_returns_false( t = nil )
-      false
-    end
-  end
-end
-
-describe "Transition requirement evaluation with dynamic conditions" do
-  include MySpecHelper
-
-  before do
-    reset!
-    make_pristine_class("Klass")
-
-    Klass.send :include, MySpecHelper::DynamicTransitionObjectInstanceMethods
-
-    @machine = Klass.machine do
-
-      state :default do
-        requires :method_which_requires_one_arg, :on => [:entry, :exit]
-
-        cycle do
-          requires :method_which_requires_one_arg
-        end
-
-        event :truthify, :to => :truth do
-          requires :truthy?
-        end
-
-        event :falsify, :to => :falsehood do
-          requires :falsey?
-          requires :method_which_expects_nothing_passed_to_it
-        end
-
-        #event :impossify, :to => :impossible do
-         # requires :method_which_always_returns_false
-        #end
-
-      end
-    end
-    @obj = Klass.new
-    @fu  = @obj.state_fu # binding
-    # Because RR changes the arity of the method on @obj we need to do this:
-    # stub( @fu ).limit_arguments( anything ) { |t| t }
-  end
-
-  describe "a requirement that the transition was given one arg" do
-
-    describe "object.cycle?()" do
-
-      it "should return false given no args" do
-        @fu.cycle?().should == false
-      end
-
-      it "should be true given one arg" do
-        @fu.cycle?(1).should == true
-      end
-
-      it "should be false given two args" do
-        @fu.cycle?(1,2).should == false
-      end
-    end
-
-    it "should evaluate the requirement by passing it a transition when requirements_met? is called" do
-      t = @fu.cycle()
-      # mock.proxy( @fu ).evaluate_requirement_with_transition(:method_which_requires_one_arg, t ).at_least(2)
-      t.requirements_met?.should == false
-      t.args = [1]
-      t.requirements_met?.should == true
-    end
-
-    describe "binding.evaluate_requirement_with_args" do
-
-    end
-
-    describe "valid_transitions" do
-      describe "given no arguments" do
-        it "should return {}" do
-          @fu.valid_transitions.should == {}
-        end
-      end
-
-      it "should pass each requirement method a transition object with no args" do
-      end
-
-      it "should call method_which_requires_one_arg given call_on_object_with_optional_args(:method_which_requires_one_arg .. )" do
-        t = @fu.blank_mock_transition( :first_arg )
-        @obj.respond_to?(:method_which_requires_one_arg).should be_true
-        meth = @obj.method(:method_which_requires_one_arg)
-        meth.arity.should == 1
-        @fu.limit_arguments( meth, t ).should == [t]
-        @fu.call_on_object_with_optional_args( :method_which_requires_one_arg, t )
-      end
-
-      it "should call method_which_requires_one_arg with a mock transition with one argument" do
-        t = @fu.blank_mock_transition( :first_arg )
-        # mock( @obj ).method_which_requires_one_arg( t )
-        @fu.call_on_object_with_optional_args( :method_which_requires_one_arg, t ).should == true
-      end
-
-      it "should contain the :cycle_default event only if an arg is supplied" do
-        @fu.should == :default
-        ves = @fu.valid_events( )
-        ves.length.should == 0
-        ves = @fu.valid_events( 1 )
-        ves.length.should == 1
-        ves.first.should == @machine.events[:cycle_default]
-
-        @machine.events[:cycle_default].target.should == @fu.current_state
-        @fu.evaluate_requirement_with_args( :method_which_requires_one_arg ).should == false
-        @fu.evaluate_requirement_with_args( :method_which_requires_one_arg, 1 ).should == true
-        @fu.current_state.enterable_by?( @fu ).should == false
-        @fu.current_state.enterable_by?( @fu, 1 ).should == true
-
-        vts = @fu.valid_transitions()
-        vts.should be_kind_of( Hash )
-        vts.should be_empty
-        vts = @fu.valid_transitions( 1 )
-        vts.should_not be_empty
-        vts.length.should  == 1
-        vts.keys.first.should   == @machine.events[:cycle_default]
-        vts.values.first.should == [@machine.states[:default]]
-      end
-
-      it "should pass method_which_requires_one_argument() a transition with no arguments" do
-        # mock.proxy( @obj ).method_which_requires_one_arg( is_a(StateFu::MockTransition) ).times(3)
-        @fu.valid_transitions( 1 )
-      end
-
-    end
-  end
-
-end

data/spec/integration/ex_machine_for_accounts_spec.rb

@@ -1,79 +0,0 @@
-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/sanity_spec.rb

@@ -1,31 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../helper")
-
-class Moo
-  def arity_1( a )
-    raise "!"
-  end
-
-  def arity_0( )
-    raise "!"
-  end
-end
-
-describe "sanity check: rr / arity" do
-  it "should have the expected arity for standard methods" do
-    m = Moo.new()
-    m.method(:arity_1).arity.should == 1
-    m.method(:arity_0).arity.should == 0
-  end
-
-  it "should have the expected arity when methods are mocked" do
-    m = Moo.new()
-    a1 = Object.new
-    a0 = Object.new
-    stub( a1 ).arity() { 1 }
-    stub( a0 ).arity() { 0 }
-    stub( m ).method(:arity_1) { a1 }
-    stub( m ).method(:arity_0) { a0 }
-    m.method(:arity_1).arity.should == 1
-    m.method(:arity_0).arity.should == 0
-  end
-end

data/spec/units/fu_space_spec.rb

@@ -1,95 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../helper")
-
-StateFu::FuSpace.reset!
-
-##
-##
-##
-describe StateFu::FuSpace do
-  include MySpecHelper
-
-  before(:each) do
-    reset!
-    make_pristine_class 'Klass'
-    @k = Klass.new()
-  end
-
-  describe "Before any Machine is defined" do
-    it "should return {} given StateFu::FuSpace.class_machines()" do
-      StateFu::FuSpace.should respond_to(:class_machines)
-      StateFu::FuSpace.class_machines.should == {}
-    end
-  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 { Klass => { ... } } given StateFu::FuSpace.class_machines()" do
-      StateFu::FuSpace.should respond_to(:class_machines)
-      machines = StateFu::FuSpace.class_machines()
-      machines.keys.should == [Klass]
-      machines.values.first.should be_kind_of( Hash )
-    end
-
-    it "should return { :state_fu => <StateFu::Machine> } given StateFu::FuSpace.class_machines[Klass]" do
-      StateFu::FuSpace.should respond_to(:class_machines)
-      machines = StateFu::FuSpace.class_machines[Klass]
-      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 return { Klass => { ... } } given StateFu::FuSpace.field_names()" do
-      StateFu::FuSpace.should respond_to(:field_names)
-      fields = StateFu::FuSpace.field_names()
-      fields.keys.should == [Klass]
-      fields.values.first.should be_kind_of( Hash )
-    end
-
-    it "should return { :state_fu => :state_fu_state } given StateFu::FuSpace.field_names[Klass]" do
-      StateFu::FuSpace.should respond_to(:field_names)
-      fields = StateFu::FuSpace.field_names[Klass]
-      fields.should be_kind_of(Hash)
-      fields.should_not be_empty
-      fields.length.should == 1
-      fields.keys.should == [:state_fu]
-      fields.values.should == [:state_fu_field]
-    end
-
-    describe "Having called Klass.machine(:two) with an empty block:" do
-      before(:each) do
-        # Klass.machine.should_not be_nil
-        Klass.machine(:two) do
-        end
-      end
-
-      it "should return { :state_fu => <StateFu::Machine>, :two => <StateFu::Machine> } given StateFu::FuSpace.class_machines()" do
-        StateFu::FuSpace.should respond_to(:class_machines)
-        machines = StateFu::FuSpace.class_machines[Klass]
-        machines.should be_kind_of(Hash)
-        machines.should_not be_empty
-        machines.length.should == 2
-        machines.keys.sort.should == [:state_fu, :two]
-        machines.values.each { |v| v.should be_kind_of( StateFu::Machine ) }
-      end
-
-      describe "Having called StateFu::FuSpace.reset!" do
-        before(:each) do
-          StateFu::FuSpace.reset!
-        end
-        it "should return {} given StateFu::FuSpace.class_machines()" do
-          StateFu::FuSpace.should respond_to(:class_machines)
-          StateFu::FuSpace.class_machines.should == {}
-        end
-      end
-
-    end
-  end
-end
-