apotomo 1.2.3 → 1.2.4

data/test/render_test.rb

@@ -1,36 +1,36 @@
 require 'test_helper'
 
-class RenderTest < ActionView::TestCase
+class RenderTest < MiniTest::Spec
   include Apotomo::TestCaseMethods::TestController
-  
-  context "#render" do
-    setup do
+
+  describe "#render" do
+    before do
       @mum = mouse('mum')
     end
-    
-    should "per default display the state content framed in a div" do
+
+    it "per default display the state content framed in a div" do
       assert_equal '<div id="mum">burp!</div>', @mum.invoke(:eating)
     end
-    
-    context "with :text" do
-      setup do
+
+    describe "with :text" do
+      before do
         @mum.instance_eval { def eating; render :text => "burp!!!"; end }
       end
-      
-      should "render the :text" do
+
+      it "render the :text" do
         assert_equal "burp!!!", @mum.invoke(:eating)
       end
     end
-    
-    should "accept :state and options" do
+
+    it "accept :state and options" do
       @mum.instance_eval { def eat(what); render :text => "#{what} today?"; end }
-      
+
       assert_equal "Rice today?", @mum.render({:state => :eat}, "Rice")
       assert_match "Rice today?", @mum.update({:state => :eat}, "Rice")
       assert_match "Rice today?", @mum.replace({:state => :eat}, "Rice")
     end
-    
-    should "expose its instance variables in the rendered view" do
+
+    it "expose its instance variables in the rendered view" do
       @mum = mouse('mum') do
         def educate
           @who  = "the cat"
@@ -40,95 +40,95 @@ class RenderTest < ActionView::TestCase
       end
       assert_equal 'If you see the cat do run away!', @mum.invoke(:educate)
     end
-    
-    context "with #render" do
-      context "and :text" do
-        setup do
+
+    describe "with #render" do
+      describe "and :text" do
+        before do
           @mum.instance_eval do
             def squeak
               render :text => "squeak();"
             end
           end
         end
-        
-        should "just return the plain :text" do
+
+        it "just return the plain :text" do
           assert_equal 'squeak();', @mum.invoke(:squeak)
         end
       end
-      
-      context "and no options" do
-        setup do
+
+      describe "and no options" do
+        before do
           @mum.instance_eval do
             def squeak
               render
             end
           end
         end
-        
-        should "render the view" do
+
+        it "render the view" do
           assert_equal "<div id=\"mum\">burp!</div>",  @mum.invoke(:eating)
         end
       end
-      
-      context "and :view" do
-        setup do
+
+      describe "and :view" do
+        before do
           @mum.instance_eval do
             def squeak
               render :view => :eating
             end
           end
         end
-        
-        should "render the :view" do
+
+        it "render the :view" do
           assert_equal "<div id=\"mum\">burp!</div>", @mum.invoke(:squeak)
         end
       end
     end
-    
-    context "#update" do
-      should "wrap the :text in an update statement" do
+
+    describe "#update" do
+      it "wrap the :text in an update statement" do
         @mum.instance_eval do
           def squeak
             update :text => "squeak!"
           end
         end
-        assert_equal "$(\"#mum\").html(\"squeak!\");", @mum.invoke(:squeak)
+        assert_equal "jQuery(\"#mum\").html(\"squeak!\");", @mum.invoke(:squeak)
       end
-      
-      should "accept a selector" do
+
+      it "accept a selector" do
         @mum.instance_eval do
           def squeak
             update "div#mouse", :text => '<div id="mum">squeak!</div>'
           end
         end
-        assert_equal "$(\"div#mouse\").html(\"<div id=\\\"mum\\\">squeak!<\\/div>\");", @mum.invoke(:squeak)
+        assert_equal "jQuery(\"div#mouse\").html(\"<div id=\\\"mum\\\">squeak!<\\/div>\");", @mum.invoke(:squeak)
       end
     end
-    
-    context "#replace" do
-      should "wrap the :text in a replace statement" do
+
+    describe "#replace" do
+      it "wrap the :text in a replace statement" do
         @mum.instance_eval do
           def squeak
             replace :text => '<div id="mum">squeak!</div>'
           end
         end
-        assert_equal "$(\"#mum\").replaceWith(\"<div id=\\\"mum\\\">squeak!<\\/div>\");", @mum.invoke(:squeak)
+        assert_equal "jQuery(\"#mum\").replaceWith(\"<div id=\\\"mum\\\">squeak!<\\/div>\");", @mum.invoke(:squeak)
       end
