apotomo 0.1.1

data/test/unit/container_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+
+class ContainerTest < Test::Unit::TestCase
+  context "Rendering a container" do
+    setup do
+      @family = container('family')
+      @family.controller = @controller
+    end
+    
+    should "return an empty view if childless" do
+      assert_equal "<div id=\"family\"></div>", @family.invoke
+    end
+    
+    should "provide a family picture" do
+      @family << mouse_mock('mum')
+      @family << mouse_mock('kid')
+      assert_equal "<div id=\"family\"><div id=\"mum\">burp!</div>\n<div id=\"kid\">burp!</div></div>", @family.invoke
+    end
+  end
+end

data/test/unit/event_handler_test.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+
+
+class EventHandlerTest < Test::Unit::TestCase
+  context "an abstract EventHandler" do
+    should "push nil to root's ordered page_updates when #call'ed" do
+      @mum = mouse_mock('mum')
+        @mum << @kid = mouse_mock('kid')
+      
+      assert_equal 0, @mum.page_updates.size
+      
+      [@mum, @kid, @mum].each do |source|
+        Apotomo::EventHandler.new.call(Apotomo::Event.new(:squeak, source))
+      end
+      
+      # order matters:
+      assert_equal 3, @mum.page_updates.size
+      assert_equal 0, @kid.page_updates.size
+      assert_equal(nil, @mum.page_updates[0])
+      assert_equal(nil, @mum.page_updates[1])
+      assert_equal(nil, @mum.page_updates[2])
+    end
+  end
+  
+  
+  
+  def test_invoke_to_s
+    h = Apotomo::InvokeEventHandler.new
+    h.widget_id = :widget_id
+    h.state     = :my_state
+    assert_equal "InvokeEventHandler:widget_id#my_state", h.to_s
+  end
+  
+  def test_proc_to_s
+    h = Apotomo::ProcEventHandler.new
+    h.proc = :my_method
+    assert_equal "ProcEventHandler:my_method", h.to_s
+  end
+  
+  def test_constructor_for_proc
+    h = Apotomo::ProcEventHandler.new
+    assert_nil h.proc
+    h = Apotomo::ProcEventHandler.new(:proc => :method)
+    assert_equal :method, h.proc
+  end
+  
+  def test_constructor_for_invoke
+    h = Apotomo::InvokeEventHandler.new
+    assert_nil h.widget_id
+    assert_nil h.state
+    h = Apotomo::InvokeEventHandler.new(:widget_id => :widget, :state => :state)
+    assert_equal :widget, h.widget_id
+    assert_equal :state,  h.state
+  end
+  
+  def test_equal
+    h1 = Apotomo::ProcEventHandler.new(:proc => :run)
+    h2 = Apotomo::ProcEventHandler.new(:proc => :run)
+    h3 = Apotomo::ProcEventHandler.new(:proc => :walk)
+    
+    assert h1 == h2
+    assert h1 != h3
+  end
+  
+  ### TODO: test #call
+  
+end

