couchrest_session_store 0.1.3 → 0.2.0

data/.travis.yml

@@ -0,0 +1,4 @@
+services:
+  - couchdb
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in couchrest-session-store.gemspec
+gemspec
+
+gem 'debugger'
+

data/README.md

@@ -1,7 +1,11 @@
-# CouchRest Session Store #
+# CouchRest::Session::Store #
 
 A simple session store based on CouchRest Model.
 
+It will automatically pick up the config/couch.yml file for CouchRest Model
+
 ## Options ##
 
 * marhal_data: (_defaults true_) - if set to false session data will be stored directly in the couch document. Otherwise it's marshalled and base64 encoded to enable restoring ruby data structures.
+* database: database to use combined with config prefix and suffix
+* exprire_after: livetime of a session in seconds

data/couchrest_session_store.gemspec

@@ -0,0 +1,25 @@
+# _*_ encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+
+  gem.authors = ["Azul"]
+  gem.email = ["azul@leap.se"]
+  gem.summary = "A Rails Session Store based on CouchRest Model"
+  gem.description = gem.summary
+  gem.homepage = "http://github.com/azul/couchrest_session_store"
+
+  gem.has_rdoc = true
+#  gem.extra_rdoc_files = ["LICENSE"]
+
+  gem.files = `git ls-files`.split("\n")
+  gem.name = "couchrest_session_store"
+  gem.require_paths = ["lib"]
+  gem.version = '0.2.0'
+
+  gem.add_dependency "couchrest"
+  gem.add_dependency "couchrest_model"
+  gem.add_dependency "actionpack"
+
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "rake"
+end

data/lib/couchrest/session/document.rb

@@ -0,0 +1,76 @@
+require 'couchrest/session/utility'
+
+class CouchRest::Session::Document
+  include CouchRest::Session::Utility
+
+  def initialize(doc)
+    @doc = doc
+  end
+
+  def self.load(sid)
+    self.allocate.tap do |session_doc|
+      session_doc.load(sid)
+    end
+  end
+
+  def self.build(sid, session, options)
+    self.new(CouchRest::Document.new({"_id" => sid})).tap do |session_doc|
+      session_doc.update session, options
+    end
+  end
+
+  def load(sid)
+    @doc = database.get(sid)
+  end
+
+  def to_session
+    if doc["marshalled"]
+      session = unmarshal(doc["data"])
+    else
+      session = doc["data"]
+    end
+    return session
+  end
+
+  def delete
+    database.delete_doc(doc)
+  end
+
+  def update(session, options)
+    # clean up old data but leave id and revision intact
+    doc.reject! do |k,v|
+      k[0] != '_'
+    end
+    doc.merge! data_for_doc(session, options)
+  end
+
+  def save
+    database.save_doc(doc)
+  end
+
+  def expired?
+    expires && expires < Time.now
+  end
+
+  protected
+
+  def data_for_doc(session, options)
+    { "data" => options[:marshal_data] ? marshal(session) : session,
+      "marshalled" => options[:marshal_data],
+      "expires" => expiry_from_options(options) }
+  end
+
+  def expiry_from_options(options)
+    expire_after = options[:expire_after]
+    expire_after && (Time.now + expire_after)
+  end
+
+  def expires
+    doc["expires"] && Time.parse_iso8601(doc["expires"])
+  end
+
+  def doc
+    @doc
+  end
+
+end

data/lib/couchrest/session/store.rb

@@ -0,0 +1,75 @@
+class CouchRest::Session::Store < ActionDispatch::Session::AbstractStore
+
+  include CouchRest::Model::Configuration
+  include CouchRest::Model::Connection
+
+  def initialize(app, options = {})
+    super
+    self.class.set_options(options)
+  end
+
+  def self.set_options(options)
+    @options = options
+  end
+
+  # just fetch from the config
+  def self.database
+    @database ||= initialize_database
+  end
+
+  def self.initialize_database
+    use_database @options[:database] || "sessions"
+  end
+
+  private
+
+  def get_session(env, sid)
+    if session = fetch_session(sid)
+      [sid, session]
+    else
+      [generate_sid, {}]
+    end
+  rescue RestClient::ResourceNotFound
+    # session data does not exist anymore
+    return [sid, {}]
+  end
+
+  def set_session(env, sid, session, options)
+    doc = build_or_update_doc(sid, session, options)
+    doc.save
+    return sid
+  end
+
+  def destroy_session(env, sid, options)
+    doc = secure_get(sid)
+    doc.delete
+    generate_sid unless options[:drop]
+  rescue RestClient::ResourceNotFound
+    # already destroyed - we're done.
+    generate_sid unless options[:drop]
+  end
+
+  def fetch_session(sid)
+    return nil unless sid
+    doc = secure_get(sid)
+    doc.to_session unless doc.expired?
+  end
+
+  def build_or_update_doc(sid, session, options)
+    options[:marshal_data] = true if options[:marshal_data].nil?
+    doc = secure_get(sid)
+    doc.update(session, options)
+    return doc
+  rescue RestClient::ResourceNotFound
+    CouchRest::Session::Document.build(sid, session, options)
+  end
+
+  # prevent access to design docs
+  # this should be prevented on a couch permission level as well.
+  # but better be save than sorry.
+  def secure_get(sid)
+    raise RestClient::ResourceNotFound if /^_design\/(.*)/ =~ sid
+    CouchRest::Session::Document.load(sid)
+  end
+end
+

