mongo 2.13.0.beta1 → 2.13.0.rc1

data/spec/spec_tests/data/sdam_integration/isMaster-timeout.yml

@@ -0,0 +1,229 @@
+# Test SDAM error handling.
+runOn:
+    # failCommand appName requirements
+    - minServerVersion: "4.4"
+
+database_name: &database_name "sdam-tests"
+collection_name: &collection_name "isMaster-timeout"
+
+data: []
+
+tests:
+  - description: Network timeout on Monitor handshake
+    # Configure the initial handshake to fail with a timeout.
+    # Use times: 2 so that the RTT isMaster is blocked as well.
+    failPoint:
+      configureFailPoint: failCommand
+      mode: { times: 2 }
+      data:
+          failCommands: ["isMaster"]
+          appName: timeoutMonitorHandshakeTest
+          blockConnection: true
+          blockTimeMS: 1000
+    clientOptions:
+      retryWrites: false
+      connectTimeoutMS: 250
+      heartbeatFrequencyMS: 500
+      appname: timeoutMonitorHandshakeTest
+    operations:
+      # The network error on the initial handshake should mark the server
+      # Unknown (emitting a ServerDescriptionChangedEvent) and clear the pool.
+      - name: waitForEvent
+        object: testRunner
+        arguments:
+          event: ServerMarkedUnknownEvent
+          count: 1
+# https://jira.mongodb.org/browse/DRIVERS-1314
+#       - name: waitForEvent
+#         object: testRunner
+#         arguments:
+#           event: PoolClearedEvent
+#           count: 1
+      # Perform an operation to ensure the node is discovered.
+      - name: insertMany
+        object: collection
+        arguments:
+          documents:
+            - _id: 1
+            - _id: 2
+      # We cannot assert the server was marked Unknown and pool was cleared an
+      # exact number of times because the RTT isMaster may or may not have
+      # triggered this failpoint as well.
+      # - name: assertEventCount
+      #   object: testRunner
+      #   arguments:
+      #     event: ServerMarkedUnknownEvent
+      #     count: 1
+      # - name: assertEventCount
+      #   object: testRunner
+      #   arguments:
+      #     event: PoolClearedEvent
+      #     count: 1
+
+    expectations:
+      - command_started_event:
+          command:
+            insert: *collection_name
+            documents:
+              - _id: 1
+              - _id: 2
+          command_name: insert
+          database_name: *database_name
+
+    outcome:
+      collection:
+        data:
+          - {_id: 1}
+          - {_id: 2}
+
+  - description: Network timeout on Monitor check
+    clientOptions:
+      retryWrites: false
+      connectTimeoutMS: 750
+      heartbeatFrequencyMS: 500
+      appname: timeoutMonitorCheckTest
+    operations:
+      # Perform an operation to ensure the node is discovered.
+      - name: insertMany
+        object: collection
+        arguments:
+          documents:
+            - _id: 1
+            - _id: 2
+      # Configure the next streaming isMaster check to fail with a timeout
+      # Use times: 2 so that the RTT isMaster is blocked as well.
+      - name: configureFailPoint
+        object: testRunner
+        arguments:
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 2 }
+            data:
+                failCommands: ["isMaster"]
+                appName: timeoutMonitorCheckTest
+                blockConnection: true
+                # blockTimeMS is evaluated after the waiting for heartbeatFrequencyMS server-side, so this value only
+                # needs to be greater than connectTimeoutMS. The driver will wait for (500+750)ms and the server will
+                # respond after (500+1000)ms.
+                blockTimeMS: 1000
+      # The network error on the next check should mark the server Unknown and
+      # clear the pool.
+      - name: waitForEvent
+        object: testRunner
+        arguments:
+          event: ServerMarkedUnknownEvent
+          count: 1
+      - name: waitForEvent
+        object: testRunner
+        arguments:
+          event: PoolClearedEvent
+          count: 1
+      # Perform an operation to ensure the node is rediscovered.
+      - name: insertMany
+        object: collection
+        arguments:
+          documents:
+            - _id: 3
+            - _id: 4
+      # Assert the server was marked Unknown and pool was cleared exactly once.
+      - name: assertEventCount
+        object: testRunner
+        arguments:
+          event: ServerMarkedUnknownEvent
+          count: 1
+      - name: assertEventCount
+        object: testRunner
+        arguments:
+          event: PoolClearedEvent
+          count: 1
+
+    expectations:
+      - command_started_event:
+          command:
+            insert: *collection_name
+            documents:
+              - _id: 1
+              - _id: 2
+          command_name: insert
+          database_name: *database_name
+      - command_started_event:
+          command:
+            insert: *collection_name
+            documents:
+              - _id: 3
+              - _id: 4
+          command_name: insert
+          database_name: *database_name
+
+    outcome:
+      collection:
+        data:
+          - {_id: 1}
+          - {_id: 2}
+          - {_id: 3}
+          - {_id: 4}
+
+  - description: Driver extends timeout while streaming
+    clientOptions:
+      retryWrites: false
+      connectTimeoutMS: 250
+      heartbeatFrequencyMS: 500
+      appname: extendsTimeoutTest
+    operations:
+      # Perform an operation to ensure the node is discovered.
+      - name: insertMany
+        object: collection
+        arguments:
+          documents:
+            - _id: 1
+            - _id: 2
+      # Wait for multiple monitor checks to complete.
+      - name: wait
+        object: testRunner
+        arguments:
+          ms: 2000
+      # Perform an operation to ensure the node is still selectable.
+      - name: insertMany
+        object: collection
+        arguments:
+          documents:
+            - _id: 3
+            - _id: 4
+      # Assert that the server was never marked Unknown and the pool was never
+      # cleared.
+      - name: assertEventCount
+        object: testRunner
+        arguments:
+          event: ServerMarkedUnknownEvent
+          count: 0
+      - name: assertEventCount
+        object: testRunner
+        arguments:
+          event: PoolClearedEvent
+          count: 0
+
+    expectations:
+      - command_started_event:
+          command:
+            insert: *collection_name
+            documents:
+              - _id: 1
+              - _id: 2
+          command_name: insert
+          database_name: *database_name
+      - command_started_event:
+          command:
+            insert: *collection_name
+            documents:
+              - _id: 3
+              - _id: 4
+          command_name: insert
+          database_name: *database_name
+
+    outcome:
+      collection:
+        data:
+          - {_id: 1}
+          - {_id: 2}
+          - {_id: 3}
+          - {_id: 4}

