cells 3.3.10 → 3.4.0.beta1

data/test/rails/caching_test.rb

@@ -0,0 +1,215 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class DirectorCell < Cell::Rails
+  cache :count
+  @@counter = 0
+  
+  def count
+    @@counter += 1
+    render :text => @@counter
+  end 
+end
+
+class CachingTest < ActiveSupport::TestCase
+  context "A cell" do
+    setup do
+      ::ActionController::Base.cache_store = :memory_store
+      ::ActionController::Base.perform_caching = true
+    end
+    
+    should "respond to state_cached?" do
+      assert cell(:director).state_cached?(:count)
+      assert_not cell(:director).state_cached?(:sing)
+    end
+    
+    context "caching a state" do
+      setup do
+        @proc = Proc.new{}
+      end
+      
+      should "save the version proc" do
+        DirectorCell.cache :count, @proc
+        
+        assert_equal @proc, cell(:director).class.version_procs[:count]
+        assert_equal({}, cell(:director).class.cache_options[:count])
+      end
+      
+      should "save the cache options" do
+        DirectorCell.cache :count, @proc, :expires_in => 10.minutes
+
+        assert_equal @proc, cell(:director).class.version_procs[:count]
+        assert_equal({:expires_in => 10.minutes}, cell(:director).class.cache_options[:count])
+      end
+      
+      should "not mix caching configuration with other classes" do
+        DirectorCell.cache :count
+        class SecondDirectorCell < DirectorCell; end
+        SecondDirectorCell.cache :count, @proc
+        
+        assert_equal nil, cell(:director).class.version_procs[:count]
+        assert_equal @proc, cell(:"caching_test/second_director").class.version_procs[:count]
+      end
+    end
+    
+    context "caching without options" do
+      setup do
+        DirectorCell.class_eval do
+          @@counter = 0
+          cattr_accessor :count
+        end
+        
+                key = cell(:director).cache_key(:count, :count => 0)
+        Cell::Base.expire_cache_key(key)  ### TODO: separate test
+      end
+      
+      should "cache forever" do
+        DirectorCell.class_eval do
+          cache :count
+        end
+        
+        assert cell(:director).state_cached?(:count)
+        assert_equal nil, cell(:director).class.version_procs[:count]
+        assert_equal({}, cell(:director).class.cache_options[:count])
+        
+        assert_equal render_cell(:director, :count), render_cell(:director, :count)
+      end
+      
+      should "not cache at all" do
+        DirectorCell.class_eval do
+          def dictate
+            @@counter += 1
+            render :text => @@counter
+          end
+        end
+        
+        assert_equal "1", render_cell(:director, :dictate)
+        assert_equal "2", render_cell(:director, :dictate)
+      end
+      
+      should "expire the cache with a version proc" do
+        DirectorCell.class_eval do
+          cache :count, Proc.new { |cell|
+            cell.class.count >= 2 ? {:count => 2} : {:count => 0}
+          }
+          
+          def count
+            render :text => @@count += 1
+            #@@count
+          end 
+        end
+        DirectorCell.count = 0
+        
+        assert_equal "1", render_cell(:director, :count)
+        assert_equal "1", render_cell(:director, :count)  # cached.
+        
+        DirectorCell.count = 2  # invalidates the view cache.
+        assert_equal "3", render_cell(:director, :count)
+        assert_equal "3", render_cell(:director, :count)  # cached.
+      end
+      
+      should "expire the cache with an instance method" do
+        DirectorCell.class_eval do
+          cache :count, :expire_count
+          
+          def expire_count
+            self.class.count >= 2 ? {:count => 2} : {:count => 0}
+          end
+          
+          def count
+            @@count += 1
+            render :text => @@count
+          end 
+        end
+        DirectorCell.count = 0
+        
+        assert_equal "1", render_cell(:director, :count)
+        assert_equal "1", render_cell(:director, :count)  # cached.
+        
+        DirectorCell.count = 2  # invalidates the view cache.
+        assert_equal "3", render_cell(:director, :count)
+        assert_equal "3", render_cell(:director, :count)  # cached.
+      end
+    end
+  end
+
+  context "cache_key" do
+    setup do
+      @cell = cell(:director)
+    end
+    
+    should "respond to cache_key" do
+      assert_equal "cells/director/count", @cell.cache_key(:count)
+      assert_equal @cell.cache_key(:count), ::Cell::Base.cache_key_for(:director, :count)
+    end
+    
+    should "order options lexically" do
+      assert_equal "cells/director/count/a=1/b=2", @cell.cache_key(:count, :b => 2, :a => 1)
+    end
+  end
+  
+  context "expire_cache_key" do
+    setup do
+      DirectorCell.class_eval do
+        cache :count
+        def count
+          render :text => @@count += 1
+        end
+      end
+      DirectorCell.count = 0
+      
+      @key = cell(:director).cache_key(:count)
+      render_cell(:director, :count)
+      assert_equal "1", ::Cell::Base.cache_store.read(@key)
+    end
+    
+    should "delete the view from cache" do
+      ::Cell::Base.expire_cache_key(@key)
+      assert_not ::Cell::Base.cache_store.read(@key)
+    end
+    
+    should "be available in controllers for sweepers" do
+      MusicianController.new.expire_cell_state(:director, :count)
+      assert_not ::Cell::Base.cache_store.read(@key)
+    end
+    
+    should "accept cache options" do
+      key = cell(:director).cache_key(:count, :volume => 9)
+      assert ::Cell::Base.cache_store.write(key, 'ONE!')
+  
+      MusicianController.new.expire_cell_state(:director, :count, :volume => 9)
+      assert_not ::Cell::Base.cache_store.read(key)
+    end
+  end
+
+  def test_find_family_view_for_state_with_caching
+    # test environment: --------------------------------------
+    BassistCell.instance_variable_set :@state2view_cache, {}
+    assert_equal({}, BassistCell.state2view_cache)
+    
+    BassistCell.instance_eval do
+      self.default_template_format = :html
+      
+      def play; render; end
+    end
+    
+    
+    cell = cell(:bassist)
+    cell.class.instance_eval do
+      def cache_configured?; false; end
+    end
+    cell.render_state :play
+    # in development/test environment, no view name caching should happen,
+    # if perform_caching is false.
+    assert_equal({}, BassistCell.state2view_cache)
+
+    # production environment: --------------------------------
+    cell = BassistCell.new(@controller)
+    cell.class.instance_eval do
+      def cache_configured?; true; end
+    end
+    
+    cell.render_state :play
+    assert BassistCell.state2view_cache["play/html"] 
+  end
+end

