mongoid 3.1.6 → 4.0.2

data/spec/mongoid/sessions/factory_spec.rb

@@ -30,11 +30,11 @@ describe Mongoid::Sessions::Factory do
           end
 
           it "returns a session" do
-            session.should be_a(Moped::Session)
+            expect(session).to be_a(Moped::Session)
           end
 
           it "sets the cluster's seeds" do
-            cluster.seeds.should eq([ "localhost:27017" ])
+            expect(cluster.seeds.first.address.resolved).to eq("127.0.0.1:27017")
           end
         end
 
@@ -64,15 +64,15 @@ describe Mongoid::Sessions::Factory do
           end
 
           it "returns a session" do
-            session.should be_a(Moped::Session)
+            expect(session).to be_a(Moped::Session)
           end
 
           it "sets the cluster's seed ports to 27017" do
-            cluster.seeds.should eq([ "localhost:27017" ])
+            expect(cluster.seeds.first.address.original).to eq("localhost:27017")
           end
 
           it "sets ips with no ports to 27017" do
-            default.cluster.seeds.should eq([ "127.0.0.1:27017" ])
+            expect(default.cluster.seeds.first.address.original).to eq("127.0.0.1:27017")
           end
         end
 
@@ -100,30 +100,30 @@ describe Mongoid::Sessions::Factory do
             end
 
             it "returns a session" do
-              session.should be_a(Moped::Session)
+              expect(session).to be_a(Moped::Session)
             end
 
             it "sets the cluster's seeds" do
-              cluster.seeds.should eq([ "localhost:27017" ])
+              expect(cluster.seeds.first.address.original).to eq("localhost:27017")
             end
 
             it "sets the database" do
-              session.options[:database].should eq("mongoid_test")
+              expect(session.options[:database]).to eq("mongoid_test")
             end
 
             it "sets the database in the configuration" do
               session
-              Mongoid.sessions[:secondary].should include(:database)
+              expect(Mongoid.sessions[:secondary]).to include(:database)
             end
 
             it "sets the hosts in the configuration" do
               session
-              Mongoid.sessions[:secondary].should include(:hosts)
+              expect(Mongoid.sessions[:secondary]).to include(:hosts)
             end
 
             it "removes the uri from the configuration" do
               session
-              Mongoid.sessions[:secondary].should_not include(:uri)
+              expect(Mongoid.sessions[:secondary]).to_not include(:uri)
             end
           end
 
@@ -148,31 +148,35 @@ describe Mongoid::Sessions::Factory do
               session.cluster
             end
 
+            let(:seeds) do
+              cluster.seeds.map{ |node| node.address.original }
+            end
+
             it "returns a session" do
-              session.should be_a(Moped::Session)
+              expect(session).to be_a(Moped::Session)
             end
 
             it "sets the cluster's seeds" do
-              cluster.seeds.should eq([ "localhost:27017", "localhost:27017" ])
+              expect(seeds).to eq([ "localhost:27017", "localhost:27017" ])
             end
 
             it "sets the database" do
-              session.options[:database].should eq("mongoid_test")
+              expect(session.options[:database]).to eq("mongoid_test")
             end
 
             it "sets the database in the configuration" do
               session
-              Mongoid.sessions[:secondary].should include(:database)
+              expect(Mongoid.sessions[:secondary]).to include(:database)
             end
 
             it "sets the hosts in the configuration" do
               session
-              Mongoid.sessions[:secondary].should include(:hosts)
+              expect(Mongoid.sessions[:secondary]).to include(:hosts)
             end
 
             it "removes the uri from the configuration" do
               session
-              Mongoid.sessions[:secondary].should_not include(:uri)
+              expect(Mongoid.sessions[:secondary]).to_not include(:uri)
             end
           end
         end
@@ -206,12 +210,16 @@ describe Mongoid::Sessions::Factory do
         session.cluster
       end
 
+      let(:seeds) do
+        cluster.seeds.map{ |node| node.address.original }
+      end
+
       it "returns the default session" do
-        session.should be_a(Moped::Session)
+        expect(session).to be_a(Moped::Session)
       end
 
       it "sets the cluster's seeds" do
-        cluster.seeds.should eq([ "localhost:27017" ])
+        expect(seeds).to eq([ "localhost:27017" ])
       end
     end
 
@@ -247,12 +255,16 @@ describe Mongoid::Sessions::Factory do
       session.cluster
     end
 
+    let(:seeds) do
+      cluster.seeds.map{ |node| node.address.original }
+    end
+
     it "returns the default session" do
