jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/test/dispatch/rack_cache_test.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "action_dispatch/http/rack_cache"
-
-class RackCacheMetaStoreTest < ActiveSupport::TestCase
-  class ReadWriteHash < ::Hash
-    alias :read  :[]
-    alias :write :[]=
-  end
-
-  setup do
-    @store = ActionDispatch::RailsMetaStore.new(ReadWriteHash.new)
-  end
-
-  test "stuff is deep duped" do
-    @store.write(:foo, bar: :original)
-    hash = @store.read(:foo)
-    hash[:bar] = :changed
-    hash = @store.read(:foo)
-    assert_equal :original, hash[:bar]
-  end
-end

data/vendor/rails/actionpack/test/dispatch/reloader_test.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class ReloaderTest < ActiveSupport::TestCase
-  teardown do
-    ActiveSupport::Reloader.reset_callbacks :prepare
-    ActiveSupport::Reloader.reset_callbacks :complete
-  end
-
-  class MyBody < Array
-    def initialize(&block)
-      @on_close = block
-    end
-
-    def foo
-      "foo"
-    end
-
-    def bar
-      "bar"
-    end
-
-    def close
-      @on_close.call if @on_close
-    end
-  end
-
-  def test_prepare_callbacks
-    a = b = c = nil
-    reloader.to_prepare { |*args| a = b = c = 1 }
-    reloader.to_prepare { |*args| b = c = 2 }
-    reloader.to_prepare { |*args| c = 3 }
-
-    # Ensure to_prepare callbacks are not run when defined
-    assert_nil a || b || c
-
-    # Run callbacks
-    call_and_return_body
-
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
-  end
-
-  def test_returned_body_object_always_responds_to_close
-    body = call_and_return_body
-    assert_respond_to body, :close
-  end
-
-  def test_returned_body_object_always_responds_to_close_even_if_called_twice
-    body = call_and_return_body
-    assert_respond_to body, :close
-    body.close
-
-    body = call_and_return_body
-    assert_respond_to body, :close
-    body.close
-  end
-
-  def test_condition_specifies_when_to_reload
-    i, j = 0, 0, 0, 0
-
-    reloader = reloader(lambda { i < 3 })
-    reloader.to_prepare { |*args| i += 1 }
-    reloader.to_complete { |*args| j += 1 }
-
-    app = middleware(lambda { |env| [200, {}, []] }, reloader)
-    5.times do
-      resp = app.call({})
-      resp[2].close
-    end
-    assert_equal 3, i
-    assert_equal 3, j
-  end
-
-  def test_returned_body_object_behaves_like_underlying_object
-    body = call_and_return_body do
-      b = MyBody.new
-      b << "hello"
-      b << "world"
-      [200, { "Content-Type" => "text/html" }, b]
-    end
-    assert_equal 2, body.size
-    assert_equal "hello", body[0]
-    assert_equal "world", body[1]
-    assert_equal "foo", body.foo
-    assert_equal "bar", body.bar
-  end
-
-  def test_it_calls_close_on_underlying_object_when_close_is_called_on_body
-    close_called = false
-    body = call_and_return_body do
-      b = MyBody.new do
-        close_called = true
-      end
-      [200, { "Content-Type" => "text/html" }, b]
-    end
-    body.close
-    assert close_called
-  end
-
-  def test_returned_body_object_responds_to_all_methods_supported_by_underlying_object
-    body = call_and_return_body do
-      [200, { "Content-Type" => "text/html" }, MyBody.new]
-    end
-    assert_respond_to body, :size
-    assert_respond_to body, :each
-    assert_respond_to body, :foo
-    assert_respond_to body, :bar
-  end
-
-  def test_complete_callbacks_are_called_when_body_is_closed
-    completed = false
-    reloader.to_complete { completed = true }
-
-    body = call_and_return_body
-    assert !completed
-
-    body.close
-    assert completed
-  end
-
-  def test_prepare_callbacks_arent_called_when_body_is_closed
-    prepared = false
-    reloader.to_prepare { prepared = true }
-
-    body = call_and_return_body
-    prepared = false
-
-    body.close
-    assert !prepared
-  end
-
-  def test_complete_callbacks_are_called_on_exceptions
-    completed = false
-    reloader.to_complete { completed = true }
-
-    begin
-      call_and_return_body do
-        raise "error"
-      end
-    rescue
-    end
-
-    assert completed
-  end
-
-  private
-    def call_and_return_body(&block)
-      app = middleware(block || proc { [200, {}, "response"] })
-      _, _, body = app.call("rack.input" => StringIO.new(""))
-      body
-    end
-
-    def middleware(inner_app, reloader = reloader())
-      ActionDispatch::Reloader.new(inner_app, reloader)
-    end
-
-    def reloader(check = lambda { true })
-      @reloader ||= begin
-                      reloader = Class.new(ActiveSupport::Reloader)
-                      reloader.check = check
-                      reloader
-                    end
-    end
-end

