cells 2.3.0

data/test/helper_test.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/../../../../test/test_helper'
+require File.dirname(__FILE__) + '/testing_helper'
+
+# usually done by rails' autoloading:
+require File.dirname(__FILE__) + '/cells/test_cell'
+
+class CellsHelperTest < ActionController::TestCase
+  include CellsTestMethods
+  
+  
+  def test_helper
+    cell = HelperUsingCell.new(@controller)
+
+    content = cell.render_state(:state_with_helper_invocation)
+    assert_selekt content, "p#stateWithHelperInvocation", "mysterious"
+  end
+  
+  #ActiveSupport::Dependencies.load_paths << RAILS_ROOT + "/vendor/plugins/cells/test/helpers"
+  # test if the HelperUsingCellHelper is automatically included:
+  
+  ## FIXME: currently loading should happen in render_view_for_state, since
+  #   there seems to be no automatic mechanism.
+  def dont_test_auto_helper
+    #ActionController::Base.helpers_dir = RAILS_ROOT + "/vendor/plugins/cells/test/helpers"
+    
+    Cell::Base.helpers_dir = RAILS_ROOT + "/vendor/plugins/cells/test/helpers"
+    setup
+    
+    cell = HelperUsingCell.new(@controller)
+
+    content = cell.render_state(:state_with_automatic_helper_invocation)
+    assert_selekt content, "p#stateWithAutomaticHelperInvocation", "automatic"
+  end
+
+  def test_helper_method
+    cell = HelperUsingCell.new(@controller)
+
+    content = cell.render_state(:state_with_helper_method_invocation)
+    assert_selekt content, "p#stateWithHelperMethodInvocation", "helped by a method"
+  end
+
+  def test_helper_with_subclassing
+    subclassedcell = HelperUsingSubCell.new(@controller)
+    content = subclassedcell.render_state(:state_with_helper_invocation)
+    assert_selekt content, "p#stateWithHelperInvocation", "mysterious"
+  end
+
+  def test_helper_including_and_cleanup
+    # this cell includes a helper, and uses it:
+    cell = HelperUsingCell.new(@controller)
+
+    content = cell.render_state(:state_with_helper_invocation)
+    assert_selekt content, "p#stateWithHelperInvocation", "mysterious"
+
+    # this cell doesn't include the helper, but uses it anyway, which should
+    # produce an error:
+
+    cell = TestCell.new(@controller)
+
+#    assert_raises (NameError) do
+     assert_raises (ActionView::TemplateError) do
+      cell.render_state(:state_with_not_included_helper_method)
+    end
+  end
+  
+  
+  def test_helpers_included_on_different_inheritance_levels
+    cell = TwoHelpersIncludingCell.new(@controller)
+
+    c = cell.render_state(:state_with_helper_invocation)
+    assert_selekt c, "p#stateWithHelperInvocation", "mysterious"
+    
+    c = cell.render_state(:state_using_another_helper)
+    assert_selekt c, "p#stateUsingAnotherHelper", "senseless"
+  end
+  
+  
+  def test_application_helper
+    cell = HelperUsingCell.new(@controller)
+
+    c = cell.render_state(:state_using_application_helper)
+    assert_selekt c, "p#stateUsingApplicationHelper", "global"
+  end
+  
+  def test_rails_helper_url_for
+    cell = HelperUsingCell.new(@controller)
+    cell.instance_eval do
+      def state_with_url_for
+        render :inline => "<%= url_for '/test' %>"
+      end
+    end
+    
+    c = cell.render_state(:state_with_url_for)
+    assert_equal "/test", c
+  end
+end
+
+
+module ApplicationHelper
+  def application_helper_method
+    "global"
+  end
+end
+
+
+module CellsTestHelper
+  def a_mysterious_helper_method
+    "mysterious"
+  end
+end
+
+
+module AnotherHelper
+  def senseless_helper_method
+    "senseless"
+  end
+end
+
+
+class HelperUsingCell < Cell::Base
+  helper CellsTestHelper
+  
+  def state_with_helper_invocation
+    render
+  end
+
+  def state_with_automatic_helper_invocation
+    render
+  end
+
+  def state_with_helper_method_invocation
+    render
+  end
+  
+  def state_using_application_helper
+    render
+  end
+
+protected
+
+  def my_helper_method
+    "helped by a method"
+  end
+
+  helper_method :my_helper_method
+end
+
+class TwoHelpersIncludingCell < HelperUsingCell
+  
+  helper AnotherHelper
+  
+  def state_using_another_helper
+    render
+  end
+end
+
+
+class HelperUsingSubCell < HelperUsingCell
+end

