webroar 0.2.2 → 0.2.3

data/src/admin_panel/vendor/rails/actionpack/test/controller/flash_test.rb

@@ -1,142 +0,0 @@
-require 'abstract_unit'
-
-class FlashTest < ActionController::TestCase
-  class TestController < ActionController::Base
-    def set_flash
-      flash["that"] = "hello"
-      render :inline => "hello"
-    end
-
-    def set_flash_now
-      flash.now["that"] = "hello"
-      flash.now["foo"] ||= "bar"
-      flash.now["foo"] ||= "err"
-      @flashy = flash.now["that"]
-      @flash_copy = {}.update flash
-      render :inline => "hello"
-    end
-
-    def attempt_to_use_flash_now
-      @flash_copy = {}.update flash
-      @flashy = flash["that"]
-      render :inline => "hello"
-    end
-
-    def use_flash
-      @flash_copy = {}.update flash
-      @flashy = flash["that"]
-      render :inline => "hello"
-    end
-
-    def use_flash_and_keep_it
-      @flash_copy = {}.update flash
-      @flashy = flash["that"]
-      flash.keep
-      render :inline => "hello"
-    end
-    
-    def use_flash_and_update_it
-      flash.update("this" => "hello again")
-      @flash_copy = {}.update flash
-      render :inline => "hello"
-    end
-
-    def use_flash_after_reset_session
-      flash["that"] = "hello"
-      @flashy_that = flash["that"]
-      reset_session
-      @flashy_that_reset = flash["that"]
-      flash["this"] = "good-bye"
-      @flashy_this = flash["this"]
-      render :inline => "hello"
-    end
-
-    def rescue_action(e)
-      raise unless ActionView::MissingTemplate === e
-    end
-
-    # methods for test_sweep_after_halted_filter_chain
-    before_filter :halt_and_redir, :only => "filter_halting_action"
-
-    def std_action
-      @flash_copy = {}.update(flash)
-    end
-
-    def filter_halting_action
-      @flash_copy = {}.update(flash)
-    end
-
-    def halt_and_redir
-      flash["foo"] = "bar"
-      redirect_to :action => "std_action"
-      @flash_copy = {}.update(flash)
-    end
-  end
-
-  tests TestController
-
-  def test_flash
-    get :set_flash
-
-    get :use_flash
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello", @response.template.assigns["flashy"]
-
-    get :use_flash
-    assert_nil @response.template.assigns["flash_copy"]["that"], "On second flash"
-  end
-
-  def test_keep_flash
-    get :set_flash
-    
-    get :use_flash_and_keep_it
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello", @response.template.assigns["flashy"]
-
-    get :use_flash
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"], "On second flash"
-
-    get :use_flash
-    assert_nil @response.template.assigns["flash_copy"]["that"], "On third flash"
-  end
-  
-  def test_flash_now
-    get :set_flash_now
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "bar"  , @response.template.assigns["flash_copy"]["foo"]
-    assert_equal "hello", @response.template.assigns["flashy"]
-
-    get :attempt_to_use_flash_now
-    assert_nil @response.template.assigns["flash_copy"]["that"]
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
-    assert_nil @response.template.assigns["flashy"]
-  end 
-  
-  def test_update_flash
-    get :set_flash
-    get :use_flash_and_update_it
-    assert_equal "hello",       @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"]
-    get :use_flash
-    assert_nil                  @response.template.assigns["flash_copy"]["that"], "On second flash"
-    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"], "On second flash"
-  end
-  
-  def test_flash_after_reset_session
-    get :use_flash_after_reset_session
-    assert_equal "hello",    @response.template.assigns["flashy_that"]
-    assert_equal "good-bye", @response.template.assigns["flashy_this"]
-    assert_nil   @response.template.assigns["flashy_that_reset"]
-  end 
-
-  def test_sweep_after_halted_filter_chain
-    get :std_action
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
-    get :filter_halting_action
-    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
-    get :std_action # follow redirection
-    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
-    get :std_action
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
-  end
-end

