jets 1.9.7 → 1.9.8

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

@@ -1,184 +0,0 @@
-# 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

@@ -1,131 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,116 +0,0 @@
-# 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