mongo 2.4.1 → 2.14.0

data/spec/mongo/cluster_spec.rb

@@ -6,8 +6,38 @@ describe Mongo::Cluster do
     Mongo::Monitoring.new(monitoring: false)
   end
 
-  let(:cluster) do
-    described_class.new(ADDRESSES, monitoring, TEST_OPTIONS)
+  let(:cluster_with_semaphore) do
+    register_cluster(
+      described_class.new(SpecConfig.instance.addresses, monitoring,
+        SpecConfig.instance.test_options.merge(
+          server_selection_semaphore: Mongo::Semaphore.new)))
+  end
+
+  let(:cluster_without_io) do
+    register_cluster(
+      described_class.new(SpecConfig.instance.addresses, monitoring,
+        SpecConfig.instance.test_options.merge(monitoring_io: false)))
+  end
+
+  let(:cluster) { cluster_without_io }
+
+  describe 'initialize' do
+
+    context 'when there are duplicate addresses' do
+
+      let(:addresses) do
+        SpecConfig.instance.addresses + SpecConfig.instance.addresses
+      end
+      let(:cluster_with_dup_addresses) do
+        register_cluster(
+          described_class.new(addresses, monitoring, SpecConfig.instance.test_options))
+      end
+
+      it 'does not raise an exception' do
+        expect { cluster_with_dup_addresses }.not_to raise_error
+      end
+    end
+
   end
 
   describe '#==' do
@@ -19,22 +49,24 @@ describe Mongo::Cluster do
         context 'when the options are the same' do
 
           let(:other) do
-            described_class.new(ADDRESSES, monitoring, TEST_OPTIONS)
+            described_class.new(SpecConfig.instance.addresses, monitoring,
+              SpecConfig.instance.test_options.merge(monitoring_io: false))
           end
 
           it 'returns true' do
-            expect(cluster).to eq(other)
+            expect(cluster_without_io).to eq(other)
           end
         end
 
         context 'when the options are not the same' do
 
           let(:other) do
-            described_class.new([ '127.0.0.1:27017' ], monitoring, TEST_OPTIONS.merge(:replica_set => 'test'))
+            described_class.new([ '127.0.0.1:27017' ], monitoring,
+              SpecConfig.instance.test_options.merge(replica_set: 'test', monitoring_io: false))
           end
 
           it 'returns false' do
-            expect(cluster).to_not eq(other)
+            expect(cluster_without_io).to_not eq(other)
           end
         end
       end
@@ -42,11 +74,12 @@ describe Mongo::Cluster do
       context 'when the addresses are not the same' do
 
         let(:other) do
-          described_class.new([ '127.0.0.1:27018' ], monitoring, TEST_OPTIONS)
+          described_class.new([ '127.0.0.1:27999' ], monitoring,
+            SpecConfig.instance.test_options.merge(monitoring_io: false))
         end
 
         it 'returns false' do
-          expect(cluster).to_not eq(other)
+          expect(cluster_without_io).to_not eq(other)
         end
       end
     end
@@ -54,7 +87,7 @@ describe Mongo::Cluster do
     context 'when the other is not a cluster' do
 
       it 'returns false' do
-        expect(cluster).to_not eq('test')
+        expect(cluster_without_io).to_not eq('test')
       end
     end
   end
@@ -62,37 +95,37 @@ describe Mongo::Cluster do
   describe '#has_readable_server?' do
 
     let(:selector) do
-      Mongo::ServerSelector.get(mode: :primary)
+      Mongo::ServerSelector.primary
     end
 
     it 'delegates to the topology' do
-      expect(cluster.has_readable_server?).to eq(cluster.topology.has_readable_server?(cluster))
+      expect(cluster_without_io.has_readable_server?).to eq(cluster_without_io.topology.has_readable_server?(cluster_without_io))
     end
   end
 
   describe '#has_writable_server?' do
 
     it 'delegates to the topology' do
-      expect(cluster.has_writable_server?).to eq(cluster.topology.has_writable_server?(cluster))
+      expect(cluster_without_io.has_writable_server?).to eq(cluster_without_io.topology.has_writable_server?(cluster_without_io))
     end
   end
 
   describe '#inspect' do
 
     let(:preference) do