data/test/unit/event_methods_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), %w(.. test_helper))
+ 
+class EventMethodsTest < Test::Unit::TestCase
+
+  context "#respond_to_event and #fire" do
+    setup do
+      mum_and_kid!
+    end
+    
+    should "alert @mum first, then make her squeak when @kid squeaks" do
+      @kid.fire :squeak
+      assert_equal ['be alerted', 'answer squeak'], @mum.list
+    end
+    
+    should "make @mum just squeak back when @jerry squeaks" do
+      @mum << @jerry = mouse_mock('jerry')
+      @jerry.fire :squeak
+      assert_equal ['answer squeak'], @mum.list
+    end
+    
+    
+    should "make @mum run away while @kid keeps watching" do
+      @kid.fire :footsteps
+      assert_equal ['peek', 'escape'], @mum.list
+    end
+    
+    should "by default add a handler only once" do
+      @mum.respond_to_event :peep, :with => :answer_squeak
+      @mum.respond_to_event :peep, :with => :answer_squeak
+      @mum.fire :peep
+      assert_equal ['answer squeak'], @mum.list
+    end
+    
+    should "squeak back twice when using the :once => false option" do
+      @mum.respond_to_event :peep, :with => :answer_squeak
+      @mum.respond_to_event :peep, :with => :answer_squeak, :once => false
+      @mum.fire :peep
+      assert_equal ['answer squeak', 'answer squeak'], @mum.list
+    end
+    
+    context "#responds_to_event in class context" do
+      setup do
+        class AdultMouseCell < MouseCell
+          responds_to_event :peep, :with => :answer_squeak
+        end
+        class BabyMouseCell < AdultMouseCell
+          responds_to_event :footsteps, :with => :squeak
+        end
+      end
+      
+      should "add the handlers at creation time" do
+        assert_equal [Apotomo::InvokeEventHandler.new(:widget_id => 'mum', :state => :answer_squeak)], AdultMouseCell.new('mum', :show).event_table.all_handlers_for(:peep, 'mum')
+      end
+      
+      should "not inherit handlers for now" do
+        assert_equal [], BabyMouseCell.new('kid', :show).event_table.all_handlers_for(:peep, 'kid')
+      end
+    end
+    
+    
+    context "#trigger" do
+      should "be an alias for #fire" do
+        @kid.trigger :footsteps
+        assert_equal ['peek', 'escape'], @mum.list
+      end
+    end
+    
+    
+    context "page_updates" do
+      should "expose a simple Array for now" do
+        assert_kind_of Array, @mum.page_updates
+        assert_equal 0, @mum.page_updates.size
+      end
+      
+      should "be queued in root#page_updates after #fire" do
+        @mum.fire :footsteps
+        assert_equal ["escape"], @mum.page_updates
+      end
+      
+    end
+    
+  end 
+end

data/test/unit/event_test.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+ 
+class EventTest < Test::Unit::TestCase
+  context "An Event" do
+    should "require type and respond to #type" do
+      assert_equal :footsteps, Apotomo::Event.new(:footsteps).type
+    end
+    
+    should "require source and respond to #source" do
+      @event = Apotomo::Event.new(:footsteps, 'mum')
+      assert_equal :footsteps,  @event.type
+      assert_equal 'mum',       @event.source
+    end
+    
+    should "accept an additional data object and respond to #data" do
+      @event = Apotomo::Event.new(:footsteps, 'mum', {:volume => :loud})
+      assert_equal({:volume => :loud}, @event.data)
+    end
+    
+    should "complain when serialized" do
+      assert_raises RuntimeError do
+        Marshal.dump(Apotomo::Event.new(:footsteps, 'mum'))
+      end
+    end
+    
+    should "respond to #stopped?" do
+      assert_not Apotomo::Event.new(:footsteps, 'mum').stopped?
+    end
+  end
+end

data/test/unit/invoke_test.rb

