File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby19/lib64/ruby/gems/1.9.1/gems/rack-1.6.4/test

opt / alt / ruby19 / lib64 / ruby / gems / 1.9.1 / gems / rack-1.6.4 / test /

ðŸ“ ..
ðŸ“ builder
ðŸ“ cgi
ðŸ“„ gemloader.rb(298 B)
ðŸ“ multipart
ðŸ“ rackup
ðŸ“ registering_handler
ðŸ“„ spec_auth_basic.rb(2.26 KB)
ðŸ“„ spec_auth_digest.rb(8.08 KB)
ðŸ“„ spec_body_proxy.rb(2.2 KB)
ðŸ“„ spec_builder.rb(6.2 KB)
ðŸ“„ spec_cascade.rb(2.11 KB)
ðŸ“„ spec_cgi.rb(2.92 KB)
ðŸ“„ spec_chunked.rb(3.87 KB)
ðŸ“„ spec_commonlogger.rb(2.37 KB)
ðŸ“„ spec_conditionalget.rb(3.28 KB)
ðŸ“„ spec_config.rb(544 B)
ðŸ“„ spec_content_length.rb(2.8 KB)
ðŸ“„ spec_content_type.rb(1.47 KB)
ðŸ“„ spec_deflater.rb(10.04 KB)
ðŸ“„ spec_directory.rb(2.19 KB)
ðŸ“„ spec_etag.rb(3.84 KB)
ðŸ“„ spec_fastcgi.rb(3.08 KB)
ðŸ“„ spec_file.rb(6.32 KB)
ðŸ“„ spec_handler.rb(1.87 KB)
ðŸ“„ spec_head.rb(1.36 KB)
ðŸ“„ spec_lint.rb(19.23 KB)
ðŸ“„ spec_lobster.rb(1.23 KB)
ðŸ“„ spec_lock.rb(4.33 KB)
ðŸ“„ spec_logger.rb(622 B)
ðŸ“„ spec_methodoverride.rb(2.38 KB)
ðŸ“„ spec_mime.rb(1.81 KB)
ðŸ“„ spec_mock.rb(9.34 KB)
ðŸ“„ spec_mongrel.rb(5.73 KB)
ðŸ“„ spec_multipart.rb(23.62 KB)
ðŸ“„ spec_nulllogger.rb(514 B)
ðŸ“„ spec_recursive.rb(1.83 KB)
ðŸ“„ spec_request.rb(42.52 KB)
ðŸ“„ spec_response.rb(10.08 KB)
ðŸ“„ spec_rewindable_input.rb(2.78 KB)
ðŸ“„ spec_runtime.rb(1.53 KB)
ðŸ“„ spec_sendfile.rb(4.12 KB)
ðŸ“„ spec_server.rb(5.57 KB)
ðŸ“„ spec_session_abstract_id.rb(1.29 KB)
ðŸ“„ spec_session_cookie.rb(12.94 KB)
ðŸ“„ spec_session_memcache.rb(11.12 KB)
ðŸ“„ spec_session_pool.rb(6.53 KB)
ðŸ“„ spec_showexceptions.rb(2.01 KB)
ðŸ“„ spec_showstatus.rb(2.74 KB)
ðŸ“„ spec_static.rb(4.6 KB)
ðŸ“„ spec_tempfile_reaper.rb(1.57 KB)
ðŸ“„ spec_thin.rb(2.55 KB)
ðŸ“„ spec_urlmap.rb(8.82 KB)
ðŸ“„ spec_utils.rb(24.89 KB)
ðŸ“„ spec_version.rb(504 B)
ðŸ“„ spec_webrick.rb(5.5 KB)
ðŸ“ static
ðŸ“„ testrequest.rb(1.96 KB)
ðŸ“ unregistered_handler

Editing: spec_urlmap.rb

require 'rack/urlmap'
require 'rack/mock'

describe Rack::URLMap do
  it "dispatches paths correctly" do
    app = lambda { |env|
      [200, {
        'X-ScriptName' => env['SCRIPT_NAME'],
        'X-PathInfo' => env['PATH_INFO'],
        'Content-Type' => 'text/plain'
      }, [""]]
    }
    map = Rack::Lint.new(Rack::URLMap.new({
      'http://foo.org/bar' => app,
      '/foo' => app,
      '/foo/bar' => app
    }))

res = Rack::MockRequest.new(map).get("/")
    res.should.be.not_found

res = Rack::MockRequest.new(map).get("/qux")
    res.should.be.not_found

res = Rack::MockRequest.new(map).get("/foo")
    res.should.be.ok
    res["X-ScriptName"].should.equal "/foo"
    res["X-PathInfo"].should.equal ""

res = Rack::MockRequest.new(map).get("/foo/")
    res.should.be.ok
    res["X-ScriptName"].should.equal "/foo"
    res["X-PathInfo"].should.equal "/"

res = Rack::MockRequest.new(map).get("/foo/bar")
    res.should.be.ok
    res["X-ScriptName"].should.equal "/foo/bar"
    res["X-PathInfo"].should.equal ""

res = Rack::MockRequest.new(map).get("/foo/bar/")
    res.should.be.ok
    res["X-ScriptName"].should.equal "/foo/bar"
    res["X-PathInfo"].should.equal "/"

res = Rack::MockRequest.new(map).get("/foo///bar//quux")
    res.status.should.equal 200
    res.should.be.ok
    res["X-ScriptName"].should.equal "/foo/bar"
    res["X-PathInfo"].should.equal "//quux"

res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
    res.should.be.ok
    res["X-ScriptName"].should.equal "/bleh/foo"
    res["X-PathInfo"].should.equal "/quux"

