mongo_session_store 2.0.0 → 3.0.0.beta.1

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,247 @@
+require "spec_helper"
+
+if mongo_orm == "mongo"
+  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 => generate_sid).tap(&:save) }
+        let(:id) { session._id }
+        before do
+          # Noise
+          described_class.new(:_id => generate_sid).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 => generate_sid,
+            :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(String)
+          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 => generate_sid,
+            :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(String)
+          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 => generate_sid,
+            "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(String)
+          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) { generate_sid }
+      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) { generate_sid }
+      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

data/spec/lib/mongo_session_store/mongo_store_base_spec.rb

@@ -0,0 +1,269 @@
+require "spec_helper"
+require "ostruct"
+
+class TestStore < ActionDispatch::Session::MongoStoreBase
+  class Session < OpenStruct
+    def self.where(_ = {})
+      []
+    end
+  end
+end
+
+describe ActionDispatch::Session::MongoStoreBase do
+  describe ".session_class" do
+    let(:store_class) { TestStore }
+    let(:store) { store_class.new(nil) }
+    subject { store_class.session_class }
+
+    it "returns child session class" do
+      expect(subject).to eq(TestStore::Session)
+    end
+  end
+
+  describe "#get_session" do
+    let(:env) { {} }
+    let(:store_class) { TestStore }
+    let(:store) { store_class.new(nil) }
+    let(:session_class) { store_class::Session }
+    let(:session_record) { env[store_class::SESSION_RECORD_KEY] }
+
+    context "when no session exists" do
+      it "creates a new session" do
+        sid, session_data = store.send(:get_session, env, nil)
+
+        expect(sid).to be_kind_of(String)
+        expect(session_data).to be_nil
+        expect(session_record).to be_kind_of(session_class)
+        expect(session_record._id).to eq sid
+
+        env_record = env[described_class::SESSION_RECORD_KEY]
+        expect(env_record).to be_kind_of(session_class)
+        expect(env_record._id).to eq sid
+      end
+    end
+
+    context "when given session is found" do
+      let(:session) { session_class.new(:_id => "foo", :data => nil) }
+      before do
+        expect(session_class).to receive(:where).and_return([session])
+      end
+
+      it "returns the existing session" do
+        sid, session_data = store.send(:get_session, env, session._id)
+
+        expect(sid).to eq(session._id)
+        expect(sid).to be_kind_of(String)
+        expect(session_data).to be_nil
+        expect(session_record).to be_kind_of(session_class)
+        expect(session_record._id).to eq sid
+
+        env_record = env[described_class::SESSION_RECORD_KEY]
+        expect(env_record).to be_kind_of(session_class)
+        expect(env_record._id).to eq sid
+      end
+    end
+
+    context "when given session is not found" do
+      let(:not_existing_session_id) { SecureRandom.hex }
+
+      it "creates a new session" do
+        sid, session_data = store.send(:get_session, env, not_existing_session_id)
+
+        expect(sid).to_not eq(not_existing_session_id)
+        expect(sid).to be_kind_of(String)
+        expect(session_data).to be_nil
+        expect(session_record).to be_kind_of(session_class)
+        expect(session_record._id).to eq sid
+
+        env_record = env[described_class::SESSION_RECORD_KEY]
+        expect(env_record).to be_kind_of(session_class)
+        expect(env_record._id).to eq sid
+      end
+    end
+
+    context "with custom session class" do
+      let(:store_class) { TestStore }
+
+      it "returns a session record from the custom session class" do
+        sid, session_data = store.send(:get_session, env, nil)
+
+        expect(sid).to be_kind_of(String)
+        expect(session_data).to be_nil
+        expect(session_record).to be_kind_of(session_class)
+        expect(session_record._id.to_s).to eq sid
+      end
+    end
+  end
+
+  describe "#set_session" do
+    let(:store_class) { mongo_orm == "mongoid" ? MongoidStore : MongoStore }
+    let(:store) { store_class.new(nil) }
+    let(:session_class) { store_class::Session }
+    subject { store.send(:set_session, env, generate_sid, {}) }
+
+    context "with existing session record" do
+      let(:id) { generate_sid }
+      let!(:session_record) { session_class.new(:_id => id).tap(&:save) }
+      let(:env) do
+        {
+          "rack.session" => double(:id => id),
+          Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY => { :id => id }
+        }
+      end
+      subject { store.send(:set_session, env, id, {}) }
+
+      it "uses the existing record" do
+        expect do
+          subject
+        end.to_not change { session_class.collection.find(:_id => id).count }
+        expect(subject).to eq(id.to_s)
+      end
+
+      it "yields" do
+        yielded_variable = :not_called
+        block =
+          proc do
+            yielded_variable = :called
+          end
+        store.send(:set_session, env, id, {}, &block)
+        expect(yielded_variable).to eq(:called)
+      end
+
+      context "with session record in the ENV" do
+        let(:env) do
+          {
+            "rack.session" => double(:id => id),
+            Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY => { :id => id },
+            "rack.session.record" => session_record
+          }
+        end
+
+        it "uses the record from the ENV" do
+          expect do
+            expect(session_record).to receive(:data=).and_call_original
+            subject
+          end.to_not change { session_class.collection.find(:_id => id).count }
+        end
+      end
+    end
+
+    context "without existing session record" do
+      let :env do
+        {
+          "rack.session" => {},
+          Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY => {}
+        }
+      end
+
+      it "creates a session record" do
+        expect do
+          subject
+        end.to change { session_class.collection.find.count }.from(0).to(1)
+        expect(subject).to be_kind_of(String)
+      end
+
+      it "sets the session record in the env" do
+        sid = subject
+        expect(env["rack.session.record"]).to be_kind_of(session_class)
+        expect(env["rack.session.record"]._id.to_s).to eq(sid)
+      end
+
+      context "when not saved" do
+        before do
+          record = double("data=" => nil, :save => false)
+          expect(store).to receive(:get_session_record).and_return([1, record])
+        end
+
+        it "returns false" do
+          expect(subject).to be false
+        end
+      end
+    end
+  end
+
+  describe "#destroy_session" do
+    let(:id) { generate_sid }
+    let(:store_class) { mongo_orm == "mongoid" ? MongoidStore : MongoStore }
+    let(:store) { store_class.new(nil) }
+    let(:session_class) { store_class::Session }
+    let(:env) do
+      {
+        "rack.session" => double(:id => id),
+        Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY => {}
+      }
+    end
+
+    context "without existing session" do
+      subject { store.send(:destroy_session, env, id, {}) }
+
+      it "does not remove any record" do
+        expect { subject }.to_not change { session_class.collection.count }
+      end
+
+      it "returns new session id" do
+        expect(subject).to be_kind_of(String)
+        expect(subject).to_not eq(id)
+      end
+
+      context "with option :drop" do
+        subject { store.send(:destroy_session, env, id, :drop => true) }
+
+        it "does not remove any record" do
+          expect { subject }.to_not change { session_class.collection.count }
+        end
+
+        it "returns nothing" do
+          expect(subject).to be_nil
+        end
+      end
+    end
+
+    context "with existing session" do
+      let!(:session_record) { session_class.new(:_id => id).tap(&:save) }
+      subject { store.send(:destroy_session, env, id, {}) }
+
+      it "removes the session record" do
+        expect do
+          subject
+        end.to change { session_class.collection.find(:_id => id).count }.from(1).to(0)
+      end
+
+      it "returns new session id" do
+        expect(subject).to be_kind_of(String)
+        expect(subject).to_not eq(session_record._id)
+      end
+
+      context "with session record in the ENV" do
+        let(:env) do
+          {
+            "rack.session" => double(:id => id),
+            Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY => { :id => id },
+            "rack.session.record" => session_record
+          }
+        end
+        subject { store.send(:destroy_session, env, id, :drop => true) }
+
+        it "destroys record in the env" do
+          expect do
+            expect(session_record).to receive(:destroy).and_call_original
+            subject
+          end.to change { session_class.collection.find(:_id => id).count }.from(1).to(0)
+        end
+      end
+
+      context "with option :drop" do
+        subject { store.send(:destroy_session, env, id, :drop => true) }
+
+        it "removes the session record" do
+          expect do
+            subject
+          end.to change { session_class.collection.find(:_id => id).count }.from(1).to(0)
+        end
+
+        it "returns nothing" do
+          expect(subject).to be_nil
+        end
+      end
+    end
+  end
+end