jets 1.4.11 → 1.5.0

data/vendor/rails/actionpack/test/controller/new_base/bare_metal_test.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module BareMetalTest
+  class BareController < ActionController::Metal
+    def index
+      self.response_body = "Hello world"
+    end
+  end
+
+  class BareTest < ActiveSupport::TestCase
+    test "response body is a Rack-compatible response" do
+      status, headers, body = BareController.action(:index).call(Rack::MockRequest.env_for("/"))
+      assert_equal 200, status
+      string = "".dup
+
+      body.each do |part|
+        assert part.is_a?(String), "Each part of the body must be a String"
+        string << part
+      end
+
+      assert_kind_of Hash, headers, "Headers must be a Hash"
+      assert headers["Content-Type"], "Content-Type must exist"
+
+      assert_equal "Hello world", string
+    end
+
+    test "response_body value is wrapped in an array when the value is a String" do
+      controller = BareController.new
+      controller.set_request!(ActionDispatch::Request.empty)
+      controller.set_response!(BareController.make_response!(controller.request))
+      controller.index
+      assert_equal ["Hello world"], controller.response_body
+    end
+
+    test "connect a request to controller instance without dispatch" do
+      env = {}
+      controller = BareController.new
+      controller.set_request! ActionDispatch::Request.new(env)
+      assert controller.request
+    end
+  end
+
+  class BareEmptyController < ActionController::Metal
+    def index
+      self.response_body = nil
+    end
+  end
+
+  class BareEmptyTest < ActiveSupport::TestCase
+    test "response body is nil" do
+      controller = BareEmptyController.new
+      controller.set_request!(ActionDispatch::Request.empty)
+      controller.set_response!(BareController.make_response!(controller.request))
+      controller.index
+      assert_nil controller.response_body
+    end
+  end
+
+  class HeadController < ActionController::Metal
+    include ActionController::Head
+
+    def index
+      head :not_found
+    end
+
+    def continue
+      self.content_type = "text/html"
+      head 100
+    end
+
+    def switching_protocols
+      self.content_type = "text/html"
+      head 101
+    end
+
+    def processing
+      self.content_type = "text/html"
+      head 102
+    end
+
+    def no_content
+      self.content_type = "text/html"
+      head 204
+    end
+
+    def reset_content
+      self.content_type = "text/html"
+      head 205
+    end
+
+    def not_modified
+      self.content_type = "text/html"
+      head 304
+    end
+  end
+
+  class HeadTest < ActiveSupport::TestCase
+    test "head works on its own" do
+      status = HeadController.action(:index).call(Rack::MockRequest.env_for("/")).first
+      assert_equal 404, status
+    end
+
+    test "head :continue (100) does not return a content-type header" do
+      headers = HeadController.action(:continue).call(Rack::MockRequest.env_for("/")).second
+      assert_nil headers["Content-Type"]
+      assert_nil headers["Content-Length"]
+    end
+
+    test "head :switching_protocols (101) does not return a content-type header" do
+      headers = HeadController.action(:switching_protocols).call(Rack::MockRequest.env_for("/")).second
+      assert_nil headers["Content-Type"]
+      assert_nil headers["Content-Length"]
+    end
+
+    test "head :processing (102) does not return a content-type header" do
+      headers = HeadController.action(:processing).call(Rack::MockRequest.env_for("/")).second
+      assert_nil headers["Content-Type"]
+      assert_nil headers["Content-Length"]
+    end
+
+    test "head :no_content (204) does not return a content-type header" do
+      headers = HeadController.action(:no_content).call(Rack::MockRequest.env_for("/")).second
+      assert_nil headers["Content-Type"]
+      assert_nil headers["Content-Length"]
+    end
+
+    test "head :reset_content (205) does not return a content-type header" do
+      headers = HeadController.action(:reset_content).call(Rack::MockRequest.env_for("/")).second
+      assert_nil headers["Content-Type"]
+      assert_nil headers["Content-Length"]
+    end
+
+    test "head :not_modified (304) does not return a content-type header" do
+      headers = HeadController.action(:not_modified).call(Rack::MockRequest.env_for("/")).second
+      assert_nil headers["Content-Type"]
+      assert_nil headers["Content-Length"]
+    end
+
+    test "head :no_content (204) does not return any content" do
+      content = body(HeadController.action(:no_content).call(Rack::MockRequest.env_for("/")))
+      assert_empty content
+    end
+
+    test "head :reset_content (205) does not return any content" do
+      content = body(HeadController.action(:reset_content).call(Rack::MockRequest.env_for("/")))
+      assert_empty content
+    end
+
+    test "head :not_modified (304) does not return any content" do
+      content = body(HeadController.action(:not_modified).call(Rack::MockRequest.env_for("/")))
+      assert_empty content
+    end
+
+    test "head :continue (100) does not return any content" do
+      content = body(HeadController.action(:continue).call(Rack::MockRequest.env_for("/")))
+      assert_empty content
+    end
+
+    test "head :switching_protocols (101) does not return any content" do
+      content = body(HeadController.action(:switching_protocols).call(Rack::MockRequest.env_for("/")))
+      assert_empty content
+    end
+
+    test "head :processing (102) does not return any content" do
+      content = body(HeadController.action(:processing).call(Rack::MockRequest.env_for("/")))
+      assert_empty content
+    end
+
+    def body(rack_response)
+      buf = []
+      rack_response[2].each { |x| buf << x }
+      buf.join
+    end
+  end
+
+  class BareControllerTest < ActionController::TestCase
+    test "GET index" do
+      get :index
+      assert_equal "Hello world", @response.body
+    end
+  end
+end

