apotomo 1.2.3 → 1.2.4

data/test/event_handler_test.rb

@@ -1,69 +1,39 @@
 require 'test_helper'
-require 'apotomo/proc_event_handler'
 
-class EventHandlerTest < Test::Unit::TestCase
+class EventHandlerTest < MiniTest::Spec
   include Apotomo::TestCaseMethods::TestController
-  
-  context "an abstract EventHandler" do
-    should "push nil to root's ordered page_updates when #call'ed" do
+
+  describe "EventHandler" do
+    before do
       @mum = mouse
         @mum << mouse_mock(:kid)
-      
-      assert_equal 0, @mum.page_updates.size
-      
-      [@mum, @mum[:kid], @mum].each do |source|
-        Apotomo::EventHandler.new.call(Apotomo::Event.new(:squeak, source))
+    end
+
+    it "respond to #process_event" do
+      h = Apotomo::EventHandler.new
+      e = Apotomo::Event.new(:squeak, @mum)
+      assert_equal nil, h.process_event(e)
+    end
+
+    describe "#call" do 
+      it "push #process_events' results ordered to root's #page_updates" do
+        [@mum, @mum[:kid], @mum].each_with_index do |source, i|
+          e = Apotomo::Event.new(:squeak, source)
+          h = Apotomo::EventHandler.new
+          h.stub :process_event, "tick#{i}" do
+            h.call(e)
+          end
+        end
+
+        assert_equal 3, @mum.page_updates.size
+        assert_equal "tick0", @mum.page_updates[0]
+        assert_equal "tick1", @mum.page_updates[1]
+        assert_equal "tick2", @mum.page_updates[2]
+        assert_equal 0, @mum[:kid].page_updates.size
       end
-      
-      # order matters:
-      assert_equal 3, @mum.page_updates.size
-      assert_equal 0, @mum[: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])
+
+      #TODO: handler expect #process_event
     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/event_methods_test.rb

@@ -1,105 +1,105 @@
 require 'test_helper'
- 
-class EventMethodsTest < Test::Unit::TestCase
+
+class EventMethodsTest < MiniTest::Spec
   include Apotomo::TestCaseMethods::TestController
-  
+
   def handler(id, state)
     Apotomo::InvokeEventHandler.new(:widget_id => id, :state => state)
   end
-  
-  
-  context "#respond_to_event and #fire" do
-    setup do
+
+
+  describe "#respond_to_event and #fire" do
+    before do
       mum_and_kid!
     end
-    
-    should "alert @mum first, then make her squeak when @kid squeaks" do
+
+    it "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
+
+    it "make @mum just squeak back when jerry squeaks" do
       @mum << mouse_mock(:jerry)
       @mum[:jerry].fire :squeak
       assert_equal ['answer squeak'], @mum.list
     end
-    
-    
-    should "make @mum run away while @kid keeps watching" do
+
+
+    it "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
+
+    it "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
+
+    it "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
-    
-    should "also accept an event argument only" do
+
+    it "also accept an event argument only" do
       @mum.respond_to_event :answer_squeak
       @mum.fire :answer_squeak
       assert_equal ['answer squeak'], @mum.list
-    end 
-    
-    should "make pass the event into the triggered state" do
+    end
+
+    it "make pass the event into the triggered state" do
       @mum.instance_eval do
         respond_to_event :footsteps
-          
+
         def footsteps(evt)
           list << evt
         end
       end
-      
+
       @mum.trigger :footsteps, "near"
       assert_kind_of Apotomo::Event, @mum.list.last
     end
-    
-    should "accept payload data for the event" do
+
+    it "accept payload data for the event" do
       @mum.respond_to_event :answer_squeak
       @mum.instance_eval do
         def answer_squeak(evt)
           list << evt.data
         end
       end
-      
+
       @mum.fire :answer_squeak, :volume => 9
       assert_equal [{:volume => 9}], @mum.list
     end
-    
-    
-    context "#responds_to_event with :passing" do
-      setup do
+
+
+    describe "#responds_to_event with :passing" do
+      before do
         class AdolescentMouse < MouseWidget
           responds_to_event :squeak, :passing => :root
         end