-      Mongo::ServerSelector.get(ServerSelector::PRIMARY)
+      Mongo::ServerSelector.primary
     end
 
     it 'displays the cluster seeds and topology' do
-      expect(cluster.inspect).to include('topology')
-      expect(cluster.inspect).to include('servers')
+      expect(cluster_without_io.inspect).to include('topology')
+      expect(cluster_without_io.inspect).to include('servers')
     end
   end
 
   describe '#replica_set_name' do
 
     let(:preference) do
-      Mongo::ServerSelector.get(ServerSelector::PRIMARY)
+      Mongo::ServerSelector.primary
     end
 
     context 'when the option is provided' do
@@ -101,7 +134,7 @@ describe Mongo::Cluster do
         described_class.new(
           [ '127.0.0.1:27017' ],
           monitoring,
-          TEST_OPTIONS.merge(:connect => :replica_set, :replica_set => 'testing')
+          {monitoring_io: false, connect: :replica_set, replica_set: 'testing'},
         )
       end
 
@@ -113,7 +146,11 @@ describe Mongo::Cluster do
     context 'when the option is not provided' do
 
       let(:cluster) do
-        described_class.new([ '127.0.0.1:27017' ], monitoring, TEST_OPTIONS.dup.delete_if { |k| k == :replica_set })
+        described_class.new(
+          [ '127.0.0.1:27017' ],
+          monitoring,
+          {monitoring_io: false, connect: :direct},
+        )
       end
 
       it 'returns nil' do
@@ -125,15 +162,25 @@ describe Mongo::Cluster do
   describe '#scan!' do
 
     let(:preference) do
-      Mongo::ServerSelector.get(ServerSelector::PRIMARY)
+      Mongo::ServerSelector.primary
     end
 
     let(:known_servers) do
       cluster.instance_variable_get(:@servers)
     end
 
+    let(:server) { known_servers.first }
+
+    let(:monitor) do
+      double('monitor')
+    end
+
     before do
-      expect(known_servers.first).to receive(:scan!).and_call_original
+      expect(server).to receive(:monitor).at_least(:once).and_return(monitor)
+      expect(monitor).to receive(:scan!)
+
+      # scan! complains that there isn't a monitor on the server, calls summary
+      allow(monitor).to receive(:running?)
     end
 
     it 'returns true' do
@@ -142,17 +189,25 @@ describe Mongo::Cluster do
   end
 
   describe '#servers' do
+    let(:cluster) { cluster_with_semaphore }
 
-    context 'when topology is single', if: single_seed? do
+    context 'when topology is single' do
+      before do
+        unless ClusterConfig.instance.single_server?
+          skip 'Topology is not a single server'
+        end
+      end
 
-      context 'when the server is a mongos', if: single_mongos?  do
+      context 'when the server is a mongos' do
+        require_topology :sharded
 
         it 'returns the mongos' do
           expect(cluster.servers.size).to eq(1)
         end
       end
 
-      context 'when the server is a replica set member', if: single_rs_member? do
+      context 'when the server is a replica set member' do
+        require_topology :replica_set
 
         it 'returns the replica set member' do
           expect(cluster.servers.size).to eq(1)
@@ -163,55 +218,55 @@ describe Mongo::Cluster do
     context 'when the cluster has no servers' do
 
       let(:servers) do
-        [nil]
+        []
       end
 
       before do
-        cluster.instance_variable_set(:@servers, servers)
-        cluster.instance_variable_set(:@topology, topology)
+        cluster_without_io.instance_variable_set(:@servers, servers)
+        cluster_without_io.instance_variable_set(:@topology, topology)
       end
 
       context 'when topology is Single' do
 
         let(:topology) do
-          Mongo::Cluster::Topology::Single.new({}, monitoring)
+          Mongo::Cluster::Topology::Single.new({}, monitoring, cluster_without_io)
         end
 
         it 'returns an empty array' do
-          expect(cluster.servers).to eq([])
+          expect(cluster_without_io.servers).to eq([])
         end
       end
 
