text: // In MongoDB 3.4, $graphLookup was introduced. In this file, we test basic behavior and correctness
  // of the stage.
  
  (function() {
      "use strict";
  
      var local = db.local;
      var foreign = db.foreign;
  
      local.drop();
      foreign.drop();
  
      // Ensure a $graphLookup works even if one of the involved collections doesn't exist.
      const basicGraphLookup = {
          $graphLookup: {
              from: "foreign",
              startWith: "$starting",
              connectFromField: "from",
              connectToField: "to",
              as: "results"
          }
      };
  
      assert.eq(
          local.aggregate([basicGraphLookup]).toArray().length,
          0,
          "expected an empty result set for a $graphLookup with non-existent local and foreign " +
              "collections");
  
      assert.writeOK(foreign.insert({}));
  
      assert.eq(local.aggregate([basicGraphLookup]).toArray().length,
                0,
                "expected an empty result set for a $graphLookup on a non-existent local collection");
  
      local.drop();
      foreign.drop();
  
      assert.writeOK(local.insert({_id: 0}));
  
      assert.eq(local.aggregate([basicGraphLookup]).toArray(),
                [{_id: 0, results: []}],
                "expected $graphLookup to succeed with a non-existent foreign collection");
  
      local.drop();
      foreign.drop();
  
      var bulk = foreign.initializeUnorderedBulkOp();
      for (var i = 0; i < 100; i++) {
          bulk.insert({_id: i, neighbors: [i - 1, i + 1]});
      }
      assert.writeOK(bulk.execute());
  
      assert.writeOK(local.insert({starting: 50}));
  
      // Perform a simple $graphLookup and ensure it retrieves every result.
      var res = local
                    .aggregate({
                        $graphLookup: {
                            from: "foreign",
                            startWith: "$starting",
                            connectFromField: "neighbors",
                            connectToField: "_id",
                            as: "integers"
                        }
                    })
                    .toArray()[0];
  
      assert.eq(res.integers.length, 100);
  
      // Perform a $graphLookup and ensure it respects "maxDepth".
      res = local
                .aggregate({
                    $graphLookup: {
                        from: "foreign",
                        startWith: "$starting",
                        connectFromField: "neighbors",
                        connectToField: "_id",
                        maxDepth: 5,
                        as: "integers"
                    }
                })
                .toArray()[0];
  
      // At depth zero, we retrieve one integer, and two for every depth thereafter.
      assert.eq(res.integers.length, 11);
  
      // Perform a $graphLookup and ensure it properly evaluates "startWith".
      res = local
                .aggregate({
                    $graphLookup: {
                        from: "foreign",
                        startWith: {$add: ["$starting", 3]},
                        connectFromField: "neighbors",
                        connectToField: "_id",
                        maxDepth: 0,
                        as: "integers"
                    }
                })
                .toArray()[0];
  
      assert.eq(res.integers.length, 1);
      assert.eq(res.integers[0]._id, 53);
  
      // Perform a $graphLookup and ensure it properly expands "startWith".
      res = local
                .aggregate({
                    $graphLookup: {
                        from: "foreign",
                        startWith: {$literal: [1, 2, 3]},
                        connectFromField: "neighbors",
                        connectToField: "_id",
                        maxDepth: 0,
                        as: "integers"
                    }
                })
                .toArray()[0];
  
      assert.eq(res.integers.length, 3);
  
      // $graphLookup should not recurse when the 'connectFromField' is missing. However, if it
      // mistakenly does, then it would look for a 'connectToField' value of null. In order to prevent
      // regressions, we insert a document with a 'connectToField' value of null, then perform a
      // $graphLookup, and ensure that we do not find the erroneous document.
      assert.writeOK(foreign.remove({_id: 51}));
      assert.writeOK(foreign.insert({_id: 51}));
      assert.writeOK(foreign.insert({_id: null, neighbors: [50, 52]}));
  
      res = local
                .aggregate({
                    $graphLookup: {
                        from: "foreign",
                        startWith: "$starting",
                        connectFromField: "neighbors",
                        connectToField: "_id",
                        as: "integers"
                    }
                })
                .toArray()[0];
  
      // Our result should be missing the values with _id from 52 to 99.
      assert.eq(res.integers.length, 52);
  
      // Perform a $graphLookup and ensure we don't go into an infinite loop when our graph is cyclic.
      assert.writeOK(foreign.remove({_id: {$in: [null, 51]}}));
      assert.writeOK(foreign.insert({_id: 51, neighbors: [50, 52]}));
  
      assert.writeOK(foreign.update({_id: 99}, {$set: {neighbors: [98, 0]}}));
      assert.writeOK(foreign.update({_id: 0}, {$set: {neighbors: [99, 1]}}));
  
      res = local
                .aggregate({
                    $graphLookup: {
                        from: "foreign",
                        startWith: "$starting",
                        connectFromField: "neighbors",
                        connectToField: "_id",
                        as: "integers"
                    }
                })
                .toArray()[0];
  
      assert.eq(res.integers.length, 100);
  
      // Perform a $graphLookup and ensure that "depthField" is properly populated.
      res = local
                .aggregate({
                    $graphLookup: {
                        from: "foreign",
                        startWith: "$starting",
                        connectFromField: "neighbors",
                        connectToField: "_id",
                        depthField: "distance",
                        as: "integers"
                    }
                })
                .toArray()[0];
  
      assert.eq(res.integers.length, 100);
  
      res.integers.forEach(function(n) {
          assert.eq(n.distance, Math.abs(50 - n._id));
      });
  }());
  