-        
+
         @root = mouse(:root)
       end
-      
-      should "add handlers to root when called with :passing" do
+
+      it "add handlers to root when called with :passing" do
         AdolescentMouse.new(@root, 'jerry')
-        
+
         assert_equal [handler('jerry', :squeak)], @root.event_table.all_handlers_for(:squeak, 'jerry')
       end
-      
-      should "inherit :passing handlers" do
+
+      it "inherit :passing handlers" do
         Class.new(AdolescentMouse).new(@root, 'jerry')
-        
+
         assert_equal [handler('jerry', :squeak)], @root.event_table.all_handlers_for(:squeak, 'jerry')
       end
-      
+
     end
-    
-    context "#responds_to_event in class context" do
+
+    describe "#responds_to_event in class context" do
       class AdultMouse < Apotomo::Widget
         responds_to_event :peep, :with => :answer_squeak
       end
@@ -107,46 +107,46 @@ class EventMethodsTest < Test::Unit::TestCase
         responds_to_event :peep
         responds_to_event :footsteps, :with => :squeak
       end
-        
-      setup do
+
+      before do
         @mum = AdultMouse.new(parent_controller, 'mum')
       end
-      
-      should "add the handlers at creation time" do
+
+      it "add the handlers at creation time" do
         assert_equal [handler('mum', :answer_squeak)], @mum.event_table.all_handlers_for(:peep, 'mum')
       end
-      
-      should "inherit handlers" do
+
+      it "inherit handlers" do
         assert_equal [[:peep, {:with=>:answer_squeak}]], AdultMouse.responds_to_event_options
         assert_equal [[:peep, {:with=>:answer_squeak}], [:peep], [:footsteps, {:with=>:squeak}]], BabyMouse.responds_to_event_options
       end
-      
-      should "not share responds_to_event options between different instances" do
+
+      it "not share responds_to_event options between different instances" do
         assert_equal [handler('mum', :answer_squeak)], @mum.event_table.all_handlers_for(:peep, 'mum')
-        
+
         assert_equal [handler('dad', :answer_squeak)], AdultMouse.new(parent_controller, 'dad', :show).event_table.all_handlers_for(:peep, 'dad')
       end
     end
-    
-    context "#trigger" do
-      should "be an alias for #fire" do
+
+    describe "#trigger" do
+      it "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
+
+
+    describe "page_updates" do
+      it "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
+
+      it "be queued in root#page_updates after #fire" do
         @mum.fire :footsteps
         assert_equal ["escape"], @mum.page_updates
       end
     end
-    
-  end 
+
+  end
 end

data/test/event_test.rb

@@ -1,26 +1,26 @@
 require 'test_helper'
- 
-class EventTest < Test::Unit::TestCase
+
+class EventTest < MiniTest::Spec
   include Apotomo::TestCaseMethods::TestController
-  
-  context "An Event" do
-    should "respond to #type and #source" do
+
+  describe "An Event" do
+    it "respond to #type and #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
+
+    it "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 "delegate #[] to data" do
+
+    it "delegate #[] to data" do
       @event = Apotomo::Event.new(:footsteps, 'mum', {:volume => :loud})
       assert_equal :loud, @event[:volume]
     end
-    
-    should "respond to #to_s" do
+
+    it "respond to #to_s" do
       @event = Apotomo::Event.new(:footsteps, mouse('mum'))
       assert_equal "<Event :footsteps source=mum>", @event.to_s
     end

