mongo 2.6.4 → 2.7.0.rc0

data/spec/mongo/cluster/cursor_reaper_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Mongo::Cluster::CursorReaper do
 
-  after do
-    authorized_collection.delete_many
+  before do
+    authorized_collection.drop
   end
 
   let(:reaper) do

data/spec/mongo/cluster/topology/replica_set_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mongo::Cluster::Topology::ReplicaSet do
+describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
 
   let(:address) do
     Mongo::Address.new('127.0.0.1:27017')
@@ -14,45 +14,64 @@ describe Mongo::Cluster::Topology::ReplicaSet do
     Mongo::Monitoring.new(monitoring: false)
   end
 
+  # Cluster needs a topology and topology needs a cluster...
+  # This temporary cluster is used for topology construction.
+  let(:temp_cluster) do
+    double('temp cluster').tap do |cluster|
+      allow(cluster).to receive(:servers_list).and_return([])
+    end
+  end
+
   let(:cluster) do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      allow(cl).to receive(:options).and_return({})
     end
   end
 
   describe '#servers' do
 
     let(:mongos) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false))
     end
 
     let(:standalone) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false))
     end
 
     let(:replica_set) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false))
     end
 
     let(:replica_set_two) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false))
     end
 
     let(:mongos_description) do
-      Mongo::Server::Description.new(address, { 'msg' => 'isdbgrid' })
+      Mongo::Server::Description.new(address, { 'msg' => 'isdbgrid',
+        'minWireVersion' => 2, 'maxWireVersion' => 8, 'ok' => 1 })
     end
 
     let(:standalone_description) do
-      Mongo::Server::Description.new(address, { 'ismaster' => true })
+      Mongo::Server::Description.new(address, { 'ismaster' => true,
+        'minWireVersion' => 2, 'maxWireVersion' => 8, 'ok' => 1 })
     end
 
     let(:replica_set_description) do
-      Mongo::Server::Description.new(address, { 'ismaster' => true, 'setName' => 'testing' })
+      Mongo::Server::Description.new(address, { 'ismaster' => true,
+        'minWireVersion' => 2, 'maxWireVersion' => 8,
+        'setName' => 'testing', 'ok' => 1 })
     end
 
     let(:replica_set_two_description) do
-      Mongo::Server::Description.new(address, { 'ismaster' => true, 'setName' => 'test' })
+      Mongo::Server::Description.new(address, { 'ismaster' => true,
+        'minWireVersion' => 2, 'maxWireVersion' => 8,
+        'setName' => 'test', 'ok' => 1 })
     end
 
     before do
@@ -62,25 +81,10 @@ describe Mongo::Cluster::Topology::ReplicaSet do
       replica_set_two.monitor.instance_variable_set(:@description, replica_set_two_description)
     end
 
-    context 'when no replica set name is provided' do
-
-      let(:topology) do
-        described_class.new({}, monitoring, [])
-      end
-
-      let(:servers) do
-        topology.servers([ mongos, standalone, replica_set, replica_set_two ])
-      end
-
-      it 'returns only replica set members' do
-        expect(servers).to eq([ replica_set, replica_set_two ])
-      end
-    end
-
     context 'when a replica set name is provided' do
 
       let(:topology) do
-        described_class.new({ :replica_set => 'testing' }, monitoring)
+        described_class.new({ :replica_set_name => 'testing' }, monitoring, temp_cluster)
       end
 
       let(:servers) do
@@ -96,28 +100,48 @@ describe Mongo::Cluster::Topology::ReplicaSet do
   describe '.replica_set?' do
 
     it 'returns true' do
-      expect(described_class.new({}, monitoring)).to be_replica_set
+      expect(described_class.new({replica_set_name: 'foo'}, monitoring, temp_cluster)).to be_replica_set
     end
   end
 
   describe '.sharded?' do
 
     it 'returns false' do
-      expect(described_class.new({}, monitoring)).to_not be_sharded
+      expect(described_class.new({replica_set_name: 'foo'}, monitoring, temp_cluster)).to_not be_sharded
     end
   end
 
   describe '.single?' do
 
     it 'returns false' do