data/test/rails/capture_test.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), '/../test_helper')
+
+class ProducerCell < Cell::Base
+  helper ::Cells::Helpers::CaptureHelper
+  
+  def logger(*args); puts args.inspect; end
+end
+
+class RailsCaptureTest < ActionController::TestCase
+  context "A Rails controller rendering cells" do
+    setup do
+      @routes = ActionDispatch::Routing::RouteSet.new
+      @routes.draw do
+        |map| match ':action', :to => MusicianController
+      end
+      @controller = MusicianController.new
+    end
+    
+    should "see content from global_capture" do
+      @controller.class_eval do
+        def featured
+          render :inline => '<h3><%= @recorded %></h3>' << render_cell(:producer, :capture)
+        end
+      end
+      
+      ProducerCell.class_eval do
+        def capture; render; end
+      end
+      
+      get 'featured'
+      assert_equal '<h3>DummDoo</h3> DummDoo', @response.body
+    end
+    
+    
+    should "see yieldable content from global_content_for" do
+      @controller.class_eval do
+        def featured
+          render_cell(:producer, :content_for)
+          render :inline => '<pre><%= yield :recorded %></pre>'
+        end
+      end
+      
+      ProducerCell.class_eval do
+        def content_for; render; end
+      end
+       
+      get 'featured'
+      assert_equal "\n<pre>DummDooDiiDoo</pre>", @response.body
+    end
+  end
+end