data/test/invoke_event_handler_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class EventHandlerTest < MiniTest::Spec
+  include Apotomo::TestCaseMethods::TestController
+
+  describe "InvokeEventHandler" do
+    describe "constructor" do
+      it "accept no arguments" do
+        h = Apotomo::InvokeEventHandler.new
+        assert_nil h.widget_id
+        assert_nil h.state
+      end
+
+      it "accept options" do
+        h = Apotomo::InvokeEventHandler.new(:widget_id => :widget, :state => :state)
+        assert_equal :widget, h.widget_id
+        assert_equal :state,  h.state
+      end
+    end
+
+    describe "equality methods" do
+      it "repond to #==" do
+        h1 = Apotomo::InvokeEventHandler.new(:widget_id => :widget, :state => :state)
+        h2 = Apotomo::InvokeEventHandler.new(:widget_id => :widget, :state => :state)
+
+        assert h1 == h2
+        assert h2 == h1
+      end
+
+      it "repond to #!=" do
+        h1 = Apotomo::InvokeEventHandler.new(:widget_id => :widget, :state => :state)
+
+        h3 = Apotomo::InvokeEventHandler.new(:widget_id => :another_widget, :state => :state)
+        assert h1 != h3
+        assert h3 != h1
+
+        h4 = Apotomo::InvokeEventHandler.new(:widget_id => :widget, :state => :another_state)
+        assert h1 != h4
+        assert h4 != h1
+
+        h5 = Apotomo::InvokeEventHandler.new
+        assert h1 != h5
+        assert h5 != h1
+
+        # TODO: test InvokeEventHandler == EventHandler
+      end
+    end
+
+    it "respond to #to_s" do
+      h = Apotomo::InvokeEventHandler.new
+      h.widget_id = :widget_id
+      h.state     = :my_state
+      assert_equal "InvokeEventHandler:widget_id#my_state", h.to_s
+    end
+  end
+
+  ### TODO: test #process_event
+
+end

data/test/javascript_generator_test.rb

@@ -1,89 +1,74 @@
 require '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 replace" do
-        assert_equal "$(\"drinks\").replace(\"EMPTY!\");", @gen.replace(:drinks, 'EMPTY!')
-      end
-      
-      should "respond to replace_id" do
-        assert_equal "$(\"drinks\").replace(\"EMPTY!\");", @gen.replace_id("drinks", 'EMPTY!')
-      end
-      
-      should "respond to update" do
-        assert_equal "$(\"drinks\").update(\"<li id=\\\"beer\\\"><\\/li>\");", @gen.update(:drinks, '<li id="beer"></li>')
+class JavascriptGeneratorTest < MiniTest::Spec
+  describe "The JavascriptGenerator" do
+    describe "constructor" do
+      it "accept framework name and return an correct instance" do
+        @gen = Apotomo::JavascriptGenerator.new(:Jquery)
+
+        assert_kind_of Apotomo::JavascriptGenerator, @gen
+        assert_kind_of Apotomo::JavascriptGenerator::Jquery, @gen
       end
-      
-      should "respond to update_id" do
-        assert_equal "$(\"drinks\").update(\"EMPTY!\");", @gen.update_id("drinks", 'EMPTY!')
+
+      it "raise an error if no framework passed" do
+        assert_raises RuntimeError do
+          Apotomo::JavascriptGenerator.new(nil)
+        end
       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 replace" do
-        assert_equal "$(\"drinks\").replace(\"EMPTY!\");", @gen.replace(:drinks, 'EMPTY!')
-      end
-      
-      should "respond to replace_id" do
-        assert_equal "$(\"drinks\").replace(\"EMPTY!\");", @gen.replace_id("drinks", 'EMPTY!')
-      end
-      
-      should "respond to update" do
-        assert_equal "$(\"drinks\").update(\"<li id=\\\"beer\\\"><\\/li>\");", @gen.update(:drinks, '<li id="beer"></li>')
+
+    it "respond to ::escape" do
+      assert_equal '', Apotomo::JavascriptGenerator.escape(nil)
+      assert_equal %(This \\"thing\\" is really\\n netos\\'), Apotomo::JavascriptGenerator.escape(%(This "thing" is really\n netos'))
+      assert_equal %(backslash\\\\test), Apotomo::JavascriptGenerator.escape(%(backslash\\test))
+      assert_equal %(dont <\\/close> tags), Apotomo::JavascriptGenerator.escape(%(dont </close> tags))
+    end
+
+    describe "in jQuery mode" do
+      before do
+        @gen = Apotomo::JavascriptGenerator.new(:Jquery)
       end
