rack-redic 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b908eba6dfd16a9c0288fc441f5034a71d90182b
-  data.tar.gz: 3670a26907451fee9bfbe96b47563e4048fd0d69
+  metadata.gz: 0343dd0cb8b4c338b4ffb2f103969e6aa9681556
+  data.tar.gz: f8493e153c5f85648d55d5e99433351645e52cb7
 SHA512:
-  metadata.gz: 171a60f038d7a62e9af3f5bcf577f89efe7db6a7ea1aaeb73a0de3025147818ed461a9fa2cffb6fff44622006fe90dbbc600d5140a004e668eea670a4006dc29
-  data.tar.gz: 6e7ff29f664c03f3901dd869a9784837c0a815de439a0f966fc507f5f6ee9bdeb34a3aa2e39fb0189ea33762b5f7d322faf74d4202b38baf81d7c1b7658cd48b
+  metadata.gz: 5dbfc8659cc61a1610acb82c1306da982f1ca07bdc39295394743c928ee04d53b038f5454e892dc64eee93b49b605fa4f5005f304b550d855122533fdf893384
+  data.tar.gz: ad56f8b4d338f9b6a375309397ab28969a0c92485b159c064d1017816328b408365e38845a976ddf6a58afbad74571d6c3439e1abeaa7cf8f4ac50c6443703cd

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/rack/session/redic.rb

@@ -30,14 +30,16 @@ module Rack
     class Redic < Abstract::Persisted
       REDIS_URL = 'REDIS_URL'.freeze
 
+      attr_reader :storage
+
       def initialize(app, options = {})
         super
 
         @mutex = Mutex.new
         @storage = Storage.new(
           options[:expire_after],
-          options.fetch(:marshaller, Marshal),
-          options.fetch(:url, ENV.fetch(REDIS_URL))
+          options.fetch(:marshaller) { Marshal },
+          options.fetch(:url) { ENV.fetch(REDIS_URL) }
         )
       end
 
@@ -52,8 +54,9 @@ module Rack
       # Find the session (or generate a blank one).
       def find_session(_req, sid)
         @mutex.synchronize do
-          sid ||= generate_sid
-          session = @storage.get(sid) || @storage.init(sid, {})
+          unless sid && session = @storage.get(sid)
+            sid, session = generate_sid, {}
+          end
 
           [sid, session]
         end
@@ -100,11 +103,6 @@ module Rack
           @storage.call(EXISTS, id) != ZERO
         end
 
-        def init(sid, initial)
-          set(sid, initial)
-          initial
-        end
-
         def get(id)
           deserialize(@storage.call(GET, id))
         end

data/rack-redic.gemspec

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 Gem::Specification.new do |spec|
   spec.name    = 'rack-redic'
-  spec.version = '0.5.0'
+  spec.version = '0.6.0'
   spec.authors = ['Evan Lecklider']
   spec.email   = ['evan@lecklider.com']
 
@@ -11,7 +11,10 @@ Gem::Specification.new do |spec|
   spec.homepage    = 'https://github.com/evanleck/rack-redic'
   spec.license     = 'MIT'
   spec.files       = `git ls-files`.split("\n")
+  spec.test_files  = spec.files.grep(/^spec/)
 
   spec.add_dependency 'rack'
   spec.add_dependency 'redic'
+
+  spec.add_development_dependency 'rspec'
 end

data/spec/session_redic_spec.rb