data/vendor/rails/actionpack/test/dispatch/request/json_params_parsing_test.rb

@@ -1,207 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class JsonParamsParsingTest < ActionDispatch::IntegrationTest
-  class TestController < ActionController::Base
-    class << self
-      attr_accessor :last_request_parameters
-    end
-
-    def parse
-      self.class.last_request_parameters = request.request_parameters
-      head :ok
-    end
-  end
-
-  def teardown
-    TestController.last_request_parameters = nil
-  end
-
-  test "parses json params for application json" do
-    assert_parses(
-      { "person" => { "name" => "David" } },
-      "{\"person\": {\"name\": \"David\"}}", "CONTENT_TYPE" => "application/json"
-    )
-  end
-
-  test "parses boolean and number json params for application json" do
-    assert_parses(
-      { "item" => { "enabled" => false, "count" => 10 } },
-      "{\"item\": {\"enabled\": false, \"count\": 10}}", "CONTENT_TYPE" => "application/json"
-    )
-  end
-
-  test "parses json params for application jsonrequest" do
-    assert_parses(
-      { "person" => { "name" => "David" } },
-      "{\"person\": {\"name\": \"David\"}}", "CONTENT_TYPE" => "application/jsonrequest"
-    )
-  end
-
-  test "does not parse unregistered media types such as application/vnd.api+json" do
-    assert_parses(
-      {},
-      "{\"person\": {\"name\": \"David\"}}", "CONTENT_TYPE" => "application/vnd.api+json"
-    )
-  end
-
-  test "nils are stripped from collections" do
-    assert_parses(
-      { "person" => [] },
-      "{\"person\":[null]}", "CONTENT_TYPE" => "application/json"
-    )
-    assert_parses(
-      { "person" => ["foo"] },
-      "{\"person\":[\"foo\",null]}", "CONTENT_TYPE" => "application/json"
-    )
-    assert_parses(
-      { "person" => [] },
-      "{\"person\":[null, null]}", "CONTENT_TYPE" => "application/json"
-    )
-  end
-
-  test "logs error if parsing unsuccessful" do
-    with_test_routing do
-      output = StringIO.new
-      json = "[\"person]\": {\"name\": \"David\"}}"
-      post "/parse", params: json, headers: { "CONTENT_TYPE" => "application/json", "action_dispatch.show_exceptions" => true, "action_dispatch.logger" => ActiveSupport::Logger.new(output) }
-      assert_response :bad_request
-      output.rewind && err = output.read
-      assert err =~ /Error occurred while parsing request parameters/
-    end
-  end
-
-  test "occurring a parse error if parsing unsuccessful" do
-    with_test_routing do
-      begin
-        $stderr = StringIO.new # suppress the log
-        json = "[\"person]\": {\"name\": \"David\"}}"
-        exception = assert_raise(ActionDispatch::Http::Parameters::ParseError) do
-          post "/parse", params: json, headers: { "CONTENT_TYPE" => "application/json", "action_dispatch.show_exceptions" => false }
-        end
-        assert_equal JSON::ParserError, exception.cause.class
-        assert_equal exception.cause.message, exception.message
-      ensure
-        $stderr = STDERR
-      end
-    end
-  end
-
-  test "raw_post is not empty for JSON request" do
-    with_test_routing do
-      post "/parse", params: '{"posts": [{"title": "Post Title"}]}', headers: { "CONTENT_TYPE" => "application/json" }
-      assert_equal '{"posts": [{"title": "Post Title"}]}', request.raw_post
-    end
-  end
-
-  private
-    def assert_parses(expected, actual, headers = {})
-      with_test_routing do
-        post "/parse", params: actual, headers: headers
-        assert_response :ok
-        assert_equal(expected, TestController.last_request_parameters)
-      end
-    end
-
-    def with_test_routing
-      with_routing do |set|
-        set.draw do
-          ActiveSupport::Deprecation.silence do
-            post ":action", to: ::JsonParamsParsingTest::TestController
-          end
-        end
-        yield
-      end
-    end
-end
-
-class RootLessJSONParamsParsingTest < ActionDispatch::IntegrationTest
-  class UsersController < ActionController::Base
-    wrap_parameters format: :json
-
-    class << self
-      attr_accessor :last_request_parameters, :last_parameters
-    end
-
-    def parse
-      self.class.last_request_parameters = request.request_parameters
-      self.class.last_parameters = params.to_unsafe_h
-      head :ok
-    end
-  end
-
-  def teardown
-    UsersController.last_request_parameters = nil
-  end
-
-  test "parses json params for application json" do
-    assert_parses(
-      { "user" => { "username" => "sikachu" }, "username" => "sikachu" },
-      "{\"username\": \"sikachu\"}", "CONTENT_TYPE" => "application/json"
-    )
-  end
-
-  test "parses json params for application jsonrequest" do
-    assert_parses(
-      { "user" => { "username" => "sikachu" }, "username" => "sikachu" },
-      "{\"username\": \"sikachu\"}", "CONTENT_TYPE" => "application/jsonrequest"
-    )
-  end
-
-  test "parses json with non-object JSON content" do
-    assert_parses(
-      { "user" => { "_json" => "string content" }, "_json" => "string content" },
-      "\"string content\"", "CONTENT_TYPE" => "application/json"
-    )
-  end
-
-  test "parses json params after custom json mime type registered" do
-    begin
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w(application/vnd.rails+json)
-      assert_parses(
-        { "user" => { "username" => "meinac" }, "username" => "meinac" },
-        "{\"username\": \"meinac\"}", "CONTENT_TYPE" => "application/json"
-      )
-    ensure
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest )
-    end
-  end
-
-  test "parses json params after custom json mime type registered with synonym" do
-    begin
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w(application/vnd.rails+json)
-      assert_parses(
-        { "user" => { "username" => "meinac" }, "username" => "meinac" },
-        "{\"username\": \"meinac\"}", "CONTENT_TYPE" => "application/vnd.rails+json"
-      )
-    ensure
-      Mime::Type.unregister :json
-      Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest )
-    end
-  end
-
-  private
-    def assert_parses(expected, actual, headers = {})
-      with_test_routing(UsersController) do
-        post "/parse", params: actual, headers: headers
-        assert_response :ok
-        assert_equal(expected, UsersController.last_request_parameters)
-        assert_equal(expected.merge("action" => "parse"), UsersController.last_parameters)
-      end
-    end
-
-    def with_test_routing(controller)
-      with_routing do |set|
-        set.draw do
-          ActiveSupport::Deprecation.silence do
-            post ":action", to: controller
-          end
-        end
-        yield
-      end
-    end
-end