-      expect(described_class.new({}, monitoring)).to_not be_single
+      expect(described_class.new({replica_set_name: 'foo'}, monitoring, temp_cluster)).to_not be_single
+    end
+  end
+
+  describe '#max_election_id' do
+    let(:election_id) { BSON::ObjectId.new }
+
+    it 'returns value given in constructor options' do
+      topology = described_class.new({replica_set_name: 'foo', max_election_id: election_id},
+        monitoring, temp_cluster)
+
+      expect(topology.max_election_id).to eql(election_id)
+    end
+  end
+
+  describe '#max_set_version' do
+    it 'returns value given in constructor options' do
+      topology = described_class.new({replica_set_name: 'foo', max_set_version: 5},
+        monitoring, temp_cluster)
+
+      expect(topology.max_set_version).to eq(5)
     end
   end
 
   describe '#has_readable_servers?' do
 
     let(:topology) do
-      described_class.new({}, monitoring, [])
+      described_class.new({replica_set_name: 'foo'}, monitoring, temp_cluster)
     end
 
     let(:cluster) do
@@ -284,7 +308,7 @@ describe Mongo::Cluster::Topology::ReplicaSet do
   describe '#has_writable_servers?' do
 
     let(:topology) do
-      described_class.new({}, monitoring, [])
+      described_class.new({replica_set_name: 'foo'}, monitoring, temp_cluster)
     end
 
     context 'when a primary server exists' do
@@ -322,293 +346,204 @@ describe Mongo::Cluster::Topology::ReplicaSet do
     end
   end
 
-  describe '#add_hosts?' do
-
-    let(:primary) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
-    end
-
-    let(:secondary) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
-    end
-
-    let(:primary_description) do
-      Mongo::Server::Description.new(address, { 'ismaster' => true, 'setName' => 'testing' })
-    end
-
-    let(:secondary_description) do
-      Mongo::Server::Description.new(address, { 'ismaster' => false, 'secondary' => true,
-                                                'setName' => 'testing' })
-    end
-
-    let(:topology) do
-      described_class.new({ :replica_set => 'testing' }, monitoring)
-    end
-
-    before do
-      primary.monitor.instance_variable_set(:@description, primary_description)
-      secondary.monitor.instance_variable_set(:@description, secondary_description)
-    end
-
-    context 'when the list of servers does not include a primary' do
-
-      let(:servers) do
-        [ secondary ]
+  describe '#new_max_set_version' do
+    context 'initially nil' do
+      let(:topology) do
+        described_class.new({replica_set_name: 'foo'}, monitoring, temp_cluster).tap do |topology|
+          expect(topology.max_set_version).to be nil
+        end
       end
 
-      context 'when the description is a member of the replica set' do
-
+      context 'description with non-nil max set version' do
         let(:description) do
-          double('description').tap do |d|
-            allow(d).to receive(:replica_set_member?).and_return(true)
-            allow(d).to receive(:replica_set_name).and_return('testing')
+          Mongo::Server::Description.new('a', 'setVersion' => 5).tap do |description|
+            expect(description.set_version).to eq(5)
           end
         end
 
-        it 'returns true' do
-          expect(topology.add_hosts?(description, servers)).to eq(true)
+        it 'is set to max set version in description' do
+          expect(topology.new_max_set_version(description)).to eq(5)
         end
       end
 
-      context 'when the description is not a member of the replica set' do
-
+      context 'description with nil max set version' do
         let(:description) do
-          double('description').tap do |d|
-            allow(d).to receive(:replica_set_member?).and_return(false)
-            allow(d).to receive(:primary?).and_return(false)
+          Mongo::Server::Description.new('a').tap do |description|
+            expect(description.set_version).to be nil
           end
         end
 
-        it 'returns false' do
-          expect(topology.add_hosts?(description, servers)).to eq(false)
+        it 'is nil' do
+          expect(topology.new_max_set_version(description)).to be nil
         end
       end
     end
 