data/test/helpers/helper_using_cell_helper.rb

@@ -0,0 +1,5 @@
+module HelperUsingCellHelper
+  def an_automatically_included_helper_method
+    "automatic"
+  end
+end

data/test/rails_extensions_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../test/test_helper'
+require File.dirname(__FILE__) + '/testing_helper'
+
+class ACell < Cell::Base
+  def existing_view
+    @a = "a"; render
+  end
+end
+
+### DISCUSS: rename file. just found out that rails automagically tries to load a file named
+### after the test, which fails with RailsExtensions.
+
+class RenderCellTest < ActionController::TestCase
+  include CellsTestMethods
+  include Cell::ActionController
+  
+  def test_render_cell
+    assert_equal "A/existing_view/a", render_cell(:a, :existing_view)
+  end
+  
+  # #render_cell_to_string is just an alias of #render_cell
+  def test_render_cell_to_string
+    assert_equal render_cell_to_string(:a, :existing_view), render_cell(:a, :existing_view)
+  end
+end

data/test/render_test.rb

@@ -0,0 +1,229 @@
+require File.dirname(__FILE__) + '/../../../../test/test_helper'
+require File.dirname(__FILE__) + '/testing_helper'
+
+class ACell < Cell::Base
+  def existing_view
+    @a = "a"; render
+  end
+  
+  def not_existing_view
+    @a = "a"; render
+  end
+end
+
+class BCell < ACell
+  def existing_view
+    @b = "b"; render
+  end
+  
+  def not_existing_view
+    @b = "b"; render
+  end
+end
+
+class RenderTest < ActionController::TestCase
+  include CellsTestMethods
+  include Cell::ActionView
+  
+  def test_return_nil_with_locally_existing_view
+    assert_equal "A/existing_view/a", render_cell(:a, :existing_view)
+    assert_equal "B/existing_view/b", render_cell(:b, :existing_view)
+  end
+  
+  def test_return_nil_with_inherited_view
+    BCell.class_eval do   
+      def inherited_view;   @a = "b"; render; end
+    end
+    assert_equal "A/inherited_view/b", render_cell(:b, :inherited_view)
+  end
+  
+  def test_render_with_not_existing_view
+    assert_raises ActionView::MissingTemplate do render_cell(:a, :not_existing_view)  end
+    assert_raises ActionView::MissingTemplate do render_cell(:b, :not_existing_view)  end
+  end
+  
+  def test_render_without_arguments_with_locally_existing_view
+    ACell.class_eval do
+      def existing_view;    @a = "a"; render; end
+    end
+    BCell.class_eval do
+      def existing_view;    @b = "b"; render; end
+    end
+    assert_equal "A/existing_view/a", render_cell(:a, :existing_view)
+    assert_equal "B/existing_view/b", render_cell(:b, :existing_view)
+  end
+  
+  def test_render_passing_view_with_locally_existing_view
+    ACell.class_eval do
+      def existing_view;    @a = "a"; render :view => "existing_view"; end
+    end
+    BCell.class_eval do
+      def existing_view;    @b = "b"; render :view => "existing_view"; end
+    end
+    assert_equal "A/existing_view/a", render_cell(:a, :existing_view)
+    assert_equal "B/existing_view/b", render_cell(:b, :existing_view)
+  end
+  
+  def test_render_passing_view_and_layout_with_locally_existing_view
+    BCell.class_eval do
+      def existing_view;    @b = "b"; 
+        render :view => "existing_view", :layout => "metal"; end
+    end
+    assert_equal "Metal:B/existing_view/b", render_cell(:b, :existing_view)
+  end
+  
+  def test_render_passing_view_and_template_format_with_locally_existing_view
+    BCell.class_eval do
+      def existing_view;    @b = "b"; 
+        render :view => "existing_view", :template_format => :js; end
+    end
+    assert_equal "B/existing_view/b/js", render_cell(:b, :existing_view)
+  end
+  
+  def test_render_passing_view_and_template_format_and_layout_with_locally_existing_view
+    BCell.class_eval do
+      def existing_view;    @b = "b"; 
+        render :view => "existing_view", :template_format => :js, :layout => "metal"; end
+    end
+    assert_equal "Metal:B/existing_view/b/js", render_cell(:b, :existing_view)
+  end
+  
+  # test :layout
+  def test_render_passing_layout_located_in_cells_layout
+    ACell.class_eval do
+      def existing_view;    @a = "a"; 
+        render :layout => "metal"; end
+    end
+    assert_equal "Metal:A/existing_view/a", render_cell(:a, :existing_view)
+  end
+  
+  ### DISCUSS: currently undocumented feature:
+  def test_render_passing_layout_located_in_cells_b_layouts
+    BCell.class_eval do
+      def existing_view;    @b = "b"; 
+        render :layout => "b/layouts/metal"; end
+    end
+    assert_equal "B-Metal:B/existing_view/b", render_cell(:b, :existing_view)
+  end
+  
+  # test with inherited view:
+  def test_render_without_arguments_with_inherited_view
+    BCell.class_eval do
+      def inherited_view;   @a = "b"; render; end
+    end
+    assert_equal "A/inherited_view/b", render_cell(:b, :inherited_view)
+  end
+  
+  def test_render_passing_view_with_inherited_view
+    BCell.class_eval do
+      def existing_view;    @a = "b"; render :view => "inherited_view"; end
+    end
+    assert_equal "A/inherited_view/b", render_cell(:b, :existing_view)
+  end
+  
+  def test_render_passing_view_and_layout_with_inherited_view
+    BCell.class_eval do
+      def inherited_view;    @a = "b"; 
+        render :view => "inherited_view", :layout => "metal"; end
+    end
+    assert_equal "Metal:A/inherited_view/b", render_cell(:b, :inherited_view)
+  end
+  
+  def test_render_passing_view_and_template_format_with_inherited_view
+    BCell.class_eval do
+      def inherited_view;    @a = "b"; 
+        render :view => "inherited_view", :template_format => :js; end
+    end
+    assert_equal "A/inherited_view/b/js", render_cell(:b, :inherited_view)
+  end
+  
+  def test_render_passing_view_and_template_format_and_layout_with_inherited_view
+    BCell.class_eval do
+      def existing_view;    @a = "b"; 
+        render :view => "inherited_view", :template_format => :js, :layout => "metal"; end
+    end
+    assert_equal "Metal:A/inherited_view/b/js", render_cell(:b, :existing_view)
+  end
+  
+  
+  def test_render_passing_locals
+    ACell.class_eval do
+      def view_with_locals; @a = "a"; 
+        render :locals => {:name => "Nick"}; end
+    end
+    assert_equal "A/view_with_locals/a/Nick", render_cell(:a, :view_with_locals)
+  end
+  
+  
+  def test_recursive_render_view_with_existing_view
+    ACell.class_eval do
+      def view_with_render_call; @a = "a"; 
+        render; end
+    end
+    assert_equal "A/view_with_render_call/a:A/existing_view/a", render_cell(:a, :view_with_render_call)
+  end
+  
+  def test_recursive_render_view_with_inherited_view
+    BCell.class_eval do
+      def view_with_render_call; @a = "b"; 
+        render; end
+    end
+    assert_equal "B/view_with_render_call/b:A/inherited_view/b", render_cell(:b, :view_with_render_call)
+  end
+  
+  def test_render_text
+    ACell.class_eval do
+      def existing_view;
+        render :text => "Cells kick ass!"; end
+    end
+    assert_equal "Cells kick ass!", render_cell(:a, :existing_view)
+  end
+  
+  def test_render_text_with_layout
+    ACell.class_eval do
+      def existing_view;
+        render :text => "Cells kick ass!", :layout => 'metal'; end
+    end
+    assert_equal "Metal:Cells kick ass!", render_cell(:a, :existing_view)
+  end
+  
+  def test_render_nothing
+    ACell.class_eval do
+      def existing_view;
+        render :nothing => true; end
+    end
+    assert_equal "", render_cell(:a, :existing_view)
+  end
+  
+  def test_render_inline
+    ACell.class_eval do
+      def existing_view; @a = "a"; 
+        render :inline => 'A/existing_view/a:<%= a %>', :type => :erb, :locals => {:a=>'a'}; end
+    end
+    assert_equal "A/existing_view/a:a", render_cell(:a, :existing_view)
+  end
+  
+  def test_render_state
+    ACell.class_eval do
+      def existing_view; @a = "a"; 
+        render :state => :another_state
+      end
+      def another_state; @b = "b";
+        render
+      end
+    end
+    assert_equal "A/another_state/a,b", render_cell(:a, :existing_view)
+  end
+  
+  def test_render_state_with_layout
+    ACell.class_eval do
+      def existing_view; @a = "a"; 
+        render :state => :another_state, :layout => 'metal'
+      end
+      def another_state; @b = "b";
+        render
+      end
+    end
+    assert_equal "Metal:A/another_state/a,b", render_cell(:a, :existing_view)
+  end
+end