-      context 'when topology is ReplicaSet' do
+      context 'when topology is ReplicaSetNoPrimary' do
 
         let(:topology) do
-          Mongo::Cluster::Topology::ReplicaSet.new({}, monitoring)
+          Mongo::Cluster::Topology::ReplicaSetNoPrimary.new({replica_set_name: 'foo'}, monitoring, cluster_without_io)
         end
 
         it 'returns an empty array' do
-          expect(cluster.servers).to eq([])
+          expect(cluster_without_io.servers).to eq([])
         end
       end
 
       context 'when topology is Sharded' do
 
         let(:topology) do
-          Mongo::Cluster::Topology::Sharded.new({}, monitoring)
+          Mongo::Cluster::Topology::Sharded.new({}, monitoring, cluster_without_io)
         end
 
         it 'returns an empty array' do
-          expect(cluster.servers).to eq([])
+          expect(cluster_without_io.servers).to eq([])
         end
       end
 
       context 'when topology is Unknown' do
 
         let(:topology) do
-          Mongo::Cluster::Topology::Unknown.new({}, monitoring)
+          Mongo::Cluster::Topology::Unknown.new({}, monitoring, cluster_without_io)
         end
 
         it 'returns an empty array' do
-          expect(cluster.servers).to eq([])
+          expect(cluster_without_io.servers).to eq([])
         end
       end
     end
@@ -221,8 +276,10 @@ describe Mongo::Cluster do
 
     context 'when topology is Single' do
 
+      let(:cluster) { cluster_with_semaphore }
+
       let(:topology) do
-        Mongo::Cluster::Topology::Single.new({})
+        Mongo::Cluster::Topology::Single.new({}, cluster)
       end
 
       before do
@@ -233,41 +290,88 @@ describe Mongo::Cluster do
         expect(cluster.servers[0].address.seed).to_not eq('a')
       end
     end
+
+    context 'topology is Sharded' do
+
+      let(:topology) do
+        Mongo::Cluster::Topology::Single.new({}, cluster)
+      end
+
+      before do
+        cluster.add('a')
+      end
+
+      it 'creates server with nil last_scan' do
+        server = cluster.servers_list.detect do |server|
+          server.address.seed == 'a'
+        end
+
+        expect(server).not_to be nil
+
+        expect(server.last_scan).to be nil
+      end
+    end
   end
 
   describe '#disconnect!' do
+    let(:cluster) { cluster_with_semaphore }
 
     let(:known_servers) do
       cluster.instance_variable_get(:@servers)
     end
 
-    let(:cursor_reaper) do
-      cluster.instance_variable_get(:@cursor_reaper)
+    let(:periodic_executor) do
+      cluster.instance_variable_get(:@periodic_executor)
     end
 
-    before do
-      known_servers.each do |server|
-        expect(server).to receive(:disconnect!).and_call_original
+    describe 'disconnection' do
+      before do
+        known_servers.each do |server|
+          expect(server).to receive(:disconnect!).and_call_original
+        end
+        expect(periodic_executor).to receive(:stop!).and_call_original
+      end
+
+      it 'disconnects each server and the cursor reaper and returns true' do
+        expect(cluster.disconnect!).to be(true)
       end
-      expect(cursor_reaper).to receive(:stop!).and_call_original
     end
 
-    it 'disconnects each server and the cursor reaper and returns true' do
-      expect(cluster.disconnect!).to be(true)
+    describe 'repeated disconnection' do
+      before do
+        known_servers.each do |server|
+          expect(server).to receive(:disconnect!).and_call_original
+        end
+        expect(periodic_executor).to receive(:stop!).and_call_original
+      end
+
+      let(:monitoring) { Mongo::Monitoring.new }
+      let(:subscriber) { EventSubscriber.new }
+
+      it 'publishes server closed event once' do
+        monitoring.subscribe(Mongo::Monitoring::SERVER_CLOSED, subscriber)
+        expect(cluster.disconnect!).to be(true)
+        expect(subscriber.first_event('server_closed_event')).not_to be nil
+        subscriber.succeeded_events.clear
+        expect(cluster.disconnect!).to be(true)
+        expect(subscriber.first_event('server_closed_event')).to be nil
+      end
     end
   end
 
   describe '#reconnect!' do
 
