apotomo 1.0.5 → 1.1.0.rc1

data/test/unit/request_processor_test.rb

@@ -4,42 +4,40 @@ class RequestProcessorTest < ActiveSupport::TestCase
   include Apotomo::TestCaseMethods::TestController
   
   def root_mum_and_kid!
+    mum_and_kid!
     
-        mum_and_kid!
-        
-        @root = Apotomo::Widget.new(parent_controller, 'root', :display)
-        @root << @mum
-        
-        
-        @session = {}
-        #freeze!
-  end
-  
-  # Call SW.freeze_for on @session, "freezing" stateful widgets below @root there.
-  def freeze!
-    Apotomo::StatefulWidget.freeze_for(@session, @root)
+    @root = Apotomo::Widget.new(parent_controller, 'root', :display)
+    @root << @mum
   end
   
   
-  context "#root" do
-    should "allow external modification of the tree" do
-      @processor = Apotomo::RequestProcessor.new(parent_controller, {})
+  context "RequestProcessor" do
+    setup do
+      @processor = Apotomo::RequestProcessor.new(parent_controller)
       root = @processor.root
       root << mouse_mock
+    end
+    
+    should "allow external modification of the tree" do
+      root = @processor.root
       assert_equal 2, @processor.root.size
     end
+    
+    should "delegate #render_widget_for to #root" do
+      assert_equal 'squeak!', @processor.render_widget_for('mouse', :squeak)
+    end
   end
   
   context "#attach_stateless_blocks_for" do
     setup do
-      @processor  = Apotomo::RequestProcessor.new(parent_controller, {})
+      @processor  = Apotomo::RequestProcessor.new(parent_controller)
       @root       = @processor.root
       assert_equal @root.size, 1
     end
     
     should "allow has_widgets blocks with root parameter" do
       @processor.send(:attach_stateless_blocks_for, [Proc.new{ |root|
-        root.add widget('mouse_cell', 'mouse') 
+        root << widget(:mouse, 'mouse') 
       }], @root, parent_controller)
       
       assert_equal 'mouse', @processor.root['mouse'].name
@@ -47,13 +45,9 @@ class RequestProcessorTest < ActiveSupport::TestCase
   end
     
   context "option processing at construction time" do
-    context "with empty session and options" do
+    context "with empty options" do
       setup do
-        @processor = Apotomo::RequestProcessor.new(parent_controller, {})
-      end
-      
-      should "mark the tree as flushed" do
-        assert @processor.widgets_flushed?
+        @processor = Apotomo::RequestProcessor.new(parent_controller)
       end
       
       should "provide a single root-node for #root" do
@@ -63,60 +57,15 @@ class RequestProcessorTest < ActiveSupport::TestCase
     
     context "with controller" do
       should "attach the passed parent_controller to root" do
-        assert_equal parent_controller, Apotomo::RequestProcessor.new(parent_controller, {}, {}, []).root.parent_controller
+        assert_equal parent_controller, Apotomo::RequestProcessor.new(parent_controller, {}, []).root.parent_controller
       end
     end
-    
-    context "with session" do
-      setup do
-        root_mum_and_kid!
-        @mum.version = 1
-        freeze!
-        
-        @processor = Apotomo::RequestProcessor.new(parent_controller, @session)
-      end
-      
-      should "provide a widget family for #root" do
-        assert_equal 3, @processor.root.size
-        assert_equal 1, @processor.root['mum'].version
-        assert_not @processor.widgets_flushed?
-      end
-      
-      context "having a flush flag set" do
-        setup do
-          @processor = Apotomo::RequestProcessor.new(parent_controller, @session, :flush_widgets => true)
-        end
-        
-        should "provide a single root for #root when :flush_widgets is set" do
-          assert_equal 1, @processor.root.size
-          assert @processor.widgets_flushed?
-        end
-        
-        should "wipe-out our session variables" do
-          assert_nil @session[:apotomo_stateful_branches]
-          assert_nil @session[:apotomo_widget_ivars]
-        end
-        
-      end
-      
-      context "and with stateless widgets" do
-        setup do
-          root_mum_and_kid!
-          freeze!
-          @processor = Apotomo::RequestProcessor.new(parent_controller, @session, {}, [Proc.new { |root| root << Apotomo::Widget.new(parent_controller, 'grandma', :eating) }])
-        end
-        
-        should "first attach passed stateless, then stateful widgets to root" do
-          assert_equal 4, @processor.root.size
-        end
-      end
-    end
-    
   end
   
+  
   context "#process_for" do
     setup do