data/spec/spec_tests/data/sdam_integration/rediscover-quickly-after-step-down.yml

@@ -0,0 +1,87 @@
+runOn:
+    # 4.4 is required for streaming.
+    # A replica set is required for replSetStepDown.
+    - minServerVersion: "4.4"
+      topology: ["replicaset"]
+
+database_name: &database_name "sdam-tests"
+collection_name: &collection_name "test-replSetStepDown"
+
+data: &data
+  - {_id: 1}
+  - {_id: 2}
+
+tests:
+  - description: Rediscover quickly after replSetStepDown
+    clientOptions:
+      appname: replSetStepDownTest
+      # Configure a large heartbeatFrequencyMS
+      heartbeatFrequencyMS: 60000
+      # Configure a much smaller server selection timeout so that the test
+      # will error when it cannot discover the new primary soon.
+      serverSelectionTimeoutMS: 5000
+      w: majority
+    operations:
+      # Discover the primary.
+      - name: insertMany
+        object: collection
+        arguments:
+          documents:
+            - _id: 3
+            - _id: 4
+      - name: recordPrimary
+        object: testRunner
+      # Run replSetStepDown on the meta client.
+      - name: runAdminCommand
+        object: testRunner
+        command_name: replSetStepDown
+        arguments:
+          command:
+            replSetStepDown: 1
+            secondaryCatchUpPeriodSecs: 1
+            force: false
+      - name: waitForPrimaryChange
+        object: testRunner
+        arguments:
+          timeoutMS: 5000
+      # Rediscover the new primary.
+      - name: insertMany
+        object: collection
+        arguments:
+          documents:
+            - _id: 5
+            - _id: 6
+      # Assert that no pools were cleared.
+      - name: assertEventCount
+        object: testRunner
+        arguments:
+          event: PoolClearedEvent
+          count: 0
+
+    expectations:
+      - command_started_event:
+          command:
+            insert: *collection_name
+            documents:
+              - _id: 3
+              - _id: 4
+          command_name: insert
+          database_name: *database_name
+      - command_started_event:
+          command:
+            insert: *collection_name
+            documents:
+              - _id: 5
+              - _id: 6
+          command_name: insert
+          database_name: *database_name
+
+    outcome:
+      collection:
+        data:
+          - {_id: 1}
+          - {_id: 2}
+          - {_id: 3}
+          - {_id: 4}
+          - {_id: 5}
+          - {_id: 6}

data/spec/spec_tests/max_staleness_spec.rb

@@ -1,147 +1,9 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 require 'runners/server_selection'
 
-describe 'Max Staleness Spec' do
+MAX_STALENESS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/max_staleness/**/*.yml").sort
 
