mongo_session_store-rails 7.0.0

data/lib/mongo_session_store/mongo_store_base.rb

@@ -0,0 +1,69 @@
+require "action_dispatch/middleware/session/abstract_store"
+
+module ActionDispatch
+  module Session
+    class MongoStoreBase < AbstractStore
+      SESSION_RECORD_KEY = "rack.session.record".freeze
+      ENV_SESSION_OPTIONS_KEY = Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY
+
+      def self.session_class
+        self::Session
+      end
+
+      private
+
+      def session_class
+        self.class.session_class
+      end
+
+      def generate_sid
+        BSON::ObjectId.new.to_s
+      end
+
+      def get_session(env, sid)
+        id, record = find_or_initialize_session(sid)
+        env[SESSION_RECORD_KEY] = record
+        [id, record.data]
+      end
+
+      def set_session(env, sid, session_data, _options = {})
+        id, record = get_session_record(env, sid)
+        record.data = session_data
+        yield if block_given?
+        # Rack spec dictates that set_session should return true or false
+        # depending on whether or not the session was saved or not.
+        # However, ActionPack seems to want a session id instead.
+        record.save ? id : false
+      end
+
+      def find_or_initialize_session(id)
+        existing_session = (id && session_class.where(:_id => id).first)
+        session = existing_session if existing_session
+        session ||= session_class.new(:_id => generate_sid)
+        [session._id.to_s, session]
+      end
+
+      def get_session_record(env, sid)
+        if env[ENV_SESSION_OPTIONS_KEY][:id].nil? || !env[SESSION_RECORD_KEY]
+          sid, env[SESSION_RECORD_KEY] = find_or_initialize_session(sid)
+        end
+
+        [sid, env[SESSION_RECORD_KEY]]
+      end
+
+      def destroy_session(env, _session_id, options)
+        destroy(env)
+        generate_sid unless options[:drop]
+      end
+
+      def destroy(env)
+        sid = current_session_id(env)
+        return unless sid
+
+        _, record = get_session_record(env, sid)
+        record.destroy
+        env[SESSION_RECORD_KEY] = nil
+      end
+    end
+  end
+end

data/lib/mongo_session_store/mongoid_store.rb