-      session.should be_a(Moped::Session)
+      expect(session).to be_a(Moped::Session)
     end
 
     it "sets the cluster's seeds" do
-      cluster.seeds.should eq([ "localhost:27017" ])
+      expect(seeds).to eq([ "localhost:27017" ])
     end
   end
 
@@ -267,7 +279,8 @@ describe Mongoid::Sessions::Factory do
             "down_interval" => 10,
             "max_retries" => 5,
             "refresh_interval" => 30,
-            "retry_interval" => 0.1
+            "retry_interval" => 0.1,
+            "write" => { "w" => 1 }
           }
         }
       }
@@ -285,28 +298,36 @@ describe Mongoid::Sessions::Factory do
       session.cluster
     end
 
+    let(:seeds) do
+      cluster.seeds.map{ |node| node.address.original }
+    end
+
     it "returns the default session" do
-      session.should be_a(Moped::Session)
+      expect(session).to be_a(Moped::Session)
     end
 
     it "sets the cluster's seeds" do
-      cluster.seeds.should eq([ "localhost:27017" ])
+      expect(seeds).to eq([ "localhost:27017" ])
     end
 
     it "sets the cluster down interval" do
-      cluster.down_interval.should eq(10)
+      expect(cluster.down_interval).to eq(10)
     end
 
     it "sets the cluster max retries" do
-      cluster.max_retries.should eq(5)
+      expect(cluster.max_retries).to eq(5)
     end
 
     it "sets the cluster refresh interval" do
-      cluster.refresh_interval.should eq(30)
+      expect(cluster.refresh_interval).to eq(30)
     end
 
     it "sets the cluster retry interval" do
-      cluster.retry_interval.should eq(0.1)
+      expect(cluster.retry_interval).to eq(0.1)
+    end
+
+    it "sets the write concern" do
+      expect(session.write_concern).to be_a(Moped::WriteConcern::Propagate)
     end
   end
 end

data/spec/mongoid/sessions/mongo_uri_spec.rb

@@ -17,7 +17,7 @@ describe Mongoid::Sessions::MongoUri do
     end
 
     it "returns the database name" do
-      uri.database.should eq("mongoid_test")
+      expect(uri.database).to eq("mongoid_test")
     end
   end
 
@@ -30,7 +30,7 @@ describe Mongoid::Sessions::MongoUri do
       end
 
       it "returns an array with 1 node" do
-        uri.hosts.should eq([ "localhost:27017" ])
+        expect(uri.hosts).to eq([ "localhost:27017" ])
       end
     end
 
@@ -41,7 +41,7 @@ describe Mongoid::Sessions::MongoUri do
       end
 
       it "returns an array with 2 nodes" do
-        uri.hosts.should eq([ "localhost:27017", "localhost:27017" ])
+        expect(uri.hosts).to eq([ "localhost:27017", "localhost:27017" ])
       end
     end
   end
@@ -53,7 +53,7 @@ describe Mongoid::Sessions::MongoUri do
     end
 
     it "returns the password" do
-      uri.password.should eq("pass")
+      expect(uri.password).to eq("pass")
     end
   end
 
@@ -66,7 +66,7 @@ describe Mongoid::Sessions::MongoUri do
       end
 
       it "does not include the username and password" do
