jets 1.9.7 → 1.9.8

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "concurrent/atomic/count_down_latch"
-
-module ActionController
-  module Live
-    class ResponseTest < ActiveSupport::TestCase
-      def setup
-        @response = Live::Response.new
-        @response.request = ActionDispatch::Request.empty
-      end
-
-      def test_header_merge
-        header = @response.header.merge("Foo" => "Bar")
-        assert_kind_of(ActionController::Live::Response::Header, header)
-        assert_not_equal header, @response.header
-      end
-
-      def test_initialize_with_default_headers
-        r = Class.new(Live::Response) do
-          def self.default_headers
-            { "omg" => "g" }
-          end
-        end
-
-        header = r.new.header
-        assert_kind_of(ActionController::Live::Response::Header, header)
-      end
-
-      def test_parallel
-        latch = Concurrent::CountDownLatch.new
-
-        t = Thread.new {
-          @response.stream.write "foo"
-          latch.wait
-          @response.stream.close
-        }
-
-        @response.await_commit
-        @response.each do |part|
-          assert_equal "foo", part
-          latch.count_down
-        end
-        assert t.join
-      end
-
-      def test_setting_body_populates_buffer
-        @response.body = "omg"
-        @response.close
-        assert_equal ["omg"], @response.body_parts
-      end
-
-      def test_cache_control_is_set
-        @response.stream.write "omg"
-        assert_equal "no-cache", @response.headers["Cache-Control"]
-      end
-
-      def test_content_length_is_removed
-        @response.headers["Content-Length"] = "1234"
-        @response.stream.write "omg"
-        assert_nil @response.headers["Content-Length"]
-      end
-
-      def test_headers_cannot_be_written_after_webserver_reads
-        @response.stream.write "omg"
-        latch = Concurrent::CountDownLatch.new
-
-        t = Thread.new {
-          @response.each do
-            latch.count_down
-          end
-        }
-
-        latch.wait
-        assert_predicate @response.headers, :frozen?
-        e = assert_raises(ActionDispatch::IllegalStateError) do
-          @response.headers["Content-Length"] = "zomg"
-        end
-
-        assert_equal "header already sent", e.message
-        @response.stream.close
-        t.join
-      end
-
-      def test_headers_cannot_be_written_after_close
-        @response.stream.close
-        # we can add data until it's actually written, which happens on `each`
-        @response.each { |x| }
-
-        e = assert_raises(ActionDispatch::IllegalStateError) do
-          @response.headers["Content-Length"] = "zomg"
-        end
-        assert_equal "header already sent", e.message
-      end
-    end
-  end
-end

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

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-module ActionDispatch
-  module Routing
-    class MapperTest < ActiveSupport::TestCase
-      class FakeSet < ActionDispatch::Routing::RouteSet
-        def resources_path_names
-          {}
-        end
-
-        def request_class
-          ActionDispatch::Request
-        end
-
-        def dispatcher_class
-          RouteSet::Dispatcher
-        end
-
-        def defaults
-          routes.map(&:defaults)
-        end
-
-        def conditions
-          routes.map(&:constraints)
-        end
-
-        def requirements
-          routes.map(&:path).map(&:requirements)
-        end
-
-        def asts
-          routes.map(&:path).map(&:spec)
-        end
-      end
-
-      def test_initialize
-        Mapper.new FakeSet.new
-      end
-
-      def test_scope_raises_on_anchor
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        assert_raises(ArgumentError) do
-          mapper.scope(anchor: false) do
-          end
-        end
-      end
-
-      def test_blows_up_without_via
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        assert_raises(ArgumentError) do
-          mapper.match "/", to: "posts#index", as: :main
-        end
-      end
-
-      def test_unscoped_formatted
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.get "/foo", to: "posts#index", as: :main, format: true
-        assert_equal({ controller: "posts", action: "index" },
-                     fakeset.defaults.first)
-        assert_equal "/foo.:format", fakeset.asts.first.to_s
-      end
-
-      def test_scoped_formatted
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.scope(format: true) do
-          mapper.get "/foo", to: "posts#index", as: :main
-        end
-        assert_equal({ controller: "posts", action: "index" },
-                     fakeset.defaults.first)
-        assert_equal "/foo.:format", fakeset.asts.first.to_s
-      end
-
-      def test_random_keys
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.scope(omg: :awesome) do
-          mapper.get "/", to: "posts#index", as: :main
-        end
-        assert_equal({ omg: :awesome, controller: "posts", action: "index" },
-                     fakeset.defaults.first)
-        assert_equal("GET", fakeset.routes.first.verb)
-      end
-
-      def test_mapping_requirements
-        options = {}
-        scope = Mapper::Scope.new({})
-        ast = Journey::Parser.parse "/store/:name(*rest)"
-        m = Mapper::Mapping.build(scope, FakeSet.new, ast, "foo", "bar", nil, [:get], nil, {}, true, options)
-        assert_equal(/.+?/, m.requirements[:rest])
-      end
-
-      def test_via_scope
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.scope(via: :put) do
-          mapper.match "/", to: "posts#index", as: :main
-        end
-        assert_equal("PUT", fakeset.routes.first.verb)
-      end
-
-      def test_to_scope
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.scope(to: "posts#index") do
-          mapper.get :all
-          mapper.post :most
-        end
-
-        assert_equal "posts#index", fakeset.routes.to_a[0].defaults[:to]
-        assert_equal "posts#index", fakeset.routes.to_a[1].defaults[:to]
-      end
-
-      def test_map_slash
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.get "/", to: "posts#index", as: :main
-        assert_equal "/", fakeset.asts.first.to_s
-      end
-
-      def test_map_more_slashes
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-
-        # FIXME: is this a desired behavior?
-        mapper.get "/one/two/", to: "posts#index", as: :main
-        assert_equal "/one/two(.:format)", fakeset.asts.first.to_s
-      end
-
-      def test_map_wildcard
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.get "/*path", to: "pages#show"
-        assert_equal "/*path(.:format)", fakeset.asts.first.to_s
-        assert_equal(/.+?/, fakeset.requirements.first[:path])
-      end
-
-      def test_map_wildcard_with_other_element
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.get "/*path/foo/:bar", to: "pages#show"
-        assert_equal "/*path/foo/:bar(.:format)", fakeset.asts.first.to_s
-        assert_equal(/.+?/, fakeset.requirements.first[:path])
-      end
-
-      def test_map_wildcard_with_multiple_wildcard
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.get "/*foo/*bar", to: "pages#show"
-        assert_equal "/*foo/*bar(.:format)", fakeset.asts.first.to_s
-        assert_equal(/.+?/, fakeset.requirements.first[:foo])
-        assert_equal(/.+?/, fakeset.requirements.first[:bar])
-      end
-
-      def test_map_wildcard_with_format_false
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.get "/*path", to: "pages#show", format: false
-        assert_equal "/*path", fakeset.asts.first.to_s
-        assert_nil fakeset.requirements.first[:path]
-      end
-
-      def test_map_wildcard_with_format_true
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        mapper.get "/*path", to: "pages#show", format: true
-        assert_equal "/*path.:format", fakeset.asts.first.to_s
-      end
-
-      def test_raising_error_when_path_is_not_passed
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        app = lambda { |env| [200, {}, [""]] }
-        assert_raises ArgumentError do
-          mapper.mount app
-        end
-      end
-
-      def test_raising_error_when_rack_app_is_not_passed
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-        assert_raises ArgumentError do
-          mapper.mount 10, as: "exciting"
-        end
-
-        assert_raises ArgumentError do
-          mapper.mount as: "exciting"
-        end
-      end
-
-      def test_scope_does_not_destructively_mutate_default_options
-        fakeset = FakeSet.new
-        mapper = Mapper.new fakeset
-
-        frozen = { foo: :bar }.freeze
-
-        assert_nothing_raised do
-          mapper.scope(defaults: frozen) do
-            # pass
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class MiddlewareStackTest < ActiveSupport::TestCase
-  class FooMiddleware; end
-  class BarMiddleware; end
-  class BazMiddleware; end
-  class HiyaMiddleware; end
-  class BlockMiddleware
-    attr_reader :block
-    def initialize(&block)
-      @block = block
-    end
-  end
-
-  def setup
-    @stack = ActionDispatch::MiddlewareStack.new
-    @stack.use FooMiddleware
-    @stack.use BarMiddleware
-  end
-
-  def test_delete_works
-    assert_difference "@stack.size", -1 do
-      @stack.delete FooMiddleware
-    end
-  end
-
-  test "use should push middleware as class onto the stack" do
-    assert_difference "@stack.size" do
-      @stack.use BazMiddleware
-    end
-    assert_equal BazMiddleware, @stack.last.klass
-  end
-
-  test "use should push middleware class with arguments onto the stack" do
-    assert_difference "@stack.size" do
-      @stack.use BazMiddleware, true, foo: "bar"
-    end
-    assert_equal BazMiddleware, @stack.last.klass
-    assert_equal([true, { foo: "bar" }], @stack.last.args)
-  end
-
-  test "use should push middleware class with block arguments onto the stack" do
-    proc = Proc.new {}
-    assert_difference "@stack.size" do
-      @stack.use(BlockMiddleware, &proc)
-    end
-    assert_equal BlockMiddleware, @stack.last.klass
-    assert_equal proc, @stack.last.block
-  end
-
-  test "insert inserts middleware at the integer index" do
-    @stack.insert(1, BazMiddleware)
-    assert_equal BazMiddleware, @stack[1].klass
-  end
-
-  test "insert_after inserts middleware after the integer index" do
-    @stack.insert_after(1, BazMiddleware)
-    assert_equal BazMiddleware, @stack[2].klass
-  end
-
-  test "insert_before inserts middleware before another middleware class" do
-    @stack.insert_before(BarMiddleware, BazMiddleware)
-    assert_equal BazMiddleware, @stack[1].klass
-  end
-
-  test "insert_after inserts middleware after another middleware class" do
-    @stack.insert_after(BarMiddleware, BazMiddleware)
-    assert_equal BazMiddleware, @stack[2].klass
-  end
-
-  test "swaps one middleware out for another" do
-    assert_equal FooMiddleware, @stack[0].klass
-    @stack.swap(FooMiddleware, BazMiddleware)
-    assert_equal BazMiddleware, @stack[0].klass
-  end
-
-  test "swaps one middleware out for same middleware class" do
-    assert_equal FooMiddleware, @stack[0].klass
-    @stack.swap(FooMiddleware, FooMiddleware, Proc.new { |env| [500, {}, ["error!"]] })
-    assert_equal FooMiddleware, @stack[0].klass
-  end
-
-  test "unshift adds a new middleware at the beginning of the stack" do
-    @stack.unshift MiddlewareStackTest::BazMiddleware
-    assert_equal BazMiddleware, @stack.first.klass
-  end
-
-  test "raise an error on invalid index" do
-    assert_raise RuntimeError do
-      @stack.insert(HiyaMiddleware, BazMiddleware)
-    end
-
-    assert_raise RuntimeError do
-      @stack.insert_after(HiyaMiddleware, BazMiddleware)
-    end
-  end
-
-  test "can check if Middleware are equal - Class" do
-    assert_equal @stack.last, BarMiddleware
-  end
-
-  test "includes a class" do
-    assert_equal true, @stack.include?(BarMiddleware)
-  end
-
-  test "can check if Middleware are equal - Middleware" do
-    assert_equal @stack.last, @stack.last
-  end
-
-  test "includes a middleware" do
-    assert_equal true, @stack.include?(ActionDispatch::MiddlewareStack::Middleware.new(BarMiddleware, nil, nil))
-  end
-end

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

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class MimeTypeTest < ActiveSupport::TestCase
-  test "parse single" do
-    Mime::LOOKUP.each_key do |mime_type|
-      unless mime_type == "image/*"
-        assert_equal [Mime::Type.lookup(mime_type)], Mime::Type.parse(mime_type)
-      end
-    end
-  end
-
-  test "unregister" do
-    assert_nil Mime[:mobile]
-
-    begin
-      mime = Mime::Type.register("text/x-mobile", :mobile)
-      assert_equal mime, Mime[:mobile]
-      assert_equal mime, Mime::Type.lookup("text/x-mobile")
-      assert_equal mime, Mime::Type.lookup_by_extension(:mobile)
-
-      Mime::Type.unregister(:mobile)
-      assert_nil Mime[:mobile], "Mime[:mobile] should be nil after unregistering :mobile"
-      assert_nil Mime::Type.lookup_by_extension(:mobile), "Should be missing MIME extension lookup for :mobile"
-    ensure
-      Mime::Type.unregister :mobile
-    end
-  end
-
-  test "parse text with trailing star at the beginning" do
-    accept = "text/*, text/html, application/json, multipart/form-data"
-    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:vtt], Mime[:xml], Mime[:yaml], Mime[:json], Mime[:multipart_form]]
-    parsed = Mime::Type.parse(accept)
-    assert_equal expect.map(&:to_s), parsed.map(&:to_s)
-  end
-
-  test "parse text with trailing star in the end" do
-    accept = "text/html, application/json, multipart/form-data, text/*"
-    expect = [Mime[:html], Mime[:json], Mime[:multipart_form], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:vtt], Mime[:xml], Mime[:yaml]]
-    parsed = Mime::Type.parse(accept)
-    assert_equal expect.map(&:to_s), parsed.map(&:to_s)
-  end
-
-  test "parse text with trailing star" do
-    accept = "text/*"
-    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:vtt], Mime[:xml], Mime[:yaml], Mime[:json]]
-    parsed = Mime::Type.parse(accept)
-    assert_equal expect.map(&:to_s).sort!, parsed.map(&:to_s).sort!
-  end
-
-  test "parse application with trailing star" do
-    accept = "application/*"
-    expect = [Mime[:html], Mime[:js], Mime[:xml], Mime[:rss], Mime[:atom], Mime[:yaml], Mime[:url_encoded_form], Mime[:json], Mime[:pdf], Mime[:zip], Mime[:gzip]]
-    parsed = Mime::Type.parse(accept)
-    assert_equal expect.map(&:to_s).sort!, parsed.map(&:to_s).sort!
-  end
-
-  test "parse without q" do
-    accept = "text/xml,application/xhtml+xml,text/yaml,application/xml,text/html,image/png,text/plain,application/pdf,*/*"
-    expect = [Mime[:html], Mime[:xml], Mime[:yaml], Mime[:png], Mime[:text], Mime[:pdf], "*/*"]
-    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
-  end
-
-  test "parse with q" do
-    accept = "text/xml,application/xhtml+xml,text/yaml; q=0.3,application/xml,text/html; q=0.8,image/png,text/plain; q=0.5,application/pdf,*/*; q=0.2"
-    expect = [Mime[:html], Mime[:xml], Mime[:png], Mime[:pdf], Mime[:text], Mime[:yaml], "*/*"]
-    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
-  end
-
-  test "parse single media range with q" do
-    accept = "text/html;q=0.9"
-    expect = [Mime[:html]]
-    assert_equal expect, Mime::Type.parse(accept)
-  end
-
-  test "parse arbitrary media type parameters" do
-    accept = 'multipart/form-data; boundary="simple boundary"'
-    expect = [Mime[:multipart_form]]
-    assert_equal expect, Mime::Type.parse(accept)
-  end
-
-  # Accept header send with user HTTP_USER_AGENT: Sunrise/0.42j (Windows XP)
-  test "parse broken acceptlines" do
-    accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/*,,*/*;q=0.5"
-    expect = [Mime[:html], Mime[:xml], "image/*", Mime[:text], "*/*"]
-    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
-  end
-
-  # Accept header send with user HTTP_USER_AGENT: Mozilla/4.0
-  #  (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; InfoPath.1)
-  test "parse other broken acceptlines" do
-    accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword,  , pronto/1.00.00, sslvpn/1.00.00.00, */*"
-    expect = ["image/gif", "image/x-xbitmap", "image/jpeg", "image/pjpeg", "application/x-shockwave-flash", "application/vnd.ms-excel", "application/vnd.ms-powerpoint", "application/msword", "pronto/1.00.00", "sslvpn/1.00.00.00", "*/*"]
-    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
-  end
-
-  test "custom type" do
-    begin
-      type = Mime::Type.register("image/foo", :foo)
-      assert_equal type, Mime[:foo]
-    ensure
-      Mime::Type.unregister(:foo)
-    end
-  end
-
-  test "custom type with type aliases" do
-    begin
-      Mime::Type.register "text/foobar", :foobar, ["text/foo", "text/bar"]
-      %w[text/foobar text/foo text/bar].each do |type|
-        assert_equal Mime[:foobar], type
-      end
-    ensure
-      Mime::Type.unregister(:foobar)
-    end
-  end
-
-  test "register callbacks" do
-    begin
-      registered_mimes = []
-      Mime::Type.register_callback do |mime|
-        registered_mimes << mime
-      end
-
-      mime = Mime::Type.register("text/foo", :foo)
-      assert_equal [mime], registered_mimes
-    ensure
-      Mime::Type.unregister(:foo)
-    end
-  end
-
-  test "custom type with extension aliases" do
-    begin
-      Mime::Type.register "text/foobar", :foobar, [], [:foo, "bar"]
-      %w[foobar foo bar].each do |extension|
-        assert_equal Mime[:foobar], Mime::EXTENSION_LOOKUP[extension]
-      end
-    ensure
-      Mime::Type.unregister(:foobar)
-    end
-  end
-
-  test "register alias" do
-    begin
-      Mime::Type.register_alias "application/xhtml+xml", :foobar
-      assert_equal Mime[:html], Mime::EXTENSION_LOOKUP["foobar"]
-    ensure
-      Mime::Type.unregister(:foobar)
-    end
-  end
-
-  test "type should be equal to symbol" do
-    assert_equal Mime[:html], "application/xhtml+xml"
-    assert_equal Mime[:html], :html
-  end
-
-  test "type convenience methods" do
-    types = Mime::SET.symbols.uniq - [:iphone]
-
-    types.each do |type|
-      mime = Mime[type]
-      assert_respond_to mime, "#{type}?"
-      assert_equal type, mime.symbol, "#{mime.inspect} is not #{type}?"
-      invalid_types = types - [type]
-      invalid_types.delete(:html)
-      invalid_types.each { |other_type|
-        assert_not_equal mime.symbol, other_type, "#{mime.inspect} is #{other_type}?"
-      }
-    end
-  end
-
-  test "references gives preference to symbols before strings" do
-    assert_equal :html, Mime[:html].ref
-    another = Mime::Type.lookup("foo/bar")
-    assert_nil another.to_sym
-    assert_equal "foo/bar", another.ref
-  end
-
-  test "regexp matcher" do
-    assert Mime[:js] =~ "text/javascript"
-    assert Mime[:js] =~ "application/javascript"
-    assert Mime[:js] !~ "text/html"
-    assert !(Mime[:js] !~ "text/javascript")
-    assert !(Mime[:js] !~ "application/javascript")
-    assert Mime[:html] =~ "application/xhtml+xml"
-  end
-end