data/test/rails/cells_test.rb

@@ -0,0 +1,88 @@
+require File.join(File.dirname(__FILE__), '/../test_helper')
+
+
+class RailsCellsTest < ActiveSupport::TestCase
+  context "A rails cell" do
+    should "respond to view_paths" do
+      assert_kind_of ActionView::PathSet, Cell::Rails.view_paths, "must be a PathSet for proper template caching/reloading (see issue#2)"
+    end
+    
+    should "respond to view_paths=" do
+      swap( Cell::Base, :view_paths => ['you', 'are', 'here'])  do
+        assert_kind_of ActionView::PathSet, Cell::Base.view_paths, "must not wipe out the PathSet"
+      end
+    end
+    
+    
+    context "invoking defaultize_render_options_for" do
+      should "set default values" do
+        cell(:bassist).class.default_template_format = :html  ### FIXME: remove and get it working.
+        
+        options = cell(:bassist).defaultize_render_options_for({}, :play)
+        
+        assert_equal :html, options[:template_format]
+        assert_equal :play, options[:view]
+      end
+      
+      should "allow overriding defaults" do
+        assert cell(:bassist).defaultize_render_options_for({:view => :slap}, :play)[:view] == :slap
+      end
+    end
+    
+    context "invoking find_family_view_for_state" do
+      should "### use find_template" do
+        assert cell(:bassist).find_template("bassist/play")
+        assert_raises ActionView::MissingTemplate do
+          cell(:bassist).find_template("bassist/playyy")
+        end
+      end
+      
+      
+      should "return play.html.erb" do
+        assert_equal "bassist/play", cell(:bassist).find_family_view_for_state(:play).virtual_path
+      end
+      
+      should "find inherited play.html.erb" do
+        assert_equal "bassist/play", cell(:bad_guitarist).find_family_view_for_state(:play).virtual_path
+      end
+      
+      should_eventually "find the EN-version if i18n instructs" do
+        swap I18n, :locale => :en do
+          assert_equal "bassist/yell.en.html.erb", cell(:bassist).find_family_view_for_state(:yell).virtual_path
+        end
+      end
+      
+      
+      should_eventually "return an already cached family view"
+    end
+    
+    context "delegation" do
+      setup do
+        @request = ActionController::TestRequest.new 
+        @request.env["action_dispatch.request.request_parameters"] = {:song => "Creatures"}
+        @cell = cell(:bassist)
+        @cell.request= @request
+      end
+      
+      should_eventually "delegate log" do
+        assert_nothing_raised do
+          cell(:bassist).class.logger.info("everything is perfect!")
+        end
+      end
+      
+      should "respond to session" do
+        assert_kind_of Hash, @cell.session
+      end
+    end
+    
+    
+    should "precede cell ivars over controller ivars" do
+      @controller.instance_variable_set(:@note, "E")
+      BassistCell.class_eval do
+        def slap; @note = "A"; render; end
+      end
+      assert_equal "Boing in A", render_cell(:bassist, :slap)
+    end
+    
+  end   
+end

data/test/rails/integration_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '/../test_helper')
+
+require 'active_support/core_ext/object/to_query'
+
+class RailsIntegrationTest < ActionController::TestCase
+  
+  context "A Rails controller" do
+    setup do
+      @routes = ActionDispatch::Routing::RouteSet.new
+      @routes.draw do
+        |map| match ':action', :to => MusicianController
+      end
+      @controller = MusicianController.new
+    end
+    
+    should "respond to render_cell" do
+      get 'promotion'
+      assert_equal "Doo", @response.body
+    end
+    
+    should "respond to render_cell in the view" do
+      get 'featured'
+      assert_equal "Doo", @response.body
+    end
+    
+    should "make params (and friends) available in a cell" do
+      BassistCell.class_eval do
+        def listen
+          render :text => "That's a #{params[:note]}"
+        end
+      end
+      get 'skills', :note => "D"
+      assert_equal "That's a D", @response.body
+    end
+  end
+  
+end

