ULTRA [ growontech.com ]

Linux premium216.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64

LiteSpeed

66.29.141.148 | Your IP: 3.135.220.30

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / thread-self / root / opt / alt / ruby21 / lib64 / ruby / gems / 2.1.0 / gems / rack-1.6.4 / test /

Home Upload Mass Deface Mass Delete Back Connect Notify

spec_session_memcache.rb

begin
  require 'rack/session/memcache'
  require 'rack/lint'
  require 'rack/mock'
  require 'thread'

describe Rack::Session::Memcache do
    session_key = Rack::Session::Memcache::DEFAULT_OPTIONS[:key]
    session_match = /#{session_key}=([0-9a-fA-F]+);/
    incrementor = lambda do |env|
      env["rack.session"]["counter"] ||= 0
      env["rack.session"]["counter"] += 1
      Rack::Response.new(env["rack.session"].inspect).to_a
    end
    drop_session = Rack::Lint.new(proc do |env|
      env['rack.session.options'][:drop] = true
      incrementor.call(env)
    end)
    renew_session = Rack::Lint.new(proc do |env|
      env['rack.session.options'][:renew] = true
      incrementor.call(env)
    end)
    defer_session = Rack::Lint.new(proc do |env|
      env['rack.session.options'][:defer] = true
      incrementor.call(env)
    end)
    skip_session = Rack::Lint.new(proc do |env|
      env['rack.session.options'][:skip] = true
      incrementor.call(env)
    end)
    incrementor = Rack::Lint.new(incrementor)

# test memcache connection
    Rack::Session::Memcache.new(incrementor)

it "faults on no connection" do
      lambda{
        Rack::Session::Memcache.new(incrementor, :memcache_server => 'nosuchserver')
      }.should.raise
    end

it "connects to existing server" do
      test_pool = MemCache.new(incrementor, :namespace => 'test:rack:session')
      test_pool.namespace.should.equal 'test:rack:session'
    end

it "passes options to MemCache" do
      pool = Rack::Session::Memcache.new(incrementor, :namespace => 'test:rack:session')
      pool.pool.namespace.should.equal 'test:rack:session'
    end

it "creates a new cookie" do
      pool = Rack::Session::Memcache.new(incrementor)
      res = Rack::MockRequest.new(pool).get("/")
      res["Set-Cookie"].should.include("#{session_key}=")
      res.body.should.equal '{"counter"=>1}'
    end

it "determines session from a cookie" do
      pool = Rack::Session::Memcache.new(incrementor)
      req = Rack::MockRequest.new(pool)
      res = req.get("/")
      cookie = res["Set-Cookie"]
      req.get("/", "HTTP_COOKIE" => cookie).
        body.should.equal '{"counter"=>2}'
      req.get("/", "HTTP_COOKIE" => cookie).
        body.should.equal '{"counter"=>3}'
    end

it "determines session only from a cookie by default" do
      pool = Rack::Session::Memcache.new(incrementor)
      req = Rack::MockRequest.new(pool)
      res = req.get("/")
      sid = res["Set-Cookie"][session_match, 1]
      req.get("/?rack.session=#{sid}").
        body.should.equal '{"counter"=>1}'
      req.get("/?rack.session=#{sid}").
        body.should.equal '{"counter"=>1}'
    end

it "determines session from params" do
      pool = Rack::Session::Memcache.new(incrementor, :cookie_only => false)
      req = Rack::MockRequest.new(pool)
      res = req.get("/")
      sid = res["Set-Cookie"][session_match, 1]
      req.get("/?rack.session=#{sid}").
        body.should.equal '{"counter"=>2}'
      req.get("/?rack.session=#{sid}").
        body.should.equal '{"counter"=>3}'
    end

