redis-rack 1.6.0 → 2.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc742a461ac6cb3cd6b1cf5e6bac8fad3c704de8
-  data.tar.gz: 851c2fb3b482eb6f44e948d475cd1e7315cbb70d
+  metadata.gz: 96a69ed4c43926e06dcf69e386e4de732d50015b
+  data.tar.gz: fe4d17f25dacea679c05bffd32d336b7b1c3d985
 SHA512:
-  metadata.gz: ae3e5966785213132068f31674dd32dd0622316433757f59bb652a0f58461d752068f740b62948420851ccf247198ae2ef0feaf5ca7353784eb020d2e3ead9e3
-  data.tar.gz: 72f618348fb097d7cdb3057116ed79350a4ad2661d2eeeb93ce3e009c6b6b026a7eaee68810f6baefaf3bb5c0e60b083eceb6bf0bf3f79c33f1846846a110d46
+  metadata.gz: fe09f61db9f21f3f7632dabf04cf1e88e0d30590d2bca9f285f874bc552046677c49631688ba077654a7ca89a6b9f3060545a771486e4ba8ac341698986286c8
+  data.tar.gz: 9ab90da88c6a1e56b5aa6e7d1c62bd773b33db189a41f0be5efe523f985aa30ec3c4d3821673f715c82a987dd036020f9470f934addfa6bb3d868700cb965725

data/.travis.yml

@@ -1,8 +1,10 @@
 language: ruby
 script: 'bundle exec rake'
 rvm:
-  - 1.9.3
   - 2.0.0
+  - 2.1.7
+  - 2.2.3
+  - 2.3.0
   - ruby-head
   - rbx-19mode
   - jruby-19mode

data/Gemfile

@@ -2,5 +2,5 @@ source 'https://rubygems.org'
 gemspec
 
 if ::File.directory?(gem_path = '../redis-store')
-  gem 'redis-store', '~> 1.1.0', path: gem_path
+  gem 'redis-store', '~> 1.2.0.pre', path: gem_path
 end

data/README.md

@@ -1,14 +1,37 @@
-# Redis stores for Rack
+# Redis session store for Rack
 