data/lib/couchrest/session/utility.rb

@@ -0,0 +1,16 @@
+module CouchRest::Session::Utility
+  module_function
+
+  def marshal(data)
+    ::Base64.encode64(Marshal.dump(data)) if data
+  end
+
+  def unmarshal(data)
+    Marshal.load(::Base64.decode64(data)) if data
+  end
+
+  def database
+    CouchRest::Session::Store.database
+  end
+
+end

data/lib/couchrest/session.rb

@@ -0,0 +1,5 @@
+module CouchRest
+  module Session
+  end
+end
+

data/lib/couchrest_session_store.rb

@@ -4,118 +4,7 @@ require 'couchrest_model'
 gem 'actionpack', '~> 3.0'
 require 'action_dispatch'
 
-# CouchDB session storage for Rails.
-#
-# It will automatically pick up the config/couch.yml file for CouchRest Model
-#
-# Options:
-# :database => database to use combined with config prefix and suffix
-#
-class CouchRestSessionStore < ActionDispatch::Session::AbstractStore
-
-  include CouchRest::Model::Configuration
-  include CouchRest::Model::Connection
-
-  class << self
-    def marshal(data)
-      ::Base64.encode64(Marshal.dump(data)) if data
-    end
-
-    def unmarshal(data)
-      Marshal.load(::Base64.decode64(data)) if data
-    end
-
-  end
-
-  def initialize(app, options = {})
-    super
-    self.class.set_options(options)
-  end
-
-  def self.set_options(options)
-    @options = options
-  end
-
-  # just fetch from the config
-  def self.database
-    @database ||= initialize_database
-  end
-
-  def self.initialize_database
-    use_database @options[:database] || "sessions"
-  end
-
-  def database
-    self.class.database
-  end
-
-  private
-
-  def get_session(env, sid)
-    if sid
-      doc = secure_get(sid)
-      if doc["not_marshalled"]
-        session = doc.to_hash
-        session.delete("not_marshalled")
-      else
-        session = self.class.unmarshal(doc["data"])
-      end
-      [sid, session]
-    else
-      [generate_sid, {}]
-    end
-  rescue RestClient::ResourceNotFound
-    # session data does not exist anymore
-    return [sid, {}]
-  end
-
-  def set_session(env, sid, session, options)
-    doc = build_or_update_doc(sid, session, options[:marshal_data])
-    database.save_doc(doc)
-    return sid
-  end
-
-  def destroy_session(env, sid, options)
-    doc = secure_get(sid)
-    database.delete_doc(doc)
-    generate_sid unless options[:drop]
-  rescue RestClient::ResourceNotFound
-    # already destroyed - we're done.
-    generate_sid unless options[:drop]
-  end
-
-  def build_or_update_doc(sid, session, marshal_data)
-    marshal_data = true if marshal_data.nil?
-    doc = secure_get(sid)
-    update_doc doc, data_for_doc(session, marshal_data)
-    return doc
-  rescue RestClient::ResourceNotFound
-    data = data_for_doc(session, marshal_data).merge({"_id" => sid})
-    return CouchRest::Document.new(data)
-  end
-
-  def update_doc(doc, data)
-    # clean up old data but leave id and revision intact
-    doc.reject! do |k,v|
-      k[0] != '_'
-    end
-    doc.merge! data
-  end
-
-  def data_for_doc(session, marshal_data)
-    if marshal_data
-      { "data" => self.class.marshal(session) }
-    else
-      session.merge({"not_marshalled" => true})
-    end
-  end
-
-  # prevent access to design docs
-  # this should be prevented on a couch permission level as well.
-  # but better be save than sorry.
-  def secure_get(sid)
-    raise RestClient::ResourceNotFound if /^_design\/(.*)/ =~ sid
-    database.get(sid)
-  end
-end
+require 'couchrest/session'
+require 'couchrest/session/store'
+require 'couchrest/session/document'
 

data/test/couch_tester.rb