it "survives nonexistant cookies" do
      bad_cookie = "rack.session=blarghfasel"
      pool = Rack::Session::Memcache.new(incrementor)
      res = Rack::MockRequest.new(pool).
        get("/", "HTTP_COOKIE" => bad_cookie)
      res.body.should.equal '{"counter"=>1}'
      cookie = res["Set-Cookie"][session_match]
      cookie.should.not.match(/#{bad_cookie}/)
    end

it "maintains freshness" do
      pool = Rack::Session::Memcache.new(incrementor, :expire_after => 3)
      res = Rack::MockRequest.new(pool).get('/')
      res.body.should.include '"counter"=>1'
      cookie = res["Set-Cookie"]
      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
      res["Set-Cookie"].should.equal cookie
      res.body.should.include '"counter"=>2'
      puts 'Sleeping to expire session' if $DEBUG
      sleep 4
      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
      res["Set-Cookie"].should.not.equal cookie
      res.body.should.include '"counter"=>1'
    end

it "does not send the same session id if it did not change" do
      pool = Rack::Session::Memcache.new(incrementor)
      req = Rack::MockRequest.new(pool)

res0 = req.get("/")
      cookie = res0["Set-Cookie"][session_match]
      res0.body.should.equal '{"counter"=>1}'

res1 = req.get("/", "HTTP_COOKIE" => cookie)
      res1["Set-Cookie"].should.be.nil
      res1.body.should.equal '{"counter"=>2}'

res2 = req.get("/", "HTTP_COOKIE" => cookie)
      res2["Set-Cookie"].should.be.nil
      res2.body.should.equal '{"counter"=>3}'
    end

it "deletes cookies with :drop option" do
      pool = Rack::Session::Memcache.new(incrementor)
      req = Rack::MockRequest.new(pool)
      drop = Rack::Utils::Context.new(pool, drop_session)
      dreq = Rack::MockRequest.new(drop)

res1 = req.get("/")
      session = (cookie = res1["Set-Cookie"])[session_match]
      res1.body.should.equal '{"counter"=>1}'

res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
      res2["Set-Cookie"].should.equal nil
      res2.body.should.equal '{"counter"=>2}'

res3 = req.get("/", "HTTP_COOKIE" => cookie)
      res3["Set-Cookie"][session_match].should.not.equal session
      res3.body.should.equal '{"counter"=>1}'
    end

it "provides new session id with :renew option" do
      pool = Rack::Session::Memcache.new(incrementor)
      req = Rack::MockRequest.new(pool)
      renew = Rack::Utils::Context.new(pool, renew_session)
      rreq = Rack::MockRequest.new(renew)

res1 = req.get("/")
      session = (cookie = res1["Set-Cookie"])[session_match]
      res1.body.should.equal '{"counter"=>1}'

res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
      new_cookie = res2["Set-Cookie"]
      new_session = new_cookie[session_match]
      new_session.should.not.equal session
      res2.body.should.equal '{"counter"=>2}'

res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
      res3.body.should.equal '{"counter"=>3}'

# Old cookie was deleted
      res4 = req.get("/", "HTTP_COOKIE" => cookie)
      res4.body.should.equal '{"counter"=>1}'
    end

it "omits cookie with :defer option but still updates the state" do
      pool = Rack::Session::Memcache.new(incrementor)
      count = Rack::Utils::Context.new(pool, incrementor)
      defer = Rack::Utils::Context.new(pool, defer_session)
      dreq = Rack::MockRequest.new(defer)
      creq = Rack::MockRequest.new(count)

res0 = dreq.get("/")
      res0["Set-Cookie"].should.equal nil
      res0.body.should.equal '{"counter"=>1}'

res0 = creq.get("/")
      res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
      res1.body.should.equal '{"counter"=>2}'
      res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
      res2.body.should.equal '{"counter"=>3}'
    end

it "omits cookie and state update with :skip option" do
      pool = Rack::Session::Memcache.new(incrementor)
      count = Rack::Utils::Context.new(pool, incrementor)
      skip = Rack::Utils::Context.new(pool, skip_session)
      sreq = Rack::MockRequest.new(skip)
      creq = Rack::MockRequest.new(count)

res0 = sreq.get("/")
      res0["Set-Cookie"].should.equal nil
      res0.body.should.equal '{"counter"=>1}'

res0 = creq.get("/")
      res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
      res1.body.should.equal '{"counter"=>2}'
      res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
      res2.body.should.equal '{"counter"=>2}'
    end

it "updates deep hashes correctly" do
      hash_check = proc do |env|
        session = env['rack.session']
        unless session.include? 'test'
          session.update :a => :b, :c => { :d => :e },
            :f => { :g => { :h => :i} }, 'test' => true
        else
          session[:f][:g][:h] = :j
        end
        [200, {}, [session.inspect]]
      end
      pool = Rack::Session::Memcache.new(hash_check)
      req = Rack::MockRequest.new(pool)

res0 = req.get("/")
      session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
      ses0 = pool.pool.get(session_id, true)

req.get("/", "HTTP_COOKIE" => cookie)
      ses1 = pool.pool.get(session_id, true)

ses1.should.not.equal ses0
    end

# anyone know how to do this better?
    it "cleanly merges sessions when multithreaded" do
      unless $DEBUG
        1.should.equal 1 # fake assertion to appease the mighty bacon
        next
      end
      warn 'Running multithread test for Session::Memcache'
      pool = Rack::Session::Memcache.new(incrementor)
      req = Rack::MockRequest.new(pool)

res = req.get('/')
      res.body.should.equal '{"counter"=>1}'
      cookie = res["Set-Cookie"]
      session_id = cookie[session_match, 1]

delta_incrementor = lambda do |env|
        # emulate disconjoinment of threading
        env['rack.session'] = env['rack.session'].dup
        Thread.stop
        env['rack.session'][(Time.now.usec*rand).to_i] = true
        incrementor.call(env)
      end
      tses = Rack::Utils::Context.new pool, delta_incrementor
      treq = Rack::MockRequest.new(tses)
      tnum = rand(7).to_i+5
      r = Array.new(tnum) do
        Thread.new(treq) do |run|
          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
        end
      end.reverse.map{|t| t.run.join.value }
      r.each do |request|
        request['Set-Cookie'].should.equal cookie
        request.body.should.include '"counter"=>2'
      end

session = pool.pool.get(session_id)
      session.size.should.equal tnum+1 # counter
      session['counter'].should.equal 2 # meeeh

tnum = rand(7).to_i+5
      r = Array.new(tnum) do
        app = Rack::Utils::Context.new pool, time_delta
        req = Rack::MockRequest.new app
        Thread.new(req) do |run|
          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
        end
      end.reverse.map{|t| t.run.join.value }
      r.each do |request|
        request['Set-Cookie'].should.equal cookie
        request.body.should.include '"counter"=>3'
      end

session = pool.pool.get(session_id)
      session.size.should.be tnum+1
      session['counter'].should.be 3

drop_counter = proc do |env|
        env['rack.session'].delete 'counter'
        env['rack.session']['foo'] = 'bar'
        [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
      end
      tses = Rack::Utils::Context.new pool, drop_counter
      treq = Rack::MockRequest.new(tses)
      tnum = rand(7).to_i+5
      r = Array.new(tnum) do
        Thread.new(treq) do |run|
          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
        end
      end.reverse.map{|t| t.run.join.value }
      r.each do |request|
        request['Set-Cookie'].should.equal cookie
        request.body.should.include '"foo"=>"bar"'
      end

session = pool.pool.get(session_id)
      session.size.should.be r.size+1
      session['counter'].should.be.nil?
      session['foo'].should.equal 'bar'
    end
  end
rescue RuntimeError
  $stderr.puts "Skipping Rack::Session::Memcache tests. Start memcached and try again."
rescue LoadError
  $stderr.puts "Skipping Rack::Session::Memcache tests (Memcache is required). `gem install memcache-client` and try again."
end

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
..	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
builder	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
cgi	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
multipart	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
rackup	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
registering_handler	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
static	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
unregistered_handler	dir	-	root/linksafe	drwxr-xr-x	2024-03-03 10:43:09
gemloader.rb	text/x-ruby	298 B	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_auth_basic.rb	text/x-ruby	2.26 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_auth_digest.rb	text/x-ruby	8.08 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_body_proxy.rb	text/x-ruby	2.2 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_builder.rb	text/x-ruby	6.2 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_cascade.rb	text/x-ruby	2.11 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_cgi.rb	text/x-ruby	2.92 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_chunked.rb	text/x-ruby	3.87 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_commonlogger.rb	text/x-ruby	2.37 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_conditionalget.rb	text/x-ruby	3.28 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_config.rb	text/x-ruby	544 B	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_content_length.rb	text/x-ruby	2.8 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_content_type.rb	text/x-ruby	1.47 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_deflater.rb	text/x-ruby	10.04 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_directory.rb	text/x-ruby	2.19 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_etag.rb	text/x-ruby	3.84 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_fastcgi.rb	text/x-ruby	3.08 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_file.rb	text/x-ruby	6.32 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_handler.rb	text/x-ruby	1.87 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_head.rb	text/x-ruby	1.36 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_lint.rb	text/x-ruby	19.23 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_lobster.rb	text/x-ruby	1.23 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_lock.rb	text/x-ruby	4.33 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_logger.rb	text/x-ruby	622 B	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_methodoverride.rb	text/x-ruby	2.38 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_mime.rb	text/x-ruby	1.81 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_mock.rb	text/x-ruby	9.34 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_mongrel.rb	text/x-ruby	5.73 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_multipart.rb	text/x-ruby	23.62 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_nulllogger.rb	text/x-ruby	514 B	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_recursive.rb	text/x-ruby	1.83 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_request.rb	text/x-ruby	42.52 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_response.rb	text/x-ruby	10.08 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_rewindable_input.rb	text/x-ruby	2.78 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_runtime.rb	text/x-ruby	1.53 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_sendfile.rb	text/x-ruby	4.12 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_server.rb	text/x-ruby	5.57 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_session_abstract_id.rb	text/x-ruby	1.29 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_session_cookie.rb	text/x-ruby	12.94 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_session_memcache.rb	text/x-ruby	11.12 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_session_pool.rb	text/x-ruby	6.53 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_showexceptions.rb	text/x-ruby	2.01 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_showstatus.rb	text/x-ruby	2.74 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_static.rb	text/x-ruby	4.6 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_tempfile_reaper.rb	text/x-ruby	1.57 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_thin.rb	text/x-ruby	2.55 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_urlmap.rb	text/x-ruby	8.82 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_utils.rb	text/x-ruby	24.89 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_version.rb	text/x-ruby	504 B	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
spec_webrick.rb	text/x-ruby	5.5 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44
testrequest.rb	text/x-ruby	1.96 KB	root/linksafe	-rw-r--r--	2019-12-02 01:00:44