data/test/testing_helper.rb

@@ -0,0 +1,67 @@
+Cell::Base.add_view_path "vendor/plugins/cells/test/cells"
+Cell::Base.add_view_path "vendor/plugins/cells/test/cells/layouts"
+
+module CellsTestMethods
+  
+  def assert_selekt(content, *args)
+    assert_select(HTML::Document.new(content).root, *args)
+  end
+
+  def setup
+    @controller = CellTestController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @controller.request = @request
+    @controller.response = @response
+    @controller.params = {}
+  end
+  
+  def self.views_path
+    File.dirname(__FILE__) + '/views/'
+  end
+end
+
+
+
+class CellTestController < ApplicationController
+  def rescue_action(e) raise e end
+
+  def render_cell_state
+    cell  = params[:cell]
+    state = params[:state]
+
+    render :text => render_cell_to_string(cell, state)
+  end
+
+  def call_render_cell_with_strings
+    static = render_cell_to_string("my_test", "direct_output")
+    render :text => static
+  end
+
+  def call_render_cell_with_syms
+    static = render_cell_to_string(:my_test, :direct_output)
+    render :text => static
+  end
+
+  def call_render_cell_with_state_view
+    render :text => render_cell_to_string(:my_test, :view_with_instance_var)
+    return
+  end
+
+  def render_view_with_render_cell_invocation
+    render :file => "#{RAILS_ROOT}/vendor/plugins/cells/test/views/view_with_render_cell_invocation.html.erb"
+    return
+  end
+
+  def render_just_one_view_cell
+    static = render_cell_to_string("just_one_view", "some_state")
+    render :text => static
+  end
+  
+  
+  def render_state_with_link_to
+    static = render_cell_to_string("my_test", "state_with_link_to")
+    render :text => static
+  end
+
+end