// Tests writeConcern metrics in the serverStatus output.
// @tags: [requires_persistence, requires_journaling, requires_replication]
(function() {
    "use strict";

    // Verifies that the server status response has the fields that we expect.
    function verifyServerStatusFields(serverStatusResponse) {
        assert(serverStatusResponse.hasOwnProperty("opWriteConcernCounters"),
               "Expected the serverStatus response to have a 'opWriteConcernCounters' field\n" +
                   tojson(serverStatusResponse));
        assert(
            serverStatusResponse.opWriteConcernCounters.hasOwnProperty("insert"),
            "The 'opWriteConcernCounters' field in serverStatus did not have the 'insert' field\n" +
                tojson(serverStatusResponse.opWriteConcernCounters));
        assert(
            serverStatusResponse.opWriteConcernCounters.hasOwnProperty("update"),
            "The 'opWriteConcernCounters' field in serverStatus did not have the 'update' field\n" +
                tojson(serverStatusResponse.opWriteConcernCounters));
        assert(
            serverStatusResponse.opWriteConcernCounters.hasOwnProperty("delete"),
            "The 'opWriteConcernCounters' field in serverStatus did not have the 'delete' field\n" +
                tojson(serverStatusResponse.opWriteConcernCounters));
    }

    // Verifies that the given path of the server status response is incremented in the way we
    // expect, and no other changes occurred. This function modifies its inputs.
    function verifyServerStatusChange(initialStats, newStats, path, expectedIncrement) {
        // Traverse to the parent of the changed element.
        let pathComponents = path.split(".");
        let initialParent = initialStats;
        let newParent = newStats;
        for (let i = 0; i < pathComponents.length - 1; i++) {
            assert(initialParent.hasOwnProperty(pathComponents[i]),
                   "initialStats did not contain component " + i + " of path " + path +
                       ", initialStats: " + tojson(initialStats));
            initialParent = initialParent[pathComponents[i]];

            assert(newParent.hasOwnProperty(pathComponents[i]),
                   "newStats did not contain component " + i + " of path " + path + ", newStats: " +
                       tojson(newStats));
            newParent = newParent[pathComponents[i]];
        }

        // Test the expected increment of the changed element. The element may not exist in the
        // initial stats, in which case it is treated as 0.
        let lastPathComponent = pathComponents[pathComponents.length - 1];
        let initialValue = 0;
        if (initialParent.hasOwnProperty(lastPathComponent)) {
            initialValue = initialParent[lastPathComponent];
        }
        assert(newParent.hasOwnProperty(lastPathComponent),
               "newStats did not contain last component of path " + path + ", newStats: " +
                   tojson(newStats));
        assert.eq(initialValue + expectedIncrement,
                  newParent[lastPathComponent],
                  "expected " + path + " to increase by " + expectedIncrement + ", initialStats: " +
                      tojson(initialStats) + ", newStats: " + tojson(newStats));

        // Delete the changed element.
        delete initialParent[lastPathComponent];
        delete newParent[lastPathComponent];

        // The stats objects should be equal without the changed element.
        assert.eq(0,
                  bsonWoCompare(initialStats, newStats),
                  "expected initialStats and newStats to be equal after removing " + path +
                      ", initialStats: " + tojson(initialStats) + ", newStats: " +
                      tojson(newStats));
    }

    const rst = new ReplSetTest(
        {nodes: 2, nodeOptions: {setParameter: 'reportOpWriteConcernCountersInServerStatus=true'}});
    rst.startSet();
    let config = rst.getReplSetConfig();
    config.members[1].priority = 0;
    config.members[0].tags = {dc_va: "rack1"};
    config.settings = {getLastErrorModes: {myTag: {dc_va: 1}}};
    rst.initiate(config);
    const primary = rst.getPrimary();
    const secondary = rst.getSecondary();
    const dbName = "test";
    const collName = "server_write_concern_metrics";
    const testDB = primary.getDB(dbName);
    const testColl = testDB[collName];

    function resetCollection() {
        testColl.drop();
        assert.commandWorked(testDB.createCollection(collName));
    }

    function testWriteConcernMetrics(cmd, opName, inc) {
        // Run command with no writeConcern.
        resetCollection();
        let serverStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(testDB.runCommand(cmd));
        let newStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusChange(serverStatus.opWriteConcernCounters,
                                 newStatus.opWriteConcernCounters,
                                 opName + ".none",
                                 inc);

        // Run command with writeConcern {j: true}. This should be counted as having no 'w' value.
        resetCollection();
        serverStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(
            testDB.runCommand(Object.assign(Object.assign({}, cmd), {writeConcern: {j: true}})));
        newStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusChange(serverStatus.opWriteConcernCounters,
                                 newStatus.opWriteConcernCounters,
                                 opName + ".none",
                                 inc);

        // Run command with writeConcern {w: "majority"}.
        resetCollection();
        serverStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(testDB.runCommand(
            Object.assign(Object.assign({}, cmd), {writeConcern: {w: "majority"}})));
        newStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusChange(serverStatus.opWriteConcernCounters,
                                 newStatus.opWriteConcernCounters,
                                 opName + ".wmajority",
                                 inc);

        // Run command with writeConcern {w: 0}.
        resetCollection();
        serverStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(
            testDB.runCommand(Object.assign(Object.assign({}, cmd), {writeConcern: {w: 0}})));
        newStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusChange(serverStatus.opWriteConcernCounters,
                                 newStatus.opWriteConcernCounters,
                                 opName + ".wnum.0",
                                 inc);

        // Run command with writeConcern {w: 1}.
        resetCollection();
        serverStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(
            testDB.runCommand(Object.assign(Object.assign({}, cmd), {writeConcern: {w: 1}})));
        newStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusChange(serverStatus.opWriteConcernCounters,
                                 newStatus.opWriteConcernCounters,
                                 opName + ".wnum.1",
                                 inc);

        // Run command with writeConcern {w: 2}.
        resetCollection();
        serverStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(
            testDB.runCommand(Object.assign(Object.assign({}, cmd), {writeConcern: {w: 2}})));
        newStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusChange(serverStatus.opWriteConcernCounters,
                                 newStatus.opWriteConcernCounters,
                                 opName + ".wnum.2",
                                 inc);

        // Run command with writeConcern {w: "myTag"}.
        resetCollection();
        serverStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(
            testDB.runCommand(Object.assign(Object.assign({}, cmd), {writeConcern: {w: "myTag"}})));
        newStatus = assert.commandWorked(testDB.adminCommand({serverStatus: 1}));
        verifyServerStatusChange(serverStatus.opWriteConcernCounters,
                                 newStatus.opWriteConcernCounters,
                                 opName + ".wtag.myTag",
                                 inc);

        // writeConcern metrics are not tracked on the secondary.
        resetCollection();
        serverStatus = assert.commandWorked(secondary.adminCommand({serverStatus: 1}));
        verifyServerStatusFields(serverStatus);
        assert.commandWorked(testDB.runCommand(cmd));
        newStatus = assert.commandWorked(secondary.adminCommand({serverStatus: 1}));
        assert.eq(
            0,
            bsonWoCompare(serverStatus.opWriteConcernCounters, newStatus.opWriteConcernCounters),
            "expected no change in secondary writeConcern metrics, before: " +
                tojson(serverStatus) + ", after: " + tojson(newStatus));
    }

    // Test single insert/update/delete.
    testWriteConcernMetrics({insert: collName, documents: [{}]}, "insert", 1);
    testWriteConcernMetrics({update: collName, updates: [{q: {}, u: {$set: {a: 1}}}]}, "update", 1);
    testWriteConcernMetrics({delete: collName, deletes: [{q: {}, limit: 1}]}, "delete", 1);

    // Test batch writes.
    testWriteConcernMetrics({insert: collName, documents: [{}, {}]}, "insert", 2);
    testWriteConcernMetrics(
        {update: collName, updates: [{q: {}, u: {$set: {a: 1}}}, {q: {}, u: {$set: {a: 1}}}]},
        "update",
        2);
    testWriteConcernMetrics(
        {delete: collName, deletes: [{q: {}, limit: 1}, {q: {}, limit: 1}]}, "delete", 2);

    // Test applyOps.
    testWriteConcernMetrics(
        {applyOps: [{op: "i", ns: testColl.getFullName(), o: {_id: 0}}]}, "insert", 1);
    testWriteConcernMetrics(
        {applyOps: [{op: "u", ns: testColl.getFullName(), o2: {_id: 0}, o: {$set: {a: 1}}}]},
        "update",
        1);
    testWriteConcernMetrics(
        {applyOps: [{op: "d", ns: testColl.getFullName(), o: {_id: 0}}]}, "delete", 1);

    rst.stopSet();
}());