cells 3.4.0 → 3.4.1

data/README.rdoc

@@ -115,14 +115,17 @@ There are multiple advanced options for expiring your view caches, including an
 
 Another big advantage compared to monolithic controller/helper/partial piles is the ability to test your cells isolated.
 
-So what if you wanna test the cart cell? Use the generated <tt>test/cells/shopping_cart_test.rb</tt> test.
+So what if you wanna test the cart cell? Use the generated <tt>test/cells/shopping_cart_cell_test.rb</tt> test.
 
-  class ShoppingCartTest < ActionController::TestCase
-    include Cells::AssertionsHelper
-    
+  class ShoppingCartCellTest < Cell::TestCase
     test "display" do
-      html = render_cell(:shopping_cart, :diplay, :user => @user_fixture)
-      assert_selekt html, "#cart", "You have 3 items in your shopping cart."
+      invoke :display, :user => @user_fixture
+      assert_select "#cart", "You have 3 items in your shopping cart."
+    end
+
+Run your tests with
+
+  $ rake test:cells
 
 That's easy, clean and strongly improves your component-driven software quality. How'd you do that with partials?
 

data/lib/cell/test_case.rb

@@ -0,0 +1,108 @@
+module Cell
+  # Test your cells.
+  #
+  # This class is roughly equal to ActionController::TestCase, exposing the same semantics. It will try 
+  # to infer the tested cell name from the test name if you use declarative testing. You can also set it
+  # with TestCase.tests.
+  #
+  # A declarative test would look like
+  #
+  #   class SellOutTest < Cell::TestCase
+  #     tests ShoppingCartCell
+  #
+  #     it "should be rendered nicely" do
+  #       invoke :order_button, :items => @fixture_items
+  #       
+  #       assert_select "button", "Order now!"
+  #     end
+  #
+  # You can also do stuff yourself, like
+  #
+  #     it "should be rendered even nicer" do
+  #       html = render_cell(:shopping_cart, :order_button, , :items => @fixture_items)
+  #       assert_selector "button", "Order now!", html
+  #     end
+  #
+  # Or even unit test your cell:
+  #
+  #     it "should provide #default_items" do
+  #       assert_equal [@item1, @item2], cell(:shopping_cart).default_items
+  #     end
+  #
+  # == Test helpers
+  #
+  # Basically, we got these new methods:
+  #
+  # +invoke+::  Renders the passed +state+ with your tested cell. You may pass options like in #render_cell.
+  # +render_cell+:: As in your views. Will return the rendered view.
+  # +assert_selector+:: Like #assert_select except that the last argument is the html markup you wanna test.     
+  # +cell+:: Gives you a cell instance for unit testing and stuff. 
+  class TestCase < ActiveSupport::TestCase
+    module AssertSelect
+      # Invokes assert_select for the last argument, the +content+ string.
+      #
+      # Example:
+      #   assert_selector "h1", "The latest and greatest!", "<h1>The latest and greatest!</h1>"
+      #
+      # would be true.
+      def assert_selector(*args, &block)
+        rails_assert_select(HTML::Document.new(args.pop).root, *args, &block)
+      end
+      
+      # Invokes assert_select on the markup set by the last #invoke.
+      #
+      # Example:
+      #   invoke :latest
+      #   assert_select "h1", "The latest and greatest!"
+      def assert_select(*args, &block)
+        super(HTML::Document.new(last_invoke).root, *args, &block)
+      end
+    end
+    
+    module TestMethods
+      def setup
+        @controller = Class.new(ActionController::Base).new
+        @request    = ::ActionController::TestRequest.new
+        @response   = ::ActionController::TestResponse.new
+        @controller.request = @request
+        @controller.response = @response
+        @controller.params = {}
+      end
+      
+      # Use this for functional tests of your application cells.
+      #
+      # Example:
+      #   should "spit out a h1 title" do
+      #     html = render_cell(:news, :latest)
+      #     assert_selekt html, "h1", "The latest and greatest!"
+      def render_cell(*args)
+        @controller.render_cell(*args)
+      end
+      
+      # Builds an instance of <tt>name</tt>Cell for unit testing.
+      # Passes the optional block to <tt>cell.instance_eval</tt>.
+      #
+      # Example:
+      #   assert_equal "Banks kill planet!" cell(:news, :topic => :terror).latest_headline
+      def cell(name, opts={}, &block)
+        cell = ::Cell::Base.create_cell_for(@controller, name, opts)
+        cell.instance_eval &block if block_given?
+        cell
+      end
+    end
+    
+    include TestMethods
+    include ActionDispatch::Assertions::SelectorAssertions  # imports "their" #assert_select.
+    alias_method :rails_assert_select, :assert_select # i hate that.
+    include AssertSelect
+    
+    extend ActionController::TestCase::Behavior::ClassMethods
+    
+    
+    attr_reader :last_invoke
+    
+    def invoke(state, *args)
+      @last_invoke = self.class.controller_class.new(@controller, *args).render_state(state)
+    end
+  end
+end