res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org')
    res.should.be.ok
    res["X-ScriptName"].should.equal "/bar"
    res["X-PathInfo"].should.be.empty

res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org')
    res.should.be.ok
    res["X-ScriptName"].should.equal "/bar"
    res["X-PathInfo"].should.equal '/'
  end

it "dispatches hosts correctly" do
    map = Rack::Lint.new(Rack::URLMap.new("http://foo.org/" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "foo.org",
                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
                              }, [""]]},
                           "http://subdomain.foo.org/" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "subdomain.foo.org",
                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
                              }, [""]]},
                           "http://bar.org/" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "bar.org",
                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
                              }, [""]]},
                           "/" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "default.org",
                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
                              }, [""]]}
                           ))

res = Rack::MockRequest.new(map).get("/")
    res.should.be.ok
    res["X-Position"].should.equal "default.org"

res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "bar.org")
    res.should.be.ok
    res["X-Position"].should.equal "bar.org"

res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "foo.org")
    res.should.be.ok
    res["X-Position"].should.equal "foo.org"

res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "subdomain.foo.org", "SERVER_NAME" => "foo.org")
    res.should.be.ok
    res["X-Position"].should.equal "subdomain.foo.org"

res = Rack::MockRequest.new(map).get("http://foo.org/")
    res.should.be.ok
    res["X-Position"].should.equal "foo.org"

res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "example.org")
    res.should.be.ok
    res["X-Position"].should.equal "default.org"

res = Rack::MockRequest.new(map).get("/",
                                         "HTTP_HOST" => "example.org:9292",
                                         "SERVER_PORT" => "9292")
    res.should.be.ok
    res["X-Position"].should.equal "default.org"
  end

should "be nestable" do
    map = Rack::Lint.new(Rack::URLMap.new("/foo" =>
      Rack::URLMap.new("/bar" =>
        Rack::URLMap.new("/quux" =>  lambda { |env|
                           [200,
                            { "Content-Type" => "text/plain",
                              "X-Position" => "/foo/bar/quux",
                              "X-PathInfo" => env["PATH_INFO"],
                              "X-ScriptName" => env["SCRIPT_NAME"],
                            }, [""]]}
                         ))))

res = Rack::MockRequest.new(map).get("/foo/bar")
    res.should.be.not_found

res = Rack::MockRequest.new(map).get("/foo/bar/quux")
    res.should.be.ok
    res["X-Position"].should.equal "/foo/bar/quux"
    res["X-PathInfo"].should.equal ""
    res["X-ScriptName"].should.equal "/foo/bar/quux"
  end

should "route root apps correctly" do
    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "root",
                                "X-PathInfo" => env["PATH_INFO"],
                                "X-ScriptName" => env["SCRIPT_NAME"]
                              }, [""]]},
                           "/foo" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "foo",
                                "X-PathInfo" => env["PATH_INFO"],
                                "X-ScriptName" => env["SCRIPT_NAME"]
                              }, [""]]}
                           ))

res = Rack::MockRequest.new(map).get("/foo/bar")
    res.should.be.ok
    res["X-Position"].should.equal "foo"
    res["X-PathInfo"].should.equal "/bar"
    res["X-ScriptName"].should.equal "/foo"

res = Rack::MockRequest.new(map).get("/foo")
    res.should.be.ok
    res["X-Position"].should.equal "foo"
    res["X-PathInfo"].should.equal ""
    res["X-ScriptName"].should.equal "/foo"

res = Rack::MockRequest.new(map).get("/bar")
    res.should.be.ok
    res["X-Position"].should.equal "root"
    res["X-PathInfo"].should.equal "/bar"
    res["X-ScriptName"].should.equal ""

res = Rack::MockRequest.new(map).get("")
    res.should.be.ok
    res["X-Position"].should.equal "root"
    res["X-PathInfo"].should.equal "/"
    res["X-ScriptName"].should.equal ""
  end

should "not squeeze slashes" do
    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "root",
                                "X-PathInfo" => env["PATH_INFO"],
                                "X-ScriptName" => env["SCRIPT_NAME"]
                              }, [""]]},
                           "/foo" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "foo",
                                "X-PathInfo" => env["PATH_INFO"],
                                "X-ScriptName" => env["SCRIPT_NAME"]
                              }, [""]]}
                           ))

res = Rack::MockRequest.new(map).get("/http://example.org/bar")
    res.should.be.ok
    res["X-Position"].should.equal "root"
    res["X-PathInfo"].should.equal "/http://example.org/bar"
    res["X-ScriptName"].should.equal ""
  end

should "not be case sensitive with hosts" do
    map = Rack::Lint.new(Rack::URLMap.new("http://example.org/" => lambda { |env|
                             [200,
                              { "Content-Type" => "text/plain",
                                "X-Position" => "root",
                                "X-PathInfo" => env["PATH_INFO"],
                                "X-ScriptName" => env["SCRIPT_NAME"]
                              }, [""]]}
                           ))

res = Rack::MockRequest.new(map).get("http://example.org/")
    res.should.be.ok
    res["X-Position"].should.equal "root"
    res["X-PathInfo"].should.equal "/"
    res["X-ScriptName"].should.equal ""

res = Rack::MockRequest.new(map).get("http://EXAMPLE.ORG/")
    res.should.be.ok
    res["X-Position"].should.equal "root"
    res["X-PathInfo"].should.equal "/"
    res["X-ScriptName"].should.equal ""
  end
end

X7ROOT File Manager

Editing: spec_urlmap.rb

Upload File

Create Folder