SERVER-22341 fix jslint errors in jstests/libs with eslint --fix

1 files changed, 122 insertions, 122 deletions

diff --git a/jstests/libs/test_background_ops.js b/jstests/libs/test_background_ops.js
index fa634816733..7adf41e9780 100644
--- a/jstests/libs/test_background_ops.js
+++ b/jstests/libs/test_background_ops.js
@@ -7,75 +7,75 @@
  */
 var waitForLock = function( mongo, name ){
     
-    var ts = new ObjectId()
-    var lockColl = mongo.getCollection( "config.testLocks" )
+    var ts = new ObjectId();
+    var lockColl = mongo.getCollection( "config.testLocks" );
     
-    lockColl.update({ _id : name, state : 0 }, { $set : { state : 0 } }, true)
+    lockColl.update({ _id : name, state : 0 }, { $set : { state : 0 } }, true);
     
     //
     // Wait until we can set the state to 1 with our id
     //
     
-    var startTime = new Date().getTime()
+    var startTime = new Date().getTime();
     
     assert.soon( function() {
-        lockColl.update({ _id : name, state : 0 }, { $set : { ts : ts, state : 1 } })
-        var gleObj = lockColl.getDB().getLastErrorObj()
+        lockColl.update({ _id : name, state : 0 }, { $set : { ts : ts, state : 1 } });
+        var gleObj = lockColl.getDB().getLastErrorObj();
         
         if( new Date().getTime() - startTime > 20 * 1000 ){
-            print( "Waiting for..." )
-            printjson( gleObj )
-            printjson( lockColl.findOne() )
-            printjson( ts )
+            print( "Waiting for..." );
+            printjson( gleObj );
+            printjson( lockColl.findOne() );
+            printjson( ts );
         }
         
-        return gleObj.n == 1 || gleObj.updatedExisting
-    }, "could not acquire lock", 30 * 1000, 100 )
+        return gleObj.n == 1 || gleObj.updatedExisting;
+    }, "could not acquire lock", 30 * 1000, 100 );
     
     print( "Acquired lock " + tojson( { _id : name, ts : ts } ) + " curr : " + 
-           tojson( lockColl.findOne({ _id : name }) ) )
+           tojson( lockColl.findOne({ _id : name }) ) );
     
     // Set the state back to 0
     var unlock = function(){
         print( "Releasing lock " + tojson( { _id : name, ts : ts } ) + " curr : " + 
-                tojson( lockColl.findOne({ _id : name }) ) )
-        lockColl.update({ _id : name, ts : ts }, { $set : { state : 0 } })
-    }
+                tojson( lockColl.findOne({ _id : name }) ) );
+        lockColl.update({ _id : name, ts : ts }, { $set : { state : 0 } });
+    };
     
     // Return an object we can invoke unlock on
