jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/test/dispatch/system_testing/server_test.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "capybara/dsl"
-require "action_dispatch/system_testing/server"
-
-class ServerTest < ActiveSupport::TestCase
-  setup do
-    @old_capybara_server = Capybara.server
-  end
-
-  test "port is always included" do
-    ActionDispatch::SystemTesting::Server.new.run
-    assert Capybara.always_include_port, "expected Capybara.always_include_port to be true"
-  end
-
-  test "server is changed from `default` to `puma`" do
-    Capybara.server = :default
-    ActionDispatch::SystemTesting::Server.new.run
-    refute_equal Capybara.server, Capybara.servers[:default]
-  end
-
-  test "server is not changed to `puma` when is different than default" do
-    Capybara.server = :webrick
-    ActionDispatch::SystemTesting::Server.new.run
-    assert_equal Capybara.server, Capybara.servers[:webrick]
-  end
-
-  teardown do
-    Capybara.server = @old_capybara_server
-  end
-end

data/vendor/rails/actionpack/test/dispatch/system_testing/system_test_case_test.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class SetDriverToRackTestTest < DrivenByRackTest
-  test "uses rack_test" do
-    assert_equal :rack_test, Capybara.current_driver
-  end
-end
-
-class OverrideSeleniumSubclassToRackTestTest < DrivenBySeleniumWithChrome
-  driven_by :rack_test
-
-  test "uses rack_test" do
-    assert_equal :rack_test, Capybara.current_driver
-  end
-end
-
-class SetDriverToSeleniumTest < DrivenBySeleniumWithChrome
-  test "uses selenium" do
-    assert_equal :selenium, Capybara.current_driver
-  end
-end
-
-class SetDriverToSeleniumHeadlessChromeTest < DrivenBySeleniumWithHeadlessChrome
-  test "uses selenium headless chrome" do
-    assert_equal :selenium, Capybara.current_driver
-  end
-end
-
-class SetDriverToSeleniumHeadlessFirefoxTest < DrivenBySeleniumWithHeadlessFirefox
-  test "uses selenium headless firefox" do
-    assert_equal :selenium, Capybara.current_driver
-  end
-end
-
-class SetHostTest < DrivenByRackTest
-  test "sets default host" do
-    assert_equal "http://127.0.0.1", Capybara.app_host
-  end
-
-  test "overrides host" do
-    host! "http://example.com"
-
-    assert_equal "http://example.com", Capybara.app_host
-  end
-end
-
-class UndefMethodsTest < DrivenBySeleniumWithChrome
-  test "get" do
-    exception = assert_raise NoMethodError do
-      get "http://example.com"
-    end
-    assert_equal "System tests cannot make direct requests via #get; use #visit and #click_on instead. See http://www.rubydoc.info/github/teamcapybara/capybara/master#The_DSL for more information.", exception.message
-  end
-
-  test "post" do
-    exception = assert_raise NoMethodError do
-      post "http://example.com"
-    end
-    assert_equal "System tests cannot make direct requests via #post; use #visit and #click_on instead. See http://www.rubydoc.info/github/teamcapybara/capybara/master#The_DSL for more information.", exception.message
-  end
-
-  test "put" do
-    exception = assert_raise NoMethodError do
-      put "http://example.com"
-    end
-    assert_equal "System tests cannot make direct requests via #put; use #visit and #click_on instead. See http://www.rubydoc.info/github/teamcapybara/capybara/master#The_DSL for more information.", exception.message
-  end
-
-  test "patch" do
-    exception = assert_raise NoMethodError do
-      patch "http://example.com"
-    end
-    assert_equal "System tests cannot make direct requests via #patch; use #visit and #click_on instead. See http://www.rubydoc.info/github/teamcapybara/capybara/master#The_DSL for more information.", exception.message
-  end
-
-  test "delete" do
-    exception = assert_raise NoMethodError do
-      delete "http://example.com"
-    end
-    assert_equal "System tests cannot make direct requests via #delete; use #visit and #click_on instead. See http://www.rubydoc.info/github/teamcapybara/capybara/master#The_DSL for more information.", exception.message
-  end
-end

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

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class TestRequestTest < ActiveSupport::TestCase
-  test "sane defaults" do
-    env = ActionDispatch::TestRequest.create.env
-
-    assert_equal "GET", env.delete("REQUEST_METHOD")
-    assert_equal "off", env.delete("HTTPS")
-    assert_equal "http", env.delete("rack.url_scheme")
-    assert_equal "example.org", env.delete("SERVER_NAME")
-    assert_equal "80", env.delete("SERVER_PORT")
-    assert_equal "/", env.delete("PATH_INFO")
-    assert_equal "", env.delete("SCRIPT_NAME")
-    assert_equal "", env.delete("QUERY_STRING")
-    assert_equal "0", env.delete("CONTENT_LENGTH")
-
-    assert_equal "test.host", env.delete("HTTP_HOST")
-    assert_equal "0.0.0.0", env.delete("REMOTE_ADDR")
-    assert_equal "Rails Testing", env.delete("HTTP_USER_AGENT")
-
-    assert_equal [1, 3], env.delete("rack.version")
-    assert_equal "", env.delete("rack.input").string
-    assert_kind_of StringIO, env.delete("rack.errors")
-    assert_equal true, env.delete("rack.multithread")
-    assert_equal true, env.delete("rack.multiprocess")
-    assert_equal false, env.delete("rack.run_once")
-  end
-
-  test "cookie jar" do
-    req = ActionDispatch::TestRequest.create({})
-
-    assert_equal({}, req.cookies)
-    assert_nil req.env["HTTP_COOKIE"]
-
-    req.cookie_jar["user_name"] = "david"
-    assert_cookies({ "user_name" => "david" }, req.cookie_jar)
-
-    req.cookie_jar["login"] = "XJ-122"
-    assert_cookies({ "user_name" => "david", "login" => "XJ-122" }, req.cookie_jar)
-
-    assert_nothing_raised do
-      req.cookie_jar["login"] = nil
-      assert_cookies({ "user_name" => "david", "login" => nil }, req.cookie_jar)
-    end
-
-    req.cookie_jar.delete(:login)
-    assert_cookies({ "user_name" => "david" }, req.cookie_jar)
-
-    req.cookie_jar.clear
-    assert_cookies({}, req.cookie_jar)
-
-    req.cookie_jar.update(user_name: "david")
-    assert_cookies({ "user_name" => "david" }, req.cookie_jar)
-  end
-
-  test "does not complain when there is no application config" do
-    req = ActionDispatch::TestRequest.create({})
-    assert_equal false, req.env.empty?
-  end
-
-  test "default remote address is 0.0.0.0" do
-    req = ActionDispatch::TestRequest.create({})
-    assert_equal "0.0.0.0", req.remote_addr
-  end
-
-  test "allows remote address to be overridden" do
-    req = ActionDispatch::TestRequest.create("REMOTE_ADDR" => "127.0.0.1")
-    assert_equal "127.0.0.1", req.remote_addr
-  end
-
-  test "default host is test.host" do
-    req = ActionDispatch::TestRequest.create({})
-    assert_equal "test.host", req.host
-  end
-
-  test "allows host to be overridden" do
-    req = ActionDispatch::TestRequest.create("HTTP_HOST" => "www.example.com")
-    assert_equal "www.example.com", req.host
-  end
-
-  test "default user agent is 'Rails Testing'" do
-    req = ActionDispatch::TestRequest.create({})
-    assert_equal "Rails Testing", req.user_agent
-  end
-
-  test "allows user agent to be overridden" do
-    req = ActionDispatch::TestRequest.create("HTTP_USER_AGENT" => "GoogleBot")
-    assert_equal "GoogleBot", req.user_agent
-  end
-
-  test "request_method getter and setter" do
-    req = ActionDispatch::TestRequest.create
-    req.request_method # to reproduce bug caused by memoization
-    req.request_method = "POST"
-    assert_equal "POST", req.request_method
-  end
-
-  test "setter methods" do
-    req = ActionDispatch::TestRequest.create({})
-    get = "GET"
-
-    [
-      "request_method=", "host=", "request_uri=", "path=", "if_modified_since=", "if_none_match=",
-      "remote_addr=", "user_agent=", "accept="
-    ].each do |method|
-      req.send(method, get)
-    end
-
-    req.port = 8080
-    req.accept = "hello goodbye"
-
-    assert_equal(get, req.get_header("REQUEST_METHOD"))
-    assert_equal(get, req.get_header("HTTP_HOST"))
-    assert_equal(8080, req.get_header("SERVER_PORT"))
-    assert_equal(get, req.get_header("REQUEST_URI"))
-    assert_equal(get, req.get_header("PATH_INFO"))
-    assert_equal(get, req.get_header("HTTP_IF_MODIFIED_SINCE"))
-    assert_equal(get, req.get_header("HTTP_IF_NONE_MATCH"))
-    assert_equal(get, req.get_header("REMOTE_ADDR"))
-    assert_equal(get, req.get_header("HTTP_USER_AGENT"))
-    assert_nil(req.get_header("action_dispatch.request.accepts"))
-    assert_equal("hello goodbye", req.get_header("HTTP_ACCEPT"))
-  end
-
-  private
-    def assert_cookies(expected, cookie_jar)
-      assert_equal(expected, cookie_jar.instance_variable_get("@cookies"))
-    end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class TestResponseTest < ActiveSupport::TestCase
-  def assert_response_code_range(range, predicate)
-    response = ActionDispatch::TestResponse.new
-    (0..599).each do |status|
-      response.status = status
-      assert_equal range.include?(status), response.send(predicate),
-                   "ActionDispatch::TestResponse.new(#{status}).#{predicate}"
-    end
-  end
-
-  test "helpers" do
-    assert_response_code_range 200..299, :successful?
-    assert_response_code_range [404],    :not_found?
-    assert_response_code_range 300..399, :redirection?
-    assert_response_code_range 500..599, :server_error?
-    assert_response_code_range 400..499, :client_error?
-  end
-
-  test "response parsing" do
-    response = ActionDispatch::TestResponse.create(200, {}, "")
-    assert_equal response.body, response.parsed_body
-
-    response = ActionDispatch::TestResponse.create(200, { "Content-Type" => "application/json" }, '{ "foo": "fighters" }')
-    assert_equal({ "foo" => "fighters" }, response.parsed_body)
-  end
-
-  test "response status aliases deprecated" do
-    response = ActionDispatch::TestResponse.create
-    assert_deprecated { response.success? }
-    assert_deprecated { response.missing? }
-    assert_deprecated { response.error? }
-  end
-end

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

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-module ActionDispatch
-  class UploadedFileTest < ActiveSupport::TestCase
-    def test_constructor_with_argument_error
-      assert_raises(ArgumentError) do
-        Http::UploadedFile.new({})
-      end
-    end
-
-    def test_original_filename
-      uf = Http::UploadedFile.new(filename: "foo", tempfile: Object.new)
-      assert_equal "foo", uf.original_filename
-    end
-
-    def test_filename_is_different_object
-      file_str = "foo"
-      uf = Http::UploadedFile.new(filename: file_str, tempfile: Object.new)
-      assert_not_equal file_str.object_id, uf.original_filename.object_id
-    end
-
-    def test_filename_should_be_in_utf_8
-      uf = Http::UploadedFile.new(filename: "foo", tempfile: Object.new)
-      assert_equal "UTF-8", uf.original_filename.encoding.to_s
-    end
-
-    def test_filename_should_always_be_in_utf_8
-      uf = Http::UploadedFile.new(filename: "foo".encode(Encoding::SHIFT_JIS),
-                                  tempfile: Object.new)
-      assert_equal "UTF-8", uf.original_filename.encoding.to_s
-    end
-
-    def test_content_type
-      uf = Http::UploadedFile.new(type: "foo", tempfile: Object.new)
-      assert_equal "foo", uf.content_type
-    end
-
-    def test_headers
-      uf = Http::UploadedFile.new(head: "foo", tempfile: Object.new)
-      assert_equal "foo", uf.headers
-    end
-
-    def test_tempfile
-      uf = Http::UploadedFile.new(tempfile: "foo")
-      assert_equal "foo", uf.tempfile
-    end
-
-    def test_to_io_returns_the_tempfile
-      tf = Object.new
-      uf = Http::UploadedFile.new(tempfile: tf)
-      assert_equal tf, uf.to_io
-    end
-
-    def test_delegates_path_to_tempfile
-      tf = Class.new { def path; "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse", uf.path
-    end
-
-    def test_delegates_open_to_tempfile
-      tf = Class.new { def open; "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse", uf.open
-    end
-
-    def test_delegates_close_to_tempfile
-      tf = Class.new { def close(unlink_now = false); "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse", uf.close
-    end
-
-    def test_close_accepts_parameter
-      tf = Class.new { def close(unlink_now = false); "thunderhorse: #{unlink_now}" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse: true", uf.close(true)
-    end
-
-    def test_delegates_read_to_tempfile
-      tf = Class.new { def read(length = nil, buffer = nil); "thunderhorse" end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal "thunderhorse", uf.read
-    end
-
-    def test_delegates_read_to_tempfile_with_params
-      tf = Class.new { def read(length = nil, buffer = nil); [length, buffer] end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_equal %w{ thunder horse }, uf.read(*%w{ thunder horse })
-    end
-
-    def test_delegate_respects_respond_to?
-      tf = Class.new { def read; yield end; private :read }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_raises(NoMethodError) do
-        uf.read
-      end
-    end
-
-    def test_delegate_eof_to_tempfile
-      tf = Class.new { def eof?; true end; }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_predicate uf, :eof?
-    end
-
-    def test_respond_to?
-      tf = Class.new { def read; yield end }
-      uf = Http::UploadedFile.new(tempfile: tf.new)
-      assert_respond_to uf, :headers
-      assert_respond_to uf, :read
-    end
-  end
-end

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-module TestUrlGeneration
-  class WithMountPoint < ActionDispatch::IntegrationTest
-    Routes = ActionDispatch::Routing::RouteSet.new
-    include Routes.url_helpers
-
-    class ::MyRouteGeneratingController < ActionController::Base
-      include Routes.url_helpers
-      def index
-        render plain: foo_path
-      end
-    end
-
-    Routes.draw do
-      get "/foo", to: "my_route_generating#index", as: :foo
-
-      resources :bars
-
-      mount MyRouteGeneratingController.action(:index), at: "/bar"
-    end
-
-    APP = build_app Routes
-
-    def _routes
-      Routes
-    end
-
-    def app
-      APP
-    end
-
-    test "generating URLS normally" do
-      assert_equal "/foo", foo_path
-    end
-
-    test "accepting a :script_name option" do
-      assert_equal "/bar/foo", foo_path(script_name: "/bar")
-    end
-
-    test "the request's SCRIPT_NAME takes precedence over the route" do
-      get "/foo", headers: { "SCRIPT_NAME" => "/new", "action_dispatch.routes" => Routes }
-      assert_equal "/new/foo", response.body
-    end
-
-    test "the request's SCRIPT_NAME wraps the mounted app's" do
-      get "/new/bar/foo", headers: { "SCRIPT_NAME" => "/new", "PATH_INFO" => "/bar/foo", "action_dispatch.routes" => Routes }
-      assert_equal "/new/bar/foo", response.body
-    end
-
-    test "handling http protocol with https set" do
-      https!
-      assert_equal "http://www.example.com/foo", foo_url(protocol: "http")
-    end
-
-    test "extracting protocol from host when protocol not present" do
-      assert_equal "httpz://www.example.com/foo", foo_url(host: "httpz://www.example.com", protocol: nil)
-    end
-
-    test "formatting host when protocol is present" do
-      assert_equal "http://www.example.com/foo", foo_url(host: "httpz://www.example.com", protocol: "http://")
-    end
-
-    test "default ports are removed from the host" do
-      assert_equal "http://www.example.com/foo", foo_url(host: "www.example.com:80", protocol: "http://")
-      assert_equal "https://www.example.com/foo", foo_url(host: "www.example.com:443", protocol: "https://")
-    end
-
-    test "port is extracted from the host" do
-      assert_equal "http://www.example.com:8080/foo", foo_url(host: "www.example.com:8080", protocol: "http://")
-      assert_equal "//www.example.com:8080/foo", foo_url(host: "www.example.com:8080", protocol: "//")
-      assert_equal "//www.example.com:80/foo", foo_url(host: "www.example.com:80", protocol: "//")
-    end
-
-    test "port option is used" do
-      assert_equal "http://www.example.com:8080/foo", foo_url(host: "www.example.com", protocol: "http://", port: 8080)
-      assert_equal "//www.example.com:8080/foo", foo_url(host: "www.example.com", protocol: "//", port: 8080)
-      assert_equal "//www.example.com:80/foo", foo_url(host: "www.example.com", protocol: "//", port: 80)
-    end
-
-    test "port option overrides the host" do
-      assert_equal "http://www.example.com:8080/foo", foo_url(host: "www.example.com:8443", protocol: "http://", port: 8080)
-      assert_equal "//www.example.com:8080/foo", foo_url(host: "www.example.com:8443", protocol: "//", port: 8080)
-      assert_equal "//www.example.com:80/foo", foo_url(host: "www.example.com:443", protocol: "//", port: 80)
-    end
-
-    test "port option disables the host when set to nil" do
-      assert_equal "http://www.example.com/foo", foo_url(host: "www.example.com:8443", protocol: "http://", port: nil)
-      assert_equal "//www.example.com/foo", foo_url(host: "www.example.com:8443", protocol: "//", port: nil)
-    end
-
-    test "port option disables the host when set to false" do
-      assert_equal "http://www.example.com/foo", foo_url(host: "www.example.com:8443", protocol: "http://", port: false)
-      assert_equal "//www.example.com/foo", foo_url(host: "www.example.com:8443", protocol: "//", port: false)
-    end
-
-    test "keep subdomain when key is true" do
-      assert_equal "http://www.example.com/foo", foo_url(subdomain: true)
-    end
-
-    test "keep subdomain when key is missing" do
-      assert_equal "http://www.example.com/foo", foo_url
-    end
-
-    test "omit subdomain when key is nil" do
-      assert_equal "http://example.com/foo", foo_url(subdomain: nil)
-    end
-
-    test "omit subdomain when key is false" do
-      assert_equal "http://example.com/foo", foo_url(subdomain: false)
-    end
-
-    test "omit subdomain when key is blank" do
-      assert_equal "http://example.com/foo", foo_url(subdomain: "")
-    end
-
-    test "generating URLs with trailing slashes" do
-      assert_equal "/bars.json", bars_path(
-        trailing_slash: true,
-        format: "json"
-      )
-    end
-
-    test "generating URLS with querystring and trailing slashes" do
-      assert_equal "/bars.json?a=b", bars_path(
-        trailing_slash: true,
-        a: "b",
-        format: "json"
-      )
-    end
-
-    test "generating URLS with empty querystring" do
-      assert_equal "/bars.json", bars_path(
-        a: {},
-        format: "json"
-      )
-    end
-  end
-end