Skip to content
This repository
tree: 7e10504bde
Fetching contributors…

Cannot retrieve contributors at this time

file 239 lines (193 sloc) 6.642 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")

module AbstractController
  module Testing
  
    # Test basic dispatching.
    # ====
    # * Call process
    # * Test that the response_body is set correctly
    class SimpleController < AbstractController::Base
    end
    
    class Me < SimpleController
      def index
        self.response_body = "Hello world"
        "Something else"
      end
    end
    
    class TestBasic < ActiveSupport::TestCase
      test "dispatching works" do
        result = Me.process(:index)
        assert_equal "Hello world", result.response_body
      end
    end
    
    # Test Render mixin
    # ====
    class RenderingController < AbstractController::Base
      include Renderer

      def _prefix() end

      def render(options = {})
        if options.is_a?(String)
          options = {:_template_name => options}
        end
        
        options[:_prefix] = _prefix
        super
      end

      append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views"))
    end
    
    class Me2 < RenderingController
      def index
        render "index.erb"
      end
      
      def action_with_ivars
        @my_ivar = "Hello"
        render "action_with_ivars.erb"
      end
      
      def naked_render
        render
      end

      def rendering_to_body
        self.response_body = render_to_body :_template_name => "naked_render.erb"
      end

      def rendering_to_string
        self.response_body = render_to_string :_template_name => "naked_render.erb"
      end
    end
    
    class TestRenderer < ActiveSupport::TestCase
      test "rendering templates works" do
        result = Me2.process(:index)
        assert_equal "Hello from index.erb", result.response_body
      end
      
      test "rendering passes ivars to the view" do
        result = Me2.process(:action_with_ivars)
        assert_equal "Hello from index_with_ivars.erb", result.response_body
      end
      
      test "rendering with no template name" do
        result = Me2.process(:naked_render)
        assert_equal "Hello from naked_render.erb", result.response_body
      end

      test "rendering to a rack body" do
        result = Me2.process(:rendering_to_body)
        assert_equal "Hello from naked_render.erb", result.response_body
      end

      test "rendering to a string" do
        result = Me2.process(:rendering_to_string)
        assert_equal "Hello from naked_render.erb", result.response_body
      end
    end
    
    # Test rendering with prefixes
    # ====
    # * self._prefix is used when defined
    class PrefixedViews < RenderingController
      private
      def self.prefix
        name.underscore
      end
      
      def _prefix
        self.class.prefix
      end
    end
    
    class Me3 < PrefixedViews
      def index
        render
      end
      
      def formatted
        self.formats = [:html]
        render
      end
    end
    
    class TestPrefixedViews < ActiveSupport::TestCase
      test "templates are located inside their 'prefix' folder" do
        result = Me3.process(:index)
        assert_equal "Hello from me3/index.erb", result.response_body
      end

      test "templates included their format" do
        result = Me3.process(:formatted)
        assert_equal "Hello from me3/formatted.html.erb", result.response_body
      end
    end
    
    # Test rendering with layouts
    # ====
    # self._layout is used when defined
    class WithLayouts < PrefixedViews
      include Layouts
      
      def self.inherited(klass)
        klass._write_layout_method
        super
      end
      
      private
      def self.layout(formats)
        begin
          view_paths.find_by_parts(name.underscore, {:formats => formats}, "layouts")
        rescue ActionView::MissingTemplate
          begin
            view_paths.find_by_parts("application", {:formats => formats}, "layouts")
          rescue ActionView::MissingTemplate
          end
        end
      end

      def render_to_body(options = {})
        options[:_layout] = options[:layout] || _default_layout
        super
      end
    end
    
    class Me4 < WithLayouts
      def index
        render
      end
    end
    
    class Me5 < WithLayouts
      def index
        render
      end
    end
    
    class TestLayouts < ActiveSupport::TestCase
      test "layouts are included" do
        result = Me4.process(:index)
        assert_equal "Me4 Enter : Hello from me4/index.erb : Exit", result.response_body
      end
    end
    
    # respond_to_action?(action_name)
    # ====
    # * A method can be used as an action only if this method
    # returns true when passed the method name as an argument
    # * Defaults to true in AbstractController
    class DefaultRespondToActionController < AbstractController::Base
      def index() self.response_body = "success" end
    end
    
    class ActionMissingRespondToActionController < AbstractController::Base
      # No actions
    private
      def action_missing(action_name)
        self.response_body = "success"
      end
    end
    
    class RespondToActionController < AbstractController::Base;
      def index() self.response_body = "success" end
        
      def fail() self.response_body = "fail" end
        
    private

      def method_for_action(action_name)
        action_name.to_s != "fail" && action_name
      end
    end
    
    class TestRespondToAction < ActiveSupport::TestCase
      
      def assert_dispatch(klass, body = "success", action = :index)
        response = klass.process(action).response_body
        assert_equal body, response
      end
      
      test "an arbitrary method is available as an action by default" do
        assert_dispatch DefaultRespondToActionController, "success", :index
      end
      
      test "raises ActionNotFound when method does not exist and action_missing is not defined" do
        assert_raise(ActionNotFound) { DefaultRespondToActionController.process(:fail) }
      end
      
      test "dispatches to action_missing when method does not exist and action_missing is defined" do
        assert_dispatch ActionMissingRespondToActionController, "success", :ohai
      end
      
      test "a method is available as an action if respond_to_action? returns true" do
        assert_dispatch RespondToActionController, "success", :index
      end
      
      test "raises ActionNotFound if method is defined but respond_to_action? returns false" do
        assert_raise(ActionNotFound) { RespondToActionController.process(:fail) }
      end
    end
    
  end
end
Something went wrong with that request. Please try again.