mongoid 3.1.4 → 3.1.5

data/spec/mongoid/sessions/factory_spec.rb

@@ -0,0 +1,312 @@
+require "spec_helper"
+
+describe Mongoid::Sessions::Factory do
+
+  describe ".create" do
+
+    context "when provided a name" do
+
+      context "when the configuration exists" do
+
+        context "when the configuration is standard" do
+
+          let(:config) do
+            {
+              default: { hosts: [ "localhost:27017" ], database: database_id },
+              secondary: { hosts: [ "localhost:27017" ], database: database_id }
+            }
+          end
+
+          before do
+            Mongoid::Config.sessions = config
+          end
+
+          let(:session) do
+            described_class.create(:secondary)
+          end
+
+          let(:cluster) do
+            session.cluster
+          end
+
+          it "returns a session" do
+            session.should be_a(Moped::Session)
+          end
+
+          it "sets the cluster's seeds" do
+            cluster.seeds.should eq([ "localhost:27017" ])
+          end
+        end
+
+        context "when the configuration has no ports" do
+
+          let(:config) do
+            {
+              default: { hosts: [ "127.0.0.1" ], database: database_id },
+              secondary: { hosts: [ "localhost" ], database: database_id }
+            }
+          end
+
+          before do
+            Mongoid::Config.sessions = config
+          end
+
+          let(:session) do
+            described_class.create(:secondary)
+          end
+
+          let(:default) do
+            described_class.create(:default)
+          end
+
+          let(:cluster) do
+            session.cluster
+          end
+
+          it "returns a session" do
+            session.should be_a(Moped::Session)
+          end
+
+          it "sets the cluster's seed ports to 27017" do
+            cluster.seeds.should eq([ "localhost:27017" ])
+          end
+
+          it "sets ips with no ports to 27017" do
+            default.cluster.seeds.should eq([ "127.0.0.1:27017" ])
+          end
+        end
+
+        context "when configured via a uri" do
+
+          context "when the uri has a single host:port" do
+
+            let(:config) do
+              {
+                default: { hosts: [ "localhost:27017" ], database: database_id },
+                secondary: { uri: "mongodb://localhost:27017/mongoid_test" }
+              }
+            end
+
+            before do
+              Mongoid::Config.sessions = config
+            end
+
+            let(:session) do
+              described_class.create(:secondary)
+            end
+
+            let(:cluster) do
+              session.cluster
+            end
+
+            it "returns a session" do
+              session.should be_a(Moped::Session)
+            end
+
+            it "sets the cluster's seeds" do
+              cluster.seeds.should eq([ "localhost:27017" ])
+            end
+
+            it "sets the database" do
+              session.options[:database].should eq("mongoid_test")
+            end
+
+            it "sets the database in the configuration" do
+              session
+              Mongoid.sessions[:secondary].should include(:database)
+            end
+
+            it "sets the hosts in the configuration" do
+              session
+              Mongoid.sessions[:secondary].should include(:hosts)
+            end
+
+            it "removes the uri from the configuration" do
+              session
+              Mongoid.sessions[:secondary].should_not include(:uri)
+            end
+          end
+
+          context "when the uri has multiple host:port pairs" do
+
+            let(:config) do
+              {
+                default: { hosts: [ "localhost:27017" ], database: database_id },
+                secondary: { uri: "mongodb://localhost:27017,localhost:27017/mongoid_test" }
+              }
+            end
+
+            before do
+              Mongoid::Config.sessions = config
+            end
+
+            let(:session) do
+              described_class.create(:secondary)
+            end
+
+            let(:cluster) do
+              session.cluster
+            end
+
+            it "returns a session" do
+              session.should be_a(Moped::Session)
+            end
+
+            it "sets the cluster's seeds" do
+              cluster.seeds.should eq([ "localhost:27017", "localhost:27017" ])
+            end
+
+            it "sets the database" do
+              session.options[:database].should eq("mongoid_test")
+            end
+
+            it "sets the database in the configuration" do
+              session
+              Mongoid.sessions[:secondary].should include(:database)
+            end
+
+            it "sets the hosts in the configuration" do
+              session
+              Mongoid.sessions[:secondary].should include(:hosts)
+            end
+
+            it "removes the uri from the configuration" do
+              session
+              Mongoid.sessions[:secondary].should_not include(:uri)
+            end
+          end
+        end
+      end
+
+      context "when the configuration does not exist" do
+
+        it "raises an error" do
+          expect {
+            described_class.create(:unknown)
+          }.to raise_error(Mongoid::Errors::NoSessionConfig)
+        end
+      end
+    end
+
+    context "when no name is provided" do
+
+      let(:config) do
+        { default: { hosts: ["localhost:27017"], database: database_id }}
+      end
+
+      before do
+        Mongoid::Config.sessions = config
+      end
+
+      let(:session) do
+        described_class.create
+      end
+
+      let(:cluster) do
+        session.cluster
+      end
+
+      it "returns the default session" do
+        session.should be_a(Moped::Session)
+      end
+
+      it "sets the cluster's seeds" do
+        cluster.seeds.should eq([ "localhost:27017" ])
+      end
+    end
+
+    context "when nil is provided and no default config" do
+
+      let(:config) { nil }
+
+      before do
+        Mongoid.sessions[:default] = nil
+      end
+
+      it "raises NoSessionsConfig error" do
+        expect{ Mongoid::Sessions::Factory.create(config) }.to raise_error(Mongoid::Errors::NoSessionsConfig)
+      end
+    end
+  end
+
+  describe ".default" do
+
+    let(:config) do
+      { default: { hosts: ["localhost:27017"], database: database_id }}
+    end
+
+    before do
+      Mongoid::Config.sessions = config
+    end
+
+    let(:session) do
+      described_class.default
+    end
+
+    let(:cluster) do
+      session.cluster
+    end
+
+    it "returns the default session" do
+      session.should be_a(Moped::Session)
+    end
+
+    it "sets the cluster's seeds" do
+      cluster.seeds.should eq([ "localhost:27017" ])
+    end
+  end
+
+  context "when options are provided with string keys" do
+
+    let(:config) do
+      {
+        default: {
+          hosts: [ "localhost:27017" ],
+          database: database_id,
+          options: {
+            "down_interval" => 10,
+            "max_retries" => 5,
+            "refresh_interval" => 30,
+            "retry_interval" => 0.1
+          }
+        }
+      }
+    end
+
+    before do
+      Mongoid::Config.sessions = config
+    end
+
+    let(:session) do
+      described_class.default
+    end
+
+    let(:cluster) do
+      session.cluster
+    end
+
+    it "returns the default session" do
+      session.should be_a(Moped::Session)
+    end
+
+    it "sets the cluster's seeds" do
+      cluster.seeds.should eq([ "localhost:27017" ])
+    end
+
+    it "sets the cluster down interval" do
+      cluster.down_interval.should eq(10)
+    end
+
+    it "sets the cluster max retries" do
+      cluster.max_retries.should eq(5)
+    end
+
+    it "sets the cluster refresh interval" do
+      cluster.refresh_interval.should eq(30)
+    end
+
+    it "sets the cluster retry interval" do
+      cluster.retry_interval.should eq(0.1)
+    end
+  end
+end

