rack-sanitizer 2.0.3 → 2.1.0

data/test/test_sanitizer.rb

@@ -1,27 +1,70 @@
-# encoding:ascii-8bit
+# encoding: ascii-8bit
+# frozen_string_literal: true
 
-require 'bacon/colored_output'
 require 'cgi'
+require 'rack/lint'
+require 'rack/mock'
 require 'rack/sanitizer'
 
 describe Rack::Sanitizer do
+  class ResponseBody < String
+    attr_reader :env
+
+    def initialize(env)
+      super('')
+      @env = env
+    end
+  end
+
   before do
-    @app = Rack::Sanitizer.new(-> env { env["rack.input"]&.size; env })
+    @build_app = ->(options = {}) do
+      linted_app = Rack::Lint.new(->env { [200, {}, [ResponseBody.new(env)]] })
+      Rack::Sanitizer.new(->env { linted_app.(env) }, options)
+    end
+
+    @rack_env = ->(env) do
+      Rack::MockRequest.env_for('/').tap do |request_env|
+        request_env.delete('CONTENT_LENGTH')
+        request_env.merge!(env.reject { |_key, value| value.nil? })
+      end
+    end
+
+    @call_app = ->(env) do
+      response = @app.(@rack_env.call(env))
+      response_body = nil
+      response[2].each do |chunk|
+        response_body = chunk
+      end
+      response[2].close
+      response_body.env
+    end
+
+    @app = @build_app.call
+  end
+
+  it "conforms to Rack::Lint" do
+    app = Rack::Lint.new(Rack::Sanitizer.new(->(_env) { [200, {}, ["OK"]] }))
+    status, headers, body = app.(Rack::MockRequest.env_for('/'))
+
+    status.should == 200
+    headers.should == {}
+    body.each { |chunk| chunk.should == "OK" }
+    body.close
   end
 
   shared :does_sanitize_plain do
     it "sanitizes plaintext entity (HTTP_USER_AGENT)" do
-      env    = @app.({ "HTTP_USER_AGENT" => @plain_input })
+      env    = @call_app.call({ "HTTP_USER_AGENT" => @plain_input })
       result = env["HTTP_USER_AGENT"]
 
-      result.encoding.should == Encoding::UTF_8
+      result.encoding.should == Encoding::ASCII_8BIT
       result.should.be.valid_encoding
     end
   end
 
   shared :does_sanitize_uri do
     it "sanitizes URI-like entity (REQUEST_PATH)" do