@@ -0,0 +1,234 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+require 'rack/lint'
+require 'rack/mock'
+
+# These tests are unceremoniously copied and modified from
+# https://github.com/rack/rack/blob/master/test/spec_session_memcache.rb.
+describe Rack::Session::Redic do
+  ROOT = '/'
+
+  session_key = Rack::Session::Abstract::Persisted::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)
+
+  it 'creates a new cookie' do
+    redic = Rack::Session::Redic.new(incrementor)
+    res = Rack::MockRequest.new(redic).get(ROOT)
+
+    expect(res[Rack::SET_COOKIE]).to include("#{ session_key }=")
+    expect(res.body).to eq('{"counter"=>1}')
+  end
+
+  it 'determines session from a cookie' do
+    redic = Rack::Session::Redic.new(incrementor)
+    req = Rack::MockRequest.new(redic)
+    res = req.get(ROOT)
+
+    cookie = res[Rack::SET_COOKIE]
+
+    expect(req.get(ROOT, Rack::HTTP_COOKIE => cookie).body).to eq('{"counter"=>2}')
+    expect(req.get(ROOT, Rack::HTTP_COOKIE => cookie).body).to eq('{"counter"=>3}')
+  end
+
+  it 'determines session only from a cookie by default' do
+    redic = Rack::Session::Redic.new(incrementor)
+    req = Rack::MockRequest.new(redic)
+    res = req.get(ROOT)
+    sid = res[Rack::SET_COOKIE][session_match, 1]
+
+    expect(req.get("/?rack.session=#{sid}").body).to eq('{"counter"=>1}')
+    expect(req.get("/?rack.session=#{sid}").body).to eq('{"counter"=>1}')
+  end
+
+  it 'determines session from params' do
+    redic = Rack::Session::Redic.new(incrementor, cookie_only: false)
+    req = Rack::MockRequest.new(redic)
+    res = req.get(ROOT)
+    sid = res[Rack::SET_COOKIE][session_match, 1]
+
+    expect(req.get("/?rack.session=#{sid}").body).to eq('{"counter"=>2}')
+    expect(req.get("/?rack.session=#{sid}").body).to eq('{"counter"=>3}')
+  end
+
+  it 'survives nonexistant cookies' do
+    bad_cookie = "rack.session=#{ SecureRandom.hex(16) }"
+
+    redic = Rack::Session::Redic.new(incrementor)
+    res = Rack::MockRequest.new(redic).get(ROOT, Rack::HTTP_COOKIE => bad_cookie)
+
+    expect(res.body).to eq('{"counter"=>1}')
+
+    cookie = res[Rack::SET_COOKIE][session_match]
+    expect(cookie).not_to match(/#{ bad_cookie }/)
+  end
+
+  it 'maintains freshness' do
+    redic = Rack::Session::Redic.new(incrementor, expire_after: 3)
+    res = Rack::MockRequest.new(redic).get(ROOT)
+    expect(res.body).to include('"counter"=>1')
+
+    cookie = res[Rack::SET_COOKIE]
+    res = Rack::MockRequest.new(redic).get(ROOT, Rack::HTTP_COOKIE => cookie)
+
+    expect(res[Rack::SET_COOKIE]).to eq(cookie)
+    expect(res.body).to include('"counter"=>2')
+
+    puts 'Sleeping to expire session' if $DEBUG
+    sleep 4
+
+    res = Rack::MockRequest.new(redic).get(ROOT, Rack::HTTP_COOKIE => cookie)
+    expect(res[Rack::SET_COOKIE]).not_to eq(cookie)
+    expect(res.body).to include('"counter"=>1')
+  end
+
+  it 'does not send the same session id if it did not change' do
+    redic = Rack::Session::Redic.new(incrementor)
+    req = Rack::MockRequest.new(redic)
+
+    res0 = req.get(ROOT)
+    cookie = res0[Rack::SET_COOKIE][session_match]
+    expect(res0.body).to eq('{"counter"=>1}')
+
+    res1 = req.get(ROOT, Rack::HTTP_COOKIE => cookie)
+    expect(res1[Rack::SET_COOKIE]).to eq(nil)
+    expect(res1.body).to eq('{"counter"=>2}')
+
+    res2 = req.get(ROOT, Rack::HTTP_COOKIE => cookie)
+    expect(res2[Rack::SET_COOKIE]).to eq(nil)
+    expect(res2.body).to eq('{"counter"=>3}')
+  end
+
+  it 'deletes cookies with :drop option' do
+    redic = Rack::Session::Redic.new(incrementor)
+    req = Rack::MockRequest.new(redic)
+    drop = Rack::Utils::Context.new(redic, drop_session)
+    dreq = Rack::MockRequest.new(drop)
+
+    res1 = req.get(ROOT)
+    session = (cookie = res1[Rack::SET_COOKIE])[session_match]
+    expect(res1.body).to eq('{"counter"=>1}')
+
+    res2 = dreq.get(ROOT, Rack::HTTP_COOKIE => cookie)
+    expect(res2[Rack::SET_COOKIE]).to eq(nil)
+    expect(res2.body).to eq('{"counter"=>2}')
+
+    res3 = req.get(ROOT, Rack::HTTP_COOKIE => cookie)
+    expect(res3[Rack::SET_COOKIE][session_match]).not_to eq(session)
+    expect(res3.body).to eq('{"counter"=>1}')
+  end
+
+  it 'provides new session id with :renew option' do
+    redic = Rack::Session::Redic.new(incrementor)
+    req = Rack::MockRequest.new(redic)
+    renew = Rack::Utils::Context.new(redic, renew_session)
+    rreq = Rack::MockRequest.new(renew)
+
+    res1 = req.get(ROOT)
+    session = (cookie = res1[Rack::SET_COOKIE])[session_match]
+    expect(res1.body).to eq('{"counter"=>1}')
+
+    res2 = rreq.get(ROOT, Rack::HTTP_COOKIE => cookie)
+    new_cookie = res2[Rack::SET_COOKIE]
+    new_session = new_cookie[session_match]
+    expect(new_session).not_to eq(session)
+    expect(res2.body).to eq('{"counter"=>2}')
+
+    res3 = req.get(ROOT, Rack::HTTP_COOKIE => new_cookie)
+    expect(res3.body).to eq('{"counter"=>3}')
+
+    # Old cookie was deleted
+    res4 = req.get(ROOT, Rack::HTTP_COOKIE => cookie)
+    expect(res4.body).to eq('{"counter"=>1}')
+  end
+
+  it 'omits cookie with :defer option but still updates the state' do
+    redic = Rack::Session::Redic.new(incrementor)
+    count = Rack::Utils::Context.new(redic, incrementor)
+    defer = Rack::Utils::Context.new(redic, defer_session)
+    dreq = Rack::MockRequest.new(defer)
+    creq = Rack::MockRequest.new(count)
+
+    res0 = dreq.get(ROOT)
+    expect(res0[Rack::SET_COOKIE]).to eq(nil)
+    expect(res0.body).to eq('{"counter"=>1}')
+
+    res0 = creq.get(ROOT)
+    res1 = dreq.get(ROOT, Rack::HTTP_COOKIE => res0[Rack::SET_COOKIE])
+    expect(res1.body).to eq('{"counter"=>2}')
+    res2 = dreq.get(ROOT, Rack::HTTP_COOKIE => res0[Rack::SET_COOKIE])
+    expect(res2.body).to eq('{"counter"=>3}')
+  end
+
+  it 'omits cookie and state update with :skip option' do
+    redic = Rack::Session::Redic.new(incrementor)
+    count = Rack::Utils::Context.new(redic, incrementor)
+    skip = Rack::Utils::Context.new(redic, skip_session)
+    sreq = Rack::MockRequest.new(skip)
+    creq = Rack::MockRequest.new(count)
+
+    res0 = sreq.get(ROOT)
+    expect(res0[Rack::SET_COOKIE]).to eq(nil)
+    expect(res0.body).to eq('{"counter"=>1}')
+
+    res0 = creq.get(ROOT)
+    res1 = sreq.get(ROOT, Rack::HTTP_COOKIE => res0[Rack::SET_COOKIE])
+    expect(res1.body).to eq('{"counter"=>2}')
+    res2 = sreq.get(ROOT, Rack::HTTP_COOKIE => res0[Rack::SET_COOKIE])
+    expect(res2.body).to eq('{"counter"=>2}')
+  end
+
+  it 'updates deep hashes correctly' do
+    hash_check = proc do |env|
+      session = env['rack.session']
+
+      if session.include?('test')
+        session[:f][:g][:h] = :j
+      else
+        session.update a: :b, c: { d: :e }, f: { g: { h: :i } }, 'test' => true
+      end
+
+      [200, {}, [session.inspect]]
+    end
+
+    redic = Rack::Session::Redic.new(hash_check)
+    req = Rack::MockRequest.new(redic)
+
+    res0 = req.get(ROOT)
+    session_id = (cookie = res0[Rack::SET_COOKIE])[session_match, 1]
+    ses0 = redic.storage.get(session_id)
+
+    req.get(ROOT, Rack::HTTP_COOKIE => cookie)
+    ses1 = redic.storage.get(session_id)
+
+    expect(ses1).not_to eq(ses0)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Ensure we have this set before trying to initialize anything.
+ENV['REDIS_URL'] ||= 'redis://localhost:6379'
+
+require 'rack/session/redic'

data/spec/storage_spec.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+describe Rack::Session::Redic::Storage do
+  subject do
+    Rack::Session::Redic::Storage.new(nil, Marshal, ENV['REDIS_URL'])
+  end
+
+  it 'returns nil for empty keys' do
+    expect(subject.get('not-here')).to eq(nil)
+  end
+
+  it 'saves objects' do
+    object = { saved: true }
+    subject.set('saving', object)
+
+    expect(subject.get('saving')).to eq(object)
+    subject.delete('saving') # Cleanup.
+  end
+
+  it 'checks the existence of keys' do
+    subject.set('exists', false)
+
+    expect(subject.exists?('exists')).to eq(true)
+  end
+
+  it 'deletes objects' do
+    object = { deleted: true }
+    subject.set('deleted', object)
+
+    expect(subject.get('deleted')).to eq(object)
+    subject.delete('deleted')
+
+    expect(subject.get('deleted')).to eq(nil)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-redic
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Evan Lecklider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-03 00:00:00.000000000 Z
+date: 2017-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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::Session in Redis via Redic
 email:
 - evan@lecklider.com
@@ -46,6 +60,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -53,6 +68,9 @@ files:
 - Rakefile
 - lib/rack/session/redic.rb
 - rack-redic.gemspec
+- spec/session_redic_spec.rb
+- spec/spec_helper.rb
+- spec/storage_spec.rb
 homepage: https://github.com/evanleck/rack-redic
 licenses:
 - MIT
@@ -73,8 +91,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Rack::Session in Redis via Redic
-test_files: []
+test_files:
+- spec/session_redic_spec.rb
+- spec/spec_helper.rb
+- spec/storage_spec.rb