mongo/jstests/aggregation/expressions/date_from_string_on_error.js

/**
 * Tests for the $dateFromString expression with the optional 'onError' parameter.
 */
import "jstests/libs/query/sbe_assert_error_override.js";

import {assertErrCodeAndErrMsgContains} from "jstests/aggregation/extras/utils.js";

const onErrorValue = ISODate("2017-07-04T11:56:02Z");
const coll = db.date_from_string_on_error;
coll.drop();

assert.commandWorked(coll.insert({_id: 0}));

// Test that the 'onError' value is returned when 'dateString' is not a valid date/time.
for (let inputDate of ["July 4th", "12:50:53", "2017", "60.Monday1770/06:59", "Not even close", "July 4th, 10000"]) {
    assert.eq(
        [{_id: 0, date: onErrorValue}],
        coll
            .aggregate({
                $project: {date: {$dateFromString: {dateString: inputDate, onError: onErrorValue}}},
            })
            .toArray(),
    );
}

// Test that the 'onError' value is returned when 'dateString' is not a string.
for (let inputDate of [5, {year: 2018, month: 2, day: 5}, ["2018-02-05"]]) {
    assert.eq(
        [{_id: 0, date: onErrorValue}],
        coll
            .aggregate({
                $project: {date: {$dateFromString: {dateString: inputDate, onError: onErrorValue}}},
            })
            .toArray(),
    );
}

// Test that the 'onError' value is ignored when 'dateString' is nullish.
for (let inputDate of [null, undefined, "$missing"]) {
    assert.eq(
        [{_id: 0, date: null}],
        coll
            .aggregate({
                $project: {date: {$dateFromString: {dateString: inputDate, onError: onErrorValue}}},
            })
            .toArray(),
    );
}

// Test that the 'onError' value is returned for unmatched format strings.
for (let inputFormat of ["%Y", "%Y-%m-%dT%H", "Y-m-d"]) {
    assert.eq(
        [{_id: 0, date: onErrorValue}],
        coll
            .aggregate({
                $project: {
                    date: {
                        $dateFromString: {dateString: "2018-02-06", format: inputFormat, onError: onErrorValue},
                    },
                },
            })
            .toArray(),
    );
}

// Test that null is returned when the 'timezone' or 'format' is nullish, regardless of the
// 'onError' value.
for (let nullishValue of [null, undefined, "$missing"]) {
    assert.eq(
        [{_id: 0, date: null}],
        coll
            .aggregate({
                $project: {
                    date: {
                        $dateFromString: {
                            dateString: "2018-02-06T11:56:02Z",
                            format: nullishValue,
                            onError: onErrorValue,
                        },
                    },
                },
            })
            .toArray(),
    );
    assert.eq(
        [{_id: 0, date: null}],
        coll
            .aggregate({
                $project: {
                    date: {
                        $dateFromString: {
                            dateString: "2018-02-06T11:56:02Z",
                            timezone: nullishValue,
                            onError: onErrorValue,
                        },
                    },
                },
            })
            .toArray(),
    );
}

// Test that onError is returned when the input is not a string and other parameters are
// nullish.
assert.eq(
    [{_id: 0, date: onErrorValue}],
    coll
        .aggregate({
            $project: {date: {$dateFromString: {dateString: 5, format: null, onError: onErrorValue}}},
        })
        .toArray(),
);
assert.eq(
    [{_id: 0, date: onErrorValue}],
    coll
        .aggregate({
            $project: {
                date: {$dateFromString: {dateString: 5, timezone: "$missing", onError: onErrorValue}},
            },
        })
        .toArray(),
);

// Test that onError is ignored when the input is an invalid string and other parameters are
// nullish.
assert.eq(
    [{_id: 0, date: null}],
    coll
        .aggregate({
            $project: {
                date: {
                    $dateFromString: {dateString: "Invalid date string", format: null, onError: onErrorValue},
                },
            },
        })
        .toArray(),
);
assert.eq(
    [{_id: 0, date: null}],
    coll
        .aggregate({
            $project: {
                date: {
                    $dateFromString: {
                        dateString: "Invalid date string",
                        timezone: "$missing",
                        onError: onErrorValue,
                    },
                },
            },
        })
        .toArray(),
);

// Test that 'onError' can be any type, not just an ISODate.
for (let onError of [{}, 5, "Not a date", null, undefined]) {
    assert.eq(
        [{_id: 0, date: onError}],
        coll.aggregate({$project: {date: {$dateFromString: {dateString: "invalid", onError: onError}}}}).toArray(),
    );
}

// Test that a missing 'onError' value results in no output field when used within a $project
// stage.
assert.eq(
    [{_id: 0}],
    coll.aggregate({$project: {date: {$dateFromString: {dateString: "invalid", onError: "$missing"}}}}).toArray(),
);

// Test that 'onError' is ignored when the 'format' is invalid.
let res = coll.runCommand("aggregate", {
    pipeline: [
        {
            $project: {date: {$dateFromString: {dateString: "4/26/1992", format: 5, onError: onErrorValue}}},
        },
    ],
    cursor: {},
});
assert.commandFailedWithCode(res, 40684);

assertErrCodeAndErrMsgContains(
    coll,
    [
        {
            $project: {
                date: {$dateFromString: {dateString: "4/26/1992", format: "%n", onError: onErrorValue}},
            },
        },
    ],
    18536,
    "Invalid format character '%n' in format string",
);