-    context 'when the list of servers has a primary' do
-
-      let(:servers) do
-        [ primary, secondary ]
+    context 'initially not nil' do
+      let(:topology) do
+        described_class.new({replica_set_name: 'foo', max_set_version: 4},
+          monitoring, temp_cluster
+        ).tap do |topology|
+          expect(topology.max_set_version).to eq(4)
+        end
       end
 
-      let(:description) do
-        double('description').tap do |d|
-          allow(d).to receive(:replica_set_member?).and_return(true)
-          allow(d).to receive(:replica_set_name).and_return('testing')
-          allow(d).to receive(:primary?).and_return(false)
+      context 'description with a higher max set version' do
+        let(:description) do
+          Mongo::Server::Description.new('a', 'setVersion' => 5).tap do |description|
+            expect(description.set_version).to eq(5)
+          end
         end
-      end
 
-      it 'returns false' do
-        expect(topology.add_hosts?(description, servers)).to eq(false)
+        it 'is set to max set version in description' do
+          expect(topology.new_max_set_version(description)).to eq(5)
+        end
       end
-    end
-  end
-
-  describe '#remove_hosts?' do
-
-    let(:primary) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
-    end
-
-    let(:primary_description) do
-      Mongo::Server::Description.new(address, { 'ismaster' => true, 'setName' => 'testing' })
-    end
-
-    let(:topology) do
-      described_class.new({ :replica_set => 'testing' }, monitoring)
-    end
-
-    before do
-      primary.monitor.instance_variable_set(:@description, primary_description)
-    end
 
-    context 'when the description has an empty config' do
-
-      let(:description) do
-        double('description').tap do |d|
-          allow(d).to receive(:config).and_return({})
+      context 'description with a lower max set version' do
+        let(:description) do
+          Mongo::Server::Description.new('a', 'setVersion' => 3).tap do |description|
+            expect(description.set_version).to eq(3)
+          end
         end
-      end
 
-      it 'returns false' do
-        expect(topology.remove_hosts?(description)).to eq(false)
+        it 'is set to topology max set version' do
+          expect(topology.new_max_set_version(description)).to eq(4)
+        end
       end
-    end
 
-    context 'when the description is from a primary' do
-
-      let(:description) do
-        double('description').tap do |d|
-          allow(d).to receive(:config).and_return({ 'ismaster' => true })
-          allow(d).to receive(:primary?).and_return(true)
+      context 'description with nil max set version' do
+        let(:description) do
+          Mongo::Server::Description.new('a').tap do |description|
+            expect(description.set_version).to be nil
+          end
         end
-      end
 
-      it 'returns true' do
-        expect(topology.remove_hosts?(description)).to eq(true)
+        it 'is set to topology max set version' do
+          expect(topology.new_max_set_version(description)).to eq(4)
+        end
       end
     end
+  end
 
-    context 'when the description has an empty hosts list' do
-
-      let(:description) do
-        double('description').tap do |d|
-          allow(d).to receive(:config).and_return({ 'ismaster' => true })
-          allow(d).to receive(:primary?).and_return(false)
-          allow(d).to receive(:me_mismatch?).and_return(false)
-          allow(d).to receive(:hosts).and_return([])
+  describe '#new_max_election_id' do
+    context 'initially nil' do
+      let(:topology) do
+        described_class.new({replica_set_name: 'foo'},
+          monitoring, temp_cluster,
+        ).tap do |topology|
+          expect(topology.max_election_id).to be nil
         end
       end
 
-      it 'returns true' do
-        expect(topology.remove_hosts?(description)).to eq(true)
-      end
-    end
-
-    context 'when the description is not from the replica set' do
+      context 'description with non-nil max election id' do
+        let(:new_election_id) { BSON::ObjectId.from_string('7fffffff000000000000004f') }
 
-      let(:description) do
-        double('description').tap do |d|
-          allow(d).to receive(:config).and_return({ 'ismaster' => true })
-          allow(d).to receive(:primary?).and_return(false)
-          allow(d).to receive(:hosts).and_return([ primary ])
-          allow(d).to receive(:replica_set_name).and_return('test')
-          allow(d).to receive(:replica_set_member?).and_return(true)
-          allow(d).to receive(:me_mismatch?).and_return(false)
+        let(:description) do
+          Mongo::Server::Description.new('a', 'electionId' => new_election_id).tap do |description|
+            expect(description.election_id).to be new_election_id
+          end
         end
