SERVER-22468 Format JS code with approved style in jstests/

1 files changed, 128 insertions, 94 deletions

diff --git a/jstests/core/batch_write_command_update.js b/jstests/core/batch_write_command_update.js
index 00964131efe..2d9d2d699b2 100644
--- a/jstests/core/batch_write_command_update.js
+++ b/jstests/core/batch_write_command_update.js
@@ -2,7 +2,7 @@
 // Ensures that mongod respects the batch write protocols for updates
 //
 
-var coll = db.getCollection( "batch_write_update" );
+var coll = db.getCollection("batch_write_update");
 coll.drop();
 
 assert(coll.getDB().getMongo().useWriteCommands(), "test is not running with write commands");
@@ -13,18 +13,13 @@ var batch;
 
 var maxWriteBatchSize = 1000;
 
-function resultOK( result ) {
-    return result.ok &&
-           !( 'code' in result ) &&
-           !( 'errmsg' in result ) &&
-           !( 'errInfo' in result ) &&
-           !( 'writeErrors' in result );
+function resultOK(result) {
+    return result.ok && !('code' in result) && !('errmsg' in result) && !('errInfo' in result) &&
+        !('writeErrors' in result);
 }
 
-function resultNOK( result ) {
-    return !result.ok &&
-           typeof( result.code ) == 'number' &&
-           typeof( result.errmsg ) == 'string';
+function resultNOK(result) {
+    return !result.ok && typeof(result.code) == 'number' && typeof(result.errmsg) == 'string';
 }
 
 // EACH TEST BELOW SHOULD BE SELF-CONTAINED, FOR EASIER DEBUGGING
@@ -32,19 +27,23 @@ function resultNOK( result ) {
 //
 // NO DOCS, illegal command
 coll.remove({});
-request = { update: coll.getName() };
+request = {
+    update: coll.getName()
+};
 result = coll.runCommand(request);
 assert(resultNOK(result), tojson(result));
 
 //
 // Single document upsert, no write concern specified
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 1 }, u: { $set: { a: 1 }}, upsert: true }]};
+request = {
+    update: coll.getName(),
+    updates: [{q: {a: 1}, u: {$set: {a: 1}}, upsert: true}]
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(1, result.n);
-assert( 'upserted' in result );
+assert('upserted' in result);
 assert.eq(1, result.upserted.length);
 assert.eq(0, result.upserted[0].index);
 
@@ -56,13 +55,15 @@ assert.eq(0, result.nModified, "missing/wrong nModified");
 //
 // Single document upsert, write concern specified, no ordered specified
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 1 }, u: { $set: { a: 1 }}, upsert: true }],
-                      writeConcern: { w: 1 }};
+request = {
+    update: coll.getName(),
+    updates: [{q: {a: 1}, u: {$set: {a: 1}}, upsert: true}],
+    writeConcern: {w: 1}
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(1, result.n);
-assert( 'upserted' in result );
+assert('upserted' in result);
 assert.eq(1, result.upserted.length);
 assert.eq(0, result.upserted[0].index);
 
@@ -74,14 +75,16 @@ assert.eq(0, result.nModified, "missing/wrong nModified");
 //
 // Single document upsert, write concern specified, ordered = true
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 1 }, u: { $set: { a: 1 }}, upsert: true }],
-            writeConcern: { w: 1 },
-            ordered: true };
+request = {
+    update: coll.getName(),
+    updates: [{q: {a: 1}, u: {$set: {a: 1}}, upsert: true}],
+    writeConcern: {w: 1},
+    ordered: true
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(1, result.n);
-assert( 'upserted' in result );
+assert('upserted' in result);
 assert.eq(1, result.upserted.length);
 assert.eq(0, result.upserted[0].index);
 
@@ -93,13 +96,15 @@ assert.eq(0, result.nModified, "missing/wrong nModified");
 //
 // Single document upsert, write concern 0 specified, ordered = true
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 1 }, u: { $set: { a: 1 }}, upsert: true }],
-            writeConcern: { w: 0 },
-            ordered: true };
+request = {
+    update: coll.getName(),
+    updates: [{q: {a: 1}, u: {$set: {a: 1}}, upsert: true}],
+    writeConcern: {w: 0},
+    ordered: true
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
-assert.eq(1, coll.count({ }));
+assert.eq(1, coll.count({}));
 
 for (var field in result) {
     assert.eq('ok', field, 'unexpected field found in result: ' + field);
@@ -108,11 +113,15 @@ for (var field in result) {
 //
 // Two document upsert, write concern 0 specified, ordered = true
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 2 }, u: { $set: { a: 1 }}, upsert: true },
-                      { q: { a: 2 }, u: { $set: { a: 2 }}, upsert: true }],
-            writeConcern: { w: 0 },
-            ordered: true };
+request = {
+    update: coll.getName(),
+    updates: [
+        {q: {a: 2}, u: {$set: {a: 1}}, upsert: true},
+        {q: {a: 2}, u: {$set: {a: 2}}, upsert: true}
+    ],
+    writeConcern: {w: 0},
+    ordered: true
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(2, coll.count());
@@ -124,10 +133,12 @@ for (var field in result) {
 //
 // Single document update
 coll.remove({});
-coll.insert({a:1});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 1 }, u: { $set: { c: 1 }}}],
-            writeConcern: { w: 1 }};
+coll.insert({a: 1});
+request = {
+    update: coll.getName(),
+    updates: [{q: {a: 1}, u: {$set: {c: 1}}}],
+    writeConcern: {w: 1}
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(1, result.n);
@@ -138,12 +149,16 @@ assert.eq(1, result.nModified, "missing/wrong nModified");
 //
 // Multi document update/upsert
 coll.remove({});
-coll.insert({b:1});
-request = { update: coll.getName(),
-            updates: [{ q: { b: 1 }, u: { $set: { b: 1, a: 1 }}, upsert: true },
-                      { q: { b: 2 }, u: { $set: { b: 2, a: 1 }}, upsert: true }],
-            writeConcern: { w: 1 },
-            ordered: false };
+coll.insert({b: 1});
+request = {
+    update: coll.getName(),
+    updates: [
+        {q: {b: 1}, u: {$set: {b: 1, a: 1}}, upsert: true},
+        {q: {b: 2}, u: {$set: {b: 2, a: 1}}, upsert: true}
+    ],
+    writeConcern: {w: 1},
+    ordered: false
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(2, result.n);
@@ -157,86 +172,97 @@ assert.eq(2, coll.count());
 //
 // Multiple document update
 coll.remove({});
-coll.insert({a:1});
-coll.insert({a:1});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 1 }, u: { $set: { c: 2 }}, multi: true }],
-            writeConcern: { w: 1 },
-            ordered: false };
+coll.insert({a: 1});
+coll.insert({a: 1});
+request = {
+    update: coll.getName(),
+    updates: [{q: {a: 1}, u: {$set: {c: 2}}, multi: true}],
+    writeConcern: {w: 1},
+    ordered: false
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(2, result.n);
 assert.eq(2, result.nModified, "missing/wrong nModified");
-assert.eq(2, coll.find({a:1, c:2}).count());
+assert.eq(2, coll.find({a: 1, c: 2}).count());
 assert.eq(2, coll.count());
 
 //
-//Multiple document update, some no-ops
+// Multiple document update, some no-ops
 coll.remove({});
-coll.insert({a:1, c:2});
-coll.insert({a:1});
-request = { update: coll.getName(),
-            updates: [{ q: { a: 1 }, u: { $set: { c: 2 }}, multi: true }],
-            writeConcern: { w: 1 },
-            ordered: false };
-printjson( result = coll.runCommand(request) );
+coll.insert({a: 1, c: 2});
+coll.insert({a: 1});
+request = {
+    update: coll.getName(),
+    updates: [{q: {a: 1}, u: {$set: {c: 2}}, multi: true}],
+    writeConcern: {w: 1},
+    ordered: false
+};
+printjson(result = coll.runCommand(request));
 assert(resultOK(result), tojson(result));
 assert.eq(2, result.n);
 assert.eq(1, result.nModified, "missing/wrong nModified");
-assert.eq(2, coll.find({a:1, c:2}).count());
+assert.eq(2, coll.find({a: 1, c: 2}).count());
 assert.eq(2, coll.count());
 
 //
 // Large batch under the size threshold should update successfully
 coll.remove({});
-coll.insert({a:0});
+coll.insert({a: 0});
 batch = [];
 for (var i = 0; i < maxWriteBatchSize; ++i) {
-    batch.push({q:{}, u: {$inc: {a:1}}});
+    batch.push({q: {}, u: {$inc: {a: 1}}});
 }
-request = { update: coll.getName(),
-            updates: batch,
-            writeConcern: { w: 1 },
-            ordered: false };
+request = {
+    update: coll.getName(),
+    updates: batch,
+    writeConcern: {w: 1},
+    ordered: false
+};
 result = coll.runCommand(request);
 assert(resultOK(result), tojson(result));
 assert.eq(batch.length, result.n);
 assert.eq(batch.length, result.nModified, "missing/wrong nModified");
-assert.eq(1, coll.find({a:batch.length}).count());
+assert.eq(1, coll.find({a: batch.length}).count());
 assert.eq(1, coll.count());
 
 //
 // Large batch above the size threshold should fail to update
 coll.remove({});
-coll.insert({a:0});
+coll.insert({a: 0});
 batch = [];
 for (var i = 0; i < maxWriteBatchSize + 1; ++i) {
-    batch.push({q:{}, u: {$inc: {a:1}}});
+    batch.push({q: {}, u: {$inc: {a: 1}}});
 }
-request = { update: coll.getName(),
-            updates: batch,
-            writeConcern: { w: 1 },
-            ordered: false };
+request = {
+    update: coll.getName(),
+    updates: batch,
+    writeConcern: {w: 1},
+    ordered: false
+};
 result = coll.runCommand(request);
 assert(resultNOK(result), tojson(result));
-assert.eq(1, coll.find({a:0}).count());
+assert.eq(1, coll.find({a: 0}).count());
 assert.eq(1, coll.count());
 
-
 //
 //
 // Unique index tests
 coll.remove({});
-coll.ensureIndex({a : 1}, {unique : true});
+coll.ensureIndex({a: 1}, {unique: true});
 
 //
 // Upsert fail due to duplicate key index, w:0, ordered:true
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { b: 1 }, u: { $set: { b: 1, a: 1 }}, upsert: true },
-                      { q: { b: 2 }, u: { $set: { b: 2, a: 1 }}, upsert: true }],
-            writeConcern: { w: 0 },
-            ordered: true };
+request = {
+    update: coll.getName(),
+    updates: [
+        {q: {b: 1}, u: {$set: {b: 1, a: 1}}, upsert: true},
+        {q: {b: 2}, u: {$set: {b: 2, a: 1}}, upsert: true}
+    ],
+    writeConcern: {w: 0},
+    ordered: true
+};
 result = coll.runCommand(request);
 assert(result.ok, tojson(result));
 assert.eq(1, coll.count());