-      
-      should "accept a selector" do
+
+      it "accept a selector" do
         @mum.instance_eval do
           def squeak
             replace "div#mouse", :text => '<div id="mum">squeak!</div>'
           end
         end
-        assert_equal "$(\"div#mouse\").replaceWith(\"<div id=\\\"mum\\\">squeak!<\\/div>\");", @mum.invoke(:squeak)
+        assert_equal "jQuery(\"div#mouse\").replaceWith(\"<div id=\\\"mum\\\">squeak!<\\/div>\");", @mum.invoke(:squeak)
       end
     end
-    
-    context "#escape_js" do
-      should "escape the string" do
+
+    describe "#escape_js" do
+      it "escape the string" do
         assert_equal "<div id=\\\"mum\\\">squeak!<\\/div>", @mum.escape_js('<div id="mum">squeak!</div>')
       end
     end
-  end  
+  end
 end

data/test/request_processor_test.rb

@@ -1,131 +1,131 @@
 require 'test_helper'
 
-class RequestProcessorTest < ActiveSupport::TestCase
+class RequestProcessorTest < MiniTest::Spec
   include Apotomo::TestCaseMethods::TestController
-  
+
   def root_mum_and_kid!
     mum_and_kid!
-    
+
     @root = Apotomo::Widget.new(parent_controller, 'root', :display)
     @root << @mum
   end
-  
-  
-  context "RequestProcessor" do
-    setup do
+
+
+  describe "RequestProcessor" do
+    before do
       @processor = Apotomo::RequestProcessor.new(parent_controller)
       root = @processor.root
       root << mouse_mock
     end
-    
-    should "allow external modification of the tree" do
+
+    it "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
+
+    it "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
+
+  describe "#attach_stateless_blocks_for" do
+    before do
       @processor  = Apotomo::RequestProcessor.new(parent_controller)
       @root       = @processor.root
       assert_equal @root.size, 1
     end
-    
-    should "allow has_widgets blocks with root parameter" do
+
+    it "allow has_widgets blocks with root parameter" do
       @processor.send(:attach_stateless_blocks_for, [Proc.new{ |root|
-        root << widget(:mouse, 'mouse') 
+        root << widget(:mouse, 'mouse')
       }], @root, parent_controller)
-      
+
       assert_equal 'mouse', @processor.root['mouse'].name
     end
   end
-    
-  context "option processing at construction time" do
-    context "with empty options" do
-      setup do
+
+  describe "option processing at construction time" do
+    describe "with empty options" do
+      before do
         @processor = Apotomo::RequestProcessor.new(parent_controller)
       end
-      
-      should "provide a single root-node for #root" do
+
+      it "provide a single root-node for #root" do
         assert_equal 1, @processor.root.size
       end
     end
-    
-    context "with controller" do
-      should "attach the passed parent_controller to root" do
+
+    describe "with controller" do
+      it "attach the passed parent_controller to root" do
         assert_equal parent_controller, Apotomo::RequestProcessor.new(parent_controller, {}, []).root.parent_controller
       end
     end
   end
-  
-  
-  context "#process_for" do
-    setup do
+
+
+  describe "#process_for" do
+    before do
       class KidWidget < Apotomo::Widget
         responds_to_event :doorSlam, :with => :flight
         responds_to_event :doorSlam, :with => :squeak
         def flight; render :text => "away from here!"; end
         def squeak; render :text => "squeak!"; end
       end
