test(UnifiedTopology): fix a variety of issues with unified topology tests

The driver assumes that any connection string with only one host and
doesn't have a replicaset name is Single. We used to accommodate this
in the legacy Server topology by detecting if the connected server was
a mongos, and switching under the hood to a legacy Mongos topology.
However, SDAM (and by extension the Unified Topology) mandates that
once the topology is Single it must stay Single forever. Passing a single
host mongos in gets labeled as Single, which breaks any features that depend
on it being a Mongos. We originally switched to one shard for stability
reasons, but now that breaks our Transactions tests. So we are going
back to multiple mongoses.

Author: daprahamian

test/environments.js

@@ -137,10 +137,13 @@ class ShardedEnvironment extends EnvironmentBase {
     this.host = 'localhost';
     this.port = 51000;
 
-    // NOTE: only connect to a single shard because there can be consistency issues using
-    //       more, revolving around the inability for shards to keep up-to-date views of
-    //       changes to the world (such as dropping a database).
-    this.url = 'mongodb://%slocalhost:51000/integration_tests';
+    // TODO: we used to only connect to a single shard here b/c of consistency issues
+    // revolving around the inability for shards to keep up-to-date views of
+    // changes to the world (such as dropping a database). However, b/c the unified
+    // topology treats a single shard like a Single topology instead of a Sharded
+    // topology, we need to use multiple shards as much as possible to ensure that
+    // we get sharded test coverage (looking at you transactions tests!)
+    this.url = 'mongodb://%slocalhost:51000,localhost:51001/integration_tests';
 
     this.writeConcernMax = { w: 'majority', wtimeout: 30000 };
     this.topology = (host, port, options) => {

test/functional/runner/index.js

@@ -221,7 +221,7 @@ function parseSessionOptions(options) {
   return result;
 }
 
-const IGNORED_COMMANDS = new Set(['ismaster']);
+const IGNORED_COMMANDS = new Set(['ismaster', 'configureFailPoint']);
 
 let displayCommands = false;
 function runTestSuiteTest(configuration, spec, context) {

test/functional/sessions_tests.js

@@ -180,10 +180,19 @@ describe('Sessions', function() {
         this.skip();
         return;
       }
-
       return testContext.setup(this.configuration);
     });
 
-    generateTopologyTests(testSuites, testContext);
+    function testFilter(spec) {
+      const SKIP_TESTS = [
+        // These two tests need to run against multiple mongoses
+        'Dirty explicit session is discarded',
+        'Dirty implicit session is discarded (write)'
+      ];
+
+      return SKIP_TESTS.indexOf(spec.description) === -1;
+    }
+
+    generateTopologyTests(testSuites, testContext, testFilter);
   });
 });

test/functional/sharding_read_preference_tests.js

@@ -19,9 +19,12 @@ describe('Sharding (Read Preference)', function() {
     // The actual test we wish to run
     test: function(done) {
       const configuration = this.configuration;
+      const host = configuration.host;
+      const port = configuration.port;
 
+      const url = `mongodb://${host}:${port}/sharded_test_db?w=1`;
       // Connect using the mongos connections
-      var client = new MongoClient(configuration.url(), { w: 0, monitorCommands: true });
+      var client = new MongoClient(url, { w: 0, monitorCommands: true });
       client.connect(function(err) {
         expect(err).to.not.exist;
         const db = client.db(configuration.db);
@@ -77,9 +80,12 @@ describe('Sharding (Read Preference)', function() {
     // The actual test we wish to run
     test: function(done) {
       const configuration = this.configuration;
+      const host = configuration.host;
+      const port = configuration.port;
 
+      const url = `mongodb://${host}:${port}/sharded_test_db?w=1`;
       // Connect using the mongos connections
-      const client = new MongoClient(configuration.url(), { w: 0 });
+      const client = new MongoClient(url, { w: 0 });
       client.connect(function(err) {
         expect(err).to.not.exist;
         const db = client.db(configuration.db);

test/functional/transactions_tests.js

@@ -31,7 +31,12 @@ describe('Transactions', function() {
           'commitTransaction retry succeeds on new mongos',
           'commitTransaction retry fails on new mongos',
           'unpin after transient error within a transaction and commit',
-          'count'
+          'count',
+          // This test needs there to be multiple mongoses
+          'increment txnNumber',
+          // There is something wrong with the distinct command in the runner:
+          // it is not failing properly
+          'add transient label to connection errors'
         ];
 
         return SKIP_TESTS.indexOf(spec.description) === -1;
@@ -74,7 +79,7 @@ describe('Transactions', function() {
       metadata: { requires: { topology: ['sharded'], mongodb: '4.0.x' } },
       test: function(done) {
         const configuration = this.configuration;
-        const client = configuration.newClient(configuration.writeConcernMax(), { poolSize: 1 });
+        const client = configuration.newClient(configuration.url());
 
         client.connect((err, client) => {
           const session = client.startSession();
@@ -93,5 +98,27 @@ describe('Transactions', function() {
         });
       }
     });
+
+    it('should not error if transactions are supported', {
+      metadata: { requires: { topology: ['sharded'], mongodb: '>=4.1.0' } },
+      test: function(done) {
+        const configuration = this.configuration;
+        const client = configuration.newClient(configuration.url());
+
+        client.connect((err, client) => {
+          const session = client.startSession();
+          const db = client.db(configuration.db);
+          const coll = db.collection('transaction_error_test');
+          coll.insertOne({ a: 1 }, err => {
+            expect(err).to.not.exist;
+            expect(() => session.startTransaction()).to.not.throw();
+
+            session.endSession(() => {
+              client.close(done);
+            });
+          });
+        });
+      }
+    });
   });
 });