-    let(:cursor_reaper) do
-      cluster.instance_variable_get(:@cursor_reaper)
+    let(:cluster) { cluster_with_semaphore }
+
+    let(:periodic_executor) do
+      cluster.instance_variable_get(:@periodic_executor)
     end
 
     before do
       cluster.servers.each do |server|
         expect(server).to receive(:reconnect!).and_call_original
       end
-      expect(cursor_reaper).to receive(:restart!).and_call_original
+      expect(periodic_executor).to receive(:restart!).and_call_original
     end
 
     it 'reconnects each server and the cursor reaper and returns true' do
@@ -278,11 +382,11 @@ describe Mongo::Cluster do
   describe '#remove' do
 
     let(:address_a) do
-      Mongo::Address.new('127.0.0.1:27017')
+      Mongo::Address.new('127.0.0.1:25555')
     end
 
     let(:address_b) do
-      Mongo::Address.new('127.0.0.1:27018')
+      Mongo::Address.new('127.0.0.1:25556')
     end
 
     let(:monitoring) do
@@ -290,11 +394,15 @@ describe Mongo::Cluster do
     end
 
     let(:server_a) do
-      Mongo::Server.new(address_a, cluster, monitoring, Mongo::Event::Listeners.new)
+      register_server(
+        Mongo::Server.new(address_a, cluster, monitoring, Mongo::Event::Listeners.new,
+          monitor: false))
     end
 
     let(:server_b) do
-      Mongo::Server.new(address_b, cluster, monitoring, Mongo::Event::Listeners.new)
+      register_server(
+        Mongo::Server.new(address_b, cluster, monitoring, Mongo::Event::Listeners.new,
+          monitor: false))
     end
 
     let(:servers) do
@@ -307,8 +415,7 @@ describe Mongo::Cluster do
 
     before do
       cluster.instance_variable_set(:@servers, servers)
-      cluster.instance_variable_set(:@addresses, addresses)
-      cluster.remove('127.0.0.1:27017')
+      cluster.remove('127.0.0.1:25555')
     end
 
     it 'removes the host from the list of servers' do
@@ -316,197 +423,378 @@ describe Mongo::Cluster do
     end
 
     it 'removes the host from the list of addresses' do
-      expect(cluster.instance_variable_get(:@addresses)).to eq([address_b])
+      expect(cluster.addresses).to eq([address_b])
     end
   end
 
-  describe '#add_hosts' do
+  describe '#next_primary' do
 
-    let(:servers) do
-      [nil]
+    let(:cluster) do
+      # We use next_primary to wait for server selection, and this is
+      # also the method we are testing.
+      authorized_client.tap { |client| client.cluster.next_primary }.cluster
     end
 
-    let(:hosts) do
-      ["127.0.0.1:27018"]
+    let(:primary_candidates) do
+      if cluster.single?
+        cluster.servers
+      elsif cluster.sharded?
+        cluster.servers
+      else
+        cluster.servers.select { |s| s.primary? }
+      end
     end
 
-    let(:description) do
-      Mongo::Server::Description.new(double('address'), { 'hosts' => hosts })
+    it 'always returns the primary, mongos, or standalone' do
+      expect(primary_candidates).to include(cluster.next_primary)
     end
+  end
 
-    before do
-      cluster.instance_variable_set(:@servers, servers)
-      cluster.instance_variable_set(:@topology, topology)
+  describe '#app_metadata' do
+
+    it 'returns an AppMetadata object' do
+      expect(cluster_without_io.app_metadata).to be_a(Mongo::Server::AppMetadata)
     end
 
-    context 'when the topology allows servers to be added' do
+    context 'when the client has an app_name set' do
 
-      let(:topology) do
-        double('topology').tap do |t|
-          allow(t).to receive(:add_hosts?).and_return(true)
-        end
+      let(:cluster) do
+        authorized_client.with(app_name: 'cluster_test', monitoring_io: false).cluster
       end
 
-      it 'adds the servers' do
-        expect(cluster).to receive(:add).once
-        cluster.add_hosts(description)
+      it 'constructs an AppMetadata object with the app_name' do
+        expect(cluster.app_metadata.send(:full_client_document)[:application]).to eq('name' => 'cluster_test')
       end
     end
 