data/vendor/rails/actionpack/test/dispatch/request/multipart_params_parsing_test.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class MultipartParamsParsingTest < ActionDispatch::IntegrationTest
-  class TestController < ActionController::Base
-    class << self
-      attr_accessor :last_request_parameters, :last_parameters
-    end
-
-    def parse
-      self.class.last_request_parameters = begin
-        request.request_parameters
-      rescue EOFError
-        {}
-      end
-      self.class.last_parameters = request.parameters
-      head :ok
-    end
-
-    def read
-      render plain: "File: #{params[:uploaded_data].read}"
-    end
-  end
-
-  FIXTURE_PATH = File.expand_path("../../fixtures/multipart", __dir__)
-
-  def teardown
-    TestController.last_request_parameters = nil
-  end
-
-  test "parses single parameter" do
-    assert_equal({ "foo" => "bar" }, parse_multipart("single_parameter"))
-  end
-
-  test "parses bracketed parameters" do
-    assert_equal({ "foo" => { "baz" => "bar" } }, parse_multipart("bracketed_param"))
-  end
-
-  test "parse single utf8 parameter" do
-    assert_equal({ "Iñtërnâtiônàlizætiøn_name" => "Iñtërnâtiônàlizætiøn_value" },
-                 parse_multipart("single_utf8_param"), "request.request_parameters")
-    assert_equal(
-      "Iñtërnâtiônàlizætiøn_value",
-      TestController.last_parameters["Iñtërnâtiônàlizætiøn_name"], "request.parameters")
-  end
-
-  test "parse bracketed utf8 parameter" do
-    assert_equal({ "Iñtërnâtiônàlizætiøn_name" => {
-      "Iñtërnâtiônàlizætiøn_nested_name" => "Iñtërnâtiônàlizætiøn_value" } },
-      parse_multipart("bracketed_utf8_param"), "request.request_parameters")
-    assert_equal(
-      { "Iñtërnâtiônàlizætiøn_nested_name" => "Iñtërnâtiônàlizætiøn_value" },
-      TestController.last_parameters["Iñtërnâtiônàlizætiøn_name"], "request.parameters")
-  end
-
-  test "parses text file" do
-    params = parse_multipart("text_file")
-    assert_equal %w(file foo), params.keys.sort
-    assert_equal "bar", params["foo"]
-
-    file = params["file"]
-    assert_equal "file.txt", file.original_filename
-    assert_equal "text/plain", file.content_type
-    assert_equal "contents", file.read
-  end
-
-  test "parses utf8 filename with percent character" do
-    params = parse_multipart("utf8_filename")
-    assert_equal %w(file foo), params.keys.sort
-    assert_equal "bar", params["foo"]
-
-    file = params["file"]
-    assert_equal "ファイル%名.txt", file.original_filename
-    assert_equal "text/plain", file.content_type
-    assert_equal "contents", file.read
-  end
-
-  test "parses boundary problem file" do
-    params = parse_multipart("boundary_problem_file")
-    assert_equal %w(file foo), params.keys.sort
-
-    file = params["file"]
-    foo  = params["foo"]
-
-    assert_equal "file.txt", file.original_filename
-    assert_equal "text/plain", file.content_type
-
-    assert_equal "bar", foo
-  end
-
-  test "parses large text file" do
-    params = parse_multipart("large_text_file")
-    assert_equal %w(file foo), params.keys.sort
-    assert_equal "bar", params["foo"]
-
-    file = params["file"]
-
-    assert_equal "file.txt", file.original_filename
-    assert_equal "text/plain", file.content_type
-    assert_equal(("a" * 20480), file.read)
-  end
-
-  test "parses binary file" do
-    params = parse_multipart("binary_file")
-    assert_equal %w(file flowers foo), params.keys.sort
-    assert_equal "bar", params["foo"]
-
-    file = params["file"]
-    assert_equal "file.csv", file.original_filename
-    assert_nil file.content_type
-    assert_equal "contents", file.read
-
-    file = params["flowers"]
-    assert_equal "flowers.jpg", file.original_filename
-    assert_equal "image/jpeg", file.content_type
-    assert_equal 19512, file.size
-  end
-
-  test "parses mixed files" do
-    params = parse_multipart("mixed_files")
-    assert_equal %w(files foo), params.keys.sort
-    assert_equal "bar", params["foo"]
-
-    # Rack doesn't handle multipart/mixed for us.
-    files = params["files"]
-    assert_equal 19756, files.bytesize
-  end
-
-  test "does not create tempfile if no file has been selected" do
-    params = parse_multipart("none")
-    assert_equal %w(submit-name), params.keys.sort
-    assert_equal "Larry", params["submit-name"]
-    assert_nil params["files"]
-  end
-
-  test "parses empty upload file" do
-    params = parse_multipart("empty")
-    assert_equal %w(files submit-name), params.keys.sort
-    assert_equal "Larry", params["submit-name"]
-    assert params["files"]
-    assert_equal "", params["files"].read
-  end
-
-  test "uploads and reads binary file" do
-    with_test_routing do
-      fixture = FIXTURE_PATH + "/ruby_on_rails.jpg"
-      params = { uploaded_data: fixture_file_upload(fixture, "image/jpg") }
-      post "/read", params: params
-    end
-  end
-
-  test "uploads and reads file" do
-    with_test_routing do
-      post "/read", params: { uploaded_data: fixture_file_upload(FIXTURE_PATH + "/hello.txt", "text/plain") }
-      assert_equal "File: Hello", response.body
-    end
-  end
-
-  # This can happen in Internet Explorer when redirecting after multipart form submit.
-  test "does not raise EOFError on GET request with multipart content-type" do
-    with_routing do |set|
-      set.draw do
-        ActiveSupport::Deprecation.silence do
-          get ":action", controller: "multipart_params_parsing_test/test"
-        end
-      end
-      headers = { "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x" }
-      get "/parse", headers: headers
-      assert_response :ok
-    end
-  end
-
-  private
-    def fixture(name)
-      File.open(File.join(FIXTURE_PATH, name), "rb") do |file|
-        { "rack.input" => file.read,
-          "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
-          "CONTENT_LENGTH" => file.stat.size.to_s }
-      end
-    end
-
-    def parse_multipart(name)
-      with_test_routing do
-        headers = fixture(name)
-        post "/parse", params: headers.delete("rack.input"), headers: headers
-        assert_response :ok
-        TestController.last_request_parameters
-      end
-    end
-
-    def with_test_routing
-      with_routing do |set|
-        set.draw do
-          ActiveSupport::Deprecation.silence do
-            post ":action", controller: "multipart_params_parsing_test/test"
-          end
-        end
-        yield
-      end
-    end
-end