Как я могу проверить работу по повестке дня с шуткой? - PullRequest
0 голосов
/ 12 октября 2018

Я хочу проверить работу, которую я выполняю с повесткой дня.Я написал следующий тест, но потом понял, что все функции expect()... не вызываются до того, как он определит, что тест пройден или не пройден.Я поместил некоторые console.log() всеми expect() функциями, и они действительно вызываются не раньше, чем он определит, будет ли результат теста.Я попытался добавить expect.assertions(6); вверху теста, но тест не заставил себя ждать дольше, просто не получилось, сказав, что он не нашел все 6.

Как заставить шутить ждать всегозакончить тест?

Вот код, который я хочу проверить:

rules.js

const Account = require("./../models/user.account");
const Listing = require("./../models/user.account.listing");
const Message = require("./../models/user.account.listing.message");
const MessageRule = require("./../models/user.account.listing.messageRule");
const Reservation = require("./../models/user.account.listing.reservation");
const Core = require("./../core");
const moment = require("moment-timezone");
require("colors");

module.exports = function(agenda) {
    agenda.define("send message", {priority: "highest"}, async (job, done) => {
        try {
            console.time("send message " + job.attrs._id);
            const userID = job.attrs.data.userID;
            const listingID = job.attrs.data.listingID;
            const reservationID = job.attrs.data.reservationID;
            const messageRuleID = job.attrs.data.messageRuleID;
            const sendDate = job.attrs.data.sendDate;

            //console.log("Rule Job:".cyan + " send message - listingID: " + listingID);
            let messageQuery = {
                userID,
                listingID,
                reservationID,
                messageRuleID
            };
            let message = await Message.findOne(messageQuery);
            if (message) {
                throw new Error(
                    "Message has already been sent. userID: " +
                        userID +
                        " listingID: " +
                        listingID +
                        " reservationID: " +
                        reservationID +
                        " messageRuleID: " +
                        messageRuleID +
                        " message._id: " +
                        message._id +
                        " message.sendDate: " +
                        message.sendDate +
                        " message.sentDate: " +
                        message.sentDate
                );
            } else {
                const isLastMinuteMessage = false;
                let listing = await Listing.findById(listingID);
                let account = await Account.findById(listing.accountID);
                let messageRule = await MessageRule.findById(messageRuleID);
                let reservation = await Reservation.findById(reservationID);
                // Check that it found all of the required documents
                if (!listing || !listing._id) {
                    throw new Error("Missing the listing document. userID: " + userID + " listingID: " + listingID);
                }
                if (!account || !account._id) {
                    throw new Error(
                        "Missing the account document. userID: " + userID + " accountID: " + listing.accountID
                    );
                }
                if (!messageRule || !messageRule._id) {
                    throw new Error(
                        "Missing the messageRule document. userID: " + userID + " messageRuleID: " + messageRuleID
                    );
                }
                if (!reservation || !reservation._id) {
                    throw new Error(
                        "Missing the reservation document. userID: " + userID + " reservationID: " + reservationID
                    );
                }
                // Double check the send date by recalculating it then checking comparing them
                if (messageRule.event == "checkin" || messageRule.event == "checkout") {
                    let sendDateCheck = moment.tz(
                        reservation.startDate + " " + messageRule.time,
                        "YYYY-MM-DD H",
                        listing.timeZone
                    );
                    if (messageRule.event == "checkout") {
                        sendDateCheck = sendDateCheck.add(reservation.nights, "day");
                    }
                    sendDateCheck = sendDateCheck.add(messageRule.days, "day");
                    if (!sendDateCheck.isSame(sendDate)) {
                        throw new Error(
                            "Message send date and calculated send date don't match. userID: " +
                                userID +
                                " listingID: " +
                                listingID +
                                " reservationID: " +
                                reservationID +
                                " messageRuleID: " +
                                messageRuleID +
                                " sendDate: " +
                                moment(sendDate).format() +
                                " sendDateCheck: " +
                                moment(sendDateCheck).format()
                        );
                    }
                }
                await Core.buildMessage(account, listing, messageRule, reservation, isLastMinuteMessage);
            }
            console.timeEnd("send message " + job.attrs._id);
            done();
        } catch (error) {
            console.error("Rule Job: send message", error);
            return done(error);
        }
    });
};

А вот мой тест:

rules.test.js