@@ -248,12 +274,16 @@ for (var field in result) {
 //
 // Upsert fail due to duplicate key index, w:1, ordered:true
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { b: 1 }, u: { $set: { b: 1, a: 1 }}, upsert: true },
-                      { q: { b: 3 }, u: { $set: { b: 3, a: 2 }}, upsert: true },
-                      { q: { b: 2 }, u: { $set: { b: 2, a: 1 }}, upsert: true }],
-            writeConcern: { w: 1 },
-            ordered: true };
+request = {
+    update: coll.getName(),
+    updates: [
+        {q: {b: 1}, u: {$set: {b: 1, a: 1}}, upsert: true},
+        {q: {b: 3}, u: {$set: {b: 3, a: 2}}, upsert: true},
+        {q: {b: 2}, u: {$set: {b: 2, a: 1}}, upsert: true}
+    ],
+    writeConcern: {w: 1},
+    ordered: true
+};
 result = coll.runCommand(request);
 assert(result.ok, tojson(result));
 assert.eq(2, result.n);
@@ -274,13 +304,17 @@ assert.eq(1, coll.count({_id: result.upserted[1]._id}));
 //
 // Upsert fail due to duplicate key index, w:1, ordered:false
 coll.remove({});
-request = { update: coll.getName(),
-            updates: [{ q: { b: 1 }, u: { $set: { b: 1, a: 1 }}, upsert: true },
-                      { q: { b: 2 }, u: { $set: { b: 2, a: 1 }}, upsert: true },
-                      { q: { b: 2 }, u: { $set: { b: 2, a: 1 }}, upsert: true },
-                      { q: { b: 3 }, u: { $set: { b: 3, a: 3 }}, upsert: true }],
-            writeConcern: { w: 1 },
-            ordered: false };
+request = {
+    update: coll.getName(),
+    updates: [
+        {q: {b: 1}, u: {$set: {b: 1, a: 1}}, upsert: true},
+        {q: {b: 2}, u: {$set: {b: 2, a: 1}}, upsert: true},
+        {q: {b: 2}, u: {$set: {b: 2, a: 1}}, upsert: true},
+        {q: {b: 3}, u: {$set: {b: 3, a: 3}}, upsert: true}
+    ],
+    writeConcern: {w: 1},
+    ordered: false
+};
 result = coll.runCommand(request);
 assert(result.ok, tojson(result));
 assert.eq(2, result.n);