-    context 'when the topology does not allow servers to be added' do
+    context 'when the client does not have an app_name set' do
 
-      let(:topology) do
-        double('topology').tap do |t|
-          allow(t).to receive(:add_hosts?).and_return(false)
-        end
+      let(:cluster) do
+        authorized_client.cluster
       end
 
-      it 'does not add the servers' do
-        expect(cluster).not_to receive(:add)
-        cluster.add_hosts(description)
+      it 'constructs an AppMetadata object with no app_name' do
+        expect(cluster.app_metadata.send(:full_client_document)[:application]).to be_nil
       end
     end
   end
 
-  describe '#remove_hosts' do
+  describe '#cluster_time' do
 
-    let(:listeners) do
-      Mongo::Event::Listeners.new
+    let(:operation) do
+      client.command(ping: 1)
     end
 
-    let(:address) do
-      Mongo::Address.new('127.0.0.1:27017')
+    let(:operation_with_session) do
+      client.command({ ping: 1 }, session: session)
     end
 
-    let(:monitoring) do
-      Mongo::Monitoring.new(monitoring: false)
+    let(:second_operation) do
+      client.command({ ping: 1 }, session: session)
     end
 
-    let(:server) do
-      Mongo::Server.new(address, cluster, monitoring, listeners)
-    end
+    it_behaves_like 'an operation updating cluster time'
+  end
 
-    let(:servers) do
-      [ server ]
-    end
+  describe '#update_cluster_time' do
 
-    let(:hosts) do
-      ["127.0.0.1:27018"]
+    let(:cluster) do
+      described_class.new(SpecConfig.instance.addresses, monitoring,
+        SpecConfig.instance.test_options.merge(heartbeat_frequency: 1000, monitoring_io: false))
     end
 
-    let(:description) do
-      Mongo::Server::Description.new(double('address'), { 'hosts' => hosts })
+    let(:result) do
+      double('result', cluster_time: cluster_time_doc)
     end
 
-    context 'when the topology allows servers to be removed' do
+    context 'when the cluster_time variable is nil' do
 
-      context 'when the topology allows a specific server to be removed' do
+      before do
+        cluster.instance_variable_set(:@cluster_time, nil)
+        cluster.update_cluster_time(result)
+      end
 
-        let(:topology) do
-          double('topology').tap do |t|
-            allow(t).to receive(:remove_hosts?).and_return(true)
-            allow(t).to receive(:remove_server?).and_return(true)
-          end
+      context 'when the cluster time received is nil' do
+
+        let(:cluster_time_doc) do
+          nil
         end
 
-        before do
-          cluster.instance_variable_set(:@servers, servers)
-          cluster.instance_variable_set(:@topology, topology)
+        it 'does not set the cluster_time variable' do
+          expect(cluster.cluster_time).to be_nil
         end
+      end
+
+      context 'when the cluster time received is not nil' do
 
-        it 'removes the servers' do
-          expect(cluster).to receive(:remove).once
-          cluster.remove_hosts(description)
+        let(:cluster_time_doc) do
+          BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1))
+        end
+
+        it 'sets the cluster_time variable to the cluster time doc' do
+          expect(cluster.cluster_time).to eq(cluster_time_doc)
         end
       end
+    end
 
-      context 'when the topology does not allow a specific server to be removed' do
+    context 'when the cluster_time variable has a value' do
 