-__`redis-rack`__ provides a Redis backed session store __Rack__. See the main [redis-store readme](https://github.com/redis-store/redis-store) for general guidelines.
+__`redis-rack`__ provides a Redis-backed session store for __Rack__.
+
+See the main [redis-store readme] for general guidelines.
+
+**NOTE:** This is not [redis-rack-cache][], the library for using Redis
+as a backend store for the `Rack::Cache` HTTP cache. All this gem does
+is store the Rack session within Redis.
+
+[![Build Status](https://secure.travis-ci.org/redis-store/redis-rack.png?branch=master)](http://travis-ci.org/jodosha/redis-rack?branch=master)
+[![Code Climate](https://codeclimate.com/github/jodosha/redis-store.png)](https://codeclimate.com/github/redis-store/redis-rack)
+[![Gem Version](https://badge.fury.io/rb/redis-rack.png)](http://badge.fury.io/rb/redis-rack)
 
 ## Installation
 
+Install with Bundler by adding the following to Gemfile:
+
 ```ruby
-# Gemfile
 gem 'redis-rack'
 ```
 
+Then, run:
+
+```shell
+$ bundle install
+```
+
+Or, you can install it manually using RubyGems:
+
+```shell
+$ gem install redis-rack
+```
+
 ## Usage
 
 If you are using redis-store with Rails, consider using the [redis-rails gem](https://github.com/redis-store/redis-rails) instead. For standalone usage:
@@ -21,22 +44,35 @@ require 'rack/session/redis'
 use Rack::Session::Redis
 ```
 
-## Running tests
+## Development
+
+To install this gem for development purposes:
 
 ```shell
-gem install bundler
-git clone git://github.com/redis-store/redis-rack.git
-cd redis-rack
-bundle install
-bundle exec rake
+$ gem install bundler # note: you don't need to do this if you already have it installed
+$ git clone git://github.com/redis-store/redis-rack.git
+$ cd redis-rack
+$ bundle install
 ```
 
-If you are on **Snow Leopard** you have to run `env ARCHFLAGS="-arch x86_64" bundle exec rake`
+## Running tests
 
-## Status
+To run tests:
 
-[![Gem Version](https://badge.fury.io/rb/redis-rack.png)](http://badge.fury.io/rb/redis-rack) [![Build Status](https://secure.travis-ci.org/redis-store/redis-rack.png?branch=master)](http://travis-ci.org/jodosha/redis-rack?branch=master) [![Code Climate](https://codeclimate.com/github/jodosha/redis-store.png)](https://codeclimate.com/github/redis-store/redis-rack)
+```shell
+$ bundle exec rake
+```
+
+If you are on **Snow Leopard** you have to run the following command to
+build this software:
+
+```shell
+$ env ARCHFLAGS="-arch x86_64" bundle exec rake
+```
 
 ## Copyright
 
 2009 - 2013 Luca Guidi - [http://lucaguidi.com](http://lucaguidi.com), released under the MIT license
+
+[redis-rack-cache]: https://github.com/redis-store/redis-rack-cache
+[redis-store readme]: https://github.com/redis-store/redis-store

data/lib/rack/session/redis.rb

@@ -14,38 +14,58 @@ module Rack
         super
 
         @mutex = Mutex.new
-        @pool = ::Redis::Store::Factory.create @default_options[:redis_server]
+        @pool = if @default_options[:pool]
+                 raise "pool must be an instance of ConnectionPool" unless @default_options[:pool].is_a?(ConnectionPool)
+                  @pooled = true
+                  @default_options[:pool]
+                elsif [:pool_size, :pool_timeout].any? { |key| @default_options.has_key?(key) }
+                  pool_options           = {}
+                  pool_options[:size]    = options[:pool_size] if options[:pool_size]
+                  pool_options[:timeout] = options[:pool_timeout] if options[:pool_timeout]
+                  @pooled = true
+                  ::ConnectionPool.new(pool_options) { ::Redis::Store::Factory.create(@default_options[:redis_server]) } 
+                else
+                  @default_options.has_key?(:redis_store) ? 
+                    @default_options[:redis_store] :
+                    ::Redis::Store::Factory.create(@default_options[:redis_server])
+
+                end
       end
 
-      def generate_sid
+      def generate_unique_sid(session)
         loop do
-          sid = super
-          break sid unless @pool.get(sid)
+          sid = generate_sid
+          first = with do |c|
+            [*c.setnx(sid, session, @default_options)].first
+          end
+          break sid if [1, true].include?(first)
         end
       end
 
       def get_session(env, sid)
-        with_lock(env, [nil, {}]) do
-          unless sid and session = @pool.get(sid)
-            sid, session = generate_sid, {}
-            unless /^OK/ =~ @pool.set(sid, session, @default_options)
-              raise "Session collision on '#{sid.inspect}'"
+        if env['rack.session.options'][:skip]
+          [generate_sid, {}]
+        else
+          with_lock(env, [nil, {}]) do
+            unless sid and session = with { |c| c.get(sid) }
+              session = {}
+              sid = generate_unique_sid(session)
             end
+            [sid, session]
           end
-          [sid, session]
         end
       end
 
       def set_session(env, session_id, new_session, options)
         with_lock(env, false) do
-          @pool.set session_id, new_session, options
+          with { |c| c.set session_id, new_session, options }
           session_id
         end
       end
 
       def destroy_session(env, session_id, options)
         with_lock(env) do
-          @pool.del(session_id)
+          with { |c| c.del(session_id) }
           generate_sid unless options[:drop]
         end
       end
@@ -63,6 +83,14 @@ module Rack
         @mutex.unlock if @mutex.locked?
       end
 
+      def with(&block)
+        if @pooled
+          @pool.with(&block)
+        else
+          block.call(@pool)
+        end
+      end
+
     end
   end
 end

data/lib/redis/rack/version.rb

@@ -1,6 +1,6 @@
 class Redis
   module Rack
-    VERSION = '1.6.0'
+    VERSION = '2.0.0.pre'
   end
 end
 

data/redis-rack.gemspec

@@ -19,13 +19,14 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'redis-store',   '~> 1.2.0'
-  s.add_runtime_dependency 'rack',          '~> 1.5'
+  s.add_runtime_dependency 'redis-store',   '~> 1.2.0.pre'
+  s.add_runtime_dependency 'rack',          '> 1.5', '< 3'
 
   s.add_development_dependency 'rake',     '~> 10'
   s.add_development_dependency 'bundler',  '~> 1.3'
   s.add_development_dependency 'mocha',    '~> 0.14.0'
   s.add_development_dependency 'minitest', '~> 5'
   s.add_development_dependency 'redis-store-testing'
+  s.add_development_dependency 'connection_pool',     '~> 1.2.0'
 end
 

data/test/rack/session/redis_test.rb

@@ -1,6 +1,7 @@
 require 'test_helper'
 require 'rack/mock'
 require 'thread'
+require 'connection_pool'
 
 describe Rack::Session::Redis do
   session_key = Rack::Session::Redis::DEFAULT_OPTIONS[:key]
@@ -22,6 +23,10 @@ describe Rack::Session::Redis do
     env['rack.session.options'][:defer] = true
     incrementor.call(env)
   end
+  skip_session = proc do |env|
+    env['rack.session.options'][:skip] = true
+    incrementor.call(env)
+  end
 
   # # test Redis connection
   # Rack::Session::Redis.new(incrementor)
@@ -32,6 +37,36 @@ describe Rack::Session::Redis do
   #   }.must_raise(Exception)
   # end
 
+  it "can create it's own pool" do
+    session_store = Rack::Session::Redis.new(incrementor, pool_size: 5, pool_timeout: 10)
+    session_store.pool.class.must_equal ::ConnectionPool
+    session_store.pool.instance_variable_get(:@size).must_equal 5
+  end
+
+  it "can create it's own pool using default Redis server" do
+    session_store = Rack::Session::Redis.new(incrementor, pool_size: 5, pool_timeout: 10)
+    session_store.with { |connection| connection.to_s.must_match(/127\.0\.0\.1:6379 against DB 0 with namespace rack:session$/)  }
+  end
+
+  it "can create it's own pool using provided Redis server" do
+    session_store = Rack::Session::Redis.new(incrementor, redis_server: 'redis://127.0.0.1:6380/1', pool_size: 5, pool_timeout: 10)
+    session_store.with { |connection| connection.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)  }
+  end
+
+
+  it "can use a supplied pool" do
+    session_store = Rack::Session::Redis.new(incrementor, pool: ::ConnectionPool.new(size: 1, timeout: 1) { ::Redis::Store::Factory.create("redis://127.0.0.1:6380/1")})
+    session_store.pool.class.must_equal ::ConnectionPool
+    session_store.pool.instance_variable_get(:@size).must_equal 1
+  end
+
+  it "uses the specified Redis store when provided" do
+    store = ::Redis::Store::Factory.create('redis://127.0.0.1:6380/1')
+    pool = Rack::Session::Redis.new(incrementor, :redis_store => store)
+    pool.pool.to_s.must_match(/127\.0\.0\.1:6380 against DB 1$/)
+    pool.pool.must_equal(store)
+  end
+
   it "uses the default Redis server and namespace when not provided" do
     pool = Rack::Session::Redis.new(incrementor)
     pool.pool.to_s.must_match(/127\.0\.0\.1:6379 against DB 0 with namespace rack:session$/)
@@ -48,139 +83,162 @@ describe Rack::Session::Redis do
   end
 
   it "creates a new cookie" do
-    pool = Rack::Session::Redis.new(incrementor)
-    res = Rack::MockRequest.new(pool).get("/")
-    res["Set-Cookie"].must_include("#{session_key}=")
-    res.body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      res = Rack::MockRequest.new(pool).get("/")
+      res["Set-Cookie"].must_include("#{session_key}=")
+      res.body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "determines session from a cookie" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    res = req.get("/")
-    cookie = res["Set-Cookie"]
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.must_equal('{"counter"=>2}')
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.must_equal('{"counter"=>3}')
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      cookie = res["Set-Cookie"]
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.must_equal('{"counter"=>2}')
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.must_equal('{"counter"=>3}')
+    end
   end
 
   it "determines session only from a cookie by default" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    res = req.get("/")
-    sid = res["Set-Cookie"][session_match, 1]
-    req.get("/?rack.session=#{sid}").
-      body.must_equal('{"counter"=>1}')
-    req.get("/?rack.session=#{sid}").
-      body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      sid = res["Set-Cookie"][session_match, 1]
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>1}')
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "determines session from params" do
-    pool = Rack::Session::Redis.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.must_equal('{"counter"=>2}')
-    req.get("/?rack.session=#{sid}").
-      body.must_equal('{"counter"=>3}')
+    with_pool_management(incrementor, :cookie_only => false) do |pool|
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      sid = res["Set-Cookie"][session_match, 1]
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>2}')
+      req.get("/?rack.session=#{sid}").
+        body.must_equal('{"counter"=>3}')
+    end
   end
 
   it "survives nonexistant cookies" do
     bad_cookie = "rack.session=blarghfasel"
-    pool = Rack::Session::Redis.new(incrementor)
-    res = Rack::MockRequest.new(pool).
-      get("/", "HTTP_COOKIE" => bad_cookie)
-    res.body.must_equal('{"counter"=>1}')
-    cookie = res["Set-Cookie"][session_match]
-    cookie.wont_match(/#{bad_cookie}/)
+    with_pool_management(incrementor) do |pool|
+      res = Rack::MockRequest.new(pool).
+        get("/", "HTTP_COOKIE" => bad_cookie)
+      res.body.must_equal('{"counter"=>1}')
+      cookie = res["Set-Cookie"][session_match]
+      cookie.wont_match(/#{bad_cookie}/)
+    end
   end
 
   it "maintains freshness" do
-    pool = Rack::Session::Redis.new(incrementor, :expire_after => 3)
-    res = Rack::MockRequest.new(pool).get('/')
-    res.body.must_include('"counter"=>1')
-    cookie = res["Set-Cookie"]
-    sid = cookie[session_match, 1]
-    res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-    res["Set-Cookie"][session_match, 1].must_equal(sid)
-    res.body.must_include('"counter"=>2')
-    puts 'Sleeping to expire session' if $DEBUG
-    sleep 4
-    res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-    res["Set-Cookie"][session_match, 1].wont_equal(sid)
-    res.body.must_include('"counter"=>1')
+    with_pool_management(incrementor, :expire_after => 3) do |pool|
+      res = Rack::MockRequest.new(pool).get('/')
+      res.body.must_include('"counter"=>1')
+      cookie = res["Set-Cookie"]
+      sid = cookie[session_match, 1]
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+      res["Set-Cookie"][session_match, 1].must_equal(sid)
+      res.body.must_include('"counter"=>2')
+      puts 'Sleeping to expire session' if $DEBUG
+      sleep 4
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+      res["Set-Cookie"][session_match, 1].wont_equal(sid)
+      res.body.must_include('"counter"=>1')
+    end
   end
 
   it "does not send the same session id if it did not change" do
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
 
-    res0 = req.get("/")
-    cookie = res0["Set-Cookie"]
-    res0.body.must_equal('{"counter"=>1}')
+      res0 = req.get("/")
+      cookie = res0["Set-Cookie"]
+      res0.body.must_equal('{"counter"=>1}')
 
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"].must_be_nil
-    res1.body.must_equal('{"counter"=>2}')
+      res1 = req.get("/", "HTTP_COOKIE" => cookie)
+      res1["Set-Cookie"].must_be_nil
+      res1.body.must_equal('{"counter"=>2}')
 
-    res2 = req.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].must_be_nil
-    res2.body.must_equal('{"counter"=>3}')
+      res2 = req.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].must_be_nil
+      res2.body.must_equal('{"counter"=>3}')
+    end
   end
 
   it "deletes cookies with :drop option" do
-    pool = Rack::Session::Redis.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.must_equal('{"counter"=>1}')
-
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].must_be_nil
-    res2.body.must_equal('{"counter"=>2}')
-
-    res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    res3["Set-Cookie"][session_match].wont_equal(session)
-    res3.body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      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.must_equal('{"counter"=>1}')
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].must_be_nil
+      res2.body.must_equal('{"counter"=>2}')
+
+      res3 = req.get("/", "HTTP_COOKIE" => cookie)
+      res3["Set-Cookie"][session_match].wont_equal(session)
+      res3.body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "provides new session id with :renew option" do
-    pool = Rack::Session::Redis.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.must_equal('{"counter"=>1}')
-
-    res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
-    new_cookie = res2["Set-Cookie"]
-    new_session = new_cookie[session_match]
-    new_session.wont_equal(session)
-    res2.body.must_equal('{"counter"=>2}')
-
-    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-    res3.body.must_equal('{"counter"=>3}')
-
-    # Old cookie was deleted
-    res4 = req.get("/", "HTTP_COOKIE" => cookie)
-    res4.body.must_equal('{"counter"=>1}')
+    with_pool_management(incrementor) do |pool|
+      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.must_equal('{"counter"=>1}')
+
+      res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+      new_cookie = res2["Set-Cookie"]
+      new_session = new_cookie[session_match]
+      new_session.wont_equal(session)
+      res2.body.must_equal('{"counter"=>2}')
+
+      res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+      res3.body.must_equal('{"counter"=>3}')
+
+      # Old cookie was deleted
+      res4 = req.get("/", "HTTP_COOKIE" => cookie)
+      res4.body.must_equal('{"counter"=>1}')
+    end
   end
 
   it "omits cookie with :defer option" do
-    pool = Rack::Session::Redis.new(incrementor)
-    defer = Rack::Utils::Context.new(pool, defer_session)
-    dreq = Rack::MockRequest.new(defer)
+    with_pool_management(incrementor) do |pool|
+      defer = Rack::Utils::Context.new(pool, defer_session)
+      dreq = Rack::MockRequest.new(defer)
+
+      res0 = dreq.get("/")
+      res0["Set-Cookie"].must_be_nil
+      res0.body.must_equal('{"counter"=>1}')
+    end
+  end
+
+  it "does not hit with :skip option" do
+    with_pool_management(incrementor) do |pool|
+      skip = Rack::Utils::Context.new(pool, skip_session)
+      sreq = Rack::MockRequest.new(skip)
+
+      pool.instance_variable_set('@pool', MiniTest::Mock.new)
 
-    res0 = dreq.get("/")
-    res0["Set-Cookie"].must_be_nil
-    res0.body.must_equal('{"counter"=>1}')
+      res0 = sreq.get("/")
+      res0.body.must_equal('{"counter"=>1}')
+      assert pool.pool.verify
+    end
   end
 
   it "updates deep hashes correctly" do
@@ -194,17 +252,18 @@ describe Rack::Session::Redis do
       end
       [200, {}, [session.inspect]]
     end
-    pool = Rack::Session::Redis.new(hash_check)
-    req = Rack::MockRequest.new(pool)
+    with_pool_management(hash_check) do |pool|
+      req = Rack::MockRequest.new(pool)
 
-    res0 = req.get("/")
-    session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
-    ses0 = pool.pool.get(session_id)
+      res0 = req.get("/")
+      session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
+      ses0 = pool.with { |c| c.get(session_id) }
 
-    req.get("/", "HTTP_COOKIE" => cookie)
-    ses1 = pool.pool.get(session_id)
+      req.get("/", "HTTP_COOKIE" => cookie)
+      ses1 = pool.with { |c| c.get(session_id) }
 
-    ses1.wont_equal(ses0)
+      ses1.wont_equal(ses0)
+    end
   end
 
   # anyone know how to do this better?
@@ -214,76 +273,98 @@ describe Rack::Session::Redis do
       next
     end
     warn 'Running multithread test for Session::Redis'
-    pool = Rack::Session::Redis.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-
-    res = req.get('/')
-    res.body.must_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)
+    with_pool_management(incrementor) do |pool|
+      req = Rack::MockRequest.new(pool)
+
+      res = req.get('/')
+      res.body.must_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'].must_equal(cookie)
+        request.body.must_include('"counter"=>2')
       end
-    end.reverse.map{|t| t.run.join.value }
-    r.each do |request|
-      request['Set-Cookie'].must_equal(cookie)
-      request.body.must_include('"counter"=>2')
-    end
 
-    session = pool.pool.get(session_id)
-    session.size.must_equal(tnum+1) # counter
-    session['counter'].must_equal(2) # meeeh
+      session = pool.with { |c| c.get(session_id) }
+      session.size.must_equal(tnum+1) # counter
+      session['counter'].must_equal(2) # meeeh
+
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do |i|
+        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'].must_equal(cookie)
+        request.body.must_include('"counter"=>3')
+      end
 
-    tnum = rand(7).to_i+5
-    r = Array.new(tnum) do |i|
-      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)
+      session = pool.with { |c| c.get(session_id) }
+      session.size.must_equal(tnum+1)
+      session['counter'].must_equal(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'].must_equal(cookie)
+        request.body.must_include('"foo"=>"bar"')
       end
-    end.reverse.map{|t| t.run.join.value }
-    r.each do |request|
-      request['Set-Cookie'].must_equal(cookie)
-      request.body.must_include('"counter"=>3')
+
+      session = pool.with { |c| c.get(session_id) }
+      session.size.must_equal(r.size+1)
+      session['counter'].must_be_nil
+      session['foo'].must_equal('bar')
     end
+  end
 
-    session = pool.pool.get(session_id)
-    session.size.must_equal(tnum+1)
-    session['counter'].must_equal(3)
+  private
+    def with_pool_management(*args)
+      yield simple(*args)
+      yield pooled(*args)
+      yield external_pooled(*args)
+    end
 
-    drop_counter = proc do |env|
-      env['rack.session'].delete 'counter'
-      env['rack.session']['foo'] = 'bar'
-      [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+    def simple(app, options = {})
+      Rack::Session::Redis.new(app, options)
     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'].must_equal(cookie)
-      request.body.must_include('"foo"=>"bar"')
+
+    def pooled(app, options = {})
+      Rack::Session::Redis.new(app, options)
+      Rack::Session::Redis.new(app, options.merge(pool_size: 5, pool_timeout: 10))
+    end
+
+    def external_pooled(app, options = {})
+      Rack::Session::Redis.new(app, options.merge(pool: ::ConnectionPool.new(size: 1, timeout: 1) { ::Redis::Store::Factory.create("redis://127.0.0.1:6380/1") }))
     end
 
-    session = pool.pool.get(session_id)
-    session.size.must_equal(r.size+1)
-    session['counter'].must_be_nil
-    session['foo'].must_equal('bar')
-  end
 end

data/test/redis/rack/version_test.rb

@@ -2,6 +2,6 @@ require 'test_helper'
 
 describe Redis::Rack::VERSION do
   it 'returns current version' do
-    Redis::Rack::VERSION.must_equal '1.5.0'
+    Redis::Rack::VERSION.must_equal '2.0.0.pre'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-rack
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.0.0.pre
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-04 00:00:00.000000000 Z
+date: 2016-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-store
@@ -16,28 +16,34 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.2.0.pre
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.2.0.pre
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>'
       - !ruby/object:Gem::Version
         version: '1.5'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>'
       - !ruby/object:Gem::Version
         version: '1.5'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +114,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 description: Redis Store for Rack applications
 email:
 - me@lucaguidi.com
@@ -143,9 +163,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: redis-rack
 rubygems_version: 2.5.2