data/lib/cells.rb

@@ -63,7 +63,7 @@ require 'action_controller'
 require 'cell'
 require 'cells/rails'
 require 'cell/rails'
-
+require 'cell/test_case' if Rails.env == "test"
 
 module Cells
   # Any config should be placed here using +mattr_accessor+.
@@ -122,4 +122,8 @@ class Cells::Railtie < Rails::Railtie
     #ActiveSupport::Dependencies.load_paths << Rails.root.join(*%w[app cells])
     ### DISCUSS: how are cell classes found by Rails?
   end
+  
+  rake_tasks do
+    load "tasks.rake"
+  end 
 end

data/lib/cells/version.rb

@@ -1,3 +1,3 @@
 module Cells
-  VERSION = '3.4.0'
+  VERSION = '3.4.1'
 end

data/lib/generators/cells/USAGE

@@ -7,20 +7,12 @@ Description:
   
 Examples:
   
-  ./script/generate cell Announcements index
+  rails g cells:cell ShoppingCart index --haml
   
-  This will create an Announcements cell:
+  This will create these cell assets:
     Cell:
-      app/cells/announcements_cell.rb
+      app/cells/shopping_cart_cell.rb
     Views:
-      app/cells/announcements/index.html.erb
-      
-      
-  ./script/generate cell Articles popular recent --haml
-  
-  This will create an Articles cell:
-    Cell:
-      app/cells/articles_cell.rb
-    Views:
-      app/cells/articles/popular.html.haml
-      app/cells/articles/recent.html.haml
+      app/cells/shopping_cart/index.html.haml
+    Test:
+      test/cells/shopping_cart_cell_test

data/lib/generators/cells/templates/cell_test.rb

@@ -1,13 +1,11 @@
 require 'test_helper'
 
-class <%= class_name %>CellTest < ActionController::TestCase
-  include Cells::AssertionsHelper
-  
-  <% for state in @states -%>
+class <%= class_name %>CellTest < Cell::TestCase
+<% for state in @states -%>
   test "<%= state %>" do
-    html = render_cell(:<%= file_name %>, :<%= state %>)
-    assert_selekt html, "p"
+    invoke :<%= state %>
+    assert_select "p"
   end
   
-  <% end %>
-end
+<% end %>
+end

data/lib/tasks.rake

@@ -0,0 +1,6 @@
+namespace "test" do
+  TestTaskWithoutDescription.new(:cells => "test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/cells/**/*_test.rb'
+  end
+end

data/test/cell_generator_test.rb

@@ -20,7 +20,7 @@ class CellGeneratorTest < Rails::Generators::TestCase
         assert_file "app/cells/blog/post.html.erb", %r(<p>)
         assert_file "app/cells/blog/latest.html.erb", %r(app/cells/blog/latest\.html\.erb)
 
-        assert_file "test/cells/blog_cell_test.rb"
+        assert_file "test/cells/blog_cell_test.rb", %r(class BlogCellTest < Cell::TestCase)
       end
       
       should "create haml assets with --haml" do

data/test/cell_module_test.rb

@@ -1,6 +1,8 @@
 require 'test_helper'
 
 class CellModuleTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
+  
   context "Cell::Base" do
     
     should "provide AbstractBase.render_cell_for" do

data/test/dummy/tmp/test/cells/blog_cell_test.rb

@@ -1,17 +1,15 @@
 require 'test_helper'
 
-class BlogCellTest < ActionController::TestCase
-  include Cells::AssertionsHelper
-  
-    test "post" do
-    html = render_cell(:blog, :post)
-    assert_selekt html, "p"
+class BlogCellTest < Cell::TestCase
+  test "post" do
+    invoke :post
+    assert_select "p"
   end
   
-    test "latest" do
-    html = render_cell(:blog, :latest)
-    assert_selekt html, "p"
+  test "latest" do
+    invoke :latest
+    assert_select "p"
   end
   
-  
-end
+
+end

data/test/helper_test.rb

@@ -14,6 +14,8 @@ end
 
 
 class HelperTest < ActionController::TestCase
+  include Cell::TestCase::TestMethods
+  
   context "a cell view" do
     should "have access to all helpers" do
       BassistCell.class_eval do

data/test/rails/caching_test.rb

@@ -24,6 +24,8 @@ class DirectorCell < Cell::Rails
 end
 
 class CachingTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
+  
   context "The DirectorCell" do
     setup do
       DirectorCell.reset!

data/test/rails/cells_test.rb

@@ -1,6 +1,21 @@
 require 'test_helper'
 
 class RailsCellsTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
+  
+  def swap(object, new_values)
+    old_values = {}
+    new_values.each do |key, value|
+      old_values[key] = object.send key
+      object.send :"#{key}=", value
+    end
+    yield
+  ensure
+    old_values.each do |key, value|
+      object.send :"#{key}=", value
+    end
+  end
+  
   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)"