@@ -0,0 +1,123 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+
+class InvokeTest < Test::Unit::TestCase
+  class LocalMouse < MouseCell
+    def snuggle; render; end
+    def educate; render :view => :snuggle; end
+  end
+  
+  context "Invoking a single widget" do
+    setup do
+      @mum = LocalMouse.new('mum', :snuggle)
+    end
+    
+    context "implicitely" do
+      should "always enter the given state" do
+        @mum.invoke :snuggle
+        assert_equal :snuggle, @mum.last_state
+        
+        @mum.invoke :educate
+        assert_equal :educate, @mum.last_state
+      end
+    end
+    
+    context "explicitely" do
+      should "per default enter the start state" do
+        @mum.invoke
+        assert_equal :snuggle, @mum.last_state
+        
+        @mum.invoke
+        assert_equal :snuggle, @mum.last_state
+      end
+      
+      context "with defined transitions" do
+        setup do
+          @mum.instance_eval do
+            self.class.transition :from => :snuggle, :to => :educate
+          end
+          
+          @mum.invoke
+          assert_equal :snuggle, @mum.last_state
+        end
+        
+        should "automatically follow the transitions if defined" do
+          @mum.invoke
+          assert_equal :educate, @mum.last_state
+        end
+        
+        should "nevertheless allow undefined implicit invokes" do
+          @mum.invoke :snuggle
+          assert_equal :snuggle, @mum.last_state
+        end
+      end
+    end
+  end
+  
+  context "Invoking a widget family" do
+    setup do
+      @mum = LocalMouse.new('mum', :snuggle)
+      
+      # create an anonym class for @kid so we don't pollute with #transition's.
+      @mum << @kid = mouse_class_mock.new('kid', :snooze)
+      @kid.instance_eval do
+        def snooze; render :nothing => true; end
+        def listen; render :nothing => true; end
+      end
+    end
+    
+    context "implicitely" do
+      should "per default send kid to its start state" do
+        @mum.invoke :snuggle
+        assert_equal :snuggle,  @mum.last_state
+        assert_equal :snooze,   @kid.last_state
+        
+        @mum.invoke :educate
+        assert_equal :educate,  @mum.last_state
+        assert_equal :snooze,   @kid.last_state
+      end
+      
+      should "follow the kid's transition if defined" do
+        @kid.instance_eval do
+          self.class.transition :from => :snooze, :to => :listen
+        end
+        
+        @mum.invoke :snuggle
+        @mum.invoke :educate
+        assert_equal :educate,  @mum.last_state
+        assert_equal :listen,   @kid.last_state
+      end
+      
+      should "send kid to the given state passed to #render" do
+        @mum.instance_eval do
+          def snuggle
+            render :invoke => {'kid' => :listen}
+          end
+        end
+        
+        @mum.invoke :snuggle
+        assert_equal :snuggle,  @mum.last_state
+        assert_equal :listen,   @kid.last_state
+      end
+      
+      should "send kid to the :invoke state as it overrides #transition" do
+        @kid.instance_eval do
+          self.class.transition :from => :snooze, :to => :listen
+        end
+        
+        @mum.instance_eval do
+          def educate
+            render :nothing => true, :invoke => {'kid' => :snooze}
+          end
+        end
+        
+        @mum.invoke :snuggle
+        assert_equal :snuggle,  @mum.last_state
+        assert_equal :snooze,   @kid.last_state
+        
+        @mum.invoke :educate
+        assert_equal :educate,  @mum.last_state
+        assert_equal :snooze,   @kid.last_state
+      end
+    end
+  end
+end