-      env    = @app.({ "REQUEST_PATH" => @uri_input })
+      env    = @call_app.call({ "REQUEST_PATH" => @uri_input })
       result = env["REQUEST_PATH"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -31,8 +74,8 @@ describe Rack::Sanitizer do
 
   describe "with invalid host input" do
     it "sanitizes host entity (SERVER_NAME)" do
-      host   = "host\xD0".force_encoding('UTF-8')
-      env    = @app.({ "SERVER_NAME" => host })
+      host   = "host\xD0".dup.force_encoding(Encoding::UTF_8)
+      env    = @call_app.call({ "SERVER_NAME" => host })
       result = env["SERVER_NAME"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -42,8 +85,8 @@ describe Rack::Sanitizer do
 
   describe "with invalid UTF-8 input" do
     before do
-      @plain_input = "foo\xe0".force_encoding('UTF-8')
-      @uri_input   = "http://bar/foo%E0".force_encoding('UTF-8')
+      @plain_input = "foo\xe0".dup.force_encoding(Encoding::UTF_8)
+      @uri_input   = "http://bar/foo%E0".dup.force_encoding(Encoding::UTF_8)
     end
 
     behaves_like :does_sanitize_plain
@@ -52,7 +95,7 @@ describe Rack::Sanitizer do
 
   describe "with invalid, incorrectly percent-encoded UTF-8 URI input" do
     before do
-      @uri_input   = "http://bar/foo%E0\xe0".force_encoding('UTF-8')
+      @uri_input   = "http://bar/foo%E0\xe0".dup.force_encoding(Encoding::UTF_8)
     end
 
     behaves_like :does_sanitize_uri
@@ -78,18 +121,18 @@ describe Rack::Sanitizer do
 
   shared :identity_plain do
     it "does not change plaintext entity (HTTP_USER_AGENT)" do
-      env    = @app.({ "HTTP_USER_AGENT" => @plain_input })
+      env    = @call_app.call({ "HTTP_USER_AGENT" => @plain_input })
       result = env["HTTP_USER_AGENT"]
 
-      result.encoding.should == Encoding::UTF_8
+      result.encoding.should == (@plain_input.ascii_only? ? Encoding::UTF_8 : Encoding::ASCII_8BIT)
       result.should.be.valid_encoding
-      result.should == @plain_input
+      result.bytes.should == @plain_input.bytes
     end
   end
 
   shared :identity_uri do
     it "does not change URI-like entity (REQUEST_PATH)" do
-      env    = @app.({ "REQUEST_PATH" => @uri_input })
+      env    = @call_app.call({ "REQUEST_PATH" => @uri_input })
       result = env["REQUEST_PATH"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -100,8 +143,8 @@ describe Rack::Sanitizer do
 
   describe "with valid UTF-8 input" do
     before do
-      @plain_input = "foo bar лол".force_encoding('UTF-8')
-      @uri_input   = "http://bar/foo+bar+%D0%BB%D0%BE%D0%BB".force_encoding('UTF-8')
+      @plain_input = "foo bar лол".dup.force_encoding(Encoding::UTF_8)
+      @uri_input   = "http://bar/foo+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
     end
 
     behaves_like :identity_plain
@@ -109,7 +152,7 @@ describe Rack::Sanitizer do
 
     describe "with URI characters from reserved range" do
       before do
-        @uri_input   = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".force_encoding('UTF-8')
+        @uri_input   = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
       end
 
       behaves_like :identity_uri
@@ -118,12 +161,12 @@ describe Rack::Sanitizer do
 
   describe "with valid, not percent-encoded UTF-8 URI input" do
     before do
-      @uri_input   = "http://bar/foo+bar+лол".force_encoding('UTF-8')
+      @uri_input   = "http://bar/foo+bar+лол".dup.force_encoding(Encoding::UTF_8)
       @encoded     = "http://bar/foo+bar+#{CGI.escape("лол")}"
     end
 
     it "does not change URI-like entity (REQUEST_PATH)" do
-      env    = @app.({ "REQUEST_PATH" => @uri_input })
+      env    = @call_app.call({ "REQUEST_PATH" => @uri_input })
       result = env["REQUEST_PATH"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -152,13 +195,13 @@ describe Rack::Sanitizer do
 
   describe "with frozen strings" do
     before do
-      @plain_input = "bar baz".freeze
-      @uri_input   = "http://bar/bar+baz".freeze
+      @plain_input = "bar baz"
+      @uri_input   = "http://bar/bar+baz"
     end
 
     it "preserves the frozen? status of input" do
-      env  = @app.({ "HTTP_USER_AGENT" => @plain_input,
-                     "REQUEST_PATH" => @uri_input })
+      env  = @call_app.call({ "HTTP_USER_AGENT" => @plain_input,
+                              "REQUEST_PATH" => @uri_input })
 
       env["HTTP_USER_AGENT"].should.be.frozen
       env["REQUEST_PATH"].should.be.frozen
@@ -167,12 +210,12 @@ describe Rack::Sanitizer do
 
   describe "with symbols in the env" do
     before do
-      @uri_input = "http://bar/foo%E0\xe0".force_encoding('UTF-8')
+      @uri_input = "http://bar/foo%E0\xe0".dup.force_encoding(Encoding::UTF_8)
     end
 
     it "sanitizes REQUEST_PATH with invalid UTF-8 URI input" do
-      env  = @app.({ :requested_at => "2014-07-22",
-                     "REQUEST_PATH" => @uri_input })
+      env = @call_app.call({ "requested_at" => "2014-07-22",
+                             "REQUEST_PATH" => @uri_input })
 
       result = env["REQUEST_PATH"]
 
@@ -183,7 +226,7 @@ describe Rack::Sanitizer do
 
   describe "with form data" do
     def request_env
-      @plain_input = "foo bar лол".force_encoding('UTF-8')
+      @plain_input = "foo bar лол".dup.force_encoding(Encoding::UTF_8)
       {
          "REQUEST_METHOD" => "POST",
          "CONTENT_TYPE" => "application/x-www-form-urlencoded;foo=bar",
@@ -193,18 +236,16 @@ describe Rack::Sanitizer do
     end
 
     def sanitize_form_data(request_env = request_env())
-      @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".force_encoding('UTF-8')
-      @response_env = @app.(request_env)
+      @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
+      @response_env = @call_app.call(request_env)
       sanitized_input = @response_env['rack.input'].read
 
       yield sanitized_input if block_given?
 
-      @response_env['rack.input'].rewind
       behaves_like :does_sanitize_plain
       behaves_like :does_sanitize_uri
       behaves_like :identity_plain
       behaves_like :identity_uri
-      @response_env['rack.input'].close
     end
 
     class BrokenIO < StringIO
@@ -214,9 +255,18 @@ describe Rack::Sanitizer do
     end
 
     it "returns HTTP 400 on EOF" do
-      @rack_input = BrokenIO.new
-      @response_env = @app.(request_env)
-      @response_env.should == [400, {"Content-Type"=>"text/plain"}, ["Bad Request"]]
+      @rack_input = BrokenIO.new("".b)
+      app = Rack::Lint.new(Rack::Sanitizer.new(->env {
+        env['rack.input'].read
+        [200, {}, ["OK"]]
+      }))
+      env = @rack_env.call(request_env.merge("HTTP_USER_AGENT" => "foo"))
+      status, headers, body = app.(env)
+      response_body = []
+      body.each { |chunk| response_body << chunk }
+      body.close
+
+      [status, headers, response_body].should == [400, { "content-type" => "text/plain" }, ["Bad Request"]]
     end
 
     it "sanitizes StringIO rack.input" do
@@ -242,7 +292,7 @@ describe Rack::Sanitizer do
     end
 
     it "sanitizes StringIO rack.input with bad encoding" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       sanitize_form_data do |sanitized_input|
@@ -293,7 +343,7 @@ describe Rack::Sanitizer do
 
     it "sanitizes non-StringIO rack.input with bad encoding" do
       require 'rack/rewindable_input'
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = Rack::RewindableInput.new(StringIO.new(input))
 
       sanitize_form_data do |sanitized_input|
@@ -304,7 +354,7 @@ describe Rack::Sanitizer do
     end
 
     it "does not sanitize the rack body if there is no CONTENT_TYPE" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => nil)
@@ -316,7 +366,7 @@ describe Rack::Sanitizer do
     end
 
     it "does not sanitize the rack body if there is empty CONTENT_TYPE" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => '')
@@ -328,10 +378,10 @@ describe Rack::Sanitizer do
     end
 
     it "adjusts content-length when replacing input" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
-      env = request_env.update("CONTENT_LENGTH" => input.bytesize)
+      env = request_env.update("CONTENT_LENGTH" => input.bytesize.to_s)
       sanitize_form_data(env) do |sanitized_input|
         sanitized_input.bytesize.should != input.bytesize
         @response_env["CONTENT_LENGTH"].should == sanitized_input.bytesize.to_s
@@ -339,7 +389,7 @@ describe Rack::Sanitizer do
     end
 
     it "does not sanitize null bytes by default" do
-      input =  "foo=bla&quux=bar%00"
+      input = "foo=bla&quux=bar%00"
       @rack_input = StringIO.new input
 
       sanitize_form_data do |sanitized_input|
@@ -362,25 +412,31 @@ describe Rack::Sanitizer do
 
     it "sanitizes bad http cookie" do
       @cookie = "foo=bla; quux=bar\xED"
-      response_env = @app.(request_env)
+      response_env = @call_app.call(request_env)
       response_env['HTTP_COOKIE'].should != @cookie
       response_env['HTTP_COOKIE'].should == 'foo=bla; quux=bar%EF%BF%BD'
     end
 
+    it "preserves commas in http cookie values" do
+      @cookie = "foo=bar,baz; quux=qux"
+      response_env = @call_app.call(request_env)
+      response_env['HTTP_COOKIE'].should == @cookie
+    end
+
     it "does not change ok http cookie" do
       @cookie = "foo=bla; quux=bar"
-      response_env = @app.(request_env)
+      response_env = @call_app.call(request_env)
       response_env['HTTP_COOKIE'].should == @cookie
 
       @cookie = "foo=b%3bla; quux=b%20a%20r"
-      response_env = @app.(request_env)
+      response_env = @call_app.call(request_env)
       response_env['HTTP_COOKIE'].should == @cookie
     end
   end
 
   describe "with custom content-type" do
     def request_env
-      @plain_input = "foo bar лол".force_encoding('UTF-8')
+      @plain_input = "foo bar лол".dup.force_encoding(Encoding::UTF_8)
       {
           "REQUEST_METHOD" => "POST",
           "CONTENT_TYPE" => "application/vnd.api+json",
@@ -390,15 +446,15 @@ describe Rack::Sanitizer do
     end
 
     def sanitize_data(request_env = request_env())
-      @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".force_encoding('UTF-8')
-      @response_env = @app.(request_env)
+      @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
+      @response_env = @call_app.call(request_env)
       sanitized_input = @response_env['rack.input'].read
 
       yield sanitized_input if block_given?
     end
 
     it "does not sanitize custom content-type by default" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
@@ -410,47 +466,47 @@ describe Rack::Sanitizer do
     end
 
     it "sanitizes custom content-type if additional_content_types given" do
-      @app = Rack::Sanitizer.new(-> env { env }, additional_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(additional_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "sanitizes default content-type if additional_content_types given" do
-      @app = Rack::Sanitizer.new(-> env { env }, additional_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(additional_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => 'application/json')
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "sanitizes custom content-type if sanitizable_content_types given" do
-      @app = Rack::Sanitizer.new(-> env { env }, sanitizable_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(sanitizable_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "does not sanitize default content-type if sanitizable_content_types does not include it" do
-      @app = Rack::Sanitizer.new(-> env { env }, sanitizable_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(sanitizable_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => 'application/json')
@@ -464,7 +520,7 @@ describe Rack::Sanitizer do
 
   describe "with custom strategy" do
     def request_env
-      @plain_input = "foo bar лол".force_encoding('UTF-8')
+      @plain_input = "foo bar лол".dup.force_encoding(Encoding::UTF_8)
       {
           "REQUEST_METHOD" => "POST",
           "CONTENT_TYPE" => "application/json",
@@ -474,29 +530,29 @@ describe Rack::Sanitizer do
     end
 
     def sanitize_data(request_env = request_env())
-      @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".force_encoding('UTF-8')
-      @response_env = @app.(request_env)
+      @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
+      @response_env = @call_app.call(request_env)
       sanitized_input = @response_env['rack.input'].read
 
       yield sanitized_input if block_given?
     end
 
     it "calls a default strategy (replace)" do
-      @app = Rack::Sanitizer.new(-> env { env })
+      @app = @build_app.call
 
       input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "calls the exception strategy" do
-      @app = Rack::Sanitizer.new(-> env { env }, strategy: :exception)
+      @app = @build_app.call(strategy: :exception)
 
       input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
@@ -505,12 +561,36 @@ describe Rack::Sanitizer do
       should.raise(EncodingError) { sanitize_data(env) }
     end
 
+    it "returns HTTP 400 before the application reads invalid rack.input" do
+      input = "{\"user_session\": {\"invalid\": \"\x80\"}}".b
+      @rack_input = StringIO.new(input)
+
+      sanitizer = Rack::Sanitizer.new(->(_env) { [200, {}, ["OK"]] }, strategy: :exception)
+      app = ->(env) do
+        begin
+          sanitizer.call(env)
+        rescue EncodingError
+          [400, {}, ["Bad Request"]]
+        end
+      end
+      app = Rack::Lint.new(app)
+
+      env = @rack_env.call(request_env.merge("HTTP_USER_AGENT" => "foo"))
+      env["CONTENT_LENGTH"] = input.bytesize.to_s
+      status, headers, body = app.(env)
+      response_body = []
+      body.each { |chunk| response_body << chunk }
+      body.close
+
+      [status, headers, response_body].should == [400, {}, ["Bad Request"]]
+    end
+
     it "accepts a proc as a strategy" do
-      truncate = -> (input) do
-        'replace'.force_encoding(Encoding::UTF_8)
+      truncate = ->(input) do
+        'replace'.dup.force_encoding(Encoding::UTF_8)
       end
 
-      @app = Rack::Sanitizer.new(-> env { env }, strategy: truncate)
+      @app = @build_app.call(strategy: truncate)
 
       input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rack-sanitizer
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.1.0
 platform: ruby
 authors:
+- Shopify - Ruby and Rails Infratructure
 - Jean Boussier
 - whitequark
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -31,52 +31,10 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: bacon
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bacon-colored_output
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Rack::Sanitizer is a Rack middleware which cleans up invalid UTF8 characters
   in request URI and headers.
 email:
-- jean.boussier@gmail.org
+- ruby-and-rails-infrastructure@shopify.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -85,13 +43,22 @@ files:
 - ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
 - ".github/workflows/cla.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/bacon
+- bin/rubocop
+- dev.yml
+- gemfiles/rack_2.2.gemfile
+- gemfiles/rack_3.0.gemfile
+- gemfiles/rack_3.1.gemfile
+- gemfiles/rack_3.2.gemfile
 - lib/rack/sanitizer.rb
 - rack-sanitizer.gemspec
 - test/test_sanitizer.rb
@@ -100,7 +67,6 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org/
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -115,9 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.18
-signing_key:
+rubygems_version: 4.0.19
 specification_version: 4
 summary: It is a mordernized and optimized fork of rack-utf8_sanitizer
-test_files:
-- test/test_sanitizer.rb
+test_files: []