diff --git a/test/environments.js b/test/environments.js
index e4fa142a4..0536a5fd6 100644
--- a/test/environments.js
+++ b/test/environments.js
@@ -1,232 +1,194 @@
 'use strict';
 
-var f = require('util').format;
-var path = require('path');
-
-var topologyManagers = require('mongodb-test-runner').topologyManagers,
-  ServerManager = topologyManagers.Server,
-  ReplSetManager = topologyManagers.ReplSet,
-  ShardingManager = topologyManagers.Sharded;
-
-var replicaSetEnvironment = function() {
-  return {
-    host: 'localhost',
-    port: 31000,
-    setName: 'rs',
-    topology: function(self, _mongo) {
+const f = require('util').format;
+const path = require('path');
+
+const EnvironmentBase = require('mongodb-test-runner').EnvironmentBase;
+const topologyManagers = require('mongodb-test-runner').topologyManagers;
+const ServerManager = topologyManagers.Server;
+const ReplSetManager = topologyManagers.ReplSet;
+const ShardingManager = topologyManagers.Sharded;
+
+class ReplicaSetEnvironment extends EnvironmentBase {
+  constructor() {
+    super();
+
+    this.host = 'localhost';
+    this.port = 31000;
+    this.setName = 'rs';
+    this.topology = (self, _mongo) => {
       return new _mongo.ReplSet([{ host: 'localhost', port: 31000 }], { setName: 'rs' });
-    },
-    manager: new ReplSetManager(
-      'mongod',
-      [
-        {
-          tags: { loc: 'ny' },
-          options: {
-            bind_ip: 'localhost',
-            port: 31000,
-            dbpath: f('%s/../db/31000', __dirname)
-          }
-        },
-        {
-          tags: { loc: 'sf' },
-          options: {
-            bind_ip: 'localhost',
-            port: 31001,
-            dbpath: f('%s/../db/31001', __dirname)
-          }
-        },
-        {
-          tags: { loc: 'sf ' },
-          priority: 0,
-          options: {
-            bind_ip: 'localhost',
-            port: 31002,
-            dbpath: f('%s/../db/31002', __dirname)
-          }
-        },
+    };
+
+    const genReplsetConfig = (port, options) => {
+      return Object.assign(
         {
-          tags: { loc: 'sf' },
           options: {
             bind_ip: 'localhost',
-            port: 31003,
-            dbpath: f('%s/../db/31003', __dirname)
+            port: port,
+            dbpath: `${__dirname}/../db/${port}`
           }
         },
-        {
-          arbiter: true,
-          options: {
-            bind_ip: 'localhost',
-            port: 31004,
-            dbpath: f('%s/../db/31004', __dirname)
-          }
-        }
+        options
+      );
+    };
+
+    this.manager = new ReplSetManager(
+      'mongod',
+      [
+        genReplsetConfig(31000, { tags: { loc: 'ny' } }),
+        genReplsetConfig(31000, { tags: { loc: 'sf' } }),
+        genReplsetConfig(31002, { tags: { loc: 'sf' } }),
+        genReplsetConfig(31003, { tags: { loc: 'sf' } }),
+        genReplsetConfig(31000, { tags: { loc: 'sf' } }),
+        genReplsetConfig(31000, { arbiter: true })
       ],
       {
         replSet: 'rs'
       }
-    )
-  };
-};
-
-var shardedEnvironment = function() {
-  var shardingManager = new ShardingManager({
-    mongod: 'mongod',
-    mongos: 'mongos'
-  });
+    );
+  }
+}
 
-  shardingManager.addShard(
-    [
-      {
-        options: {
-          bind_ip: 'localhost',
-          port: 31000,
-          dbpath: f('%s/../db/31000', __dirname)
-        }
-      },
-      {
-        options: {
-          bind_ip: 'localhost',
-          port: 31001,
-          dbpath: f('%s/../db/31001', __dirname)
-        }
-      },
-      {
-        arbiter: true,
-        options: {
-          bind_ip: 'localhost',
-          port: 31002,
-          dbpath: f('%s/../db/31002', __dirname)
-        }
-      }
-    ],
+const genMongosConfig = (port, options) => {
+  return Object.assign(
     {
-      replSet: 'rs1'
-    }
-  );
-
-  shardingManager.addShard(
-    [
-      {
-        options: {
-          bind_ip: 'localhost',
-          port: 31010,
-          dbpath: f('%s/../db/31010', __dirname)
-        }
-      },
-      {
-        options: {
-          bind_ip: 'localhost',
-          port: 31011,
-          dbpath: f('%s/../db/31011', __dirname)
-        }
-      },
-      {
-        arbiter: true,
-        options: {
-          bind_ip: 'localhost',
-          port: 31012,
-          dbpath: f('%s/../db/31012', __dirname)
-        }
+      options: {
+        bind_ip: 'localhost',
+        port: port,
+        dbpath: `${__dirname}/../db/${port}`,
+        shardsvr: null
       }
-    ],
-    {
-      replSet: 'rs2'
-    }
+    },
+    options
   );
+};
 
-  shardingManager.addConfigurationServers(
-    [
-      {
-        options: {
-          bind_ip: 'localhost',
-          port: 35000,
-          dbpath: f('%s/../db/35000', __dirname)
-        }
-      },
-      {
-        options: {
-          bind_ip: 'localhost',
-          port: 35001,
-          dbpath: f('%s/../db/35001', __dirname)
-        }
-      },
-      {
-        options: {
-          bind_ip: 'localhost',
-          port: 35002,
-          dbpath: f('%s/../db/35002', __dirname)
-        }
-      }
-    ],
+const genConfigServerConfig = (port, options) => {
+  return Object.assign(
     {
-      replSet: 'rs3'
-    }
-  );
-
-  shardingManager.addProxies(
-    [
-      {
-        bind_ip: 'localhost',
-        port: 51000,
-        configdb: 'localhost:35000,localhost:35001,localhost:35002'
-      },
-      {
+      options: {
         bind_ip: 'localhost',
-        port: 51001,
-        configdb: 'localhost:35000,localhost:35001,localhost:35002'
+        port: port,
+        dbpath: `${__dirname}/../db/${port}`
       }
-    ],
-    {
-      binary: 'mongos'
-    }
+    },
+    options
   );
+};
 
-  return {
-    host: 'localhost',
-    port: 51000,
-    topology: function(self, _mongo) {
+class ShardedEnvironment extends EnvironmentBase {
+  constructor() {
+    super();
+
+    this.host = 'localhost';
+    this.port = 51000;
+    this.topology = (self, _mongo) => {
       return new _mongo.Mongos([{ host: 'localhost', port: 51000 }]);
-    },
-    manager: new ShardingManager()
-  };
-};
+    };
 
-var authEnvironment = function() {
-  return {
-    host: 'localhost',
-    port: 27017,
-    manager: new ServerManager('mongod', {
+    this.manager = new ShardingManager({
+      mongod: 'mongod',
+      mongos: 'mongos'
+    });
+  }
+
+  setup(callback) {
+    const shardingManager = this.manager;
+    const shardPromise = Promise.all([
+      shardingManager.addShard(
+        [genMongosConfig(31000), genMongosConfig(31001), genMongosConfig(31002, { arbiter: true })],
+        {
+          replSet: 'rs1'
+        }
+      ),
+      shardingManager.addShard(
+        [genMongosConfig(31010), genMongosConfig(31011), genMongosConfig(31012, { arbiter: true })],
+        {
+          replSet: 'rs2'
+        }
+      )
+    ]);
+
+    shardPromise
+      .then(() =>
+        shardingManager.addConfigurationServers(
+          [
+            genConfigServerConfig(35000),
+            genConfigServerConfig(35001),
+            genConfigServerConfig(35002)
+          ],
+          {
+            replSet: 'rs3'
+          }
+        )
+      )
+      .then(() =>
+        shardingManager.addProxies(
+          [
+            {
+              bind_ip: 'localhost',
+              port: 51000,
+              configdb: 'localhost:35000,localhost:35001,localhost:35002'
+            },
+            {
+              bind_ip: 'localhost',
+              port: 51001,
+              configdb: 'localhost:35000,localhost:35001,localhost:35002'
+            }
+          ],
+          {
+            binary: 'mongos'
+          }
+        )
+      )
+      .then(() => callback())
+      .catch(err => callback(err));
+  }
+}
+
+class AuthEnvironment extends EnvironmentBase {
+  constructor() {
+    super();
+
+    this.host = 'localhost';
+    this.port = 27017;
+    this.manager = new ServerManager('mongod', {
       dbpath: path.join(path.resolve('db'), f('data-%d', 27017)),
       auth: null
-    })
-  };
-};
+    });
+  }
+}
+
+class SingleEnvironment extends EnvironmentBase {
+  constructor() {
+    super();
 
-var singleEnvironment = function() {
-  return {
-    host: 'localhost',
-    port: 27017,
-    manager: new ServerManager('mongod', {
+    this.host = 'localhost';
+    this.port = 27017;
+    this.manager = new ServerManager('mongod', {
       dbpath: path.join(path.resolve('db'), f('data-%d', 27017))
-    })
-  };
-};
+    });
+  }
+}
 
-var snappyEnvironment = function() {
-  return {
-    host: 'localhost',
-    port: 27017,
-    manager: new ServerManager('mongod', {
+class SnappyEnvironment extends EnvironmentBase {
+  constructor() {
+    super();
+
+    this.host = 'localhost';
+    this.port = 27017;
+    this.manager = new ServerManager('mongod', {
       dbpath: path.join(path.resolve('db'), f('data-%d', 27017)),
       networkMessageCompressors: 'snappy'
-    })
-  };
-};
+    });
+  }
+}
 
 module.exports = {
-  single: singleEnvironment,
-  replicaset: replicaSetEnvironment,
-  sharded: shardedEnvironment,
-  auth: authEnvironment,
-  snappy: snappyEnvironment
+  single: SingleEnvironment,
+  replicaset: ReplicaSetEnvironment,
+  sharded: ShardedEnvironment,
+  auth: AuthEnvironment,
+  snappy: SnappyEnvironment
 };