-      class KidCell < Apotomo::Widget
+      class KidWidget < Apotomo::Widget
         responds_to_event :doorSlam, :with => :flight
         responds_to_event :doorSlam, :with => :squeak
         def flight; render :text => "away from here!"; end
@@ -124,10 +73,10 @@ class RequestProcessorTest < ActiveSupport::TestCase
       end
   
       procs = [Proc.new{ |root,controller| 
-        root << mum = MouseCell.new(parent_controller, 'mum', :squeak) << KidCell.new(parent_controller, 'kid', :squeak)
+        root << widget(:mouse, 'mum') << KidWidget.new(parent_controller, 'kid', :squeak)
       }]
     
-      @processor = Apotomo::RequestProcessor.new(parent_controller, {}, {:js_framework => :prototype}, procs)
+      @processor = Apotomo::RequestProcessor.new(parent_controller, {:js_framework => :prototype}, procs)
     end
     
     should "return an empty array if nothing was triggered" do
@@ -138,6 +87,14 @@ class RequestProcessorTest < ActiveSupport::TestCase
       assert_equal ["away from here!", "squeak!"], @processor.process_for({:type => :doorSlam, :source => 'kid'})
     end
     
+    should "append the params hash to the triggered event" do
+      KidWidget.class_eval do
+        def squeak(evt); render :text => evt.data.inspect; end
+      end
+      
+      assert_equal ["away from here!", "{:type=>:doorSlam, :source=>\"kid\"}"], @processor.process_for({:type => :doorSlam, :source => 'kid'})
+    end
+    
     should "raise an exception when :source is unknown" do
       assert_raises RuntimeError do
         @processor.process_for({:type => :squeak, :source => 'tom'})
@@ -146,47 +103,11 @@ class RequestProcessorTest < ActiveSupport::TestCase
   end
   
   
-  
-  context "#freeze!" do
-    should "serialize stateful branches to @session" do
-      @processor = Apotomo::RequestProcessor.new(parent_controller, {})
-      @processor.root << mum_and_kid!
-      assert_equal 3, @processor.root.size
-      @processor.freeze!
-      
-      @processor = Apotomo::RequestProcessor.new(parent_controller, @processor.session)
-      assert_equal 3, @processor.root.size
-    end
-  end
-  
-  context "#render_widget_for" do
-    setup do
-      class MouseCell < Apotomo::Widget
-        def squeak; render :text => "squeak!"; end
-      end
-      
-      @processor = Apotomo::RequestProcessor.new(parent_controller, {}, {}, 
-        [Proc.new { |root| root << MouseCell.new(parent_controller, 'mum', :squeak) }])
-    end
-    
-    should "render the widget when passing an existing widget id" do
-      assert_equal 'squeak!', @processor.render_widget_for('mum', {})
-    end
-    
-    should "render the widget when passing an existing widget instance" do
-      assert_equal 'squeak!', @processor.render_widget_for(@processor.root['mum'], {})
-    end
     
-    should "raise an exception when a non-existent widget id id passed" do
-      assert_raises RuntimeError do
-        @processor.render_widget_for('mummy', {})
-      end
-    end
-  end
   
   context "invoking #address_for" do
     setup do
-      @processor = Apotomo::RequestProcessor.new(parent_controller, {})
+      @processor = Apotomo::RequestProcessor.new(parent_controller)
     end
     
     should "accept an event :type" do
@@ -210,3 +131,44 @@ class RequestProcessorTest < ActiveSupport::TestCase
     end
   end
 end
+
+class RequestProcessorHooksTest < ActiveSupport::TestCase
+  include Apotomo::TestCaseMethods::TestController
+  include Apotomo::TestCaseMethods
+  
+  context "Hooks in RequestProcessor" do
+    setup do
+      @class = Class.new(Apotomo::RequestProcessor)
+    end
+    
+    context ":after_initialize hook" do
+      should "be called after the has_widgets blocks invokation" do
+        @k = mouse_mock("kid")
+        @class.after_initialize do |r|
+          r.root["mum"] << @k
+        end
+        
+        @r = @class.new(parent_controller, {}, 
+          [Proc.new { |root| root << widget(:mouse, 'mum') }])
+        
+        assert_equal @r.root["mum"]["kid"], @k
+      end
+    end
+    
+    context ":after_fire hook" do
+      should "be called in #process_for after fire" do
+        @k = mouse_mock("kid")
+        @class.after_fire do |r|
+          r.root["mum"] << @k = mouse_mock("kid")
+        end
+        
+        # DISCUSS: maybe add a trigger test here?
+        @r = @class.new(parent_controller, {}, 
+          [Proc.new { |root| root << widget(:mouse, 'mum') }])
+        @r.process_for(:source => "root", :type => :noop) # calls ~after_fire.
+        
+        assert_equal @k, @r.root["mum"]["kid"]
+      end
+    end
+  end
+end

