mongodb/jstests/sharding/change_streams_whole_db.js

// Tests the behavior of a change stream on a whole database in a sharded cluster.
// @tags: [uses_change_streams]
(function() {
"use strict";

load('jstests/replsets/libs/two_phase_drops.js');  // For TwoPhaseDropCollectionTest.
load('jstests/aggregation/extras/utils.js');       // For assertErrorCode().
load('jstests/libs/change_stream_util.js');        // For ChangeStreamTest.
load("jstests/libs/collection_drop_recreate.js");  // For assertDropCollection.

// For supportsMajorityReadConcern().
load("jstests/multiVersion/libs/causal_consistency_helpers.js");

if (!supportsMajorityReadConcern()) {
    jsTestLog("Skipping test since storage engine doesn't support majority read concern.");
    return;
}

const st = new ShardingTest({
    shards: 2,
    rs: {
        nodes: 1,
        // Use a higher frequency for periodic noops to speed up the test.
        setParameter: {periodicNoopIntervalSecs: 1, writePeriodicNoops: true}
    }
});

const mongosDB = st.s0.getDB("test");
const mongosColl = mongosDB[jsTestName()];

let cst = new ChangeStreamTest(mongosDB);
let cursor = cst.startWatchingChanges({pipeline: [{$changeStream: {}}], collection: 1});

// Test that if there are no changes, we return an empty batch.
assert.eq(0, cursor.firstBatch.length, "Cursor had changes: " + tojson(cursor));

// Test that the change stream returns operations on the unsharded test collection.
assert.writeOK(mongosColl.insert({_id: 0}));
let expected = {
    documentKey: {_id: 0},
    fullDocument: {_id: 0},
    ns: {db: mongosDB.getName(), coll: mongosColl.getName()},
    operationType: "insert",
};
cst.assertNextChangesEqual({cursor: cursor, expectedChanges: [expected]});

// Create a new sharded collection.
mongosDB.createCollection(jsTestName() + "_sharded_on_x");
const mongosCollShardedOnX = mongosDB[jsTestName() + "_sharded_on_x"];

// Shard, split, and move one chunk to shard1.
st.shardColl(mongosCollShardedOnX.getName(), {x: 1}, {x: 0}, {x: 1}, mongosDB.getName());

// Write a document to each chunk.
assert.writeOK(mongosCollShardedOnX.insert({_id: 0, x: -1}));
assert.writeOK(mongosCollShardedOnX.insert({_id: 1, x: 1}));

// Verify that the change stream returns both inserts.
expected = [
    {
        documentKey: {_id: 0, x: -1},
        fullDocument: {_id: 0, x: -1},
        ns: {db: mongosDB.getName(), coll: mongosCollShardedOnX.getName()},
        operationType: "insert",
    },
    {
        documentKey: {_id: 1, x: 1},
        fullDocument: {_id: 1, x: 1},
        ns: {db: mongosDB.getName(), coll: mongosCollShardedOnX.getName()},
        operationType: "insert",
    }
];
cst.assertNextChangesEqual({cursor: cursor, expectedChanges: expected});

// Now send inserts to both the sharded and unsharded collections, and verify that the change
// streams returns them in order.
assert.writeOK(mongosCollShardedOnX.insert({_id: 2, x: 2}));
assert.writeOK(mongosColl.insert({_id: 1}));

// Verify that the change stream returns both inserts.
expected = [
    {
        documentKey: {_id: 2, x: 2},
        fullDocument: {_id: 2, x: 2},
        ns: {db: mongosDB.getName(), coll: mongosCollShardedOnX.getName()},
        operationType: "insert",
    },
    {
        documentKey: {_id: 1},
        fullDocument: {_id: 1},
        ns: {db: mongosDB.getName(), coll: mongosColl.getName()},
        operationType: "insert",
    }
];
cst.assertNextChangesEqual({cursor: cursor, expectedChanges: expected});

// Create a third sharded collection with a compound shard key.
mongosDB.createCollection(jsTestName() + "_sharded_compound");
const mongosCollShardedCompound = mongosDB[jsTestName() + "_sharded_compound"];

// Shard, split, and move one chunk to shard1.
st.shardColl(mongosCollShardedCompound.getName(),
             {y: 1, x: 1},
             {y: 1, x: MinKey},
             {y: 1, x: MinKey},
             mongosDB.getName());

// Write a document to each chunk.
assert.writeOK(mongosCollShardedCompound.insert({_id: 0, y: -1, x: 0}));
assert.writeOK(mongosCollShardedCompound.insert({_id: 1, y: 1, x: 0}));

// Verify that the change stream returns both inserts.
expected = [
    {
        documentKey: {_id: 0, y: -1, x: 0},
        fullDocument: {_id: 0, y: -1, x: 0},
        ns: {db: mongosDB.getName(), coll: mongosCollShardedCompound.getName()},
        operationType: "insert",
    },
    {
        documentKey: {_id: 1, y: 1, x: 0},
        fullDocument: {_id: 1, y: 1, x: 0},
        ns: {db: mongosDB.getName(), coll: mongosCollShardedCompound.getName()},
        operationType: "insert",
    }
];
cst.assertNextChangesEqual({cursor: cursor, expectedChanges: expected});

// Send inserts to all 3 collections and verify that the results contain the correct
// documentKeys and are in the correct order.
assert.writeOK(mongosCollShardedOnX.insert({_id: 3, x: 3}));
assert.writeOK(mongosColl.insert({_id: 3}));
assert.writeOK(mongosCollShardedCompound.insert({_id: 2, x: 0, y: -2}));

// Verify that the change stream returns both inserts.
expected = [
    {
        documentKey: {_id: 3, x: 3},
        fullDocument: {_id: 3, x: 3},
        ns: {db: mongosDB.getName(), coll: mongosCollShardedOnX.getName()},
        operationType: "insert",
    },
    {
        documentKey: {_id: 3},
        fullDocument: {_id: 3},
        ns: {db: mongosDB.getName(), coll: mongosColl.getName()},
        operationType: "insert",
    },
    {
        documentKey: {_id: 2, x: 0, y: -2},
        fullDocument: {_id: 2, x: 0, y: -2},
        ns: {db: mongosDB.getName(), coll: mongosCollShardedCompound.getName()},
        operationType: "insert",
    },
];

const results = cst.assertNextChangesEqual({cursor: cursor, expectedChanges: expected});
// Store the resume token of the first insert to use after dropping the collection.
const resumeTokenBeforeDrop = results[0]._id;

// Write one more document to the collection that will be dropped, to be returned after
// resuming.
assert.writeOK(mongosCollShardedOnX.insert({_id: 4, x: 4}));

// Drop the collection, invalidating the open change stream.
assertDropCollection(mongosDB, mongosCollShardedOnX.getName());

// Resume the change stream from before the collection drop, and verify that the documentKey
// field contains the extracted shard key from the resume token.
cursor = cst.startWatchingChanges({
    pipeline: [
        {$changeStream: {resumeAfter: resumeTokenBeforeDrop}},
        {$match: {"ns.coll": mongosCollShardedOnX.getName()}}
    ],
    collection: 1
});
cst.assertNextChangesEqual({
    cursor: cursor,
    expectedChanges: [
        {
            documentKey: {_id: 4, x: 4},
            fullDocument: {_id: 4, x: 4},
            ns: {db: mongosDB.getName(), coll: mongosCollShardedOnX.getName()},
            operationType: "insert",
        },
    ]
});

cst.cleanUp();

st.stop();
})();