data/test/rails/render_test.rb

@@ -2,6 +2,8 @@ require 'test_helper'
 require 'builder'
 
 class RailsRenderTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
+  
   context "Invoking render" do
     
     should "render a plain view" do

data/test/rails/view_test.rb

@@ -1,6 +1,8 @@
 require 'test_helper'
 
 class RailsViewTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
+  
   context "A cell view" do
     context "calling render :partial" do
       should "render the cell partial in bassist/dii" do

data/test/test_case_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class TestCaseTest < Cell::TestCase
+  
+  context "A TestCase" do
+    setup do
+      @test = Cell::TestCase.new(:cell_test)
+      
+      BassistCell.class_eval do
+        def play; render; end
+      end
+    end
+    
+    
+    should "respond to #render_cell" do
+      assert_equal "Doo", render_cell(:bassist, :play)
+    end
+    
+    should "respond to #assert_selector with 3 args" do
+      assert_selector "p", "Doo", "<p>Doo</p>y"
+    end
+    
+    should "respond to #cell" do
+      assert_kind_of BassistCell, cell(:bassist)
+      assert !cell(:bassist).respond_to?(:opts)
+    end
+    
+    should "respond to #cell with a block" do
+      assert_respond_to cell(:bassist) { def opts; @opts; end }, :opts
+    end
+    
+    should "respond to #cell with options and block" do
+      assert_equal({:topic => :peace}, cell(:bassist, :topic => :peace) { def opts; @opts; end }.opts)
+    end
+    
+    context "in declarative tests" do
+      should "respond to TestCase.tests" do
+        self.class.tests BassistCell
+        assert_equal BassistCell, self.class.controller_class
+      end
+      
+      should "infer the cell name" do
+        class SingerCell < Cell::Rails
+        end
+        
+        class SingerCellTest < Cell::TestCase
+        end
+        
+        assert_equal SingerCell, SingerCellTest.new(:cell_test).class.controller_class
+      end
+      
+      context "with invoke" do
+        setup do
+          self.class.tests BassistCell
+        end
+        
+        should "provide #invoke" do
+          assert_equal "Doo", invoke(:play)
+        end
+        
+        should "provide #last_invoke" do
+          assert_equal nil, last_invoke
+          assert_equal "Doo", invoke(:play)
+          assert_equal "Doo", last_invoke
+        end
+        
+        should "provide #invoke accepting opts" do
+          #assert_equal "Doo", invoke(:play)
+        end
+        
+        should "provide assert_select" do
+          invoke :promote
+          assert_select "a", "vd.com"
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -26,14 +26,12 @@ require 'cells'
 Cell::Rails.append_view_path(File.join(test_app_dir, 'cells'))
 Cell::Rails.append_view_path(File.join(test_app_dir, 'cells', 'layouts'))
 
-
-Dir[File.join(gem_dir, 'test', 'support', '**', '*.rb')].each { |f| require f }
-require File.join(gem_dir, 'lib', 'cells', 'assertions_helper')
-
+require "cell/test_case"
 # Extend TestCase.
 ActiveSupport::TestCase.class_eval do
-  include Cells::AssertionsHelper
-  include Cells::InternalAssertionsHelper
+  def assert_not(assertion)
+    assert !assertion
+  end
 end
 
 # Enable dynamic states so we can do Cell.class_eval { def ... } at runtime.