-    return { unlock : unlock }
-}
+    return { unlock : unlock };
+};
 
 /**
  * Allows a test or background op to say it's finished
  */
 var setFinished = function( mongo, name, finished ){
     if( finished || finished == undefined )
-        mongo.getCollection( "config.testFinished" ).update({ _id : name }, { _id : name }, true )
+        mongo.getCollection( "config.testFinished" ).update({ _id : name }, { _id : name }, true );
     else
-        mongo.getCollection( "config.testFinished" ).remove({ _id : name })
-}
+        mongo.getCollection( "config.testFinished" ).remove({ _id : name });
+};
 
 /**
  * Checks whether a test or background op is finished
  */
 var isFinished = function( mongo, name ){
-    return mongo.getCollection( "config.testFinished" ).findOne({ _id : name }) != null 
-}
+    return mongo.getCollection( "config.testFinished" ).findOne({ _id : name }) != null; 
+};
 
 /**
  * Sets the result of a background op
  */
 var setResult = function( mongo, name, result, err ){
-    mongo.getCollection( "config.testResult" ).update({ _id : name }, { _id : name, result : result, err : err }, true )
-}
+    mongo.getCollection( "config.testResult" ).update({ _id : name }, { _id : name, result : result, err : err }, true );
+};
 
 /**
  * Gets the result for a background op
  */
 var getResult = function( mongo, name ){
-    return mongo.getCollection( "config.testResult" ).findOne({ _id : name })
-}
+    return mongo.getCollection( "config.testResult" ).findOne({ _id : name });
+};
 
 /**
  * Overrides the parallel shell code in mongo
@@ -90,21 +90,21 @@ function startParallelShell( jsCode, port ){
     }
     
     return function(){
-        jsTestLog( "Waiting for shell " + x + "..." )
+        jsTestLog( "Waiting for shell " + x + "..." );
         waitProgram( x );
-        jsTestLog( "Shell " + x + " finished." )
+        jsTestLog( "Shell " + x + " finished." );
     };
 }
 
 startParallelOps = function( mongo, proc, args, context ){
                  
-    var procName = proc.name + "-" + new ObjectId()
+    var procName = proc.name + "-" + new ObjectId();
     var seed = new ObjectId( new ObjectId().valueOf().split("").reverse().join("") )
-                                                                           .getTimestamp().getTime()
+                                                                           .getTimestamp().getTime();
        
     // Make sure we aren't finished before we start
-    setFinished( mongo, procName, false )
-    setResult( mongo, procName, undefined, undefined )
+    setFinished( mongo, procName, false );
+    setResult( mongo, procName, undefined, undefined );
     
     // TODO: Make this a context of its own
     var procContext = { procName : procName,
@@ -117,65 +117,65 @@ startParallelOps = function( mongo, proc, args, context ){
                         setup : function( context, stored ){
                             
                             waitForLock = function(){
-                                return context.waitForLock( db.getMongo(), context.procName )
-                            }
+                                return context.waitForLock( db.getMongo(), context.procName );
+                            };
                             setFinished = function( finished ){
-                                return context.setFinished( db.getMongo(), context.procName, finished )
-                            }
+                                return context.setFinished( db.getMongo(), context.procName, finished );
+                            };
                             isFinished = function(){
-                                return context.isFinished( db.getMongo(), context.procName )
-                            }
+                                return context.isFinished( db.getMongo(), context.procName );
+                            };
                             setResult = function( result, err ){
-                                return context.setResult( db.getMongo(), context.procName, result, err )
-                            }
-                        }}
+                                return context.setResult( db.getMongo(), context.procName, result, err );
+                            };
+                        }};
                     
     var bootstrapper = function( stored ){
                 
-        var procContext = stored.procContext        
-        procContext.setup( procContext, stored )
+        var procContext = stored.procContext;        
+        procContext.setup( procContext, stored );
         
-        var contexts = stored.contexts                                            
-        eval( "contexts = " + contexts )
+        var contexts = stored.contexts;                                            
+        eval( "contexts = " + contexts );
         
         for( var i = 0; i < contexts.length; i++ ){
             if( typeof( contexts[i] ) != "undefined" ){                
                 // Evaluate all contexts
-                contexts[i]( procContext )
+                contexts[i]( procContext );
             }
         }
         
-        var operation = stored.operation
-        eval( "operation = " + operation )
+        var operation = stored.operation;
+        eval( "operation = " + operation );
         
-        var args = stored.args
-        eval( "args = " + args )
+        var args = stored.args;
+        eval( "args = " + args );
         
-        result = undefined
-        err = undefined
+        result = undefined;
+        err = undefined;
         
         try{
-            result = operation.apply( null, args )
+            result = operation.apply( null, args );
         }
         catch( e ){
-            err = e 
+            err = e; 
         }
         
-        setResult( result, err )
-    }
+        setResult( result, err );
+    };
     
-    var contexts = [ RandomFunctionContext, context ]
+    var contexts = [ RandomFunctionContext, context ];
     
-    var testDataColl = mongo.getCollection( "config.parallelTest" )
+    var testDataColl = mongo.getCollection( "config.parallelTest" );
     
     testDataColl.insert({ _id : procName,
                           bootstrapper : tojson( bootstrapper ),
                           operation : tojson( proc ),
                           args : tojson( args ),
                           procContext : procContext,
-                          contexts : tojson( contexts ) })
+                          contexts : tojson( contexts ) });
                           
-    assert.eq( null, testDataColl.getDB().getLastError() )
+    assert.eq( null, testDataColl.getDB().getLastError() );
     
     var bootstrapStartup =
         "{ var procName = '" + procName + "'; " +    
@@ -184,7 +184,7 @@ startParallelOps = function( mongo, proc, args, context ){
           "var bootstrapper = stored.bootstrapper; " +
           "eval( 'bootstrapper = ' + bootstrapper ); " +
           "bootstrapper( stored ); " +
-        "}"
+        "}";
     
     // Save the global db object if it exists, so that we can restore it after starting the parallel
     // shell.
@@ -192,94 +192,94 @@ startParallelOps = function( mongo, proc, args, context ){
     if (typeof db !== 'undefined') {
         oldDB = db;
     }
-    db = mongo.getDB( "test" )
+    db = mongo.getDB( "test" );
     
-    jsTest.log( "Starting " + proc.name + " operations..." )
+    jsTest.log( "Starting " + proc.name + " operations..." );
     
-    var rawJoin = startParallelShell( bootstrapStartup )
+    var rawJoin = startParallelShell( bootstrapStartup );
                                
-    db = oldDB
+    db = oldDB;
           
     
     var join = function(){ 
-        setFinished( mongo, procName, true )
+        setFinished( mongo, procName, true );
         
         rawJoin();
-        result = getResult( mongo, procName )
+        result = getResult( mongo, procName );
                            
-        assert.neq( result, null )                 
+        assert.neq( result, null );                 
                            
         if( result.err ) throw Error("Error in parallel ops " + procName + " : "
-                                                        + tojson( result.err ) )
+                                                        + tojson( result.err ) );
                                                         
-        else return result.result
-    }
+        else return result.result;
+    };
     
     join.isFinished = function(){
-        return isFinished( mongo, procName )
-    }
+        return isFinished( mongo, procName );
+    };
     
     join.setFinished = function( finished ){
-        return setFinished( mongo, procName, finished )
-    }
+        return setFinished( mongo, procName, finished );
+    };
     
     join.waitForLock = function( name ){
-        return waitForLock( mongo, name )
-    }
+        return waitForLock( mongo, name );
+    };
     
-    return join
-}
+    return join;
+};
 
 var RandomFunctionContext = function( context ){
     
     Random.srand( context.seed );
     
-    Random.randBool = function(){ return Random.rand() > 0.5 }
+    Random.randBool = function(){ return Random.rand() > 0.5; };
     
     Random.randInt = function( min, max ){ 
         
         if( max == undefined ){
-            max = min
-            min = 0
+            max = min;
+            min = 0;
         }
         
-        return min + Math.floor( Random.rand() * max ) 
-    }
+        return min + Math.floor( Random.rand() * max ); 
+    };
     
     Random.randShardKey = function(){
         
-        var numFields = 2 //Random.randInt(1, 3)
+        var numFields = 2; //Random.randInt(1, 3)
         
-        var key = {}
+        var key = {};
         for( var i = 0; i < numFields; i++ ){
-            var field = String.fromCharCode( "a".charCodeAt() + i )
-            key[ field ] = 1
+            var field = String.fromCharCode( "a".charCodeAt() + i );
+            key[ field ] = 1;
         }
         
-        return key
-    }
+        return key;
+    };
     
     Random.randShardKeyValue = function( shardKey ){
         
-        var keyValue = {}
+        var keyValue = {};
         for( field in shardKey ){
-            keyValue[ field ] = Random.randInt(1, 100)
+            keyValue[ field ] = Random.randInt(1, 100);
         }
         
-        return keyValue
-    }
+        return keyValue;
+    };
     
     Random.randCluster = function(){
 
-        var numShards = 2 //Random.randInt( 1, 10 )
-        var rs = false //Random.randBool()
+        var numShards = 2; //Random.randInt( 1, 10 )
+        var rs = false; //Random.randBool()
         var st = new ShardingTest({ shards : numShards, 
                                     mongos : 4, 
-                                    other : { rs : rs } })
+                                    other : { rs : rs } });
         
-        return st
-    }
-}
+        return st;
+    };
+};
 
 
 //
@@ -288,57 +288,57 @@ var RandomFunctionContext = function( context ){
 
 function moveOps( collName, options ){
     
-    options = options || {}
+    options = options || {};
     
-    var admin = db.getMongo().getDB( "admin" )
-    var config = db.getMongo().getDB( "config" )
-    var shards = config.shards.find().toArray()
-    var shardKey = config.collections.findOne({ _id : collName }).key
+    var admin = db.getMongo().getDB( "admin" );
+    var config = db.getMongo().getDB( "config" );
+    var shards = config.shards.find().toArray();
+    var shardKey = config.collections.findOne({ _id : collName }).key;
     
     while( ! isFinished() ){
         
-        var findKey = Random.randShardKeyValue( shardKey )
-        var toShard = shards[ Random.randInt( shards.length ) ]._id
+        var findKey = Random.randShardKeyValue( shardKey );
+        var toShard = shards[ Random.randInt( shards.length ) ]._id;
         
         try {
             printjson( admin.runCommand({ moveChunk : collName, 
                                           find : findKey,
-                                          to : toShard }) )
+                                          to : toShard }) );
         }
         catch( e ){
-            printjson( e )
+            printjson( e );
         }
         
-        sleep( 1000 )
+        sleep( 1000 );
     }
     
-    jsTest.log( "Stopping moveOps..." )
+    jsTest.log( "Stopping moveOps..." );
 }
 
 function splitOps( collName, options ){
         
-    options = options || {}
+    options = options || {};
     
-    var admin = db.getMongo().getDB( "admin" )
-    var config = db.getMongo().getDB( "config" )
-    var shards = config.shards.find().toArray()
-    var shardKey = config.collections.findOne({ _id : collName }).key
+    var admin = db.getMongo().getDB( "admin" );
+    var config = db.getMongo().getDB( "config" );
+    var shards = config.shards.find().toArray();
+    var shardKey = config.collections.findOne({ _id : collName }).key;
     
     while( ! isFinished() ){
         
-        var middleKey = Random.randShardKeyValue( shardKey )
+        var middleKey = Random.randShardKeyValue( shardKey );
         
         try {
             printjson( admin.runCommand({ split : collName, 
-                                          middle : middleKey }) )
+                                          middle : middleKey }) );
         }
         catch( e ){
-            printjson( e )
+            printjson( e );
         }
         
-        sleep( 1000 )
+        sleep( 1000 );
     }
     
-    jsTest.log( "Stopping splitOps..." )
+    jsTest.log( "Stopping splitOps..." );
 }