data/test/unit/test_case_test.rb

@@ -18,7 +18,7 @@ class TestCaseTest < Test::Unit::TestCase
       setup do
         @klass = MouseWidgetTest
         @test = @klass.new(:widget).tap{ |t| t.setup }
-        @klass.has_widgets { |r| r << widget("mouse_cell", 'mum', :eating) }
+        @klass.has_widgets { |r| r << widget(:mouse, 'mum', :eating) }
       end
       
       should "respond to #root" do  
@@ -40,12 +40,12 @@ class TestCaseTest < Test::Unit::TestCase
       end
       
       should "respond to #render_widget" do
-        assert_equal "<div id=\"mum\">burp!</div>", @test.render_widget('mum')
-        assert_equal "<div id=\"mum\">burp!</div>", @test.last_invoke
+        assert_equal "<div id=\"mum\">burp!</div>\n", @test.render_widget('mum', :eat)
+        assert_equal "<div id=\"mum\">burp!</div>\n", @test.last_invoke
       end
       
       should "respond to #assert_select" do
-        @test.render_widget('mum')
+        @test.render_widget('mum', :eat)
         
         assert_nothing_raised { @test.assert_select("div#mum", "burp!") } 
         
@@ -68,9 +68,15 @@ class TestCaseTest < Test::Unit::TestCase
         
         should "provide options from #trigger to the widget" do
           @test.trigger(:footsteps, :source => 'mum', :direction => :kitchen)
-          assert_equal :kitchen, @mum.param(:direction)
+          assert_equal :kitchen, @mum.options[:direction]
         end
         
+        #should "merge options from #trigger and constructor" do
+        #  @test.root << @test.widget("mouse_cell", 'kid', :location => :hallway)
+        #  @test.trigger(:footsteps, :source => 'kid', :direction => :kitchen)
+        #  assert_equal({:direction => :kitchen, :location => :hallway}, @mum.param(:direction))
+        #end
+        
         should "respond to #assert_response" do
           @test.trigger(:footsteps, :source => 'mum')
           assert @test.assert_response("squeak!")
@@ -87,8 +93,8 @@ class TestCaseTest < Test::Unit::TestCase
         assert_kind_of ActionController::Base, @test.parent_controller
       end
       
-      should "respond to #controller_name" do
-        assert_equal "barn", @test.parent_controller.controller_name
+      should "respond to #controller_path" do
+        assert_equal "barn", @test.parent_controller.controller_path
       end
     end
   end

data/test/unit/widget_shortcuts_test.rb

@@ -1,105 +1,76 @@
 require 'test_helper'
 
-class MumWidget < MouseCell; end
-class MouseTabs;end
+class MumWidget < MouseWidget; end
+class MouseTabsWidget;end
 
 class WidgetShortcutsTest < Test::Unit::TestCase
   include Apotomo::TestCaseMethods::TestController
   
   context "#constant_for" do
     should "constantize symbols" do
-      assert_equal MumWidget, constant_for(:mum_widget)
+      assert_equal MumWidget, constant_for(:mum)
     end
     
     should "not try to singularize the widget class" do
-      assert_equal MouseTabs, constant_for(:mouse_tabs)
-    end
-  end
-  
-  context "#cell" do
-    should "create a MouseCell instance for backward-compatibility" do
-      assert_kind_of MouseCell, cell(:mouse, :eating, 'mum')
+      assert_equal MouseTabsWidget, constant_for(:mouse_tabs)
     end
   end
   
   context "#widget" do   
     context "with all arguments" do
       setup do
-        @mum = widget(:mum_widget, 'mum', :eating, :color => 'grey', :type => :hungry)
+        @mum = widget(:mum, 'mum', :eating, :color => 'grey', :type => :hungry)
       end
       
       should "create a MumWidget instance" do
         assert_kind_of MumWidget, @mum
-        assert_equal :eating, @mum.instance_variable_get(:@start_state)
         assert_equal 'mum', @mum.name
       end
       
       should "accept options" do
-        assert_equal({:color => "grey", :type => :hungry}, @mum.opts)
+        assert_equal({:color => "grey", :type => :hungry}, @mum.options)
       end
     end
     