@@ -45,4 +43,4 @@ require File.join(test_app_dir, 'cells', 'bassist_cell')
 require File.join(test_app_dir, 'cells', 'bad_guitarist_cell')
 
 require "haml"
-require "haml/template" # Thanks, Nathan!
+require "haml/template" # Thanks, Nathan!

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 3
   - 4
-  - 0
-  version: 3.4.0
+  - 1
+  version: 3.4.1
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-29 00:00:00 +02:00
+date: 2010-10-04 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -35,11 +35,10 @@ files:
 - Rakefile
 - lib/cell.rb
 - lib/cell/active_helper.rb
-- lib/cell/base.rb
 - lib/cell/caching.rb
 - lib/cell/rails.rb
+- lib/cell/test_case.rb
 - lib/cells.rb
-- lib/cells/assertions_helper.rb
 - lib/cells/helpers.rb
 - lib/cells/helpers/capture_helper.rb
 - lib/cells/rails.rb
@@ -50,8 +49,8 @@ files:
 - lib/generators/cells/templates/cell_test.rb
 - lib/generators/cells/templates/view.erb
 - lib/generators/cells/templates/view.haml
+- lib/tasks.rake
 - test/active_helper_test.rb
-- test/assertions_helper_test.rb
 - test/rails/router_test.rb
 - test/rails/view_test.rb
 - test/rails/capture_test.rb
@@ -61,7 +60,6 @@ files:
 - test/rails/caching_test.rb
 - test/cell_generator_test.rb
 - test/test_helper.rb
-- test/support/internal_assertions_helper.rb
 - test/dummy/config/application.rb
 - test/dummy/config/initializers/session_store.rb
 - test/dummy/config/initializers/mime_types.rb
@@ -79,6 +77,7 @@ files:
 - test/dummy/app/controllers/musician_controller.rb
 - test/dummy/app/controllers/application_controller.rb
 - test/dummy/app/helpers/application_helper.rb
+- test/test_case_test.rb
 - test/helper_test.rb
 - test/cell_module_test.rb
 - test/app/cells/bassist_cell.rb
@@ -120,7 +119,6 @@ specification_version: 3
 summary: View Components for Rails.
 test_files: 
 - test/active_helper_test.rb
-- test/assertions_helper_test.rb
 - test/rails/router_test.rb
 - test/rails/view_test.rb
 - test/rails/capture_test.rb
@@ -130,7 +128,6 @@ test_files:
 - test/rails/caching_test.rb
 - test/cell_generator_test.rb
 - test/test_helper.rb
-- test/support/internal_assertions_helper.rb
 - test/dummy/config/application.rb
 - test/dummy/config/initializers/session_store.rb
 - test/dummy/config/initializers/mime_types.rb
@@ -148,6 +145,7 @@ test_files:
 - test/dummy/app/controllers/musician_controller.rb
 - test/dummy/app/controllers/application_controller.rb
 - test/dummy/app/helpers/application_helper.rb
+- test/test_case_test.rb
 - test/helper_test.rb
 - test/cell_module_test.rb
 - test/app/cells/bassist_cell.rb

data/lib/cell/base.rb