-        let(:topology) do
-          double('topology').tap do |t|
-            allow(t).to receive(:remove_hosts?).and_return(true)
-            allow(t).to receive(:remove_server?).and_return(false)
+      before do
+        cluster.instance_variable_set(:@cluster_time, Mongo::ClusterTime.new(
+            Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+        cluster.update_cluster_time(result)
+      end
+
+      context 'when the cluster time received is nil' do
+
+        let(:cluster_time_doc) do
+          nil
+        end
+
+        it 'does not update the cluster_time variable' do
+          expect(cluster.cluster_time).to eq(BSON::Document.new(
+              Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+        end
+      end
+
+      context 'when the cluster time received is not nil' do
+
+        context 'when the cluster time received is greater than the cluster_time variable' do
+
+          let(:cluster_time_doc) do
+            BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 2))
+          end
+
+          it 'sets the cluster_time variable to the cluster time' do
+            expect(cluster.cluster_time).to eq(cluster_time_doc)
           end
         end
 
-        before do
-          cluster.instance_variable_set(:@servers, servers)
-          cluster.instance_variable_set(:@topology, topology)
+        context 'when the cluster time received is less than the cluster_time variable' do
+
+          let(:cluster_time_doc) do
+            BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(0, 1))
+          end
+
+          it 'does not set the cluster_time variable to the cluster time' do
+            expect(cluster.cluster_time).to eq(BSON::Document.new(
+                Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+          end
         end
 
-        it 'removes the servers' do
-          expect(cluster).not_to receive(:remove)
-          cluster.remove_hosts(description)
+        context 'when the cluster time received is equal to the cluster_time variable' do
+
+          let(:cluster_time_doc) do
+            BSON::Document.new(Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1))
+          end
+
+          it 'does not change the cluster_time variable' do
+            expect(cluster.cluster_time).to eq(BSON::Document.new(
+                Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
+          end
         end
       end
     end
+  end
 
-    context 'when the topology does not allow servers to be removed' do
+  describe '#validate_session_support!' do
+    shared_examples 'supports sessions' do
+      it 'supports sessions' do
+        lambda do
+          cluster.validate_session_support!
+        end.should_not raise_error
+      end
+    end
 
-      let(:topology) do
-        double('topology').tap do |t|
-          allow(t).to receive(:remove_hosts?).and_return(false)
+    shared_examples 'does not support sessions' do
+      it 'does not support sessions' do
+        lambda do
+          cluster.validate_session_support!
+        end.should raise_error(Mongo::Error::SessionsNotSupported)
+      end
+    end
+
+    context 'when client has not contacted any servers' do
+
+      let(:cluster) do
+        described_class.new(SpecConfig.instance.addresses, monitoring,
+          SpecConfig.instance.test_options.merge(
+            monitoring_io: false, server_selection_timeout: 0.183))
+      end
+
+      it_behaves_like 'does not support sessions'
+    end
+
+    context 'when client has contacted servers and then disconnected' do
+      min_server_fcv '3.6'
+      require_wired_tiger
+      require_topology :sharded, :replica_set
+
+      let(:cluster) do
+        described_class.new(SpecConfig.instance.addresses, monitoring,
+          SpecConfig.instance.test_options.merge(
+            server_selection_timeout: 0.183)
+        ).tap do |cluster|
+          register_cluster(cluster)
         end
       end
 
       before do
-        cluster.instance_variable_set(:@servers, servers)
-        cluster.instance_variable_set(:@topology, topology)
+        cluster.next_primary
+        cluster.servers_list.map(&:disconnect!)
+        cluster.servers_list.map(&:unknown!)
       end
 
-      it 'does not remove the servers' do
-        expect(cluster).not_to receive(:remove)
-        cluster.remove_hosts(description)
-      end
+      it_behaves_like 'supports sessions'
     end
-  end
 
-  describe '#next_primary' do
+    context 'in server < 3.6' do
+      max_server_version '3.4'
 
-    let(:cluster) do
-      authorized_client.cluster
-    end
+      let(:cluster) { client.cluster }
 
-    let(:primary_candidates) do
-      if cluster.single?
-        cluster.servers
-      elsif cluster.sharded?
-        cluster.servers
-      else
-        cluster.servers.select { |s| s.primary? }
+      context 'in single topology' do
+        require_topology :single
+
+        let(:client) { ClientRegistry.instance.global_client('authorized') }
+
+        it_behaves_like 'does not support sessions'
       end
-    end
 
-    it 'always returns the primary, mongos, or standalone' do
-      expect(primary_candidates).to include(cluster.next_primary)
+      context 'in single topology with replica set name set' do
+        require_topology :replica_set
+
+        let(:client) do
+          new_local_client([SpecConfig.instance.addresses.first],
+            SpecConfig.instance.test_options.merge(
+              connect: :direct, replica_set: ClusterConfig.instance.replica_set_name))
+        end
+
+        it_behaves_like 'does not support sessions'
+      end
+
+      context 'in replica set topology' do
+        require_topology :replica_set
+
+        let(:client) { ClientRegistry.instance.global_client('authorized') }
+
+        it_behaves_like 'does not support sessions'
+      end
+
+      context 'in sharded topology' do
+        require_topology :sharded
+
+        let(:client) { ClientRegistry.instance.global_client('authorized') }
+
+        it_behaves_like 'does not support sessions'
+      end
     end
-  end
 
-  describe '#app_metadata' do
+    context 'in server 3.6+' do
+      min_server_fcv '3.6'
 
-    it 'returns an AppMetadata object' do
-      expect(cluster.app_metadata).to be_a(Mongo::Cluster::AppMetadata)
+      let(:cluster) { client.cluster }
+
+      context 'in single topology' do
+        require_topology :single
+
+        let(:client) { ClientRegistry.instance.global_client('authorized') }
+
+        # Contrary to the session spec, 3.6 and 4.0 standalone servers
+        # report a logical session timeout and thus are considered to
+        # support sessions.
+        it_behaves_like 'supports sessions'
+      end
+
+      context 'in single topology with replica set name set' do
+        require_topology :replica_set
+
+        let(:client) do
+          new_local_client([SpecConfig.instance.addresses.first],
+            SpecConfig.instance.test_options.merge(
+              connect: :direct, replica_set: ClusterConfig.instance.replica_set_name))
+        end
+
+        it_behaves_like 'supports sessions'
+      end
+
+      context 'in replica set topology' do
+        require_topology :replica_set
+
+        let(:client) { ClientRegistry.instance.global_client('authorized') }
+
+        it_behaves_like 'supports sessions'
+      end
+
+      context 'in sharded topology' do
+        require_topology :sharded
+
+        let(:client) { ClientRegistry.instance.global_client('authorized') }
+
+        it_behaves_like 'supports sessions'
+      end
     end
+  end
 
-    context 'when the client has an app_name set' do
+  [
+    [:max_read_retries, 1],
+    [:read_retry_interval, 5],
+  ].each do |opt, default|
+    describe "##{opt}" do
+      let(:client_options) { {} }
+
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'], client_options)
+      end
 
       let(:cluster) do
-        authorized_client.with(app_name: 'reports').cluster
+        client.cluster
       end
 
-      it 'constructs an AppMetadata object with the app_name' do
-        expect(cluster.app_metadata.send(:full_client_document)[:application]).to eq('name' => 'reports')
+      it "defaults to #{default}" do
+        expect(default).not_to be nil
+        expect(client.options[opt]).to be nil
+        expect(cluster.send(opt)).to eq(default)
+      end
+
+      context 'specified on client' do
+        let(:client_options) { {opt => 2} }
+
+        it 'inherits from client' do
+          expect(client.options[opt]).to eq(2)
+          expect(cluster.send(opt)).to eq(2)
+        end
       end
     end
+  end
 
-    context 'when the client does not have an app_name set' do
+  describe '#summary' do
+    let(:default_address) { SpecConfig.instance.addresses.first }
 
-      let(:cluster) do
-        authorized_client.cluster
+    context 'cluster has unknown servers' do
+      it 'includes unknown servers' do
+        cluster.servers_list.each do |server|
+          expect(server).to be_unknown
+        end
+
+        expect(cluster.summary).to match(/Server address=#{default_address}/)
       end
+    end
 
-      it 'constructs an AppMetadata object with no app_name' do
-        expect(cluster.app_metadata.send(:full_client_document)[:application]).to be_nil
+    context 'cluster has known servers' do
+      let(:client) { ClientRegistry.instance.global_client('authorized') }
+      let(:cluster) { client.cluster }
+
+      before do
+        wait_for_all_servers(cluster)
+      end
+
+      it 'includes known servers' do
+        cluster.servers_list.each do |server|
+          expect(server).not_to be_unknown
+        end
+
+        expect(cluster.summary).to match(/Server address=#{default_address}/)
       end
     end
   end