data/test/unit/javascript_generator_test.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class JavascriptGeneratorTest < Test::Unit::TestCase
+  context "The JavascriptGenerator" do
+    should "raise an error if no framework passed" do
+      assert_raises RuntimeError do
+        Apotomo::JavascriptGenerator.new(nil)
+      end
+    end
+    
+    context "in prototype mode" do
+      setup do
+        @gen = Apotomo::JavascriptGenerator.new(:prototype)
+      end
+      
+      should "respond to prototype" do
+        assert_respond_to @gen, :prototype
+      end
+    
+      should "respond to xhr" do
+        assert_equal "new Ajax.Request(\"/drink/beer?source=nick\")", @gen.xhr('/drink/beer?source=nick')
+      end
+      
+      should "respond to replace" do
+        assert_equal "$(\"drinks\").replace(\"EMPTY!\")", @gen.replace(:drinks, 'EMPTY!')
+      end
+      
+      should "respond to update" do
+        assert_equal "$(\"drinks\").update(\"<li id=\\\"beer\\\"><\\/li>\")", @gen.update(:drinks, '<li id="beer"></li>')
+      end
+      
+      should "respond to <<" do
+        assert_equal "alert(\"Beer!\")", @gen << 'alert("Beer!")'
+      end
+    end
+    
+    context "in right mode" do
+      setup do
+        @gen = Apotomo::JavascriptGenerator.new(:right)
+      end
+      
+      should "respond to right" do
+        assert_respond_to @gen, :right
+      end
+    
+      should "respond to xhr" do
+        assert_equal "new Xhr(\"/drink/beer?source=nick\", {evalScripts:true}).send()", @gen.xhr('/drink/beer?source=nick')
+      end
+      
+      should "respond to replace" do
+        assert_equal "$(\"drinks\").replace(\"EMPTY!\")", @gen.replace(:drinks, 'EMPTY!')
+      end
+      
+      should "respond to update" do
+        assert_equal "$(\"drinks\").update(\"<li id=\\\"beer\\\"><\\/li>\")", @gen.update(:drinks, '<li id="beer"></li>')
+      end
+      
+      should "respond to <<" do
+        assert_equal "alert(\"Beer!\")", @gen << 'alert("Beer!")'
+      end
+    end
+    
+    context "in jquery mode" do
+      setup do
+        @gen = Apotomo::JavascriptGenerator.new(:jquery)
+      end
+      
+      should "respond to jquery" do
+        assert_respond_to @gen, :jquery
+      end
+    
+      should "respond to xhr" do
+        assert_equal "$.ajax({url: \"/drink/beer?source=nick\"})", @gen.xhr('/drink/beer?source=nick')
+      end
+      
+      should "respond to replace" do
+        assert_equal "$(\"#drinks\").replaceWith(\"EMPTY!\")", @gen.replace(:drinks, 'EMPTY!')
+      end
+      
+      should "respond to update" do
+        assert_equal "$(\"#drinks\").html(\"<li id=\\\"beer\\\"><\\/li>\")", @gen.update(:drinks, '<li id="beer"></li>')
+      end
+      
+      should "respond to <<" do
+        assert_equal "alert(\"Beer!\")", @gen << 'alert("Beer!")'
+      end
+    end
+  end
+end

data/test/unit/onfire_integration_test.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+ 
+class OnfireIntegrationTest < Test::Unit::TestCase
+  context "including Onfire into the StatefulWidget it" do
+    setup do
+      @mum = mouse_mock('mum')
+      @mum << @kid = mouse_mock('kid')
+    end
+    
+    should "respond to #root" do
+      assert @mum.root?
+      assert ! @kid.root?
+    end
+    
+    should "respond to #parent" do
+      assert_equal @mum, @kid.parent
+    end
+  end
+end

data/test/unit/persistence_test.rb