-    context "with 3 arguments and no start_state" do
-      should "set a default start_state" do
-        @mum = widget(:mum_widget, 'mum', :color => 'grey', :type => :hungry)
+    context "with 3 arguments and no options" do
+      should "not set options" do
+        @mum = widget(:mum, 'mum', :squeak)
         assert_kind_of MumWidget, @mum
-        assert_equal :display,  @mum.instance_variable_get(:@start_state)
         assert_equal 'mum',     @mum.name
-        assert_equal({:color => "grey", :type => :hungry}, @mum.opts)
+        assert_equal({},        @mum.options)
       end
     end
     
-    context "with 3 arguments and no options" do
-      should "not set options" do
-        @mum = widget(:mum_widget, 'mum', :squeak)
+    context "with class and id" do
+      setup do
+        @mum = widget(:mum, 'mummy')
+      end
+      
+      should "create a MumWidget instance" do
         assert_kind_of MumWidget, @mum
-        assert_equal :squeak,   @mum.instance_variable_get(:@start_state)
-        assert_equal 'mum',     @mum.name
-        assert_equal({},        @mum.opts)
+        assert_equal 'mummy', @mum.name
       end
     end
     
-    context "with id only" do
+    context "with class, only" do
       setup do
-        @mum = widget(:mum_widget, 'mum')
+        @mum = widget(:mum)
       end
       
-      should "create a MumWidget instance with :display start state" do
+      should "create a MumWidget instance named :mum" do
         assert_kind_of MumWidget, @mum
-        assert_equal :display, @mum.instance_variable_get(:@start_state)
-        assert_equal 'mum', @mum.name
+        assert_equal :mum, @mum.name
       end
     end
     
+    
     should "yield itself" do
-      @mum = widget(:mum_widget, :snuggle, 'mum') do |mum|
+      @mum = widget(:mum, 'mum') do |mum|
         assert_kind_of MumWidget, mum
-        mum << widget(:mum_widget, 'kid', :sleep)
+        mum << widget(:mum, 'kid')
       end
       assert_equal 2, @mum.size
       assert_kind_of MumWidget, @mum['kid']
     end
   end
-  
-  context "#container" do
-    setup do
-      @family = container('family')
-    end
-    
-    should "create a ContainerWidget instance" do
-      assert_kind_of ::Apotomo::ContainerWidget, @family
-      assert_equal 'family', @family.name
-    end
-    
-    should "yield itself" do
-      @container = container(:family) do |family|
-        family << widget(:mum_widget, 'mum')
-      end
-      assert_equal 2, @container.size
-    end
-    
-    should "be aliased to #section for backward-compatibility" do
-      assert_kind_of ::Apotomo::ContainerWidget, section('family')
-    end
-  end
 end

data/test/unit/widget_test.rb

@@ -9,34 +9,34 @@ class WidgetTest < ActiveSupport::TestCase
       @mum = Apotomo::Widget.new(@controller, 'mum', :squeak)
     end
   end
-  
+
   context "Widget.has_widgets" do
     setup do
-      @mum = Class.new(MouseCell) do
+      @mum = Class.new(MouseWidget) do
         has_widgets do |me|
-          me << widget('mouse_cell', 'baby', :squeak)
+          me << widget(:mouse, 'baby')
         end
-      end.new(@controller, 'mum', :squeak)
+      end.new(@controller, 'mum')
       
       @kid = Class.new(@mum.class).new(@controller, 'mum', :squeak)
     end
     
     should "setup the widget family at creation time" do
       assert_equal 1, @mum.children.size
-      assert_kind_of Apotomo::StatefulWidget, @mum['baby']
+      assert_kind_of Apotomo::Widget, @mum['baby']
     end
     
     should "inherit trees for now" do
       assert_equal 1, @mum.children.size
-      assert_kind_of Apotomo::StatefulWidget, @mum['baby']
+      assert_kind_of Apotomo::Widget, @mum['baby']
     end
   end
   
   context "Widget.after_add" do
     setup do
-      @mum = Class.new(MouseCell) do
+      @mum = Class.new(MouseWidget) do
         after_add do |me, parent|
-          parent << widget('mouse_cell', 'kid', :squeak)
+          parent << widget(:mouse, 'kid', :squeak)
         end
       end.new(@controller, 'mum', :squeak)
       
@@ -57,7 +57,7 @@ class WidgetTest < ActiveSupport::TestCase
       assert_equal ['berry', 'kid'], @root.children.collect { |w| w.name }
     end
   end
-  
+
   context "A stateless widget" do
     setup do
       @mum = Apotomo::Widget.new(@controller, 'mum', :squeak)