@@ -0,0 +1,26 @@
+#
+# Access the couch directly so we can test its state without relying
+# on the SessionStore
+#
+
+class CouchTester
+  include CouchRest::Model::Configuration
+  include CouchRest::Model::Connection
+
+  attr_reader :database
+
+  def initialize(options = {})
+    @database = self.class.use_database options[:database] || "sessions"
+  end
+
+  def get(sid)
+    database.get(sid)
+  end
+
+  def update(sid, diff)
+    doc = database.get(sid)
+    doc.merge! diff
+    database.save_doc(doc)
+  end
+
+end

data/test/session_store_test.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class SessionStoreTest < MiniTest::Test
+
+  def test_session_initialization
+    sid, session = store.send :get_session, env, nil
+    assert sid
+    assert_equal Hash.new, session
+  end
+
+  def test_normal_session_flow
+    sid, session = init_session
+    store_session(sid, session)
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+    store.send :destroy_session, env, sid, {}
+  end
+
+  def test_updating_session
+    sid, session = init_session
+    store_session(sid, session)
+    session[:bla] = "blub"
+    store.send :set_session, env, sid, session, {}
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+    store.send :destroy_session, env, sid, {}
+  end
+
+  def test_unmarshalled_session_flow
+    sid, session = init_session
+    store_session sid, session, :marshal_data => false
+    new_sid, new_session = store.send(:get_session, env, sid)
+    assert_equal sid, new_sid
+    assert_equal session[:key], new_session["key"]
+    store.send :destroy_session, env, sid, {}
+  end
+
+  def test_unmarshalled_data
+    sid, session = init_session
+    store_session sid, session, :marshal_data => false
+    couch = CouchTester.new
+    data = couch.get(sid)["data"]
+    assert_equal session[:key], data["key"]
+  end
+
+  def test_logout_in_between
+    sid, session = init_session
+    store_session(sid, session)
+    store.send :destroy_session, env, sid, {}
+    other_sid, other_session = store.send(:get_session, env, sid)
+    assert_equal Hash.new, other_session
+  end
+
+  def test_can_logout_twice
+    sid, session = init_session
+    store_session(sid, session)
+    store.send :destroy_session, env, sid, {}
+    store.send :destroy_session, env, sid, {}
+    other_sid, other_session = store.send(:get_session, env, sid)
+    assert_equal Hash.new, other_session
+  end
+
+  def test_stored_and_not_expired_yet
+    sid, session = init_session
+    store_session(sid, session, expire_after: 300)
+    doc = CouchRest::Session::Document.load(sid)
+    expires = doc.send :expires
+    assert expires
+    assert !doc.expired?
+    assert (expires - Time.now) > 0, "Exiry should be in the future"
+    assert (expires - Time.now) <= 300, "Should expire after 300 seconds - not more"
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+  end
+
+  def test_stored_but_expired
+    sid, session = init_session
+    store_session(sid, session, expire_after: 300)
+    CouchTester.new.update(sid, "expires" => Time.now - 2.minutes)
+    other_sid, other_session = store.send(:get_session, env, sid)
+    assert_equal Hash.new, other_session, "session should have expired"
+    assert other_sid != sid
+  end
+
+  def test_store_without_expiry
+    sid, session = init_session
+    store_session(sid, session)
+    couch = CouchTester.new
+    assert_nil couch.get(sid)["expires"]
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+  end
+
+  def app
+    nil
+  end
+
+  def store(options = {})
+    @store ||= CouchRest::Session::Store.new(app, options)
+  end
+
+  def env(settings = {})
+    env ||= settings
+  end
+
+  def init_session
+    sid, session = store.send :get_session, env, nil
+    session[:key] = "stub"
+    return sid, session
+  end
+
+  def store_session(sid, session, options = {})
+    store.send :set_session, env, sid, session, options
+  end
+end

data/test/test_clock.rb

@@ -0,0 +1,12 @@
+class TestClock
+  attr_accessor :now
+
+  def initialize(tick = 60)
+    @tick = tick
+    @now = Time.now
+  end
+
+  def tick(seconds = nil)
+    @now += seconds || @tick
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require "rubygems"
+gem 'minitest'
+require 'minitest/autorun'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/couchrest_session_store.rb')
+require File.expand_path(File.dirname(__FILE__) + '/couch_tester.rb')
+require File.expand_path(File.dirname(__FILE__) + '/test_clock.rb')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: couchrest_session_store
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-17 00:00:00.000000000 Z
+date: 2013-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: couchrest
@@ -98,9 +98,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .travis.yml
+- Gemfile
 - README.md
 - Rakefile
+- couchrest_session_store.gemspec
+- lib/couchrest/session.rb
+- lib/couchrest/session/document.rb
+- lib/couchrest/session/store.rb
+- lib/couchrest/session/utility.rb
 - lib/couchrest_session_store.rb
+- test/couch_tester.rb
+- test/session_store_test.rb
+- test/test_clock.rb
+- test/test_helper.rb
 homepage: http://github.com/azul/couchrest_session_store
 licenses: []
 post_install_message: