sprokovuln 0.2.0

data/vendor/ruby/gems/rack-2.0.5/test/spec_sendfile.rb

@@ -0,0 +1,125 @@
+require 'minitest/autorun'
+require 'fileutils'
+require 'rack/lint'
+require 'rack/sendfile'
+require 'rack/mock'
+require 'tmpdir'
+
+describe Rack::Sendfile do
+  def sendfile_body
+    FileUtils.touch File.join(Dir.tmpdir,  "rack_sendfile")
+    res = ['Hello World']
+    def res.to_path ; File.join(Dir.tmpdir,  "rack_sendfile") ; end
+    res
+  end
+
+  def simple_app(body=sendfile_body)
+    lambda { |env| [200, {'Content-Type' => 'text/plain'}, body] }
+  end
+
+  def sendfile_app(body, mappings = [])
+    Rack::Lint.new Rack::Sendfile.new(simple_app(body), nil, mappings)
+  end
+
+  def request(headers={}, body=sendfile_body, mappings=[])
+    yield Rack::MockRequest.new(sendfile_app(body, mappings)).get('/', headers)
+  end
+
+  def open_file(path)
+    Class.new(File) do
+      unless method_defined?(:to_path)
+        alias :to_path :path
+      end
+    end.open(path, 'wb+')
+  end
+
+  it "does nothing when no X-Sendfile-Type header present" do
+    request do |response|
+      response.must_be :ok?
+      response.body.must_equal 'Hello World'
+      response.headers.wont_include 'X-Sendfile'
+    end
+  end
+
+  it "sets X-Sendfile response header and discards body" do
+    request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response|
+      response.must_be :ok?
+      response.body.must_be :empty?
+      response.headers['Content-Length'].must_equal '0'
+      response.headers['X-Sendfile'].must_equal File.join(Dir.tmpdir,  "rack_sendfile")
+    end
+  end
+
+  it "sets X-Lighttpd-Send-File response header and discards body" do
+    request 'HTTP_X_SENDFILE_TYPE' => 'X-Lighttpd-Send-File' do |response|
+      response.must_be :ok?
+      response.body.must_be :empty?
+      response.headers['Content-Length'].must_equal '0'
+      response.headers['X-Lighttpd-Send-File'].must_equal File.join(Dir.tmpdir,  "rack_sendfile")
+    end
+  end
+
+  it "sets X-Accel-Redirect response header and discards body" do
+    headers = {
+      'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect',
+      'HTTP_X_ACCEL_MAPPING' => "#{Dir.tmpdir}/=/foo/bar/"
+    }
+    request headers do |response|
+      response.must_be :ok?
+      response.body.must_be :empty?
+      response.headers['Content-Length'].must_equal '0'
+      response.headers['X-Accel-Redirect'].must_equal '/foo/bar/rack_sendfile'
+    end
+  end
+
+  it 'writes to rack.error when no X-Accel-Mapping is specified' do
+    request 'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect' do |response|
+      response.must_be :ok?
+      response.body.must_equal 'Hello World'
+      response.headers.wont_include 'X-Accel-Redirect'
+      response.errors.must_include 'X-Accel-Mapping'
+    end
+  end
+
+  it 'does nothing when body does not respond to #to_path' do
+    request({'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile'}, ['Not a file...']) do |response|
+      response.body.must_equal 'Not a file...'
+      response.headers.wont_include 'X-Sendfile'
+    end
+  end
+
+  it "sets X-Accel-Redirect response header and discards body when initialized with multiple mappings" do
+    begin
+      dir1 = Dir.mktmpdir
+      dir2 = Dir.mktmpdir
+
+      first_body = open_file(File.join(dir1, 'rack_sendfile'))
+      first_body.puts 'hello world'
+
+      second_body = open_file(File.join(dir2, 'rack_sendfile'))
+      second_body.puts 'goodbye world'
+
+      mappings = [
+        ["#{dir1}/", '/foo/bar/'],
+        ["#{dir2}/", '/wibble/']
+      ]
+
+      request({'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect'}, first_body, mappings) do |response|
+        response.must_be :ok?
+        response.body.must_be :empty?
+        response.headers['Content-Length'].must_equal '0'
+        response.headers['X-Accel-Redirect'].must_equal '/foo/bar/rack_sendfile'
+      end
+
+      request({'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect'}, second_body, mappings) do |response|
+        response.must_be :ok?
+        response.body.must_be :empty?
+        response.headers['Content-Length'].must_equal '0'
+        response.headers['X-Accel-Redirect'].must_equal '/wibble/rack_sendfile'
+      end
+    ensure
+      FileUtils.remove_entry_secure dir1
+      FileUtils.remove_entry_secure dir2
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/test/spec_server.rb

@@ -0,0 +1,193 @@
+require 'minitest/autorun'
+require 'rack'
+require 'rack/server'
+require 'tempfile'
+require 'socket'
+require 'open-uri'
+
+module Minitest::Spec::DSL
+  alias :should :it
+end
+
+describe Rack::Server do
+  SPEC_ARGV = []
+
+  before { SPEC_ARGV[0..-1] = [] }
+
+  def app
+    lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['success']] }
+  end
+
+  def with_stderr
+    old, $stderr = $stderr, StringIO.new
+    yield $stderr
+  ensure
+    $stderr = old
+  end
+
+  it "overrides :config if :app is passed in" do
+    server = Rack::Server.new(:app => "FOO")
+    server.app.must_equal "FOO"
+  end
+
+  it "prefer to use :builder when it is passed in" do
+    server = Rack::Server.new(:builder => "run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['success']] }")
+    server.app.class.must_equal Proc
+    Rack::MockRequest.new(server.app).get("/").body.to_s.must_equal 'success'
+  end
+
+  it "allow subclasses to override middleware" do
+    server = Class.new(Rack::Server).class_eval { def middleware; Hash.new [] end; self }
+    server.middleware['deployment'].wont_equal []
+    server.new(:app => 'foo').middleware['deployment'].must_equal []
+  end
+
+  it "allow subclasses to override default middleware" do
+    server = Class.new(Rack::Server).instance_eval { def default_middleware_by_environment; Hash.new [] end; self }
+    server.middleware['deployment'].must_equal []
+    server.new(:app => 'foo').middleware['deployment'].must_equal []
+  end
+
+  it "only provide default middleware for development and deployment environments" do
+    Rack::Server.default_middleware_by_environment.keys.sort.must_equal %w(deployment development)
+  end
+
+  it "always return an empty array for unknown environments" do
+    server = Rack::Server.new(:app => 'foo')
+    server.middleware['production'].must_equal []
+  end
+
+  it "not include Rack::Lint in deployment environment" do
+    server = Rack::Server.new(:app => 'foo')
+    server.middleware['deployment'].flatten.wont_include Rack::Lint
+  end
+
+  it "not include Rack::ShowExceptions in deployment environment" do
+    server = Rack::Server.new(:app => 'foo')
+    server.middleware['deployment'].flatten.wont_include Rack::ShowExceptions
+  end
+
+  it "include Rack::TempfileReaper in deployment environment" do
+    server = Rack::Server.new(:app => 'foo')
+    server.middleware['deployment'].flatten.must_include Rack::TempfileReaper
+  end
+
+  it "support CGI" do
+    begin
+      o, ENV["REQUEST_METHOD"] = ENV["REQUEST_METHOD"], 'foo'
+      server = Rack::Server.new(:app => 'foo')
+      server.server.name =~ /CGI/
+      Rack::Server.logging_middleware.call(server).must_be_nil
+    ensure
+      ENV['REQUEST_METHOD'] = o
+    end
+  end
+
+  it "be quiet if said so" do
+    server = Rack::Server.new(:app => "FOO", :quiet => true)
+    Rack::Server.logging_middleware.call(server).must_be_nil
+  end
+
+  it "use a full path to the pidfile" do
+    # avoids issues with daemonize chdir
+    opts = Rack::Server.new.send(:parse_options, %w[--pid testing.pid])
+    opts[:pid].must_equal ::File.expand_path('testing.pid')
+  end
+
+  it "get options from ARGV" do
+    SPEC_ARGV[0..-1] = ['--debug', '-sthin', '--env', 'production']
+    server = Rack::Server.new
+    server.options[:debug].must_equal true
+    server.options[:server].must_equal 'thin'
+    server.options[:environment].must_equal 'production'
+  end
+
+  it "only override non-passed options from parsed .ru file" do
+    builder_file = File.join(File.dirname(__FILE__), 'builder', 'options.ru')
+    SPEC_ARGV[0..-1] = ['--debug', '-sthin', '--env', 'production', builder_file]
+    server = Rack::Server.new
+    server.app # force .ru file to be parsed
+
+    server.options[:debug].must_equal true
+    server.options[:server].must_equal 'thin'
+    server.options[:environment].must_equal 'production'
+    server.options[:Port].must_equal '2929'
+  end
+
+  it "run a server" do
+    pidfile = Tempfile.open('pidfile') { |f| break f }
+    FileUtils.rm pidfile.path
+    server = Rack::Server.new(
+      :app         => app,
+      :environment => 'none',
+      :pid         => pidfile.path,
+      :Port        => TCPServer.open('127.0.0.1', 0){|s| s.addr[1] },
+      :Host        => '127.0.0.1',
+      :Logger      => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+      :AccessLog   => [],
+      :daemonize   => false,
+      :server      => 'webrick'
+    )
+    t = Thread.new { server.start { |s| Thread.current[:server] = s } }
+    t.join(0.01) until t[:server] && t[:server].status != :Stop
+    body = open("http://127.0.0.1:#{server.options[:Port]}/") { |f| f.read }
+    body.must_equal 'success'
+
+    Process.kill(:INT, $$)
+    t.join
+    open(pidfile.path) { |f| f.read.must_equal $$.to_s }
+  end
+
+  it "check pid file presence and running process" do
+    pidfile = Tempfile.open('pidfile') { |f| f.write($$); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).must_equal :running
+  end
+
+  it "check pid file presence and dead process" do
+    dead_pid = `echo $$`.to_i
+    pidfile = Tempfile.open('pidfile') { |f| f.write(dead_pid); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).must_equal :dead
+  end
+
+  it "check pid file presence and exited process" do
+    pidfile = Tempfile.open('pidfile') { |f| break f }.path
+    ::File.delete(pidfile)
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).must_equal :exited
+  end
+
+  it "check pid file presence and not owned process" do
+    pidfile = Tempfile.open('pidfile') { |f| f.write(1); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).must_equal :not_owned
+  end
+
+  it "not write pid file when it is created after check" do
+    pidfile = Tempfile.open('pidfile') { |f| break f }.path
+    ::File.delete(pidfile)
+    server = Rack::Server.new(:pid => pidfile)
+    ::File.open(pidfile, 'w') { |f| f.write(1) }
+    with_stderr do |err|
+      lambda { server.send(:write_pid) }.must_raise SystemExit
+      err.rewind
+      output = err.read
+      output.must_match(/already running/)
+      output.must_include pidfile
+    end
+  end
+
+  it "inform the user about existing pidfiles with running processes" do
+    pidfile = Tempfile.open('pidfile') { |f| f.write(1); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    with_stderr do |err|
+      lambda { server.start }.must_raise SystemExit
+      err.rewind
+      output = err.read
+      output.must_match(/already running/)
+      output.must_include pidfile
+    end
+  end
+
+end

data/vendor/ruby/gems/rack-2.0.5/test/spec_session_abstract_id.rb

@@ -0,0 +1,31 @@
+require 'minitest/autorun'
+### WARNING: there be hax in this file.
+
+require 'rack/session/abstract/id'
+
+describe Rack::Session::Abstract::ID do
+  attr_reader :id
+
+  def setup
+    super
+    @id = Rack::Session::Abstract::ID
+  end
+
+  it "use securerandom" do
+    assert_equal ::SecureRandom, id::DEFAULT_OPTIONS[:secure_random]
+
+    id = @id.new nil
+    assert_equal ::SecureRandom, id.sid_secure
+  end
+
+  it "allow to use another securerandom provider" do
+    secure_random = Class.new do
+      def hex(*args)
+        'fake_hex'
+      end
+    end
+    id = Rack::Session::Abstract::ID.new nil, :secure_random => secure_random.new
+    id.send(:generate_sid).must_equal 'fake_hex'
+  end
+
+end

data/vendor/ruby/gems/rack-2.0.5/test/spec_session_abstract_session_hash.rb

@@ -0,0 +1,45 @@
+require 'minitest/autorun'
+require 'rack/session/abstract/id'
+
+describe Rack::Session::Abstract::SessionHash do
+  attr_reader :hash
+
+  def setup
+    super
+    store = Class.new do
+      def load_session(req)
+        ["id", {foo: :bar, baz: :qux}]
+      end
+      def session_exists?(req)
+        true
+      end
+    end
+    @hash = Rack::Session::Abstract::SessionHash.new(store.new, nil)
+  end
+
+  it "returns keys" do
+    assert_equal ["foo", "baz"], hash.keys
+  end
+
+  it "returns values" do
+    assert_equal [:bar, :qux], hash.values
+  end
+
+  describe "#fetch" do
+    it "returns value for a matching key" do
+      assert_equal :bar, hash.fetch(:foo)
+    end
+
+    it "works with a default value" do
+      assert_equal :default, hash.fetch(:unknown, :default)
+    end
+
+    it "works with a block" do
+      assert_equal :default, hash.fetch(:unkown) { :default }
+    end
+
+    it "it raises when fetching unknown keys without defaults" do
+      lambda { hash.fetch(:unknown) }.must_raise KeyError
+    end
+  end
+end