const Account = require("./../models/user.account");
const Listing = require("./../models/user.account.listing");
const Message = require("./../models/user.account.listing.message");
const MessageRule = require("./../models/user.account.listing.messageRule");
const Reservation = require("./../models/user.account.listing.reservation");
const Core = require("./../core");
const Rules = require("./rules");
const Docs = require("./../tests/docs");

describe("Tests for rules.js", () => {
    // Mock moment()
    Date.now = jest.fn(() => 1538794832371); //October 5th 2018 8pm PST

    beforeEach(() => {
        jest.clearAllMocks();
    });

    describe("rules()", () => {
        it("should send a message, message exists but is enabled", async () => {
            // Mock Message
            // Message.findOne()
            const MessageFindOneMock = jest.spyOn(Message, "findOne");
            const MessageFindOneResult = Docs.messageReviewReminderDisabledThenEnabled;
            const MessageFindOne = jest.fn(() => MessageFindOneResult);
            MessageFindOneMock.mockImplementation(MessageFindOne);

            const userID = Docs.userID;
            const reservation = Docs.reservationInTheFuture;
            const messageRule = Docs.messageRuleCheckUp;
            const accountID = Docs.listing.accountID;
            const listingID = Docs.listing._id;
            const reservationID = reservation._id;
            const messageRuleID = messageRule._id;

            // Mock Listing
            // Listing.findById()
            const ListingFindByIdMock = jest.spyOn(Listing, "findById");
            const ListingFindByIdResult = Docs.listing;
            const ListingFindById = jest.fn(() => ListingFindByIdResult);
            ListingFindByIdMock.mockImplementation(ListingFindById);
            // Mock Account
            // Account.findById()
            const AccountFindByIdMock = jest.spyOn(Account, "findById");
            const AccountFindByIdResult = {_id: accountID};
            const AccountFindById = jest.fn(() => AccountFindByIdResult);
            AccountFindByIdMock.mockImplementation(AccountFindById);
            // Mock MessageRule
            // MessageRule.findById()
            const MessageRuleFindByIdMock = jest.spyOn(MessageRule, "findById");
            const MessageRuleFindByIdResult = messageRule;
            const MessageRuleFindById = jest.fn(() => MessageRuleFindByIdResult);
            MessageRuleFindByIdMock.mockImplementation(MessageRuleFindById);
            // Mock Reservation
            // Reservation.findById()
            const ReservationFindByIdMock = jest.spyOn(Reservation, "findById");
            const ReservationFindByIdResult = reservation;
            const ReservationFindById = jest.fn(() => ReservationFindByIdResult);
            ReservationFindByIdMock.mockImplementation(ReservationFindById);
            // Mock Core
            // Core.buildMessage()
            const CoreBuildMessageMock = jest.spyOn(Core, "buildMessage");
            const CoreBuildMessage = jest.fn((account, listing, messageRule, reservation, isLastMinuteMessage) => {
                expect(account._id).toBe(accountID);
                expect(listing._id).toBe(listingID);
                expect(messageRule._id).toBe(messageRuleID);
                expect(reservation._id).toBe(reservationID);
            });
            CoreBuildMessageMock.mockImplementation(CoreBuildMessage);
            // Run test
            const sendDate = "2018-11-08T10:00:00-06:00";
            const done = jest.fn(error => {
                expect(error).toBeFalsy();
                expect(CoreBuildMessage).toHaveBeenCalledTimes(10);
            });
            const job = {
                attrs: {
                    data: {
                        userID,
                        listingID,
                        reservationID,
                        messageRuleID,
                        sendDate
                    }
                }
            };
            let agenda = {
                define: jest.fn((name, options, callback) => {
                    if (name == "send message") {
                        callback(job, done);
                    }
                })
            };
            Rules(agenda);
        });
    });
});

1 Ответ

0 голосов
/ 20 октября 2018

В вашем rules.js вы определили callback как async функцию:

agenda.define("send message", {priority: "highest"}, async (job, done) // <--- this

Однако вы вызываете ее с помощью:

define: jest.fn((name, options, callback) => {
    if (name == "send message") {
        callback(job, done);
    }
})

Так что естьнет await там ...

Это объясняет, почему вы запускаете материал, а не awaiting для его завершения.

Должно быть что-то вроде:

define: await jest.fn((name, options, callback) => {
    if (name == "send message") {
        await callback(job, done);
    }
})
...