-      
-      should "respond to update_id" do
-        assert_equal "$(\"drinks\").update(\"EMPTY!\");", @gen.update_id("drinks", 'EMPTY!')
+
+      it "respond to #escape" do
+        assert_equal '', @gen.escape(nil)
+        assert_equal %(This \\"thing\\" is really\\n netos\\'), @gen.escape(%(This "thing" is really\n netos'))
+        assert_equal %(backslash\\\\test), @gen.escape(%(backslash\\test))
+        assert_equal %(dont <\\/close> tags), @gen.escape(%(dont </close> tags))
       end
-    end
-    
-    context "in jquery mode" do
-      setup do
-        @gen = Apotomo::JavascriptGenerator.new(:jquery)
+
+      it "respond to #<< and return argument converted to String" do
+        assert_equal "bla_bla", (@gen << "bla_bla")
+        assert_equal "bla_bla", (@gen << :bla_bla)
       end
-      
-      should "respond to jquery" do
+
+      it "respond to #jquery" do
         assert_respond_to @gen, :jquery
       end
-    
-      should "respond to replace" do
-        assert_equal "$(\"#drinks\").replaceWith(\"EMPTY!\");", @gen.replace("#drinks", 'EMPTY!')
+
+      it "respond to #element" do
+        assert_equal "jQuery(\"#drinks\")", @gen.element("#drinks")
+      end
+
+      it "respond to #replace" do
+        assert_equal "jQuery(\"#drinks\").replaceWith(\"EMPTY!\");", @gen.replace("#drinks", 'EMPTY!')
       end
-      
-      should "respond to replace_id" do
-        assert_equal "$(\"#drinks\").replaceWith(\"EMPTY!\");", @gen.replace_id("drinks", 'EMPTY!')
+
+      it "respond to #replace_id" do
+        assert_equal "jQuery(\"#drinks\").replaceWith(\"EMPTY!\");", @gen.replace_id("drinks", 'EMPTY!')
       end
-      
-      should "respond to update" do
-        assert_equal "$(\"#drinks\").html(\"<li id=\\\"beer\\\"><\\/li>\");", @gen.update("#drinks", '<li id="beer"></li>')
+
+      it "respond to #update" do
+        assert_equal "jQuery(\"#drinks\").html(\"<li id=\\\"beer\\\"><\\/li>\");", @gen.update("#drinks", '<li id="beer"></li>')
       end
-      
-      should "respond to update_id" do
-        assert_equal "$(\"#drinks\").html(\"EMPTY!\");", @gen.update_id("drinks", 'EMPTY!')
+
+      it "respond to #update_id" do
+        assert_equal "jQuery(\"#drinks\").html(\"EMPTY!\");", @gen.update_id("drinks", 'EMPTY!')
       end
+
+      # TODO: Prototype mode
+
+      # TODO: Right mode
+
     end
   end
 end

data/test/rails/caching_test.rb

@@ -2,28 +2,28 @@ require 'test_helper'
 
 # TODO: assert that same-named cells and widgets don't overwrite their caches.
 
-class CachingTest < ActiveSupport::TestCase
+class CachingTest < MiniTest::Spec
   include Apotomo::TestCaseMethods::TestController
-  
+
   class CheeseWidget < Apotomo::Widget
     cache :holes
-    
+
     def holes(count)
       render :text => count
-    end 
+    end
   end
-  
-  context "A caching widget" do
-    setup do
+
+  describe "A caching widget" do
+    before do
       ActionController::Base.perform_caching = true
       @cheese = CheeseWidget.new(parent_controller, 'cheese', :holes)
     end
-    
-    teardown do
+
+    after do
       ActionController::Base.perform_caching = false
     end
-    
-    should "invoke the cached state only once" do
+
+    it "invoke the cached state only once" do
       assert_equal "1", @cheese.invoke(:holes, 1)
       assert_equal "1", @cheese.invoke(:holes, 2)
     end