data/src/admin_panel/vendor/rails/actionpack/test/controller/header_test.rb

@@ -1,14 +0,0 @@
-require 'abstract_unit'
-
-class HeaderTest < Test::Unit::TestCase
-  def setup
-    @headers = ActionController::Http::Headers.new("HTTP_CONTENT_TYPE"=>"text/plain")
-  end
-  
-  def test_content_type_works
-    assert_equal "text/plain", @headers["Content-Type"]
-    assert_equal "text/plain", @headers["content-type"]
-    assert_equal "text/plain", @headers["CONTENT_TYPE"]
-    assert_equal "text/plain", @headers["HTTP_CONTENT_TYPE"]    
-  end
-end

data/src/admin_panel/vendor/rails/actionpack/test/controller/helper_test.rb

@@ -1,224 +0,0 @@
-require 'abstract_unit'
-
-ActionController::Base.helpers_dir = File.dirname(__FILE__) + '/../fixtures/helpers'
-
-class TestController < ActionController::Base
-  attr_accessor :delegate_attr
-  def delegate_method() end
-  def rescue_action(e) raise end
-end
-
-module Fun
-  class GamesController < ActionController::Base
-    def render_hello_world
-      render :inline => "hello: <%= stratego %>"
-    end
-
-    def rescue_action(e) raise end
-  end
-
-  class PdfController < ActionController::Base
-    def test
-      render :inline => "test: <%= foobar %>"
-    end
-
-    def rescue_action(e) raise end
-  end
-end
-
-class ApplicationController < ActionController::Base
-  helper :all
-end
-
-module LocalAbcHelper
-  def a() end
-  def b() end
-  def c() end
-end
-
-class HelperTest < Test::Unit::TestCase
-  def setup
-    # Increment symbol counter.
-    @symbol = (@@counter ||= 'A0').succ!.dup
-
-    # Generate new controller class.
-    controller_class_name = "Helper#{@symbol}Controller"
-    eval("class #{controller_class_name} < TestController; end")
-    @controller_class = self.class.const_get(controller_class_name)
-
-    # Set default test helper.
-    self.test_helper = LocalAbcHelper
-  end
-  
-  def test_deprecated_helper
-    assert_equal expected_helper_methods, missing_methods
-    assert_nothing_raised { @controller_class.helper TestHelper }
-    assert_equal [], missing_methods
-  end
-
-  def test_declare_helper
-    require 'abc_helper'
-    self.test_helper = AbcHelper
-    assert_equal expected_helper_methods, missing_methods
-    assert_nothing_raised { @controller_class.helper :abc }
-    assert_equal [], missing_methods
-  end
-
-  def test_declare_missing_helper
-    assert_equal expected_helper_methods, missing_methods
-    assert_raise(MissingSourceFile) { @controller_class.helper :missing }
-  end
-
-  def test_declare_missing_file_from_helper
-    require 'broken_helper'
-  rescue LoadError => e
-    assert_nil(/\bbroken_helper\b/.match(e.to_s)[1])
-  end
-
-  def test_helper_block
-    assert_nothing_raised {
-      @controller_class.helper { def block_helper_method; end }
-    }
-    assert master_helper_methods.include?('block_helper_method')
-  end
-
-  def test_helper_block_include
-    assert_equal expected_helper_methods, missing_methods
-    assert_nothing_raised {
-      @controller_class.helper { include HelperTest::TestHelper }
-    }
-    assert [], missing_methods
-  end
-
-  def test_helper_method
-    assert_nothing_raised { @controller_class.helper_method :delegate_method }
-    assert master_helper_methods.include?('delegate_method')
-  end
-
-  def test_helper_attr
-    assert_nothing_raised { @controller_class.helper_attr :delegate_attr }
-    assert master_helper_methods.include?('delegate_attr')
-    assert master_helper_methods.include?('delegate_attr=')
-  end
-
-  def test_helper_for_nested_controller
-    request  = ActionController::TestRequest.new
-    response = ActionController::TestResponse.new
-    request.action = 'render_hello_world'
-
-    assert_equal 'hello: Iz guuut!', Fun::GamesController.process(request, response).body
-  end
-
-  def test_helper_for_acronym_controller
-    request  = ActionController::TestRequest.new
-    response = ActionController::TestResponse.new
-    request.action = 'test'
-
-    assert_equal 'test: baz', Fun::PdfController.process(request, response).body
-  end
-
-  def test_all_helpers
-    methods = ApplicationController.master_helper_module.instance_methods.map(&:to_s)
-
-    # abc_helper.rb
-    assert methods.include?('bare_a')
-
-    # fun/games_helper.rb
-    assert methods.include?('stratego')
-
-    # fun/pdf_helper.rb
-    assert methods.include?('foobar')
-  end
-
-  def test_all_helpers_with_alternate_helper_dir
-    @controller_class.helpers_dir = File.dirname(__FILE__) + '/../fixtures/alternate_helpers'
-
-    # Reload helpers
-    @controller_class.master_helper_module = Module.new
-    @controller_class.helper :all
-
-    # helpers/abc_helper.rb should not be included
-    assert !master_helper_methods.include?('bare_a')
-
-    # alternate_helpers/foo_helper.rb
-    assert master_helper_methods.include?('baz')
-  end
-
-  def test_helper_proxy
-    methods = ApplicationController.helpers.methods.map(&:to_s)
-
-    # ActionView
-    assert methods.include?('pluralize')
-
-    # abc_helper.rb
-    assert methods.include?('bare_a')
-
-    # fun/games_helper.rb
-    assert methods.include?('stratego')
-
-    # fun/pdf_helper.rb
-    assert methods.include?('foobar')
-  end
-
-  private
-    def expected_helper_methods
-      TestHelper.instance_methods.map(&:to_s)
-    end
-
-    def master_helper_methods
-      @controller_class.master_helper_module.instance_methods.map(&:to_s)
-    end
-
-    def missing_methods
-      expected_helper_methods - master_helper_methods
-    end
-
-    def test_helper=(helper_module)
-      silence_warnings { self.class.const_set('TestHelper', helper_module) }
-    end
-end
-
-
-class IsolatedHelpersTest < Test::Unit::TestCase
-  class A < ActionController::Base
-    def index
-      render :inline => '<%= shout %>'
-    end
-
-    def rescue_action(e) raise end
-  end
-
-  class B < A
-    helper { def shout; 'B' end }
-
-    def index
-      render :inline => '<%= shout %>'
-    end
-  end
-
-  class C < A
-    helper { def shout; 'C' end }
-
-    def index
-      render :inline => '<%= shout %>'
-    end
-  end
-
-  def setup
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    @request.action = 'index'
-  end
-
-  def test_helper_in_a
-    assert_raise(NameError) { A.process(@request, @response) }
-  end
-
-  def test_helper_in_b
-    assert_equal 'B', B.process(@request, @response).body
-  end
-
-  def test_helper_in_c
-    assert_equal 'C', C.process(@request, @response).body
-  end
-end