data/vendor/rails/actionpack/test/controller/new_base/base_test.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+# Tests the controller dispatching happy path
+module Dispatching
+  class SimpleController < ActionController::Base
+    before_action :authenticate
+
+    def index
+      render body: "success"
+    end
+
+    def modify_response_body
+      self.response_body = "success"
+    end
+
+    def modify_response_body_twice
+      ret = (self.response_body = "success")
+      self.response_body = "#{ret}!"
+    end
+
+    def modify_response_headers
+    end
+
+    def show_actions
+      render body: "actions: #{action_methods.to_a.sort.join(', ')}"
+    end
+
+    private
+      def authenticate
+      end
+  end
+
+  class EmptyController < ActionController::Base ; end
+  class SubEmptyController < EmptyController ; end
+  class NonDefaultPathController < ActionController::Base
+    def self.controller_path; "i_am_not_default"; end
+  end
+
+  module Submodule
+    class ContainedEmptyController < ActionController::Base ; end
+    class ContainedSubEmptyController < ContainedEmptyController ; end
+    class ContainedNonDefaultPathController < ActionController::Base
+      def self.controller_path; "i_am_extremely_not_default"; end
+    end
+  end
+
+  class BaseTest < Rack::TestCase
+    test "simple dispatching" do
+      get "/dispatching/simple/index"
+
+      assert_body "success"
+      assert_status 200
+      assert_content_type "text/plain; charset=utf-8"
+    end
+
+    test "directly modifying response body" do
+      get "/dispatching/simple/modify_response_body"
+
+      assert_body "success"
+    end
+
+    test "directly modifying response body twice" do
+      get "/dispatching/simple/modify_response_body_twice"
+
+      assert_body "success!"
+    end
+
+    test "controller path" do
+      assert_equal "dispatching/empty", EmptyController.controller_path
+      assert_equal EmptyController.controller_path, EmptyController.new.controller_path
+    end
+
+    test "non-default controller path" do
+      assert_equal "i_am_not_default", NonDefaultPathController.controller_path
+      assert_equal NonDefaultPathController.controller_path, NonDefaultPathController.new.controller_path
+    end
+
+    test "sub controller path" do
+      assert_equal "dispatching/sub_empty", SubEmptyController.controller_path
+      assert_equal SubEmptyController.controller_path, SubEmptyController.new.controller_path
+    end
+
+    test "namespaced controller path" do
+      assert_equal "dispatching/submodule/contained_empty", Submodule::ContainedEmptyController.controller_path
+      assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path
+    end
+
+    test "namespaced non-default controller path" do
+      assert_equal "i_am_extremely_not_default", Submodule::ContainedNonDefaultPathController.controller_path
+      assert_equal Submodule::ContainedNonDefaultPathController.controller_path, Submodule::ContainedNonDefaultPathController.new.controller_path
+    end
+
+    test "namespaced sub controller path" do
+      assert_equal "dispatching/submodule/contained_sub_empty", Submodule::ContainedSubEmptyController.controller_path
+      assert_equal Submodule::ContainedSubEmptyController.controller_path, Submodule::ContainedSubEmptyController.new.controller_path
+    end
+
+    test "controller name" do
+      assert_equal "empty", EmptyController.controller_name
+      assert_equal "contained_empty", Submodule::ContainedEmptyController.controller_name
+    end
+
+    test "non-default path controller name" do
+      assert_equal "non_default_path", NonDefaultPathController.controller_name
+      assert_equal "contained_non_default_path", Submodule::ContainedNonDefaultPathController.controller_name
+    end
+
+    test "sub controller name" do
+      assert_equal "sub_empty", SubEmptyController.controller_name
+      assert_equal "contained_sub_empty", Submodule::ContainedSubEmptyController.controller_name
+    end
+
+    test "action methods" do
+      assert_equal Set.new(%w(
+        index
+        modify_response_headers
+        modify_response_body_twice
+        modify_response_body
+        show_actions
+      )), SimpleController.action_methods
+
+      assert_equal Set.new, EmptyController.action_methods
+      assert_equal Set.new, Submodule::ContainedEmptyController.action_methods
+
+      get "/dispatching/simple/show_actions"
+      assert_body "actions: index, modify_response_body, modify_response_body_twice, modify_response_headers, show_actions"
+    end
+  end
+end