@@ -1,134 +0,0 @@
-    # == Basic overview
-    #
-    # A Cell is the central notion of the cells plugin.  A cell acts as a
-    # lightweight controller in the sense that it will assign variables and
-    # render a view.  Cells can be rendered from other cells as well as from
-    # regular controllers and views (see ActionView::Base#render_cell and
-    # ControllerMethods#render_cell)
-    #
-    # == A render_cell() cycle
-    #
-    # A typical <tt>render_cell</tt> state rendering cycle looks like this:
-    #   render_cell :blog, :newest_article, {...}
-    # - an instance of the class <tt>BlogCell</tt> is created, and a hash containing
-    #   arbitrary parameters is passed
-    # - the <em>state method</em> <tt>newest_article</tt> is executed and assigns instance
-    #   variables to be used in the view
-    # - Usually the state method will call #render and return
-    # - #render will retrieve the corresponding view
-    #   (e.g. <tt>app/cells/blog/newest_article.html. [erb|haml|...]</tt>),
-    #   renders this template and returns the markup.
-    #
-    # == Design Principles
-    # A cell is a completely autonomous object and it should not know or have to know
-    # from what controller it is being rendered.  For this reason, the controller's
-    # instance variables and params hash are not directly available from the cell or
-    # its views. This is not a bug, this is a feature!  It means cells are truly
-    # reusable components which can be plugged in at any point in your application
-    # without having to think about what information is available at that point.
-    # When rendering a cell, you can explicitly pass variables to the cell in the
-    # extra opts argument hash, just like you would pass locals in partials.
-    # This hash is then available inside the cell as the @opts instance variable.
-    #
-    # == Directory hierarchy
-    #
-    # To get started creating your own cells, you can simply create a new directory
-    # structure under your <tt>app</tt> directory called <tt>cells</tt>.  Cells are
-    # ruby classes which end in the name Cell.  So for example, if you have a
-    # cell which manages all user information, it would be called <tt>UserCell</tt>.
-    # A cell which manages a shopping cart could be called <tt>ShoppingCartCell</tt>.
-    #
-    # The directory structure of this example would look like this:
-    #   app/
-    #     models/
-    #       ..
-    #     views/
-    #       ..
-    #     helpers/
-    #       application_helper.rb
-    #       product_helper.rb
-    #       ..
-    #     controllers/
-    #       ..
-    #     cells/
-    #       shopping_cart_cell.rb
-    #       shopping_cart/
-    #         status.html.erb
-    #         product_list.html.erb
-    #         empty_prompt.html.erb
-    #       user_cell.rb
-    #       user/
-    #         login.html.erb
-    #       layouts/
-    #         box.html.erb
-    #     ..
-    #
-    # The directory with the same name as the cell contains views for the
-    # cell's <em>states</em>.  A state is an executed method along with a
-    # rendered view, resulting in content. This means that states are to
-    # cells as actions are to controllers, so each state has its own view.
-    # The use of partials is deprecated with cells, it is better to just
-    # render a different state on the same cell (which also works recursively).
-    #
-    # Anyway, <tt>render :partial </tt> in a cell view will work, if the
-    # partial is contained in the cell's view directory.
-    #
-    # As can be seen above, Cells also can make use of helpers.  All Cells
-    # include ApplicationHelper by default, but you can add additional helpers
-    # as well with the ::Cell::Base.helper class method:
-    #   class ShoppingCartCell < ::Cell::Base
-    #     helper :product
-    #     ...
-    #   end
-    #
-    # This will make the <tt>ProductHelper</tt> from <tt>app/helpers/product_helper.rb</tt>
-    # available from all state views from our <tt>ShoppingCartCell</tt>.
-    #
-    # == Cell inheritance
-    #
-    # Unlike controllers, Cells can form a class hierarchy.  When a cell class
-    # is inherited by another cell class, its states are inherited as regular
-    # methods are, but also its views are inherited.  Whenever a view is looked up,
-    # the view finder first looks for a file in the directory belonging to the
-    # current cell class, but if this is not found in the application or any
-    # engine, the superclass' directory is checked.  This continues all the
-    # way up until it stops at ::Cell::Base.
-    #
-    # For instance, when you have two cells:
-    #   class MenuCell < ::Cell::Base
-    #     def show
-    #     end
-    #
-    #     def edit
-    #     end
-    #   end
-    #
-    #   class MainMenuCell < MenuCell
-    #     .. # no need to redefine show/edit if they do the same!
-    #   end
-    # and the following directory structure in <tt>app/cells</tt>:
-    #   app/cells/
-    #     menu/
-    #       show.html.erb
-    #       edit.html.erb
-    #     main_menu/
-    #       show.html.erb
-    # then when you call
-    #   render_cell :main_menu, :show
-    # the main menu specific show.html.erb (<tt>app/cells/main_menu/show.html.erb</tt>)
-    # is rendered, but when you call
-    #   render_cell :main_menu, :edit
-    # cells notices that the main menu does not have a specific view for the
-    # <tt>edit</tt> state, so it will render the view for the parent class,
-    # <tt>app/cells/menu/edit.html.erb</tt>
-    #
-    #
-    # == Gettext support
-    #
-    # Cells support gettext, just name your views accordingly. It works exactly equivalent
-    # to controller views.
-    #
-    #   cells/user/user_form.html.erb
-    #   cells/user/user_form_de.html.erb
-    #
-    # If gettext is set to DE_de, the latter view will be chosen.