@@ -0,0 +1,47 @@
+require "mongo_session_store/mongo_store_base"
+
+module ActionDispatch
+  module Session
+    class MongoidStore < MongoStoreBase
+      class Session
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        attr_writer :data
+
+        store_in :collection => MongoSessionStore.collection_name
+
+        field :_data, :type => BSON::Binary, :default => -> { pack({}) }
+
+        def self.pack(data)
+          BSON::Binary.new(Marshal.dump(data), :generic)
+        end
+
+        def data
+          @data ||= unpack(_data)
+        end
+
+        private
+
+        before_save do
+          self._data = pack(data)
+        end
+
+        def pack(data)
+          self.class.pack(data)
+        end
+
+        def unpack(packed)
+          return unless packed
+          if packed.respond_to? :data
+            Marshal.load(packed.data)
+          else
+            Marshal.load(packed.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+
+MongoidStore = ActionDispatch::Session::MongoidStore

data/lib/mongo_session_store/version.rb

@@ -0,0 +1,3 @@
+module MongoSessionStore
+  VERSION = "7.0.0".freeze
+end

data/mongo_session_store.gemspec

@@ -0,0 +1,22 @@
+require File.expand_path("../lib/mongo_session_store/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "mongo_session_store-rails"
+  s.version = MongoSessionStore::VERSION
+
+  s.authors          = ["Tom de Bruijn", "Brian Hempel", "Nicolas M\303\251rouze", "Tony Pitale", "Chris Brickley"]
+  s.email            = ["tom@tomdebruijn.com.com"]
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec,perf}/*`.split("\n")
+  s.homepage         = "http://github.com/appsignal/mongo_session_store"
+  s.license          = "MIT"
+  s.require_paths    = ["lib"]
+  s.summary          = "Rails session stores for Mongoid, or any other ODM. Rails 4 compatible."
+
+  s.add_dependency "actionpack", "~> 4.0"
+  s.add_dependency "mongo", "~> 2.0"
+  s.add_development_dependency "rspec-rails", "~> 3"
+  s.add_development_dependency "pry", "~> 0.10"
+  s.add_development_dependency "rake", "~> 11"
+  s.add_development_dependency "rubocop", "0.45.0"
+end

data/perf/benchmark.rb

@@ -0,0 +1,99 @@
+require "rubygems"
+require "bundler/setup"
+require "benchmark"
+require "action_dispatch"
+require "mongoid"
+require "mongo_session_store"
+require "mongo_session_store/mongoid_store"
+require "mongo_session_store/mongo_store"
+require File.expand_path("../../lib/mongo_session_store", __FILE__)
+
+Mongo::Logger.logger.level = Logger::FATAL
+Mongoid.logger.level = Logger::FATAL
+
+MongoSessionStore.collection_name = "session_collection"
+MongoStore::Session.database =
+  Mongo::Client.new(["127.0.0.1:27017"], :database => "test_database")
+Mongoid.configure do |c|
+  c.load_configuration(
+    "clients" => {
+      "default" => {
+        "database" => "test_database",
+        "hosts" => ["127.0.0.1:27017"]
+      }
+    }
+  )
+end
+
+RUNS = 2000
+
+def benchmark(test_name)
+  time = Benchmark.realtime do
+    RUNS.times do
+      yield
+    end
+  end
+  puts "#{(time / RUNS * 100_000).round / 100.0}ms per #{test_name}"
+end
+
+def benchmark_store(store)
+  collection = store.class.session_class.collection
+  collection.drop
+
+  large_session = {
+    :something => "not nothing",
+    :left => "not right",
+    :welcome => "not despised",
+    :visits => [
+      "http://www.google.com",
+      "localhost:3000",
+      "http://localhost:3000/increment_session",
+      "http://www.iso.org/iso/country_codes/iso_3166_code_lists/iso-3166-1_decoding_table.htm",
+      "http://www.geonames.org/search.html?q=2303+australia&country="
+    ],
+    :one_k_of_data => "a" * 1024,
+    :another_k => "b" * 1024,
+    :more_data => [5] * 500,
+    :too_much_data_for_a_cookie => "c" * 8000,
+    :a_bunch_of_floats_in_embedded_docs => [:float_a => 3.141, :float_b => -1.1] * 100
+  }
+
+  ids = []
+
+  env = {
+    "rack.session" => large_session,
+    "rack.session.options" => { :id => store.send(:generate_sid) }
+  }
+  benchmark "session save" do
+    ids << store.send(
+      :set_session,
+      env.merge("rack.session.options" => { :id => nil }), nil, env["rack.session"]
+    )
+  end
+
+  ids.shuffle!
+
+  benchmark "session load" do
+    id = ids.pop
+    local_env = { "rack.request.cookie_hash" => { "_session_id" => id } }
+    _, data = store.send(:get_session, local_env, id)
+    if data[:something] != "not nothing" || data[:a_bunch_of_floats_in_embedded_docs][0][:float_a] != 3.141
+      puts data
+      raise "saved and fetched data do not match!"
+    end
+  end
+
+  stats = database.command(:collstats => MongoSessionStore.collection_name).documents.first
+  puts "           Total Size: #{stats["size"]}"
+  puts "         Object count: #{stats["count"]}"
+  puts "  Average object size: #{stats["avgObjSize"]}"
+  puts "          Index sizes: #{stats["indexSizes"].inspect}"
+end
+
+puts "MongoidStore..."
+mongoid_store = MongoidStore.new(nil)
+benchmark_store(mongoid_store)
+
+puts "MongoStore..."
+mongo_store = MongoStore.new(nil)
+benchmark_store(mongo_store)

data/spec/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_from: ../.rubocop.yml
+
+Metrics/LineLength:
+  Max: 100

data/spec/integrations/devise_spec.rb

@@ -0,0 +1,109 @@
+require "rails_helper"
+
+describe Devise::SessionsController, :type => :request do
+  def create_user
+    post "/users",
+      "user[email]" => "person@example.com",
+      "user[password]" => "secret",
+      "user[password_confirmation]" => "secret"
+  end
+
+  def sign_in
+    post "/users/sign_in",
+      "user[email]" => "person@example.com",
+      "user[password]" => "secret",
+      "user[password_confirmation]" => "secret"
+  end
+
+  def sign_out
+    delete "/users/sign_out"
+  end
+
+  def expect_to_be_signed_in
+    expect(controller.user_signed_in?).to eq(true)
+    get "/"
+    expect(response.body.squish).to include "You are signed in as person@example.com"
+  end
+
+  def expect_to_not_be_signed_in
+    expect(controller.user_signed_in?).to eq(false)
+    get "/"
+    expect(response.body.squish).to include "You are signed out"
+  end
+
+  it "creates a user" do
+    expect do
+      create_user
+      expect(response.status).to eq(302)
+    end.to change { User.count }.from(0).to(1)
+
+    get response.redirect_url
+    expect(response.body.squish).to include \
+      "You are signed in as person@example.com",
+      "You have signed up successfully"
+  end
+
+  describe "user session" do
+    describe "sign out" do
+      before do
+        create_user
+        expect_to_be_signed_in
+      end
+
+      it "signs out user" do
+        sign_out
+
+        expect(response.status).to eq(302)
+        expect_to_not_be_signed_in
+        expect(response.body.squish).to include "Signed out successfully"
+      end
+    end
+
+    describe "sign in" do
+      before do
+        create_user
+        sign_out
+        expect_to_not_be_signed_in
+      end
+
+      it "signs in user" do
+        sign_in
+
+        expect(response.status).to eq(302)
+        expect_to_be_signed_in
+        expect(response.body.squish).to include "Signed in successfully"
+      end
+    end
+  end
+
+  describe "session_store" do
+    subject { Rails.application.config.session_store.session_class.to_s }
+
+    it "uses the mongo #{mongo_orm} session store class" do
+      expect(subject).to eq \
+        "ActionDispatch::Session::#{mongo_orm.camelize}Store::Session"
+    end
+  end
+
+  describe "sessions collection" do
+    let(:collection) { test_database["sessions"] }
+
+    it "creates a record in the sessions collection" do
+      expect do
+        create_user
+      end.to change { collection.find.count }.from(0).to(1)
+    end
+
+    describe "custom collection" do
+      before { MongoSessionStore.collection_name = "dance_parties" }
+      after { MongoSessionStore.collection_name = "sessions" }
+      let(:collection) { test_database["dance_parties"] }
+
+      it "creates a record in the custom sessions collection" do
+        expect do
+          create_user
+        end.to change { collection.find.count }.from(0).to(1)
+      end
+    end
+  end
+end

data/spec/lib/mongo_session_store/mongo_store/session_spec.rb

@@ -0,0 +1,250 @@
+require "spec_helper"
+
+if mongo_orm == "mongo"
+  require "mongo_session_store"
+  require "mongo_session_store/mongo_store"
+
+  describe MongoStore::Session do
+    before { described_class.collection.drop }
+
+    describe ".database" do
+      subject { described_class.database }
+
+      context "with database" do
+        let(:database) do
+          MongoStore::Session.database = Mongo::Client.new(
+            ["127.0.0.1:27017"],
+            :database => TestDatabaseHelper.test_database_name
+          )
+        end
+        around do |example|
+          original_db = described_class.database
+          described_class.database = database
+          example.run
+          described_class.database = original_db
+        end
+
+        it "returns the database" do
+          expect(subject).to eq(database)
+        end
+      end
+
+      context "without database" do
+        it "raises an error" do
+          original_db = described_class.database
+          described_class.database = nil
+
+          expect { subject }.to raise_error(described_class::NoMongoClientError)
+
+          described_class.database = original_db
+        end
+      end
+    end
+
+    describe ".collection_name" do
+      # Where the name comes from:
+      # - "test_database" set in spec_helper
+      # - "sessions" is derived from model name
+      it "saves in the given collection_name" do
+        expect(described_class.collection.namespace).to eq("test_database.sessions")
+      end
+    end
+
+    describe ".where" do
+      subject { described_class.where(:_id => id) }
+
+      context "without matching records" do
+        let(:id) { nil }
+
+        it "returns an empty array" do
+          expect(subject).to eq([])
+        end
+      end
+
+      context "with matching records" do
+        let(:session) { described_class.new(:_id => BSON::ObjectId.new).tap(&:save) }
+        let(:id) { session._id }
+        before do
+          # Noise
+          described_class.new(:_id => BSON::ObjectId.new).tap(&:save)
+        end
+
+        it "returns session model objects" do
+          expect(subject.map(&:_id)).to eq([session._id])
+        end
+      end
+    end
+
+    describe ".load" do
+      let(:created_at) { Time.local(2016, 5, 27, 12, 25, 15) }
+      let(:updated_at) { Time.local(2016, 5, 28, 16, 15, 55) }
+      let(:session) { described_class.load(attributes) }
+
+      context "without data" do
+        let(:attributes) do
+          {
+            :_id => BSON::ObjectId.new,
+            :created_at => created_at,
+            :updated_at => updated_at
+          }
+        end
+
+        it "creates a session object with empty data" do
+          expect(session._id).to be_kind_of(BSON::ObjectId)
+          expect(session.data).to eq({})
+          expect(session.created_at).to eq(created_at)
+          expect(session.updated_at).to eq(updated_at)
+        end
+      end
+
+      context "with data key as a symbol" do
+        let(:attributes) do
+          {
+            :_id => BSON::ObjectId.new,
+            :data => BSON::Binary.new(Marshal.dump(:foo => "bar"), :generic),
+            :created_at => created_at,
+            :updated_at => updated_at
+          }
+        end
+
+        it "creates a session object with correct data" do
+          expect(session._id).to be_kind_of(BSON::ObjectId)
+          expect(session.data).to eq(:foo => "bar")
+          expect(session.created_at).to eq(created_at)
+          expect(session.updated_at).to eq(updated_at)
+        end
+      end
+
+      context "with data key as a string" do
+        let(:attributes) do
+          {
+            :_id => BSON::ObjectId.new,
+            "data" => BSON::Binary.new(Marshal.dump(:foo => "bar"), :generic),
+            :created_at => created_at,
+            :updated_at => updated_at
+          }
+        end
+
+        it "creates a session object with correct data" do
+          expect(session._id).to be_kind_of(BSON::ObjectId)
+          expect(session.data).to eq(:foo => "bar")
+          expect(session.created_at).to eq(created_at)
+          expect(session.updated_at).to eq(updated_at)
+        end
+      end
+    end
+
+    describe "#save" do
+      let(:id) { BSON::ObjectId.new }
+      subject { described_class.collection.find(:_id => id).first }
+
+      describe "_id attribute" do
+        let(:session) { described_class.new(:_id => id) }
+        before { session.save }
+
+        it "saves a record in MongoDB" do
+          expect(subject[:_id]).to eq(id)
+        end
+      end
+
+      describe "timestamps" do
+        let!(:time) { Time.now.utc }
+        let(:session) { described_class.new(:_id => id) }
+
+        describe "#created_at" do
+          context "without time" do
+            before { session.save }
+
+            it "sets the current time" do
+              expect(subject[:created_at]).to be_kind_of(Time)
+              expect(subject[:created_at].to_s).to eq(time.to_s)
+            end
+          end
+
+          context "with time" do
+            let!(:original_created_at) { Time.parse("Thu Nov 29 14:33:20 2001").utc }
+            before { session.created_at = original_created_at }
+
+            it "keeps original created_at time" do
+              expect do
+                session.save
+              end.to_not change { session.created_at.to_s }
+
+              expect(subject[:created_at]).to be_kind_of(Time)
+              expect(subject[:created_at].to_s).to eq(original_created_at.to_s)
+            end
+          end
+        end
+
+        describe "#updated_at" do
+          context "without time" do
+            it "sets the current time" do
+              expect do
+                session.save
+              end.to change { session.updated_at.to_s }.from("").to(time.to_s)
+
+              expect(subject[:updated_at]).to be_kind_of(Time)
+              expect(subject[:updated_at].to_s).to eq(time.to_s)
+            end
+          end
+
+          context "with time" do
+            let!(:original_updated_at) { Time.parse("Thu Nov 29 14:33:20 2001").utc }
+            before { session.updated_at = original_updated_at }
+
+            it "updates the time to the current time" do
+              expect do
+                session.save
+              end.to change { session.updated_at.to_s }.from(original_updated_at.to_s).to(time.to_s)
+
+              expect(subject[:updated_at]).to be_kind_of(Time)
+              expect(subject[:updated_at].to_s).to eq(time.to_s)
+            end
+          end
+        end
+      end
+
+      context "with data attribute" do
+        before do
+          session = described_class.new(
+            :_id => id,
+            :data => { :foo => "bar" }
+          )
+          session.save
+        end
+
+        it "saves the marshalled data" do
+          expect(subject[:data]).to be_kind_of(BSON::Binary)
+          unmarshalled_data = Marshal.load(StringIO.new(subject[:data].data))
+          expect(unmarshalled_data).to eq(:foo => "bar")
+        end
+      end
+
+      context "without data attribute" do
+        before do
+          session = described_class.new(:_id => id)
+          session.save
+        end
+
+        it "saves empty hash" do
+          expect(subject[:data]).to be_kind_of(BSON::Binary)
+          unmarshalled_data = Marshal.load(StringIO.new(subject[:data].data))
+          expect(unmarshalled_data).to eq({})
+        end
+      end
+    end
+
+    describe "#destroy" do
+      let(:id) { BSON::ObjectId.new }
+      let(:session) { described_class.new(:_id => id) }
+      before { session.save }
+
+      it "removes the record from the collection" do
+        expect do
+          session.destroy
+        end.to change { described_class.collection.count }.from(1).to(0)
+        expect(described_class.collection.find(:_id => session._id).count).to eq(0)
+      end
+    end
+  end
+end