mongoid_heroku_stable 4.0.0

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
+            expect(session).to be_a(Moped::Session)
+          end
+
+          it "sets the cluster's seeds" do
+            expect(cluster.seeds).to 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
+            expect(session).to be_a(Moped::Session)
+          end
+
+          it "sets the cluster's seed ports to 27017" do
+            expect(cluster.seeds).to eq([ "localhost:27017" ])
+          end
+
+          it "sets ips with no ports to 27017" do
+            expect(default.cluster.seeds).to 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
+              expect(session).to be_a(Moped::Session)
+            end
+
+            it "sets the cluster's seeds" do
+              expect(cluster.seeds).to eq([ "localhost:27017" ])
+            end
+
+            it "sets the database" do
+              expect(session.options[:database]).to eq("mongoid_test")
+            end
+
+            it "sets the database in the configuration" do
+              session
+              expect(Mongoid.sessions[:secondary]).to include(:database)
+            end
+
+            it "sets the hosts in the configuration" do
+              session
+              expect(Mongoid.sessions[:secondary]).to include(:hosts)
+            end
+
+            it "removes the uri from the configuration" do
+              session
+              expect(Mongoid.sessions[:secondary]).to_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
+              expect(session).to be_a(Moped::Session)
+            end
+
+            it "sets the cluster's seeds" do
+              expect(cluster.seeds).to eq([ "localhost:27017", "localhost:27017" ])
+            end
+
+            it "sets the database" do
+              expect(session.options[:database]).to eq("mongoid_test")
+            end
+
+            it "sets the database in the configuration" do
+              session
+              expect(Mongoid.sessions[:secondary]).to include(:database)
+            end
+
+            it "sets the hosts in the configuration" do
+              session
+              expect(Mongoid.sessions[:secondary]).to include(:hosts)
+            end
+
+            it "removes the uri from the configuration" do
+              session
+              expect(Mongoid.sessions[:secondary]).to_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
+        expect(session).to be_a(Moped::Session)
+      end
+
+      it "sets the cluster's seeds" do
+        expect(cluster.seeds).to 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
+      expect(session).to be_a(Moped::Session)
+    end
+
+    it "sets the cluster's seeds" do
+      expect(cluster.seeds).to 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
+      expect(session).to be_a(Moped::Session)
+    end
+
+    it "sets the cluster's seeds" do
+      expect(cluster.seeds).to eq([ "localhost:27017" ])
+    end
+
+    it "sets the cluster down interval" do
+      expect(cluster.down_interval).to eq(10)
+    end
+
+    it "sets the cluster max retries" do
+      expect(cluster.max_retries).to eq(5)
+    end
+
+    it "sets the cluster refresh interval" do
+      expect(cluster.refresh_interval).to eq(30)
+    end
+
+    it "sets the cluster retry interval" do
+      expect(cluster.retry_interval).to 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
+      expect(uri.database).to 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
+        expect(uri.hosts).to 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
+        expect(uri.hosts).to eq([ "localhost:27017", "localhost:27017" ])
+      end
+    end
+  end
+
+  describe "#password" do
+
+    let(:uri) do
+      described_class.new(single)
+    end
+
+    it "returns the password" do
+      expect(uri.password).to 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
+        expect(uri.to_hash).to 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
+        expect(uri.to_hash).to 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
+      expect(uri.username).to eq("user")
+    end
+  end
+end

data/spec/mongoid/sessions/options_spec.rb

@@ -0,0 +1,71 @@
+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
+    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
+      Moped::Session.any_instance.should_receive(:with).with(options).and_return({})
+      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
+end