-  include Mongo::ServerSelection::Read
-
-  MAX_STALENESS_TESTS.each do |file|
-
-    spec = Mongo::ServerSelection::Read::Spec.new(file)
-
-    context(spec.description) do
-      # 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(:topology) do
-        options = if spec.type <= Mongo::Cluster::Topology::ReplicaSetNoPrimary
-          {replica_set_name: 'foo'}
-        else
-          {}
-        end
-        spec.type.new(options, monitoring, temp_cluster)
-      end
-
-      let(:monitoring) do
-        Mongo::Monitoring.new(monitoring: false)
-      end
-
-      let(:listeners) do
-        Mongo::Event::Listeners.new
-      end
-
-      let(:options) do
-        if spec.heartbeat_frequency
-          SpecConfig.instance.test_options.merge(heartbeat_frequency: spec.heartbeat_frequency)
-        else
-          SpecConfig.instance.test_options.dup.tap do |opts|
-            opts.delete(:heartbeat_frequency)
-          end
-        end.merge!(server_selection_timeout: 0.2, connect_timeout: 0.1)
-      end
-
-      let(:cluster) do
-        double('cluster').tap do |c|
-          allow(c).to receive(:connected?).and_return(true)
-          allow(c).to receive(:summary)
-          allow(c).to receive(:topology).and_return(topology)
-          allow(c).to receive(:single?).and_return(topology.single?)
-          allow(c).to receive(:sharded?).and_return(topology.sharded?)
-          allow(c).to receive(:replica_set?).and_return(topology.replica_set?)
-          allow(c).to receive(:unknown?).and_return(topology.unknown?)
-          allow(c).to receive(:options).and_return(options)
-          allow(c).to receive(:scan!).and_return(true)
-          allow(c).to receive(:app_metadata).and_return(app_metadata)
-          allow(c).to receive(:heartbeat_interval).and_return(
-            spec.heartbeat_frequency || Mongo::Server::Monitor::DEFAULT_HEARTBEAT_INTERVAL)
-        end
-      end
-
-      let(:candidate_servers) do
-        spec.candidate_servers.collect do |server|
-          features = double('features').tap do |feat|
-            allow(feat).to receive(:max_staleness_enabled?).and_return(server['maxWireVersion'] && server['maxWireVersion'] >= 5)
-            allow(feat).to receive(:check_driver_support!).and_return(true)
-          end
-          address = Mongo::Address.new(server['address'])
-          Mongo::Server.new(address, cluster, monitoring, listeners,
-            {monitoring_io: false}.update(options)
-          ).tap do |s|
-            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'] / 1000.0) if server['avg_rtt_ms']
-            allow(s).to receive(:tags).and_return(server['tags'])
-            allow(s).to receive(:secondary?).and_return(server['type'] == 'RSSecondary')
-            allow(s).to receive(:primary?).and_return(server['type'] == 'RSPrimary')
-            allow(s).to receive(:connectable?).and_return(true)
-            allow(s).to receive(:last_write_date).and_return(
-              Time.at(server['lastWrite']['lastWriteDate']['$numberLong'].to_f / 1000)) if server['lastWrite']
-            allow(s).to receive(:last_scan).and_return(
-              Time.at(server['lastUpdateTime'].to_f / 1000))
-            allow(s).to receive(:features).and_return(features)
-          end
-        end
-      end
-
-      let(:in_latency_window) do
-        spec.in_latency_window.collect do |server|
-          Mongo::Server.new(Mongo::Address.new(server['address']), cluster, monitoring, listeners,
-            options.merge(monitoring_io: false))
-        end
-      end
-
-      let(:server_selector_definition) do
-        { mode: spec.read_preference['mode'] }.tap do |definition|
-          definition[:tag_sets] = spec.read_preference['tag_sets']
-          definition[:max_staleness] = spec.max_staleness if spec.max_staleness
-        end
-      end
-
-      let(:server_selector) do
-        Mongo::ServerSelector.get(server_selector_definition)
-      end
-
-      before do
-        allow(cluster).to receive(:servers).and_return(candidate_servers)
-        allow(cluster).to receive(:addresses).and_return(candidate_servers.map(&:address))
-      end
-
-      context 'when the max staleness is invalid' do
-
-        it 'Raises an InvalidServerPreference exception', if: spec.invalid_max_staleness? do
-
-          expect do
-            server_selector.select_server(cluster)
-          end.to raise_exception(Mongo::Error::InvalidServerPreference)
-        end
-      end
-
-      context 'when the max staleness is valid' do
-
-        context 'when there are available servers' do
-
-          it 'Finds all suitable servers in the latency window', if: (spec.replica_set? && !spec.invalid_max_staleness? && spec.server_available?) do
-            expect(server_selector.send(:select, cluster.servers)).to match_array(in_latency_window)
-          end
-
-          it 'Finds the most suitable server in the latency window', if: (!spec.invalid_max_staleness? && spec.server_available?) do
-            expect(in_latency_window).to include(server_selector.select_server(cluster))
-          end
-        end
-
-        context 'when there are no available servers', if: (!spec.invalid_max_staleness? && !spec.server_available?) do
-
-          it 'Raises a NoServerAvailable Exception' do
-            expect do
-              server_selector.select_server(cluster)
-            end.to raise_exception(Mongo::Error::NoServerAvailable)
-          end
-        end
-      end
-    end
-  end
+describe 'Max staleness spec tests' do
+  define_server_selection_spec_tests(MAX_STALENESS_TESTS)
 end