data/src/admin_panel/vendor/rails/actionpack/test/controller/html-scanner/cdata_node_test.rb

@@ -1,15 +0,0 @@
-require 'abstract_unit'
-
-class CDATANodeTest < Test::Unit::TestCase
-  def setup
-    @node = HTML::CDATA.new(nil, 0, 0, "<p>howdy</p>")
-  end
-
-  def test_to_s
-    assert_equal "<![CDATA[<p>howdy</p>]]>", @node.to_s
-  end
-
-  def test_content
-    assert_equal "<p>howdy</p>", @node.content
-  end
-end

data/src/admin_panel/vendor/rails/actionpack/test/controller/html-scanner/document_test.rb

@@ -1,148 +0,0 @@
-require 'abstract_unit'
-
-class DocumentTest < Test::Unit::TestCase
-  def test_handle_doctype
-    doc = nil
-    assert_nothing_raised do
-      doc = HTML::Document.new <<-HTML.strip
-        <!DOCTYPE "blah" "blah" "blah">
-        <html>
-        </html>
-      HTML
-    end
-    assert_equal 3, doc.root.children.length
-    assert_equal %{<!DOCTYPE "blah" "blah" "blah">}, doc.root.children[0].content
-    assert_match %r{\s+}m, doc.root.children[1].content
-    assert_equal "html", doc.root.children[2].name
-  end
-  
-  def test_find_img
-    doc = HTML::Document.new <<-HTML.strip
-      <html>
-        <body>
-          <p><img src="hello.gif"></p>
-        </body>
-      </html>
-    HTML
-    assert doc.find(:tag=>"img", :attributes=>{"src"=>"hello.gif"})
-  end
-
-  def test_find_all
-    doc = HTML::Document.new <<-HTML.strip
-      <html>
-        <body>
-          <p class="test"><img src="hello.gif"></p>
-          <div class="foo">
-            <p class="test">something</p>
-            <p>here is <em class="test">more</em></p>
-          </div>
-        </body>
-      </html>
-    HTML
-    all = doc.find_all :attributes => { :class => "test" }
-    assert_equal 3, all.length
-    assert_equal [ "p", "p", "em" ], all.map { |n| n.name }
-  end
-
-  def test_find_with_text
-    doc = HTML::Document.new <<-HTML.strip
-      <html>
-        <body>
-          <p>Some text</p>
-        </body>
-      </html>
-    HTML
-    assert doc.find(:content => "Some text")
-    assert doc.find(:tag => "p", :child => { :content => "Some text" })
-    assert doc.find(:tag => "p", :child => "Some text")
-    assert doc.find(:tag => "p", :content => "Some text")
-  end
-
-  def test_parse_xml
-    assert_nothing_raised { HTML::Document.new("<tags><tag/></tags>", true, true) }
-    assert_nothing_raised { HTML::Document.new("<outer><link>something</link></outer>", true, true) }
-  end
-
-  def test_parse_document
-    doc = HTML::Document.new(<<-HTML)
-      <div>
-        <h2>blah</h2>
-        <table>
-        </table>
-      </div>
-    HTML
-    assert_not_nil doc.find(:tag => "div", :children => { :count => 1, :only => { :tag => "table" } })
-  end
-
-  def test_tag_nesting_nothing_to_s
-    doc = HTML::Document.new("<tag></tag>")
-    assert_equal "<tag></tag>", doc.root.to_s
-  end
-
-  def test_tag_nesting_space_to_s
-    doc = HTML::Document.new("<tag> </tag>")
-    assert_equal "<tag> </tag>", doc.root.to_s
-  end
-
-  def test_tag_nesting_text_to_s
-    doc = HTML::Document.new("<tag>text</tag>")
-    assert_equal "<tag>text</tag>", doc.root.to_s
-  end
-
-  def test_tag_nesting_tag_to_s
-    doc = HTML::Document.new("<tag><nested /></tag>")
-    assert_equal "<tag><nested /></tag>", doc.root.to_s
-  end
-
-  def test_parse_cdata
-    doc = HTML::Document.new(<<-HTML)
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
-  <head>
-    <title><![CDATA[<br>]]></title>
-   </head>
-  <body>
-    <p>this document has &lt;br&gt; for a title</p>
-  </body>
-</html>
-HTML
-
-    assert_nil doc.find(:tag => "title", :descendant => { :tag => "br" })
-    assert doc.find(:tag => "title", :child => "<br>")
-  end
-
-  def test_find_empty_tag
-    doc = HTML::Document.new("<div id='map'></div>")
-    assert_nil doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /./)
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /\A\Z/)
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /^$/)
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => "")
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => nil)
-  end
-
-  def test_parse_invalid_document
-    assert_nothing_raised do
-      doc = HTML::Document.new("<html>
-        <table>
-          <tr>
-            <td style=\"color: #FFFFFF; height: 17px; onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" style=\"cursor:pointer; height: 17px;\"; nowrap onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" onmouseout=\"this.bgColor='#0066cc'; this.style.color='#FFFFFF'\" onmouseover=\"this.bgColor='#ffffff'; this.style.color='#0033cc'\">About Us</td>
-          </tr>
-        </table>
-      </html>")
-    end
-  end
-
-  def test_invalid_document_raises_exception_when_strict
-    assert_raise RuntimeError do
-      doc = HTML::Document.new("<html>
-        <table>
-          <tr>
-            <td style=\"color: #FFFFFF; height: 17px; onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" style=\"cursor:pointer; height: 17px;\"; nowrap onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" onmouseout=\"this.bgColor='#0066cc'; this.style.color='#FFFFFF'\" onmouseover=\"this.bgColor='#ffffff'; this.style.color='#0033cc'\">About Us</td>
-          </tr>
-        </table>
-      </html>", true)
-    end
-  end
-
-end

data/src/admin_panel/vendor/rails/actionpack/test/controller/html-scanner/node_test.rb

@@ -1,89 +0,0 @@
-require 'abstract_unit'
-
-class NodeTest < Test::Unit::TestCase
-  
-  class MockNode
-    def initialize(matched, value)
-      @matched = matched
-      @value = value
-    end
-    
-    def find(conditions)
-      @matched && self
-    end
-    
-    def to_s
-      @value.to_s
-    end
-  end
-  
-  def setup
-    @node = HTML::Node.new("parent")
-    @node.children.concat [MockNode.new(false,1), MockNode.new(true,"two"), MockNode.new(false,:three)]
-  end
-  
-  def test_match
-    assert !@node.match("foo")
-  end
-  
-  def test_tag
-    assert !@node.tag?
-  end
-  
-  def test_to_s
-    assert_equal "1twothree", @node.to_s
-  end
-  
-  def test_find
-    assert_equal "two", @node.find('blah').to_s
-  end
-
-  def test_parse_strict
-    s = "<b foo='hello'' bar='baz'>"
-    assert_raise(RuntimeError) { HTML::Node.parse(nil,0,0,s) }
-  end
-
-  def test_parse_relaxed
-    s = "<b foo='hello'' bar='baz'>"
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert node.attributes.has_key?("foo")
-    assert !node.attributes.has_key?("bar")
-  end
-
-  def test_to_s_with_boolean_attrs
-    s = "<b foo bar>"
-    node = HTML::Node.parse(nil,0,0,s)
-    assert node.attributes.has_key?("foo")
-    assert node.attributes.has_key?("bar")
-    assert "<b foo bar>", node.to_s
-  end
-  
-  def test_parse_with_unclosed_tag
-    s = "<span onmouseover='bang'"
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert node.attributes.has_key?("onmouseover")
-  end
-
-  def test_parse_with_valid_cdata_section
-    s = "<![CDATA[<span>contents</span>]]>"
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert_kind_of HTML::CDATA, node
-    assert_equal '<span>contents</span>', node.content
-  end
-
-  def test_parse_strict_with_unterminated_cdata_section
-    s = "<![CDATA[neverending..."
-    assert_raise(RuntimeError) { HTML::Node.parse(nil,0,0,s) }
-  end
-
-  def test_parse_relaxed_with_unterminated_cdata_section
-    s = "<![CDATA[neverending..."
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert_kind_of HTML::CDATA, node
-    assert_equal 'neverending...', node.content
-  end
-end