-  
-      procs = [Proc.new{ |root| 
-        root << widget(:mouse, 'mum') 
+
+      procs = [Proc.new{ |root|
+        root << widget(:mouse, 'mum')
           KidWidget.new(root['mum'], 'kid')
       }]
-    
+
       @processor = Apotomo::RequestProcessor.new(parent_controller, {:js_framework => :prototype}, procs)
     end
-    
-    should "return an empty array if nothing was triggered" do
+
+    it "return an empty array if nothing was triggered" do
       assert_equal [], @processor.process_for({:type => :mouseClick, :source => 'kid'})
     end
-    
-    should "return 2 page updates when @kid squeaks" do
+
+    it "return 2 page updates when @kid squeaks" do
       assert_equal ["away from here!", "squeak!"], @processor.process_for({:type => :doorSlam, :source => 'kid'})
     end
-    
-    should "append the params hash to the triggered event" do
+
+    it "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
+
+    it "raise an exception when :source is unknown" do
       assert_raises Apotomo::RequestProcessor::InvalidSourceWidget do
         @processor.process_for({:type => :squeak, :source => 'tom'})
       end
     end
   end
-  
-  
-    
-  
-  context "invoking #address_for" do
-    setup do
+
+
+
+
+  describe "invoking #address_for" do
+    before do
       @processor = Apotomo::RequestProcessor.new(parent_controller)
     end
-    
-    should "accept an event :type" do
+
+    it "accept an event :type" do
       assert_equal({:type => :squeak, :source => 'mum'}, @processor.address_for(:type => :squeak, :source => 'mum'))
     end
-    
-    should "accept arbitrary options" do
+
+    it "accept arbitrary options" do
       assert_equal({:type => :squeak, :volume => 'loud', :source => 'mum'}, @processor.address_for(:type => :squeak, :volume => 'loud', :source => 'mum'))
     end
-    
-    should "complain if no type given" do
+
+    it "complain if no type given" do
       assert_raises RuntimeError do
         @processor.address_for(:source => 'mum')
       end
     end
-    
-    should "complain if no source given" do
+
+    it "complain if no source given" do
       assert_raises RuntimeError do
         @processor.address_for(:type => :footsteps)
       end
@@ -133,12 +133,12 @@ class RequestProcessorTest < ActiveSupport::TestCase
   end
 end
 
-class RequestProcessorHooksTest < ActiveSupport::TestCase
+class RequestProcessorHooksTest < MiniTest::Spec
   include Apotomo::TestCaseMethods::TestController
   include Apotomo::TestCaseMethods
-  
-  context "Hooks in RequestProcessor" do
-    setup do
+
+  describe "Hooks in RequestProcessor" do
+    before do
       @kid = mouse_mock(:kid)
       @class = Class.new(Apotomo::RequestProcessor)
       @class.instance_eval do
@@ -147,31 +147,31 @@ class RequestProcessorHooksTest < ActiveSupport::TestCase
       end
       @class.kid = @kid
     end
-    
-    context ":after_initialize hook" do
-      should "be called after the has_widgets blocks invokation" do
+
+    describe ":after_initialize hook" do
+      it "be called after the has_widgets blocks invokation" do
         @class.after_initialize do |r|
           r.root[:mum] << self.class.kid # requires that :mum is there, yet.
         end
-        
-        @r = @class.new(parent_controller, {}, 
+
+        @r = @class.new(parent_controller, {},
           [Proc.new { |root| root << widget(:mouse, :mum) }])
-        
+
         assert @r.root[:mum][:kid]
       end
     end
-    
-    context ":after_fire hook" do
-      should "be called in #process_for after fire" do
+
+    describe ":after_fire hook" do
+      it "be called in #process_for after fire" do
         @class.after_fire do |r|
           r.root[:mum] << self.class.kid
         end
-        
+
         # DISCUSS: maybe add a trigger test here?
-        @r = @class.new(parent_controller, {}, 
+        @r = @class.new(parent_controller, {},
           [Proc.new { |root| root << widget(:mouse, :mum) }])
         @r.process_for(:source => "root", :type => :noop) # calls ~after_fire.
-        
+
         assert @r.root[:mum][:kid]
       end
     end

data/test/test_case_test.rb

@@ -1,60 +1,60 @@
 require 'test_helper'
 require 'apotomo/test_case'
 
-class TestCaseTest < Test::Unit::TestCase
-  
+class TestCaseTest < MiniTest::Spec
+
   class CommentsWidgetTest < Apotomo::TestCase
   end
-  
+
   class CommentsWidget < Apotomo::Widget
   end
-  
-  context "TestCase" do
-    
-    context "responding to #root" do
+
+  describe "TestCase" do
+
+    describe "responding to #root" do
       class MouseWidgetTest < Apotomo::TestCase
       end
-  
-      setup do
+
+      before do
         @klass = MouseWidgetTest
         @test = @klass.new(:widget).tap{ |t| t.setup }
         @klass.has_widgets { |r| r << widget(:mouse, 'mum', :eating) }
       end
-      
-      should "respond to #root" do  
+
+      it "respond to #root" do
         assert_equal ['root', 'mum'], @test.root.collect { |w| w.name }
       end
-      
-      should "raise an error if no has_widgets block given" do
+
+      it "raise an error if no has_widgets block given" do
         exc = assert_raises RuntimeError do
           @test = Class.new(Apotomo::TestCase).new(:widget).tap{ |t| t.setup }
           @test.root
         end
-        
+
         assert_equal "Please setup a widget tree using has_widgets()", exc.message
       end
-      
-      should "memorize root" do
+
+      it "memorize root" do
         @test.root.visible=false
         assert_equal false, @test.root.visible?
       end
-      
-      should "respond to #render_widget" do
+
+      it "respond to #render_widget" do
         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
+
+      it "respond to #assert_select" do
         @test.render_widget('mum', :eat)
-        
-        assert_nothing_raised { @test.assert_select("div#mum", "burp!") } 
-        
+
+        @test.assert_select("div#mum", "burp!")
+
         exc = assert_raises( MiniTest::Assertion){  @test.assert_select("div#mummy", "burp!"); }
-        assert_equal 'Expected at least 1 element matching "div#mummy", found 0.', exc.message 
+        assert_match /Expected at least 1 element matching "div#mummy", found 0/, exc.message
       end
-      
-      context "using events" do
-        setup do
+
+      describe "using events" do
+        before do
           @mum = @test.root['mum']
           @mum.respond_to_event :footsteps, :with => :squeak
           @mum.instance_eval do
@@ -63,28 +63,28 @@ class TestCaseTest < Test::Unit::TestCase
             end
           end
         end
-        
-        should "respond to #trigger" do
+
+        it "respond to #trigger" do
           assert_equal ["{}"], @test.trigger(:footsteps, 'mum')
         end
-        
-        should "pass options from #trigger to the evt" do
+
+        it "pass options from #trigger to the evt" do
           assert_equal(["{:direction=>:kitchen}"] , @test.trigger(:footsteps, 'mum', :direction => :kitchen))
         end
-        
-        should "respond to #assert_response" do
+
+        it "respond to #assert_response" do
           @test.trigger(:footsteps, 'mum')
           assert @test.assert_response("{}")
         end
       end
-      
-      context "#view_assigns" do
-        should "be emtpy when nothing was set" do
+
+      describe "#view_assigns" do
+        it "be emtpy when nothing was set" do
           @test.render_widget('mum')
           assert_equal({}, @test.view_assigns)
         end
-        
-        should "return the instance variables from the last #render_widget" do
+
+        it "return the instance variables from the last #render_widget" do
           @mum = @test.root['mum']
           @mum.instance_eval do
             def sleep
@@ -96,17 +96,17 @@ class TestCaseTest < Test::Unit::TestCase
         end
       end
     end
-    
-    context "responding to parent_controller" do
-      setup do
+
+    describe "responding to parent_controller" do
+      before do
         @test = Apotomo::TestCase.new(:widget).tap{ |t| t.setup }
       end
-      
-      should "provide a test controller" do
+
+      it "provide a test controller" do
         assert_kind_of ActionController::Base, @test.parent_controller
       end
-      
-      should "respond to #controller_path" do
+
+      it "respond to #controller_path" do
         assert_equal "barn", @test.parent_controller.controller_path
       end
     end

data/test/test_helper.rb

@@ -1,9 +1,4 @@
-# wycats says...
-require 'rubygems'
-require 'bundler'
-Bundler.setup
-
-require 'shoulda'
+require 'minitest/autorun'
 
 ENV['RAILS_ENV'] = 'test'
 require "dummy/config/environment"
@@ -18,10 +13,19 @@ Apotomo::Widget.append_view_path(File.expand_path(File.dirname(__FILE__) + "/wid
 require "test_case_methods"
 
 
-Test::Unit::TestCase.class_eval do
+MiniTest::Spec.class_eval do
+  include Apotomo::WidgetShortcuts
+  include Apotomo::TestCaseMethods
+
+  def assert_not(assertion)
+    assert !assertion
+  end
+end
+
+ActiveSupport::TestCase.class_eval do
   include Apotomo::WidgetShortcuts
   include Apotomo::TestCaseMethods
-  
+
   def assert_not(assertion)
     assert !assertion
   end
@@ -30,7 +34,7 @@ end
 class ApotomoController < ActionController::Base
   include Apotomo::Rails::ControllerMethods
   include Rails.application.routes.url_helpers
-  
+
   def mum
   end
 end
@@ -50,7 +54,7 @@ class MouseWidget < Apotomo::Widget
   def eat
     render
   end
-  
+
   def display
   end
 end

data/test/tree_node_test.rb

@@ -1,19 +1,14 @@
 require 'test_helper'
 
-class TreeNodeTest < ActiveSupport::TestCase
-  context "initialization" do
-    setup do
-      
-    end
-    
-    should "return true for #root? without parent" do
+class TreeNodeTest < MiniTest::Spec
+  describe "initialization" do
+    it "return true for #root? without parent" do
       assert MouseWidget.new(nil, :mum).root?
     end
-    
-    should "return false for #root? with parent" do
+
+    it "return false for #root? with parent" do
       @mum = MouseWidget.new(nil, :mum)
       assert_not MouseWidget.new(@mum, :kid).root?
     end
-    
   end
 end