@@ -91,23 +91,6 @@ class WidgetTest < ActiveSupport::TestCase
         @mum.visible = false
         assert_not @mum.visible?
       end
-      
-      context "in a widget family" do
-        setup do
-          @mum << @jerry = mouse_mock('jerry')
-          @mum << @berry = mouse_mock('berry')
-        end
-        
-        should "per default return all #visible_children" do
-          assert_equal [@jerry, @berry], @mum.visible_children
-          assert_equal [], @jerry.visible_children
-        end
-        
-        should "hide berry in #visible_children if he's invisible" do
-          @berry.visible = false
-          assert_equal [@jerry], @mum.visible_children
-        end
-      end
     end
     
     should "respond to #find_widget" do
@@ -128,16 +111,23 @@ class WidgetTest < ActiveSupport::TestCase
       assert_equal @mum.name, @mum.widget_id
     end
     
-    should "provide #param" do
-      @controller.params = HashWithIndifferentAccess.new('type' => 'Wireless mouse', :brand => "Logitech")
-      @mum = widget(:mouse_cell, 'mum', :display, :color => 'grey', :type => 'shrew')
-      assert_equal nil,     @mum.param(:whatever)
-      assert_equal 'grey',  @mum.param(:color)
-      assert_equal 'grey',  @mum.param('color')
-      assert_equal 'shrew', @mum.param(:type)
-      assert_equal 'Logitech', @mum.param(:brand)
+    should "mark #param as deprecated" do
+      assert_raises RuntimeError do
+        @mum.param(:volume)
+      end
     end
     
+    should "respond to DEFAULT_VIEW_PATHS" do
+      assert_equal ["app/widgets", "app/widgets/layouts"], Apotomo::Widget::DEFAULT_VIEW_PATHS
+    end
+    
+    should "respond to .view_paths" do
+      assert_equal ActionView::PathSet.new(Apotomo::Widget::DEFAULT_VIEW_PATHS + ["test/widgets"]), Apotomo::Widget.view_paths
+    end
+    
+    should "respond to .controller_path" do
+      assert_equal "mouse", MouseWidget.controller_path
+    end
     
     # internal_methods:
     should "not list internal methods in action_methods" do
@@ -145,8 +135,8 @@ class WidgetTest < ActiveSupport::TestCase
     end
     
     should "list both local and inherited states in Widget.action_methods" do
-      assert MouseCell.action_methods.collect{ |m| m.to_s }.include?("eating")
-      assert Class.new(MouseCell).action_methods.collect{ |m| m.to_s }.include?("eating")
+      assert MouseWidget.action_methods.collect{ |m| m.to_s }.include?("squeak")
+      assert Class.new(MouseWidget).action_methods.collect{ |m| m.to_s }.include?("squeak")
     end
     
     should "not list #display in internal_methods although it's defined in Object" do
@@ -154,3 +144,53 @@ class WidgetTest < ActiveSupport::TestCase
     end
   end
 end
+  
+
+class RenderWidgetTest < ActiveSupport::TestCase
+  include Apotomo::TestCaseMethods::TestController
+
+  context "#render_widget" do
+    should "allow passing widget id" do
+      assert_equal "squeak!", mouse_mock.render_widget('mouse', :squeak)
+    end
+    
+    should "allow passing widget instance" do
+      assert_equal 'squeak!', mouse_mock.render_widget(mouse_mock('mum'), :squeak)
+    end
+    
+    should "use :display as standard state" do
+      mum = mouse_mock('Mum') do
+        def display
+          render :text => "#{widget_id}, that's me!"
+        end
+      end
+      
+      assert_equal "Mum, that's me!", mouse_mock.render_widget(mum)
+    end
+    
+    should "raise an exception when a non-existent widget id is passed" do
+      e = assert_raises RuntimeError do
+        mouse_mock.render_widget('mummy')
+      end
+      
+      assert_equal "Couldn't render non-existent widget `mummy`", e.message
+    end
+    
+    should "pass options as state-args" do
+      mum = mouse_mock do
+        def display(color="grey")
+          render :text => "I'm #{color}"
+        end
+      end
+      
+      assert_equal("I'm grey", mouse_mock.render_widget(mum), "default value in state-arg didn't work")
+      assert_equal("I'm black", mouse_mock.render_widget(mum, :display, "black"))
+    end
+    
+    should "use #find_widget from self to find the passed widget id" do
+      mum = mouse_mock('mum') << mouse_mock(:kid)
+      
+      assert_equal "<div id=\"kid\">burp!</div>\n", mum.render_widget(:kid, :eat)
+    end 
+  end
+end