-        uri.to_hash.should eq({
+        expect(uri.to_hash).to eq({
           hosts: [ "localhost:27017", "localhost:27017" ],
           database: "mongoid_test"
         })
@@ -80,7 +80,7 @@ describe Mongoid::Sessions::MongoUri do
       end
 
       it "includes the username and password" do
-        uri.to_hash.should eq({
+        expect(uri.to_hash).to eq({
           hosts: [ "localhost:27017" ],
           database: "mongoid_test",
           username: "user",
@@ -97,7 +97,7 @@ describe Mongoid::Sessions::MongoUri do
     end
 
     it "returns the userame" do
-      uri.username.should eq("user")
+      expect(uri.username).to eq("user")
     end
   end
 end

data/spec/mongoid/sessions/options_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe Mongoid::Sessions::Options do
+
+  describe "#with" do
+
+    context "when passing some options" do
+
+      let(:options) { { database: 'test' } }
+
+      let!(:klass) do
+        Band.with(options)
+      end
+
+      it "sets the options into the class" do
+        expect(klass.persistence_options).to eq(options)
+      end
+
+      it "sets the options into the instance" do
+        expect(klass.new.persistence_options).to eq(options)
+      end
+
+      it "doesnt set the options on class level" do
+        expect(Band.new.persistence_options).to be_nil
+      end
+
+      context "when calling .collection method" do
+
+        before do
+          klass.collection
+        end
+
+        it "keeps the options" do
+          expect(klass.persistence_options).to eq(options)
+        end
+      end
+
+      context "when returning a criteria" do
+
+        let(:criteria) do
+          klass.all
+        end
+
+        it "sets the options into the criteria object" do
+          expect(criteria.persistence_options).to eq(options)
+        end
+
+        it "doesnt set the options on class level" do
+          expect(Band.new.persistence_options).to be_nil
+        end
+      end
+    end
+  end
+
+  describe ".with" do
+
+    let(:options) { { database: 'test' } }
+
+    let(:instance) do
+      Band.new.with(options)
+    end
+
+    it "sets the options into" do
+      expect(instance.persistence_options).to eq(options)
+    end
+
+    it "passes down the options to collection" do
+      session = Band.mongo_session
+      expect_any_instance_of(Moped::Session).to receive(:with).with(options).and_return(session)
+      instance.collection
+    end
+  end
+
+  describe "#persistence_options" do
+
+    it "touches the thread local" do
+      expect(Thread.current).to receive(:[]).with("[mongoid][Band]:persistence-options").and_return({foo: :bar})
+      expect(Band.persistence_options).to eq({foo: :bar})
+    end
+
+    it "cannot force a value on thread local" do
+      expect {
+        Band.set_persistence_options(Band, {})
+      }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe ".persistence_options" do
+
+    context "when options exist on the current thread" do
+
+      let(:klass) do
+        Band.with(write: { w: 2 })
+      end
+
+      it "returns the options" do
+        expect(klass.persistence_options).to eq(write: { w: 2 })
+      end
+    end
+
+    context "when there are no options on the current thread" do
+
+      it "returns nil" do
+        expect(Band.persistence_options).to be_nil
+      end
+    end
+  end
+end

data/spec/mongoid/sessions_spec.rb

@@ -2,104 +2,83 @@ require "spec_helper"
 
 describe Mongoid::Sessions do
 
-  describe ".clear_persistence_options" do
-
-    context "when options exist on the current thread" do
-
-      before do
-        Band.with(safe: true)
-      end
+  describe "#collection" do
 
-      let!(:cleared) do
-        Band.clear_persistence_options
-      end
+    shared_examples_for "an overridden collection at the class level" do
 
-      it "remove the options from the current thread" do
-        Band.persistence_options.should be_nil
+      let(:band) do
+        klass.new
       end
 
-      it "returns true" do
-        cleared.should be_true
+      it "returns the collection for the model" do
+        expect(band.collection).to be_a(Moped::Collection)
       end
-    end
 
-    context "when options do not exist on the current thread" do
-
-      it "returns true" do
-        Band.clear_persistence_options.should be_true
+      it "sets the correct collection name" do
+        expect(band.collection.name).to eq("artists")
       end
-    end
-  end
 
-  describe "#collection" do
-
-    context "when overriding the default with store_in" do
-
-      shared_examples_for "an overridden collection at the class level" do
-
-        let(:band) do
-          Band.new
-        end
+      context "when accessing from the class level" do
 
         it "returns the collection for the model" do
-          band.collection.should be_a(Moped::Collection)
+          expect(klass.collection).to be_a(Moped::Collection)
         end
 
         it "sets the correct collection name" do
-          band.collection.name.to_s.should eq("artists")
+          expect(klass.collection.name).to eq("artists")
         end
+      end
+    end
 
-        context "when accessing from the class level" do
-
-          it "returns the collection for the model" do
-            Band.collection.should be_a(Moped::Collection)
-          end
+    context "when overriding the persistence options" do
 
-          it "sets the correct collection name" do
-            Band.collection.name.to_s.should eq("artists")
-          end
-        end
+      let(:klass) do
+        Band.with(collection: "artists")
+      end
 
-        context "when safety options exist" do
+      it_behaves_like "an overridden collection at the class level"
+    end
 
-          context "when the options are from the current thread" do
+    context "when overriding store_in and persistence options" do
 
-            before do
-              Band.with(safe: { w: 3 })
-            end
+      let(:klass) do
+        Band.with(collection: "artists")
+      end
 
-            it "clears the options from the current thread" do
-              Band.collection
-              Band.persistence_options.should be_nil
-            end
+      before do
+        Band.store_in collection: "foo"
+      end
 
-            it "returns the collection" do
-              Band.collection.should be_a(Moped::Collection)
-            end
-          end
-        end
+      after do
+        Band.reset_storage_options!
       end
 
+      it_behaves_like "an overridden collection at the class level"
+    end
+
+    context "when overriding the default with store_in" do
+
       after do
-        Band.storage_options = nil
+        Band.reset_storage_options!
       end
 
       context "when called multiple times with different options" do
+
         before do
           Band.store_in collection: "artists"
           Band.store_in session: "another"
         end
 
         it "should merge the options together" do
-          Band.storage_options.should == {
-            collection: "artists",
-            session: "another"
-          }
+          expect(Band.storage_options[:collection]).to eq("artists")
+          expect(Band.storage_options[:session]).to eq("another")
         end
       end
 
       context "when overriding with a proc" do
 
+        let(:klass) { Band }
+
         before do
           Band.store_in(collection: ->{ "artists" })
         end
@@ -109,17 +88,29 @@ describe Mongoid::Sessions do
 
       context "when overriding with a string" do
 
+        let(:klass) { Band }
+
         before do
           Band.store_in(collection: "artists")
         end
 
+        after do
+          Band.reset_storage_options!
+        end
+
         it_behaves_like "an overridden collection at the class level"
       end
 
       context "when overriding with a symbol" do
 
+        let(:klass) { Band }
+
         before do
-          Band.store_in(collection: :artists)
+          klass.store_in(collection: :artists)
+        end
+
+        after do
+          klass.reset_storage_options!
         end
 
         it_behaves_like "an overridden collection at the class level"
@@ -133,21 +124,21 @@ describe Mongoid::Sessions do
       end
 
       it "returns the collection for the model" do
-        band.collection.should be_a(Moped::Collection)
+        expect(band.collection).to be_a(Moped::Collection)
       end
 
       it "sets the correct collection name" do
-        band.collection.name.to_s.should eq("bands")
+        expect(band.collection.name.to_s).to eq("bands")
       end
 
       context "when accessing from the class level" do
 
         it "returns the collection for the model" do
-          Band.collection.should be_a(Moped::Collection)
+          expect(Band.collection).to be_a(Moped::Collection)
         end
 
         it "sets the correct collection name" do
-          Band.collection.name.to_s.should eq("bands")
+          expect(Band.collection.name.to_s).to eq("bands")
         end
       end
     end
@@ -155,31 +146,59 @@ describe Mongoid::Sessions do
 
   describe "#collection_name" do
 
-    context "when overriding the default with store_in" do
+    shared_examples_for "an overridden collection name at the class level" do
 
-      shared_examples_for "an overridden collection name at the class level" do
+      let(:band) do
+        klass.new
+      end
 
-        let(:band) do
-          Band.new
+      context "when accessing from the instance" do
+
+        it "returns the overridden value" do
+          expect(band.collection_name).to eq(:artists)
         end
+      end
 
-        context "when accessing from the instance" do
+      context "when accessing from the class level" do
 
-          it "returns the overridden value" do
-            band.collection_name.should eq(:artists)
-          end
+        it "returns the overridden value" do
+          expect(klass.collection_name).to eq(:artists)
         end
+      end
+    end
 
-        context "when accessing from the class level" do
+    context "when overriding the persistence options" do
 
-          it "returns the overridden value" do
-            Band.collection_name.should eq(:artists)
-          end
-        end
+      let(:klass) do
+        Band.with(collection: "artists")
+      end
+
+      it_behaves_like "an overridden collection name at the class level"
+    end
+
+    context "when overriding store_in and persistence options" do
+
+      let(:klass) do
+        Band.with(collection: "artists")
+      end
+
+      before do
+        Band.store_in collection: "foo"
       end
 
       after do
-        Band.storage_options = nil
+        Band.reset_storage_options!
+      end
+
+      it_behaves_like "an overridden collection name at the class level"
+    end
+
+    context "when overriding the default with store_in" do
+
+      let(:klass) { Band }
+
+      after do
+        Band.reset_storage_options!
       end
 
       context "when overriding with a proc" do
@@ -217,13 +236,13 @@ describe Mongoid::Sessions do
       end
 
       it "returns the pluralized model name" do
-        band.collection_name.should eq(:bands)
+        expect(band.collection_name).to eq(:bands)
       end
 
       context "when accessing from the class level" do
 
         it "returns the pluralized model name" do
-          Band.collection_name.should eq(:bands)
+          expect(Band.collection_name).to eq(:bands)
         end
       end
     end
@@ -235,14 +254,120 @@ describe Mongoid::Sessions do
       end
 
       it "returns the root class pluralized model name" do
-        firefox.collection_name.should eq(:canvases)
+        expect(firefox.collection_name).to eq(:canvases)
       end
 
       context "when accessing from the class level" do
 
         it "returns the root class pluralized model name" do
-          Firefox.collection_name.should eq(:canvases)
+          expect(Firefox.collection_name).to eq(:canvases)
+        end
+      end
+    end
+  end
+
+  describe "#database_name" do
+
+    shared_examples_for "an overridden database name" do
+
+      let(:band) do
+        klass.new
+      end
+
+      context "when accessing from the instance" do
+
+        it "returns the overridden value" do
+          expect(band.mongo_session.options[:database].to_s).to eq(database_id_alt)
+        end
+      end
+
+      context "when accessing from the class level" do
+
+        it "returns the overridden value" do
+          expect(klass.database_name.to_s).to eq(database_id_alt)
+        end
+
+        it "session returns the overridden value" do
+          expect(klass.mongo_session.options[:database].to_s).to eq(database_id_alt)
+        end
+      end
+    end
+
+    context "when overriding the persistence options" do
+
+      let(:klass) do
+        Band.with(database: database_id_alt)
+      end
+
+      it_behaves_like "an overridden database name"
+    end
+
+    context "when overriding with store_in" do
+
+      let(:klass) { Band }
+
+      before do
+        Band.store_in database: database_id_alt
+      end
+
+      after do
+        Band.reset_storage_options!
+      end
+
+      it_behaves_like "an overridden database name"
+    end
+
+    context "when overriding store_in and persistence options" do
+
+      let(:klass) do
+        Band.with(database: database_id_alt)
+      end
+
+      before do
+        Band.store_in database: "foo"
+      end
+
+      after do
+        Band.reset_storage_options!
+      end
+
+      it_behaves_like "an overridden database name"
+    end
+
+    context "when overriding using the session" do
+
+      let(:session_name) { :alternative }
+
+      before do
+        Mongoid.sessions[session_name] = { database: database_id_alt, hosts: [ "#{HOST}:#{PORT}" ] }
+      end
+
+      after do
+        Mongoid.sessions.delete(session_name)
+      end
+
+      context "when overriding the persistence options" do
+
+        let(:klass) do
+          Band.with(session: session_name)
         end
+
+        it_behaves_like "an overridden database name"
+      end
+
+      context "when overriding with store_in" do
+
+        let(:klass) { Band }
+
+        before do
+          Band.store_in(session: session_name)
+        end
+
+        after do
+          Band.reset_storage_options!
+        end
+
+        it_behaves_like "an overridden database name"
       end
     end
   end
@@ -259,10 +384,6 @@ describe Mongoid::Sessions do
       Mongoid.sessions[:default][:database] = database_id
     end
 
-    after do
-      Band.storage_options = nil
-    end
-
     context "when getting the default" do
 
       let(:file) do
@@ -270,16 +391,11 @@ describe Mongoid::Sessions do
       end
 
       before do
-        Band.storage_options = nil
         described_class.clear
         Mongoid.load!(file, :test)
         Mongoid.sessions[:default][:database] = database_id
       end
 
-      after do
-        Band.storage_options = nil
-      end
-
       let!(:band) do
         Band.new
       end
@@ -289,7 +405,37 @@ describe Mongoid::Sessions do
       end
 
       it "returns the default session" do
-        mongo_session.options[:database].should eq(database_id)
+        expect(mongo_session.options[:database].to_s).to eq(database_id)
+      end
+    end
+
+    context "when overridden the database with store_in" do
+
+      before do
+        Band.store_in(database: database_id_alt)
+      end
+
+      context "on instance level" do
+
+        let(:band) do
+          Band.new.with({:read=>:primary})
+        end
+
+        it "uses the new database" do
+          expect(band.mongo_session.send(:current_database).name).to eq database_id_alt
+        end
+
+        context "when using another database before" do
+
+          before do
+            band
+            User.create!
+          end
+
+          it "uses the new database" do
+            expect(band.mongo_session.send(:current_database).name).to eq database_id_alt
+          end
+        end
       end
     end
 
@@ -306,7 +452,7 @@ describe Mongoid::Sessions do
         end
 
         it "returns the default session" do
-          single_session.options[:database].should eq(ENV["MONGOHQ_SINGLE_NAME"])
+          expect(single_session.options[:database].to_s).to eq(ENV["MONGOHQ_SINGLE_NAME"])
         end
       end
 
@@ -350,8 +496,12 @@ describe Mongoid::Sessions do
 
       shared_examples_for "an overridden session to a mongohq replica set" do
 
-        it "returns the default session" do
-          replica_session.options[:database].should eq(ENV["MONGOHQ_REPL_NAME"])
+        let(:seeds) do
+          replica_session.cluster.seeds.map{ |node| node.address.original }
+        end
+
+        it "returns the overridden session" do
+          expect(seeds).to eq([ ENV["MONGOHQ_REPL_1_URL"], ENV["MONGOHQ_REPL_2_URL"] ])
         end
       end
 
@@ -397,8 +547,12 @@ describe Mongoid::Sessions do
         band.mongo_session
       end
 
-      it "returns the default session" do
-        repl_session.options[:database].should eq(ENV["MONGOHQ_REPL_NAME"])
+      let(:seeds) do
+        repl_session.cluster.seeds.map{ |node| node.address.original }
+      end
+
+      it "returns the overridden session" do
+        expect(seeds).to eq([ ENV["MONGOHQ_REPL_1_URL"], ENV["MONGOHQ_REPL_2_URL"] ])
       end
     end
 
@@ -433,7 +587,7 @@ describe Mongoid::Sessions do
     end
 
     after do
-      Band.storage_options = nil
+      Band.reset_storage_options!
     end
 
     context "when getting the default" do
@@ -443,7 +597,7 @@ describe Mongoid::Sessions do
       end
 
       before do
-        Band.storage_options = nil
+        Band.reset_storage_options!
         described_class.clear
         Mongoid.load!(file, :test)
         Mongoid.sessions[:default][:database] = database_id
@@ -454,7 +608,7 @@ describe Mongoid::Sessions do
       end
 
       it "returns the default session" do
-        mongo_session.options[:database].should eq(database_id)
+        expect(mongo_session.options[:database].to_s).to eq(database_id)
       end
     end
 
@@ -469,7 +623,7 @@ describe Mongoid::Sessions do
       end
 
       it "returns the default session" do
-        session.options[:database].should eq(ENV["MONGOHQ_SINGLE_NAME"])
+        expect(session.options[:database].to_s).to eq(ENV["MONGOHQ_SINGLE_NAME"])
       end
     end
 
@@ -483,8 +637,12 @@ describe Mongoid::Sessions do
         Band.mongo_session
       end
 
-      it "returns the default session" do
-        repl_session.options[:database].should eq(ENV["MONGOHQ_REPL_NAME"])
+      let(:seeds) do
+        repl_session.cluster.seeds.map{ |node| node.address.original }
+      end
+
+      it "returns the overridden session" do
+        expect(seeds).to eq([ ENV["MONGOHQ_REPL_1_URL"], ENV["MONGOHQ_REPL_2_URL"] ])
       end
     end
 
@@ -502,39 +660,27 @@ describe Mongoid::Sessions do
     end
   end
 
-  describe ".persistence_options" do
-
-    context "when options exist on the current thread" do
-
-      before do
-        Band.with(safe: { w: 2 })
-      end
+  describe ".store_in" do
 
-      after do
-        Band.clear_persistence_options
-      end
+    context "when provided a non hash" do
 
-      it "returns the options" do
-        Band.persistence_options.should eq(safe: { w: 2 })
+      it "raises an error" do
+        expect {
+          Band.store_in :artists
+        }.to raise_error(Mongoid::Errors::InvalidStorageOptions)
       end
     end
 
-    context "when there are no options on the current thread" do
+    context "when provided a class that extend another document" do
 
-      it "returns nil" do
-        Band.persistence_options.should be_nil
+      let(:klass) do
+        Class.new(Band)
       end
-    end
-  end
-
-  describe ".store_in" do
-
-    context "when provided a non hash" do
 
       it "raises an error" do
         expect {
-          Band.store_in :artists
-        }.to raise_error(Mongoid::Errors::InvalidStorageOptions)
+          klass.store_in(database: :artists)
+        }.to raise_error(Mongoid::Errors::InvalidStorageParent)
       end
     end
 
@@ -556,13 +702,13 @@ describe Mongoid::Sessions do
     context "when sending operations to a different database" do
 
       after do
-        Band.with(database: "mongoid_test_alt").delete_all
+        Band.with(database: database_id_alt).delete_all
       end
 
       describe ".create" do
 
         let!(:band) do
-          Band.with(database: "mongoid_test_alt").create
+          Band.with(database: database_id_alt).create
         end
 
         it "does not persist to the default database" do
@@ -572,15 +718,15 @@ describe Mongoid::Sessions do
         end
 
         let(:from_db) do
-          Band.with(database: "mongoid_test_alt").find(band.id)
+          Band.with(database: database_id_alt).find(band.id)
         end
 
         it "persists to the specified database" do
-          from_db.should eq(band)
+          expect(from_db).to eq(band)
         end
 
         it "persists the correct number of documents" do
-          Band.with(database: "mongoid_test_alt").count.should eq(1)
+          expect(Band.with(database: database_id_alt).count).to eq(1)
         end
       end
 
@@ -605,40 +751,40 @@ describe Mongoid::Sessions do
         end
 
         before do
-          Band.with(database: "mongoid_test_alt").delete_all
+          Band.with(database: database_id_alt).delete_all
         end
 
         let!(:depeche_mode) do
-          Band.with(database: "mongoid_test_alt").
+          Band.with(database: database_id_alt).
             create(name: "Depeche Mode", likes: 200)
         end
 
         let!(:tool) do
-          Band.with(database: "mongoid_test_alt").
+          Band.with(database: database_id_alt).
             create(name: "Tool", likes: 100)
         end
 
         context "when outputting in memory" do
 
           let(:results) do
-            Band.with(database: "mongoid_test_alt").
+            Band.with(database: database_id_alt).
               map_reduce(map, reduce).out(inline: 1)
           end
 
           it "executes the map/reduce on the correct database" do
-            results.first["value"].should eq({ "likes" => 200 })
+            expect(results.first["value"]).to eq({ "likes" => 200 })
           end
         end
 
         context "when outputting to a collection" do
 
           let(:results) do
-            Band.with(database: "mongoid_test_alt").
+            Band.with(database: database_id_alt).
               map_reduce(map, reduce).out(replace: "bands_output")
           end
 
           it "executes the map/reduce on the correct database" do
-            results.first["value"].should eq({ "likes" => 200 })
+            expect(results.first["value"]).to eq({ "likes" => 200 })
           end
         end
       end
@@ -663,11 +809,11 @@ describe Mongoid::Sessions do
         end
 
         it "persists to the specified database" do
-          from_db.should eq(band)
+          expect(from_db).to eq(band)
         end
 
         it "persists the correct number of documents" do
-          Band.with(collection: "artists").count.should eq(1)
+          expect(Band.with(collection: "artists").count).to eq(1)
         end
       end
 
@@ -711,7 +857,7 @@ describe Mongoid::Sessions do
         end
 
         it "executes the map/reduce on the correct collection" do
-          results.first["value"].should eq({ "likes" => 200 })
+          expect(results.first["value"]).to eq({ "likes" => 200 })
         end
       end
     end
@@ -746,7 +892,7 @@ describe Mongoid::Sessions do
           end
 
           it "persists to the specified database" do
-            from_db.should eq(band)
+            expect(from_db).to eq(band)
           end
         end
 
@@ -767,7 +913,7 @@ describe Mongoid::Sessions do
           end
 
           it "persists to the specified database" do
-            from_db.should eq(band)
+            expect(from_db).to eq(band)
           end
         end
 
@@ -788,7 +934,7 @@ describe Mongoid::Sessions do
           end
 
           it "persists to the specified database" do
-            from_db.should eq(band)
+            expect(from_db).to eq(band)
           end
         end
       end
@@ -851,7 +997,7 @@ describe Mongoid::Sessions do
         end
 
         it "executes the map/reduce on the correct session" do
-          results.first["value"].should eq({ "likes" => 200 })
+          expect(results.first["value"]).to eq({ "likes" => 200 })
         end
       end
     end
@@ -861,33 +1007,34 @@ describe Mongoid::Sessions do
       describe ".create" do
 
         before do
-          Person.with(safe: true).create(ssn: "432-97-1111")
+          Person.create_indexes
+          Person.create(ssn: "432-97-1111")
         end
 
         context "when no error occurs" do
 
           it "inserts the document" do
-            Person.count.should eq(1)
+            expect(Person.count).to eq(1)
           end
         end
 
         context "when a mongodb error occurs" do
 
-          before do
-            Person.create_indexes
-          end
-
           it "bubbles up to the caller" do
             expect {
-              Person.with(safe: true).create(ssn: "432-97-1111")
+              Person.create(ssn: "432-97-1111")
             }.to raise_error(Moped::Errors::OperationFailure)
           end
         end
 
-        context "when using safe: false" do
+        context "when using write -1" do
+
+          let(:new_person) do
+            Person.with(write: {w: -1}).create(ssn: "432-97-1111")
+          end
 
           it "ignores mongodb error" do
-            Person.with(safe: false).create(ssn: "432-97-1111").should be_true
+            expect(new_person).to_not be nil
           end
         end
       end
@@ -895,13 +1042,13 @@ describe Mongoid::Sessions do
       describe ".create!" do
 
         before do
-          Person.with(safe: true).create!(ssn: "432-97-1112")
+          Person.create!(ssn: "432-97-1112")
         end
 
         context "when no error occurs" do
 
           it "inserts the document" do
-            Person.count.should eq(1)
+            expect(Person.count).to eq(1)
           end
         end
 
@@ -913,7 +1060,7 @@ describe Mongoid::Sessions do
 
           it "bubbles up to the caller" do
             expect {
-              Person.with(safe: true).create!(ssn: "432-97-1112")
+              Person.create!(ssn: "432-97-1112")
             }.to raise_error(Moped::Errors::OperationFailure)
           end
         end
@@ -922,7 +1069,7 @@ describe Mongoid::Sessions do
 
           it "raises the validation error" do
             expect {
-              Account.with(safe: true).create!(name: "this name is way too long")
+              Account.create!(name: "this name is way too long")
             }.to raise_error(Mongoid::Errors::Validations)
           end
         end
@@ -931,7 +1078,7 @@ describe Mongoid::Sessions do
       describe ".save" do
 
         before do
-          Person.with(safe: true).create(ssn: "432-97-1113")
+          Person.create(ssn: "432-97-1113")
         end
 
         context "when a mongodb error occurs" do
@@ -946,7 +1093,7 @@ describe Mongoid::Sessions do
 
           it "bubbles up to the caller" do
             expect {
-              person.with(safe: true).save
+              person.save
             }.to raise_error(Moped::Errors::OperationFailure)
           end
         end
@@ -955,7 +1102,7 @@ describe Mongoid::Sessions do
       describe ".save!" do
 
         before do
-          Person.with(safe: true).create!(ssn: "432-97-1114")
+          Person.create!(ssn: "432-97-1114")
         end
 
         context "when a mongodb error occurs" do
@@ -970,7 +1117,7 @@ describe Mongoid::Sessions do
 
           it "bubbles up to the caller" do
             expect {
-              person.with(safe: true).save!
+              person.save!
             }.to raise_error(Moped::Errors::OperationFailure)
           end
         end
@@ -983,7 +1130,7 @@ describe Mongoid::Sessions do
 
           it "raises the validation error" do
             expect {
-              account.with(safe: true).save!
+              account.save!
             }.to raise_error(Mongoid::Errors::Validations)
           end
         end
@@ -1013,7 +1160,7 @@ describe Mongoid::Sessions do
       end
 
       it "persists the document to the correct database" do
-        Band.find(band.id).should eq(band)
+        expect(Band.find(band.id)).to eq(band)
       end
     end
   end
@@ -1045,7 +1192,7 @@ describe Mongoid::Sessions do
 
       it "persists to the overridden database" do
         Band.mongo_session.with(database: :mongoid_optional) do |sess|
-          sess[:bands].find(name: "Tool").should_not be_nil
+          expect(sess[:bands].find(name: "Tool")).to_not be_nil
         end
       end
     end
@@ -1055,19 +1202,13 @@ describe Mongoid::Sessions do
 
     context "when the override is configured with a uri" do
 
-      let(:database_name) do
-        "mongoid_other"
-      end
-
-      let(:config) do
-        {  default: { uri: "mongodb://localhost:#{PORT}/#{database_id}" },
-          session1: { uri: "mongodb://localhost:#{PORT}/#{database_name}" }}
+      let(:file) do
+        File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
       end
 
       before do
-        Mongoid::Threaded.sessions.clear
-        Mongoid.sessions = config
-        Mongoid.override_session(:session1)
+        Mongoid::Config.load!(file, :test)
+        Mongoid.override_session(:mongohq_repl_uri)
       end
 
       after do
@@ -1075,7 +1216,7 @@ describe Mongoid::Sessions do
       end
 
       it "has some database name on session" do
-        Band.mongo_session.options[:database].should eq(database_name)
+        expect(Band.mongo_session.options[:database]).to eq(:mongoid_replica)
       end
     end
 
@@ -1104,7 +1245,7 @@ describe Mongoid::Sessions do
       end
 
       it "persists to the overridden session" do
-        persisted.should eq(band)
+        expect(persisted).to eq(band)
       end
     end
   end