data/vendor/rails/actionpack/test/controller/new_base/content_negotiation_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ContentNegotiation
+  # This has no layout and it works
+  class BasicController < ActionController::Base
+    self.view_paths = [ActionView::FixtureResolver.new(
+      "content_negotiation/basic/hello.html.erb" => "Hello world <%= request.formats.first.to_s %>!"
+    )]
+
+    def all
+      render plain: formats.inspect
+    end
+  end
+
+  class TestContentNegotiation < Rack::TestCase
+    test "A */* Accept header will return HTML" do
+      get "/content_negotiation/basic/hello", headers: { "HTTP_ACCEPT" => "*/*" }
+      assert_body "Hello world */*!"
+    end
+
+    test "Not all mimes are converted to symbol" do
+      get "/content_negotiation/basic/all", headers: { "HTTP_ACCEPT" => "text/plain, mime/another" }
+      assert_body '[:text, "mime/another"]'
+    end
+  end
+end

data/vendor/rails/actionpack/test/controller/new_base/content_type_test.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ContentType
+  class BaseController < ActionController::Base
+    def index
+      render body: "Hello world!"
+    end
+
+    def set_on_response_obj
+      response.content_type = Mime[:rss]
+      render body: "Hello world!"
+    end
+
+    def set_on_render
+      render body: "Hello world!", content_type: Mime[:rss]
+    end
+  end
+
+  class ImpliedController < ActionController::Base
+    # Template's mime type is used if no content_type is specified
+
+    self.view_paths = [ActionView::FixtureResolver.new(
+      "content_type/implied/i_am_html_erb.html.erb"         => "Hello world!",
+      "content_type/implied/i_am_xml_erb.xml.erb"           => "<xml>Hello world!</xml>",
+      "content_type/implied/i_am_html_builder.html.builder" => "xml.p 'Hello'",
+      "content_type/implied/i_am_xml_builder.xml.builder"   => "xml.awesome 'Hello'"
+    )]
+  end
+
+  class CharsetController < ActionController::Base
+    def set_on_response_obj
+      response.charset = "utf-16"
+      render body: "Hello world!"
+    end
+
+    def set_as_nil_on_response_obj
+      response.charset = nil
+      render body: "Hello world!"
+    end
+  end
+
+  class ExplicitContentTypeTest < Rack::TestCase
+    test "default response is text/plain and UTF8" do
+      with_routing do |set|
+        set.draw do
+          ActiveSupport::Deprecation.silence do
+            get ":controller", action: "index"
+          end
+        end
+
+        get "/content_type/base"
+
+        assert_body "Hello world!"
+        assert_header "Content-Type", "text/plain; charset=utf-8"
+      end
+    end
+
+    test "setting the content type of the response directly on the response object" do
+      get "/content_type/base/set_on_response_obj"
+
+      assert_body "Hello world!"
+      assert_header "Content-Type", "application/rss+xml; charset=utf-8"
+    end
+
+    test "setting the content type of the response as an option to render" do
+      get "/content_type/base/set_on_render"
+
+      assert_body "Hello world!"
+      assert_header "Content-Type", "application/rss+xml; charset=utf-8"
+    end
+  end
+
+  class ImpliedContentTypeTest < Rack::TestCase
+    test "sets Content-Type as text/html when rendering *.html.erb" do
+      get "/content_type/implied/i_am_html_erb"
+
+      assert_header "Content-Type", "text/html; charset=utf-8"
+    end
+
+    test "sets Content-Type as application/xml when rendering *.xml.erb" do
+      get "/content_type/implied/i_am_xml_erb", params: { "format" => "xml" }
+
+      assert_header "Content-Type", "application/xml; charset=utf-8"
+    end
+
+    test "sets Content-Type as text/html when rendering *.html.builder" do
+      get "/content_type/implied/i_am_html_builder"
+
+      assert_header "Content-Type", "text/html; charset=utf-8"
+    end
+
+    test "sets Content-Type as application/xml when rendering *.xml.builder" do
+      get "/content_type/implied/i_am_xml_builder", params: { "format" => "xml" }
+
+      assert_header "Content-Type", "application/xml; charset=utf-8"
+    end
+  end
+
+  class ExplicitCharsetTest < Rack::TestCase
+    test "setting the charset of the response directly on the response object" do
+      get "/content_type/charset/set_on_response_obj"
+
+      assert_body   "Hello world!"
+      assert_header "Content-Type", "text/plain; charset=utf-16"
+    end
+
+    test "setting the charset of the response as nil directly on the response object" do
+      get "/content_type/charset/set_as_nil_on_response_obj"
+
+      assert_body   "Hello world!"
+      assert_header "Content-Type", "text/plain; charset=utf-8"
+    end
+  end
+end