@@ -0,0 +1,240 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+
+class PersistenceTest < Test::Unit::TestCase
+  
+  class PersistentMouse < Apotomo::StatefulWidget # we need a named class for marshalling.
+    attr_reader :who, :what
+      
+    def educate
+      @who  = "the cat"
+      @what = "run away"
+      render :nothing => true
+    end
+      
+    def recap;  render :nothing => true; end
+  end
+  
+  context "StatefulWidget" do
+  
+    context ".stateful_branches_for" do
+      should "provide all stateful branch-roots seen from root" do
+        @root = Apotomo::Widget.new('root', :eat)
+        @root << mum_and_kid!
+        @root << Apotomo::Widget.new('berry', :eat) << @jerry = mouse_mock('jerry', :eat)
+        
+        assert_equal ['mum', 'jerry'], Apotomo::StatefulWidget.stateful_branches_for(@root).collect {|n| n.name}
+      end
+    end
+  end
+  
+  context "After #hibernate_widget (request) the widget" do
+    should "still have the same ivars" do
+      @mum = PersistentMouse.new('mum', :educate)
+      @mum.controller = @controller ### FIXME: remove that dependency
+      
+      @mum.invoke(:educate)
+      
+      assert_equal @mum.last_state, :educate
+      assert_equal @mum.who,  "the cat"
+      assert_equal @mum.what, "run away"
+      
+      @mum = hibernate_widget(@mum)
+      @mum.controller = @controller ### FIXME: remove that dependency
+      
+      @mum.invoke(:recap)
+      
+      assert_equal @mum.last_state, :recap
+      assert_equal @mum.who,  "the cat"
+      assert_equal @mum.what, "run away"
+    end
+    
+    should "still have its event_table" do
+      @mum    = PersistentMouse.new('mum', :educate)
+      @event  = Apotomo::Event.new(:squeak, @mum)
+      @mum.respond_to_event :squeak, :with => :educate
+      
+      assert_equal 1, @mum.send(:local_event_handlers, @event).size
+      @mum = hibernate_widget(@mum)
+      assert_equal 1, @mum.send(:local_event_handlers, @event).size
+    end
+  end
+  
+  context "freezing and thawing a widget family" do
+    setup do
+      mum_and_kid!
+      @storage = {}
+    end
+    
+    context "and calling #flush_storage" do
+      should "clear the storage from frozen data" do
+        @root = Apotomo::Widget.new('root', :eat)
+        @root << @mum
+          
+        Apotomo::StatefulWidget.freeze_for(@storage, @root)
+        
+        assert @storage[:apotomo_stateful_branches]
+        assert @storage[:apotomo_widget_ivars]
+        
+        Apotomo::StatefulWidget.flush_storage(@storage)
+        
+        assert_nil @storage[:apotomo_stateful_branches]
+        assert_nil @storage[:apotomo_widget_ivars]
+      end
+    end
+    
+    should "push @mum's freezable ivars to the storage when calling #freeze_ivars_to" do
+      @mum.freeze_ivars_to(@storage)
+      
+      assert_equal 1, @storage.size
+      assert_equal 5, @storage['mum'].size
+    end
+    
+    should "push family's freezable ivars to the storage when calling #freeze_data_to" do
+      @kid << mouse_mock('pet')
+      @mum.freeze_data_to(@storage)
+      
+      assert_equal 3, @storage.size
+      assert_equal 5, @storage['mum'].size
+      assert_equal 5, @storage['mum/kid'].size
+      assert_equal 4, @storage['mum/kid/pet'].size
+    end
+    
+    should "push ivars and structure to the storage when calling #freeze_to" do
+      @mum.freeze_to(@storage)
+      assert_equal 2, @storage[:apotomo_widget_ivars].size
+      assert_kind_of Apotomo::StatefulWidget, @storage[:apotomo_root]
+    end
+    
+    context "that has also stateless widgets" do
+      setup do
+        @root = Apotomo::Widget.new('root', :eat)
+          @root << mum_and_kid!
+          @root << Apotomo::Widget.new('berry', :eat) << @jerry = mouse_mock('jerry', :eat)
+        @root << Apotomo::Widget.new('tom', :eating)
+        
+        Apotomo::StatefulWidget.freeze_for(@storage, @root)
+      end
+      
+      should "ignore stateless widgets when calling #freeze_for" do
+        assert_equal(['root/mum', 'root/mum/kid', "root/berry/jerry"], @storage[:apotomo_widget_ivars].keys)
+      end
+      
+      should "save stateful branches only" do
+        #@mum.root!
+        #@jerry.root!  # disconnect stateful branches.
+        
+        assert_equal([[@mum, 'root'], [@jerry, 'berry']], @storage[:apotomo_stateful_branches])
+        assert @storage[:apotomo_stateful_branches].first.first.root?, "mum not disconnected from root"
+        assert @storage[:apotomo_stateful_branches].last.first.root?, "jerry not disconnected from berry"
+      end
+      
+      should "attach stateful branches to the tree in thaw_for" do
+        @new_root = Apotomo::Widget.new('root', :eat)
+          @new_root << Apotomo::Widget.new('berry', :eat)
+        assert_equal @new_root, Apotomo::StatefulWidget.thaw_for(@storage, @new_root)
+        
+        assert_equal 5, @new_root.size  # without tom.
+      end
+      
+      should "re-establish ivars recursivly when calling #thaw_for" do
+        @storage[:apotomo_stateful_branches] = Marshal.load(Marshal.dump(@storage[:apotomo_stateful_branches]))
+        
+        @new_root = Apotomo::Widget.new('root', :eat)
+          @new_root << Apotomo::Widget.new('berry', :eat)
+        @new_root = Apotomo::StatefulWidget.thaw_for(@storage, @new_root)
+        
+        assert_equal :answer_squeak,  @new_root['mum'].instance_variable_get(:@start_state)
+        assert_equal :peek,           @new_root['mum']['kid'].instance_variable_get(:@start_state)
+      end
+      
+      should "raise an exception when thaw_for can't find the branch's parent" do
+        @new_root = Apotomo::Widget.new('dad', :eat)
+        
+        assert_raises RuntimeError do
+           Apotomo::StatefulWidget.thaw_for(@storage, @new_root)
+        end
+      end
+      
+      should "clear the fields in the storage when fetching in #thaw_for" do
+        @new_root = Apotomo::Widget.new('root', :eat)
+          @new_root << Apotomo::Widget.new('berry', :eat)
+        
+        Apotomo::StatefulWidget.thaw_for(@storage, @new_root)
+        
+        assert_nil @storage[:apotomo_stateful_branches]
+        assert_nil @storage[:apotomo_widget_ivars]
+      end
+    end
+    
+    should "update @mum's ivars when calling #thaw_ivars_from" do
+      @mum.instance_variable_set(:@name, "zombie mum")
+      assert_equal 'zombie mum', @mum.name
+      
+      @mum.thaw_ivars_from({'zombie mum' => {'@name' => 'mum'}})
+      assert_equal 'mum', @mum.name
+    end
+    
+    should "update family's ivars when calling #thaw_data_from" do
+      @kid << @pet = mouse_mock('pet')
+      @kid.instance_variable_set(:@name, "paranoid kid")
+      @pet.instance_variable_set(:@name, "mad dog")
+      assert_equal "paranoid kid", @kid.name
+      
+      @mum.thaw_data_from({ "mum/paranoid kid"  => {'@name' => 'kid'},
+                            "mum/kid/mad dog"   => {'@name' => 'pet'}})
+      assert_equal 'kid', @kid.name
+      assert_equal 'pet', @pet.name
+    end
+    
+    
+  end
+  
+  context "dumping and loading" do
+    setup do
+      @mum = PersistentMouse.new('mum', :eating)
+      @mum << @kid = PersistentMouse.new('kid', :eating)
+    end
+    
+    context "a single stateful widget" do
+      should "provide a serialized widget on #node_dump" do
+        assert_equal "mum|PersistenceTest::PersistentMouse|mum", @mum.dump_node
+        assert_equal "kid|PersistenceTest::PersistentMouse|mum", @kid.dump_node
+      end
+      
+      should "recover the widget skeleton when invoking self.node_load" do
+        @mum, parent = ::Apotomo::StatefulWidget.load_node(@mum.dump_node)
+        assert_kind_of PersistentMouse, @mum
+        assert_equal 'mum', @mum.name
+        assert_equal 1,     @mum.size
+        assert_equal 'mum', parent
+      end
+    end
+    
+    context "a stateful widget family" do
+      should "provide the serialized tree on _dump" do
+        assert_equal "mum|PersistenceTest::PersistentMouse|mum\nkid|PersistenceTest::PersistentMouse|mum\n", @mum._dump(10)
+      end
+      
+      should "recover the widget tree on _load" do
+        @mum = ::Apotomo::StatefulWidget._load(@mum._dump(10))
+        assert_equal 2, @mum.size
+        assert_equal @mum, @mum['kid'].parent
+      end
+    end
+  end
+  
+  context "#frozen_widget_in?" do
+    should "return true if a valid widget is passed" do
+      assert_not Apotomo::StatefulWidget.frozen_widget_in?({})
+      assert Apotomo::StatefulWidget.frozen_widget_in?({:apotomo_stateful_branches => [[mouse_mock, 'root']]})
+    end
+  end
+  
+  context "#symbolized_instance_variables?" do
+    should "return instance_variables as symbols" do
+      @mum = mouse_mock
+      assert_equal @mum.instance_variables.size, @mum.symbolized_instance_variables.size
+      assert_not @mum.symbolized_instance_variables.find { |ivar| ivar.kind_of? String }
+    end
+  end
+end