-      end
 
-      it 'returns true' do
-        expect(topology.remove_hosts?(description)).to eq(true)
+        it 'is set to max election id in description' do
+          expect(topology.new_max_election_id(description)).to be new_election_id
+        end
       end
-    end
 
-  end
-
-  describe '#remove_server?' do
-
-    let(:secondary) do
-      Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
-    end
+      context 'description with nil max election id' do
+        let(:description) do
+          Mongo::Server::Description.new('a').tap do |description|
+            expect(description.election_id).to be nil
+          end
+        end
 
-    let(:secondary_description) do
-      Mongo::Server::Description.new(address, { 'ismaster' => false, 'secondary' => true,
-                                                'setName' => 'test' })
+        it 'is nil' do
+          expect(topology.new_max_election_id(description)).to be nil
+        end
+      end
     end
 
-    let(:topology) do
-      described_class.new({ :replica_set => 'testing' }, monitoring)
-    end
+    context 'initially not nil' do
+      let(:old_election_id) { BSON::ObjectId.from_string('7fffffff000000000000004c') }
 
-    before do
-      secondary.monitor.instance_variable_set(:@description, secondary_description)
-    end
+      let(:topology) do
+        described_class.new({replica_set_name: 'foo', max_election_id: old_election_id},
+          monitoring, temp_cluster,
+        ).tap do |topology|
+          expect(topology.max_election_id).to be old_election_id
+        end
+      end
 
-    context 'when the description is from a server that should itself be removed' do
+      context 'description with a higher max election id' do
+        let(:new_election_id) { BSON::ObjectId.from_string('7fffffff000000000000004f') }
 
-      let(:description) do
-        double('description').tap do |d|
-          allow(d).to receive(:config).and_return({ 'setName' => 'test' })
-          allow(d).to receive(:replica_set_member?).and_return(true)
-          allow(d).to receive(:replica_set_name).and_return('test')
-          allow(d).to receive(:is_server?).and_return(true)
-          allow(d).to receive(:ghost?).and_return(false)
-          allow(d).to receive(:address).and_return(address)
-          allow(d).to receive(:me_mismatch?).and_return(false)
-          allow(d).to receive(:unknown?).and_return(false)
+        let(:description) do
+          Mongo::Server::Description.new('a', 'electionId' => new_election_id).tap do |description|
+            expect(description.election_id).to be new_election_id
+          end
         end
-      end
 
-      it 'returns true' do
-        expect(topology.remove_server?(description, secondary)).to eq(true)
+        it 'is set to max election id in description' do
+          expect(topology.new_max_election_id(description)).to be new_election_id
+        end
       end
-    end
-
-    context 'when the description is a member of the replica set' do
 
-      context 'when the description includes the server in question' do
+      context 'description with a lower max election id' do
+        let(:low_election_id) { BSON::ObjectId.from_string('7fffffff0000000000000042') }
 
         let(:description) do
-          double('description').tap do |d|
-            allow(d).to receive(:config).and_return({ 'setName' => 'testing' })
-            allow(d).to receive(:replica_set_member?).and_return(true)
-            allow(d).to receive(:replica_set_name).and_return('testing')
-            allow(d).to receive(:lists_server?).and_return(true)
-            allow(d).to receive(:servers).and_return([double('server')])
-            allow(d).to receive(:address).and_return(address)
-            allow(d).to receive(:me_mismatch?).and_return(false)
-            allow(d).to receive(:unknown?).and_return(false)
-            allow(d).to receive(:server_type).and_return(:secondary)
+          Mongo::Server::Description.new('a', 'electionId' => low_election_id).tap do |description|
+            expect(description.election_id).to be low_election_id
           end
         end
 