data/spec/mongoid/sessions/mongo_uri_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe Mongoid::Sessions::MongoUri do
+
+  let(:single) do
+    "mongodb://user:pass@localhost:27017/mongoid_test"
+  end
+
+  let(:multiple) do
+    "mongodb://localhost:27017,localhost:27017/mongoid_test"
+  end
+
+  describe "#database" do
+
+    let(:uri) do
+      described_class.new(single)
+    end
+
+    it "returns the database name" do
+      uri.database.should eq("mongoid_test")
+    end
+  end
+
+  describe "#hosts" do
+
+    context "when a single node is provided" do
+
+      let(:uri) do
+        described_class.new(single)
+      end
+
+      it "returns an array with 1 node" do
+        uri.hosts.should eq([ "localhost:27017" ])
+      end
+    end
+
+    context "when multiple nodes are provided" do
+
+      let(:uri) do
+        described_class.new(multiple)
+      end
+
+      it "returns an array with 2 nodes" do
+        uri.hosts.should eq([ "localhost:27017", "localhost:27017" ])
+      end
+    end
+  end
+
+  describe "#password" do
+
+    let(:uri) do
+      described_class.new(single)
+    end
+
+    it "returns the password" do
+      uri.password.should eq("pass")
+    end
+  end
+
+  describe "#to_hash" do
+
+    context "when a user and password are not provided" do
+
+      let(:uri) do
+        described_class.new(multiple)
+      end
+
+      it "does not include the username and password" do
+        uri.to_hash.should eq({
+          hosts: [ "localhost:27017", "localhost:27017" ],
+          database: "mongoid_test"
+        })
+      end
+    end
+
+    context "when a user and password are provided" do
+
+      let(:uri) do
+        described_class.new(single)
+      end
+
+      it "includes the username and password" do
+        uri.to_hash.should eq({
+          hosts: [ "localhost:27017" ],
+          database: "mongoid_test",
+          username: "user",
+          password: "pass"
+        })
+      end
+    end
+  end
+
+  describe "#username" do
+
+    let(:uri) do
+      described_class.new(single)
+    end
+
+    it "returns the userame" do
+      uri.username.should eq("user")
+    end
+  end
+end