data/test/rails/render_test.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(__FILE__), '/../test_helper')
+require 'builder'
+
+class RailsRenderTest < ActiveSupport::TestCase
+  context "Invoking render" do
+    
+    should "render a plain view" do
+      BassistCell.class_eval do
+        def play; render; end
+      end
+      assert_equal "Doo", render_cell(:bassist, :play)
+    end
+    
+    should "also render alternative engines" do
+      BassistCell.class_eval do
+        def sing; @xm = Builder::XmlMarkup.new; render; end
+      end
+      assert_equal "", render_cell(:bassist, :sing) ### FIXME: where's the rendered xml?
+    end
+    
+    should "accept the :template_format option" do
+      
+    end
+    
+    should "accept the :nothing option" do
+      BassistCell.class_eval do
+        def sleep; render :nothing => true; end
+      end
+      assert_equal "", render_cell(:bassist, :sleep)
+    end
+    
+    
+    should "accept the :view option" do
+      BassistCell.class_eval do
+        def solo; render :view => :play; end
+      end
+      assert_equal "Doo", render_cell(:bassist, :solo)
+    end
+    
+    should "accept the :text options" do
+      BassistCell.class_eval do
+        def sing; render :text => "Shoobie"; end
+      end
+      assert_equal "Shoobie", render_cell(:bassist, :sing)
+    end
+    
+    should "accept the :inline option" do
+      BassistCell.class_eval do
+        def sleep; render :inline => "<%= 'Snooore' %>"; end
+      end
+      assert_equal "Snooore", render_cell(:bassist, :sleep)
+    end
+    
+    should "accept the :state option" do
+      BassistCell.class_eval do
+        def play; render; end
+        def groove; render :state => :play; end
+      end
+      assert_equal "Doo", render_cell(:bassist, :groove)
+    end
+    
+    should "accept the :locals option" do
+      BassistCell.class_eval do
+        def ahem; render :locals => {:times => 2}; end
+      end
+      assert_equal "AhemAhem", render_cell(:bassist, :ahem)
+    end
+    
+    
+    # layout
+    should "accept the :layout option" do
+      BassistCell.class_eval do
+        def play; render :layout => 'b'; end
+      end
+      assert_equal "<b>Doo</b>", render_cell(:bassist, :play)
+    end
+    
+    should "raise an error for a non-existent template" do
+      BassistCell.class_eval do
+        def groove; render; end
+      end
+      
+      assert_raises ActionView::MissingTemplate do
+        render_cell(:bassist, :groove)
+      end
+      
+      ### TODO: test error message sanity.
+    end
+    
+    should "render instance variables from the cell" do
+      BassistCell.class_eval do
+        def slap
+          @note = "D"; render
+        end
+      end
+      assert_equal "Boing in D", render_cell(:bassist, :slap)
+    end
+    
+    should "allow subsequent calls to render in the rendered view" do
+      BassistCell.class_eval do
+        def jam; @chords = [:a, :c]; render; end
+        def play; render; end
+      end
+      assert_equal "Doo\nDoo\n", render_cell(:bassist, :jam)
+    end
+    
+    should "allow multiple calls to render" do
+      BassistCell.class_eval do
+        def play; render + render + render; end
+      end
+      assert_equal "DooDooDoo", render_cell(:bassist, :play)
+    end
+    
+    
+    
+    
+    # inheriting
+    should "inherit play.html.erb from BassistCell" do
+      assert_equal "Doo", render_cell(:bad_guitarist, :play)
+    end
+  end
+  
+  context "A cell view" do
+    # rails view api
+    should "allow calls to params/response/..." do
+      BassistCell.class_eval do
+        def pose; render; end
+      end
+      
+      @request.env["action_dispatch.request.request_parameters"] = {:what => 'get'}
+      @cell = cell(:bassist)
+      @cell.request = @request  ### FIXME.
+      
+      assert_equal "Come and get me!", @cell.render_state(:pose)
+    end
+    
+    
+  end
+  
+end