-        it 'returns false' do
-          expect(topology.remove_server?(description, secondary)).to eq(false)
-        end
-      end
-
-      context 'when the description does not include the server in question' do
-
-        context 'when the description is primary' do
-          let(:description) do
-            double('description').tap do |d|
-              allow(d).to receive(:config).and_return({ 'setName' => 'testing' })
-              allow(d).to receive(:replica_set_member?).and_return(true)
-              allow(d).to receive(:replica_set_name).and_return('testing')
-              allow(d).to receive(:is_server?).and_return(false)
-              allow(d).to receive(:lists_server?).and_return(false)
-              allow(d).to receive(:servers).and_return([double('server')])
-              allow(d).to receive(:address).and_return("127.0.0.1:27018")
-              allow(d).to receive(:me_mismatch?).and_return(false)
-              allow(d).to receive(:unknown?).and_return(false)
-              allow(d).to receive(:server_type).and_return(:primary)
-            end
-          end
-
-          it 'returns true' do
-            expect(topology.remove_server?(description, secondary)).to eq(true)
-          end
+        it 'is set to topology max election id' do
+          expect(topology.new_max_election_id(description)).to be old_election_id
         end
+      end
 
-        context 'when the description is not' do
-          let(:description) do
-            double('description').tap do |d|
-              allow(d).to receive(:config).and_return({ 'setName' => 'testing' })
-              allow(d).to receive(:replica_set_member?).and_return(true)
-              allow(d).to receive(:replica_set_name).and_return('testing')
-              allow(d).to receive(:is_server?).and_return(false)
-              allow(d).to receive(:lists_server?).and_return(false)
-              allow(d).to receive(:servers).and_return([double('server')])
-              allow(d).to receive(:address).and_return('127.0.0.1:27018')
-              allow(d).to receive(:me_mismatch?).and_return(false)
-              allow(d).to receive(:unknown?).and_return(false)
-              allow(d).to receive(:server_type).and_return(:secondary)
-            end
+      context 'description with nil max election id' do
+        let(:description) do
+          Mongo::Server::Description.new('a').tap do |description|
+            expect(description.election_id).to be nil
           end
+        end
 
-          it 'returns false' do
-            expect(topology.remove_server?(description, secondary)).to eq(false)
-          end
+        it 'is set to topology max election id' do
+          expect(topology.new_max_election_id(description)).to be old_election_id
         end
       end
     end
+  end
 
-    context 'when the description is not a member of the replica set' do
+  describe '#summary' do
+    skip_if_linting
 
-      let(:description) do
-        double('description').tap do |d|
-          allow(d).to receive(:config).and_return({ 'setName' => 'test' })
-          allow(d).to receive(:replica_set_member?).and_return(true)
-          allow(d).to receive(:replica_set_name).and_return('test')
-          allow(d).to receive(:is_server?).and_return(false)
-          allow(d).to receive(:address).and_return('127.0.0.1:27018')
-          allow(d).to receive(:unknown?).and_return(false)
-        end
+    let(:desc) do
+      Mongo::Server::Description.new(Mongo::Address.new('127.0.0.2:27017'))
+    end
+
+    let(:topology) do
+      described_class.new({replica_set_name: 'foo'}, monitoring, temp_cluster)
+    end
+
+    it 'renders correctly' do
+      expect(topology).to receive(:server_descriptions).and_return({desc.address.to_s => desc})
+      expect(topology.summary).to eq('ReplicaSetNoPrimary[127.0.0.2:27017,name=foo]')
+    end
+
+    context 'with max set version and max election id' do
+      let(:topology) do
+        described_class.new({
+          replica_set_name: 'foo',
+          max_set_version: 5,
+          max_election_id: BSON::ObjectId.from_string('7fffffff0000000000000042'),
+        }, monitoring, temp_cluster)
       end
 
-      it 'returns false' do
-        expect(topology.remove_server?(description, secondary)).to eq(false)
+      it 'renders correctly' do
+        expect(topology).to receive(:server_descriptions).and_return({desc.address.to_s => desc})
+        expect(topology.summary).to eq('ReplicaSetNoPrimary[127.0.0.2:27017,name=foo,v=5,e=7fffffff0000000000000042]')
       end
     end
   end