data/spec/mongoid/sessions_spec.rb

@@ -0,0 +1,1111 @@
+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
+
+      let!(:cleared) do
+        Band.clear_persistence_options
+      end
+
+      it "remove the options from the current thread" do
+        Band.persistence_options.should be_nil
+      end
+
+      it "returns true" do
+        cleared.should be_true
+      end
+    end
+
+    context "when options do not exist on the current thread" do
+
+      it "returns true" do
+        Band.clear_persistence_options.should be_true
+      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
+
+        it "returns the collection for the model" do
+          band.collection.should be_a(Moped::Collection)
+        end
+
+        it "sets the correct collection name" do
+          band.collection.name.to_s.should eq("artists")
+        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
+
+          it "sets the correct collection name" do
+            Band.collection.name.to_s.should eq("artists")
+          end
+        end
+
+        context "when safety options exist" do
+
+          context "when the options are from the current thread" do
+
+            before do
+              Band.with(safe: { w: 3 })
+            end
+
+            it "clears the options from the current thread" do
+              Band.collection
+              Band.persistence_options.should be_nil
+            end
+
+            it "returns the collection" do
+              Band.collection.should be_a(Moped::Collection)
+            end
+          end
+        end
+      end
+
+      after do
+        Band.storage_options = nil
+      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"
+          }
+        end
+      end
+
+      context "when overriding with a proc" do
+
+        before do
+          Band.store_in(collection: ->{ "artists" })
+        end
+
+        it_behaves_like "an overridden collection at the class level"
+      end
+
+      context "when overriding with a string" do
+
+        before do
+          Band.store_in(collection: "artists")
+        end
+
+        it_behaves_like "an overridden collection at the class level"
+      end
+
+      context "when overriding with a symbol" do
+
+        before do
+          Band.store_in(collection: :artists)
+        end
+
+        it_behaves_like "an overridden collection at the class level"
+      end
+    end
+
+    context "when not overriding the default" do
+
+      let(:band) do
+        Band.new
+      end
+
+      it "returns the collection for the model" do
+        band.collection.should be_a(Moped::Collection)
+      end
+
+      it "sets the correct collection name" do
+        band.collection.name.to_s.should 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)
+        end
+
+        it "sets the correct collection name" do
+          Band.collection.name.to_s.should eq("bands")
+        end
+      end
+    end
+  end
+
+  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
+
+        let(:band) do
+          Band.new
+        end
+
+        context "when accessing from the instance" do
+
+          it "returns the overridden value" do
+            band.collection_name.should eq(:artists)
+          end
+        end
+
+        context "when accessing from the class level" do
+
+          it "returns the overridden value" do
+            Band.collection_name.should eq(:artists)
+          end
+        end
+      end
+
+      after do
+        Band.storage_options = nil
+      end
+
+      context "when overriding with a proc" do
+
+        before do
+          Band.store_in(collection: ->{ "artists" })
+        end
+
+        it_behaves_like "an overridden collection name at the class level"
+      end
+
+      context "when overriding with a string" do
+
+        before do
+          Band.store_in(collection: "artists")
+        end
+
+        it_behaves_like "an overridden collection name at the class level"
+      end
+
+      context "when overriding with a symbol" do
+
+        before do
+          Band.store_in(collection: :artists)
+        end
+
+        it_behaves_like "an overridden collection name at the class level"
+      end
+    end
+
+    context "when not overriding the default" do
+
+      let(:band) do
+        Band.new
+      end
+
+      it "returns the pluralized model name" do
+        band.collection_name.should eq(:bands)
+      end
+
+      context "when accessing from the class level" do
+
+        it "returns the pluralized model name" do
+          Band.collection_name.should eq(:bands)
+        end
+      end
+    end
+
+    context "when the model is a subclass" do
+
+      let(:firefox) do
+        Firefox.new
+      end
+
+      it "returns the root class pluralized model name" do
+        firefox.collection_name.should 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)
+        end
+      end
+    end
+  end
+
+  describe "#mongo_session" do
+
+    let(:file) do
+      File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+    end
+
+    before do
+      described_class.clear
+      Mongoid.load!(file, :test)
+      Mongoid.sessions[:default][:database] = database_id
+    end
+
+    after do
+      Band.storage_options = nil
+    end
+
+    context "when getting the default" do
+
+      let(:file) do
+        File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+      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
+
+      let!(:mongo_session) do
+        band.mongo_session
+      end
+
+      it "returns the default session" do
+        mongo_session.options[:database].should eq(database_id)
+      end
+    end
+
+    context "when overriding to a monghq single server", config: :mongohq do
+
+      shared_examples_for "an overridden session to a mongohq single server" do
+
+        let(:band) do
+          Band.new
+        end
+
+        let(:single_session) do
+          band.mongo_session
+        end
+
+        it "returns the default session" do
+          single_session.options[:database].should eq(ENV["MONGOHQ_SINGLE_NAME"])
+        end
+      end
+
+      context "when overriding with a proc" do
+
+        before do
+          Band.store_in(session: ->{ :mongohq_single })
+        end
+
+        it_behaves_like "an overridden session to a mongohq single server"
+      end
+
+      context "when overriding with a string" do
+
+        before do
+          Band.store_in(session: "mongohq_single")
+        end
+
+        it_behaves_like "an overridden session to a mongohq single server"
+      end
+
+      context "when overriding with a symbol" do
+
+        before do
+          Band.store_in(session: :mongohq_single)
+        end
+
+        it_behaves_like "an overridden session to a mongohq single server"
+      end
+    end
+
+    context "when overriding to a mongohq replica set", config: :mongohq do
+
+      let(:band) do
+        Band.new
+      end
+
+      let(:replica_session) do
+        band.mongo_session
+      end
+
+      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"])
+        end
+      end
+
+      context "when overriding with a proc" do
+
+        before do
+          Band.store_in(session: ->{ :mongohq_repl })
+        end
+
+        it_behaves_like "an overridden session to a mongohq replica set"
+      end
+
+      context "when overriding with a string" do
+
+        before do
+          Band.store_in(session: "mongohq_repl")
+        end
+
+        it_behaves_like "an overridden session to a mongohq replica set"
+      end
+
+      context "when overriding with a symbol" do
+
+        before do
+          Band.store_in(session: :mongohq_repl)
+        end
+
+        it_behaves_like "an overridden session to a mongohq replica set"
+      end
+    end
+
+    context "when overriding to a mongohq replica set with uri config", config: :mongohq do
+
+      before(:all) do
+        Band.store_in(session: :mongohq_repl_uri)
+      end
+
+      let(:band) do
+        Band.new
+      end
+
+      let(:repl_session) do
+        band.mongo_session
+      end
+
+      it "returns the default session" do
+        repl_session.options[:database].should eq(ENV["MONGOHQ_REPL_NAME"])
+      end
+    end
+
+    context "when no session exists with the key" do
+
+      before(:all) do
+        Band.store_in(session: :nonexistant)
+      end
+
+      let(:band) do
+        Band.new
+      end
+
+      it "raises an error" do
+        expect {
+          band.mongo_session
+        }.to raise_error(Mongoid::Errors::NoSessionConfig)
+      end
+    end
+  end
+
+  describe ".mongo_session" do
+
+    let(:file) do
+      File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+    end
+
+    before do
+      described_class.clear
+      Mongoid.load!(file, :test)
+      Mongoid.sessions[:default][:database] = database_id
+    end
+
+    after do
+      Band.storage_options = nil
+    end
+
+    context "when getting the default" do
+
+      let(:file) do
+        File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+      end
+
+      before do
+        Band.storage_options = nil
+        described_class.clear
+        Mongoid.load!(file, :test)
+        Mongoid.sessions[:default][:database] = database_id
+      end
+
+      let!(:mongo_session) do
+        Band.mongo_session
+      end
+
+      it "returns the default session" do
+        mongo_session.options[:database].should eq(database_id)
+      end
+    end
+
+    context "when overriding to a monghq single server", config: :mongohq do
+
+      before(:all) do
+        Band.store_in(session: :mongohq_single)
+      end
+
+      let(:session) do
+        Band.mongo_session
+      end
+
+      it "returns the default session" do
+        session.options[:database].should eq(ENV["MONGOHQ_SINGLE_NAME"])
+      end
+    end
+
+    context "when overriding to a mongohq replica set", config: :mongohq do
+
+      before(:all) do
+        Band.store_in(session: :mongohq_repl)
+      end
+
+      let(:repl_session) do
+        Band.mongo_session
+      end
+
+      it "returns the default session" do
+        repl_session.options[:database].should eq(ENV["MONGOHQ_REPL_NAME"])
+      end
+    end
+
+    context "when no session exists with the key" do
+
+      before(:all) do
+        Band.store_in(session: :nonexistant)
+      end
+
+      it "raises an error" do
+        expect {
+          Band.mongo_session
+        }.to raise_error(Mongoid::Errors::NoSessionConfig)
+      end
+    end
+  end
+
+  describe ".persistence_options" do
+
+    context "when options exist on the current thread" do
+
+      before do
+        Band.with(safe: { w: 2 })
+      end
+
+      after do
+        Band.clear_persistence_options
+      end
+
+      it "returns the options" do
+        Band.persistence_options.should eq(safe: { w: 2 })
+      end
+    end
+
+    context "when there are no options on the current thread" do
+
+      it "returns nil" do
+        Band.persistence_options.should be_nil
+      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)
+      end
+    end
+
+    context "when provided a hash" do
+
+      context "when the hash is not valid" do
+
+        it "raises an error" do
+          expect {
+            Band.store_in coll: "artists"
+          }.to raise_error(Mongoid::Errors::InvalidStorageOptions)
+        end
+      end
+    end
+  end
+
+  describe ".with" do
+
+    context "when sending operations to a different database" do
+
+      after do
+        Band.with(database: "mongoid_test_alt").delete_all
+      end
+
+      describe ".create" do
+
+        let!(:band) do
+          Band.with(database: "mongoid_test_alt").create
+        end
+
+        it "does not persist to the default database" do
+          expect {
+            Band.find(band.id)
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+
+        let(:from_db) do
+          Band.with(database: "mongoid_test_alt").find(band.id)
+        end
+
+        it "persists to the specified database" do
+          from_db.should eq(band)
+        end
+
+        it "persists the correct number of documents" do
+          Band.with(database: "mongoid_test_alt").count.should eq(1)
+        end
+      end
+
+      describe ".map_reduce", config: :mongohq do
+
+        let(:map) do
+          %Q{
+          function() {
+            emit(this.name, { likes: this.likes });
+          }}
+        end
+
+        let(:reduce) do
+          %Q{
+          function(key, values) {
+            var result = { likes: 0 };
+            values.forEach(function(value) {
+              result.likes += value.likes;
+            });
+            return result;
+          }}
+        end
+
+        before do
+          Band.with(database: "mongoid_test_alt").delete_all
+        end
+
+        let!(:depeche_mode) do
+          Band.with(database: "mongoid_test_alt").
+            create(name: "Depeche Mode", likes: 200)
+        end
+
+        let!(:tool) do
+          Band.with(database: "mongoid_test_alt").
+            create(name: "Tool", likes: 100)
+        end
+
+        context "when outputting in memory" do
+
+          let(:results) do
+            Band.with(database: "mongoid_test_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 })
+          end
+        end
+
+        context "when outputting to a collection" do
+
+          let(:results) do
+            Band.with(database: "mongoid_test_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 })
+          end
+        end
+      end
+    end
+
+    context "when sending operations to a different collection" do
+
+      describe ".create" do
+
+        let!(:band) do
+          Band.with(collection: "artists").create
+        end
+
+        it "does not persist to the default database" do
+          expect {
+            Band.find(band.id)
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+
+        let(:from_db) do
+          Band.with(collection: "artists").find(band.id)
+        end
+
+        it "persists to the specified database" do
+          from_db.should eq(band)
+        end
+
+        it "persists the correct number of documents" do
+          Band.with(collection: "artists").count.should eq(1)
+        end
+      end
+
+      describe ".map_reduce", config: :mongohq do
+
+        let(:map) do
+          %Q{
+          function() {
+            emit(this.name, { likes: this.likes });
+          }}
+        end
+
+        let(:reduce) do
+          %Q{
+          function(key, values) {
+            var result = { likes: 0 };
+            values.forEach(function(value) {
+              result.likes += value.likes;
+            });
+            return result;
+          }}
+        end
+
+        before do
+          Band.with(collection: "artists").delete_all
+        end
+
+        let!(:depeche_mode) do
+          Band.with(collection: "artists").
+            create(name: "Depeche Mode", likes: 200)
+        end
+
+        let!(:tool) do
+          Band.with(collection: "artists").
+            create(name: "Tool", likes: 100)
+        end
+
+        let(:results) do
+          Band.with(collection: "artists").
+            map_reduce(map, reduce).out(inline: 1)
+        end
+
+        it "executes the map/reduce on the correct collection" do
+          results.first["value"].should eq({ "likes" => 200 })
+        end
+      end
+    end
+
+    context "when sending operations to a different session" do
+
+      describe ".create" do
+
+        let(:file) do
+          File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+        end
+
+        before do
+          described_class.clear
+          Mongoid.load!(file, :test)
+        end
+
+        context "when sending to a mongohq single server", config: :mongohq do
+
+          let!(:band) do
+            Band.with(
+              session: "mongohq_single",
+              database: database_id
+            ).create
+          end
+
+          let(:from_db) do
+            Band.with(
+              session: "mongohq_single",
+              database: database_id
+            ).find(band.id)
+          end
+
+          it "persists to the specified database" do
+            from_db.should eq(band)
+          end
+        end
+
+        context "when sending to a mongohq replica set", config: :mongohq do
+
+          let!(:band) do
+            Band.with(
+              session: "mongohq_repl",
+              database: "mongoid_replica"
+            ).create
+          end
+
+          let(:from_db) do
+            Band.with(
+              session: "mongohq_repl",
+              database: "mongoid_replica"
+            ).find(band.id)
+          end
+
+          it "persists to the specified database" do
+            from_db.should eq(band)
+          end
+        end
+
+        context "when sending to a mongohq replica set with uri config", config: :mongohq do
+
+          let!(:band) do
+            Band.with(
+              session: "mongohq_repl_uri",
+              database: "mongoid_replica"
+            ).create
+          end
+
+          let(:from_db) do
+            Band.with(
+              session: "mongohq_repl_uri",
+              database: "mongoid_replica"
+            ).find(band.id)
+          end
+
+          it "persists to the specified database" do
+            from_db.should eq(band)
+          end
+        end
+      end
+
+      describe ".map_reduce", config: :mongohq do
+
+        let(:file) do
+          File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+        end
+
+        before do
+          described_class.clear
+          Mongoid.load!(file, :test)
+        end
+
+        let(:map) do
+          %Q{
+          function() {
+            emit(this.name, { likes: this.likes });
+          }}
+        end
+
+        let(:reduce) do
+          %Q{
+          function(key, values) {
+            var result = { likes: 0 };
+            values.forEach(function(value) {
+              result.likes += value.likes;
+            });
+            return result;
+          }}
+        end
+
+        before do
+          Band.with(
+            session: "mongohq_repl",
+            database: "mongoid_replica"
+          ).delete_all
+        end
+
+        let!(:depeche_mode) do
+          Band.with(
+            session: "mongohq_repl",
+            database: "mongoid_replica"
+          ).create(name: "Depeche Mode", likes: 200)
+        end
+
+        let!(:tool) do
+          Band.with(
+            session: "mongohq_repl",
+            database: "mongoid_replica"
+          ).create(name: "Tool", likes: 100)
+        end
+
+        let(:results) do
+          Band.with(
+            session: "mongohq_repl",
+            database: "mongoid_replica"
+          ).map_reduce(map, reduce).out(inline: 1)
+        end
+
+        it "executes the map/reduce on the correct session" do
+          results.first["value"].should eq({ "likes" => 200 })
+        end
+      end
+    end
+
+    context "when sending operations with safe mode" do
+
+      describe ".create" do
+
+        before do
+          Person.with(safe: true).create(ssn: "432-97-1111")
+        end
+
+        context "when no error occurs" do
+
+          it "inserts the document" do
+            Person.count.should 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")
+            }.to raise_error(Moped::Errors::OperationFailure)
+          end
+        end
+
+        context "when using safe: false" do
+
+          it "ignores mongodb error" do
+            Person.with(safe: false).create(ssn: "432-97-1111").should be_true
+          end
+        end
+      end
+
+      describe ".create!" do
+
+        before do
+          Person.with(safe: true).create!(ssn: "432-97-1112")
+        end
+
+        context "when no error occurs" do
+
+          it "inserts the document" do
+            Person.count.should 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-1112")
+            }.to raise_error(Moped::Errors::OperationFailure)
+          end
+        end
+
+        context "when a validation error occurs" do
+
+          it "raises the validation error" do
+            expect {
+              Account.with(safe: true).create!(name: "this name is way too long")
+            }.to raise_error(Mongoid::Errors::Validations)
+          end
+        end
+      end
+
+      describe ".save" do
+
+        before do
+          Person.with(safe: true).create(ssn: "432-97-1113")
+        end
+
+        context "when a mongodb error occurs" do
+
+          let(:person) do
+            Person.new(ssn: "432-97-1113")
+          end
+
+          before do
+            Person.create_indexes
+          end
+
+          it "bubbles up to the caller" do
+            expect {
+              person.with(safe: true).save
+            }.to raise_error(Moped::Errors::OperationFailure)
+          end
+        end
+      end
+
+      describe ".save!" do
+
+        before do
+          Person.with(safe: true).create!(ssn: "432-97-1114")
+        end
+
+        context "when a mongodb error occurs" do
+
+          let(:person) do
+            Person.new(ssn: "432-97-1114")
+          end
+
+          before do
+            Person.create_indexes
+          end
+
+          it "bubbles up to the caller" do
+            expect {
+              person.with(safe: true).save!
+            }.to raise_error(Moped::Errors::OperationFailure)
+          end
+        end
+
+        context "when a validation error occurs" do
+
+          let(:account) do
+            Account.new(name: "this name is way too long")
+          end
+
+          it "raises the validation error" do
+            expect {
+              account.with(safe: true).save!
+            }.to raise_error(Mongoid::Errors::Validations)
+          end
+        end
+      end
+    end
+  end
+
+  context "when the default database uses a uri" do
+
+    let(:file) do
+      File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+    end
+
+    let(:config) do
+      { default: { uri: "mongodb://localhost:#{PORT}/#{database_id}" }}
+    end
+
+    before do
+      Mongoid::Threaded.sessions.clear
+      Mongoid.sessions = config
+    end
+
+    context "when creating a document" do
+
+      let!(:band) do
+        Band.create(name: "Placebo")
+      end
+
+      it "persists the document to the correct database" do
+        Band.find(band.id).should eq(band)
+      end
+    end
+  end
+
+  context "when overriding the default database "do
+
+    let(:file) do
+      File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+    end
+
+    before do
+      Mongoid::Config.load!(file, :test)
+    end
+
+    context "when the override is global" do
+
+      before do
+        Mongoid.override_database(:mongoid_optional)
+      end
+
+      after do
+        Band.delete_all
+        Mongoid.override_database(nil)
+      end
+
+      let!(:band) do
+        Band.create(name: "Tool")
+      end
+
+      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
+        end
+      end
+    end
+  end
+
+  context "when overriding the default session", config: :mongohq 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}" }}
+      end
+
+      before do
+        Mongoid::Threaded.sessions.clear
+        Mongoid.sessions = config
+        Mongoid.override_session(:session1)
+      end
+
+      after do
+        Mongoid.override_session(nil)
+      end
+
+      it "has some database name on session" do
+        Band.mongo_session.options[:database].should eq(database_name)
+      end
+    end
+
+    context "when the override is global" do
+
+      let(:file) do
+        File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+      end
+
+      before do
+        Mongoid::Config.load!(file, :test)
+        Mongoid.override_session(:mongohq_single)
+      end
+
+      after do
+        Band.with(database: database_id).delete_all
+        Mongoid.override_session(nil)
+      end
+
+      let!(:band) do
+        Band.with(database: database_id).create(name: "Tool")
+      end
+
+      let(:persisted) do
+        Band.with(session: :mongohq_single, database: database_id).where(name: "Tool").first
+      end
+
+      it "persists to the overridden session" do
+        persisted.should eq(band)
+      end
+    end
+  end
+end