data/lib/cells/assertions_helper.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-require 'action_controller/test_case'
-
-module Cells
-  module AssertionsHelper
-    # Sets up a mock controller for usage in render_cell.
-    def setup
-      @controller = Class.new(ActionController::Base).new
-      @request    = ::ActionController::TestRequest.new
-      @response   = ::ActionController::TestResponse.new
-      @controller.request = @request
-      @controller.response = @response
-      @controller.params = {}
-    end
-    
-    # Use this for functional tests of your application cells.
-    #
-    # Example:
-    #   should "spit out a h1 title" do
-    #     html = render_cell(:news, :latest)
-    #     assert_selekt html, "h1", "The latest and greatest!"
-    def render_cell(*args)
-      @controller.render_cell(*args)
-    end
-    
-    # Invokes assert_select for the passed <tt>content</tt> string.
-    #
-    # Example:
-    #   html = "<h1>The latest and greatest!</h1>"
-    #   assert_selekt html, "h1", "The latest and greatest!"
-    #
-    # would be true.
-    def assert_selekt(content, *args)
-      assert_select(HTML::Document.new(content).root, *args)
-    end
-    
-    # Builds an instance of <tt>name</tt>Cell for unit testing.
-    # Passes the optional block to <tt>cell.instance_eval</tt>.
-    #
-    # Example:
-    #   assert_equal "Banks kill planet!" cell(:news, :topic => :terror).latest_headline
-    def cell(name, opts={}, &block)
-      cell = ::Cell::Base.create_cell_for(@controller, name, opts)
-      cell.instance_eval &block if block_given?
-      cell
-    end
-  end
-end
-

data/test/assertions_helper_test.rb

@@ -1,32 +0,0 @@
-require 'test_helper'
-
-class AssertionsHelperTest < ActionController::TestCase
-  context "A TestCase" do
-    setup do
-      BassistCell.class_eval do
-        def play; render; end
-      end
-    end
-    
-    should "respond to #render_cell" do
-      assert_equal "Doo", render_cell(:bassist, :play)
-    end
-    
-    should "respond to #assert_selekt" do
-      assert_selekt "<p>Doo</p>", "p", "Doo"
-    end
-    
-    should "respond to #cell" do
-      assert_kind_of BassistCell, cell(:bassist)
-      assert_not cell(:bassist).respond_to? :opts
-    end
-    
-    should "respond to #cell with a block" do
-      assert_respond_to cell(:bassist) { def opts; @opts; end }, :opts
-    end
-    
-    should "respond to #cell with options and block" do
-      assert_equal({:topic => :peace}, cell(:bassist, :topic => :peace) { def opts; @opts; end }.opts)
-    end
-  end
-end

data/test/support/internal_assertions_helper.rb

@@ -1,69 +0,0 @@
-# encoding: utf-8
-module Cells
-  # Assertion helpers extracted from Devise by José Valim.
-  #
-  module InternalAssertionsHelper
-    def setup
-      @controller = ::MusicianController.new
-      @request    = ::ActionController::TestRequest.new
-      @response   = ::ActionController::TestResponse.new
-      @controller.request = @request
-      @controller.response = @response
-      @controller.params = {}
-    end
-      
-    def assert_not(assertion)
-      assert !assertion
-    end
-
-    def assert_blank(assertion)
-      assert assertion.blank?
-    end
-
-    def assert_not_blank(assertion)
-      assert !assertion.blank?
-    end
-    alias :assert_present :assert_not_blank
-
-    # Execute the block setting the given values and restoring old values after
-    # the block is executed.
-    #
-    # == Usage/Example:
-    #
-    #   I18n.locale   # => :en
-    #
-    #   swap(I18n :locale => :se) do
-    #     I18n.locale   # => :se
-    #   end
-    #
-    #   I18n.locale   # => :en
-    #
-    def swap(object, new_values)
-      old_values = {}
-      new_values.each do |key, value|
-        old_values[key] = object.send key
-        object.send :"#{key}=", value
-      end
-      yield
-    ensure
-      old_values.each do |key, value|
-        object.send :"#{key}=", value
-      end
-    end
-    
-    # Provides a TestCell instance. The <tt>block</tt> is passed to instance_eval and should be used
-    # to extend the mock on the fly.
-    ### DISCUSS: make an anonymous subclass of TestCell?
-    def cell_mock(options={}, &block) ### DISCUSS: 2BRM.
-      cell = TestCell.new(@controller, options)
-      cell.instance_eval(&block) if block_given?
-      cell
-    end
-    
-    def bassist_mock(options={}, &block)
-      cell = BassistCell.new(@controller, options)
-      cell.instance_eval(&block) if block_given?
-      cell
-    end
-  end
-end