JavaScript模拟函数在测试

Question

我试图测试一些较大的React应用程序中的JavaScript函数。他们大量使用模块模式，我怀疑这可能是我没有正确理解的模式。这是我测试的脚本（几乎与真实应用程序中实际使用的脚本完全相同，只有实际应用程序中的GetFeedData.getFeedData调用外部API）：

const GetFeedData = (function () {
let feed, feedId;
return {
    getFeedId: function (sub) {
        switch (sub) {
            case '1': case '2': case '3': case '4': case '5': case '6': case 'S':
                feedId = 1;
                break;
            case 'A': case 'C': case 'E':
                feedId = 26;
                break;
            case 'N': case 'Q': case 'R': case 'W':
                feedId = 16;
                break;
            case 'B': case 'D': case 'F': case 'M':
                feedId = 21;
                break;
            case 'L':
                feedId = 2;
                break;
            case 'G':
                feedId = 31;
                break;
            }
        },
        getFeedData: function () {
            if (feedId === 2) {
                feed = require('./MockData');
            }
        },
        feed: feed
    };
})();

const ReverseStop = (function () {
    let stopIdN, stopIdS;
    const stopData = require('../utils/stops');
    return {
        reverseStop: function (sub, stop) {
            var invalidEntries = 0;
            function filterByName (item) {
                if (item.stop_name == stop && typeof item.stop_id === 'string' && item.stop_id.charAt(0) == sub) {
                    return true;
                }
                invalidEntries ++;
                return false;
            }
            var stopObjs = stopData.filter(filterByName);
            for (var i = 0; i < stopObjs.length; i++) {
                if (stopObjs[i].stop_id.charAt(stopObjs[i].stop_id.length - 1) == 'N') {
                    stopIdN = stopObjs[i].stop_id;
                } else if (stopObjs[i].stop_id.charAt(stopObjs[i].stop_id.length - 1) == 'S') {
                    stopIdS = stopObjs[i].stop_id;
                }
            }
        },
        stopIdN: stopIdN,
        stopIdS: stopIdS
    };
})();

export const IsDelayN = (function () {
    let noDelay, yesDelay, nextArrival, delay;
    return {
        isDelay: function (sub, stop) {
            GetFeedData.getFeedId(sub);
            GetFeedData.getFeedData();
            ReverseStop.reverseStop(sub, stop);
            var arrivals = [];
            var delays = [];
            function dataFilter () {
                var invalidEntries = 0;
                var feedObjs = GetFeedData.feed.filter(function (feedObj) {
                    if (feedObj.entity.trip_update.stop_time_update.stop_id == ReverseStop.stopIdN) {
                        return feedObj.entity.trip_update.stop_time_update;
                    }
                });
                for (var i = 0; i < feedObjs.length; i++) {
                    arrivals.push(feedObjs.arrival.time.low);
                    delays.push(feedObjs.arrival.delay);
                }
            }
            nextArrival = Math.min(...arrivals);
            var delayIndex = arrivals.indexOf(nextArrival);
            delay = delays.delayIndex;
            if (delay === null || Math.ceil(delay / 60) <= 5) {
                noDelay = Math.ceil((nextArrival - GetFeedData.feed.header.timestamp.low) / 60);
            } else {
                yesDelay = Math.ceil(delay / 60);
            }
        },
        noDelay: noDelay,
        yesDelay: yesDelay,
        nextArrival: nextArrival 
    };
})();

export const IsDelayS = (function () {
    let noDelay, yesDelay, nextArrival, delay;
    return {
        isDelay: function (sub, stop) {
            GetFeedData.getFeedId(sub);
            GetFeedData.getFeedData();
            ReverseStop.reverseStop(sub, stop);
            var arrivals = [];
            var delays = [];
            function dataFilter () {
                var invalidEntries = 0;
                var feedObjs = GetFeedData.feed.filter(function (feedObj) {
                    if (feedObj.entity.trip_update.stop_time_update.stop_id == ReverseStop.stopIdS) {
                        return feedObj.entity.trip_update.stop_time_update;
                    }
                });
                for (var i = 0; i < feedObjs; i++) {
                    arrivals.push(feedObjs.arrival.time.low);
                    delays.push(feedObjs.arrival.delay);
                }
            }
            nextArrival = Math.min(...arrivals);
            var delayIndex = arrivals.indexOf(nextArrival);
            delay = delays.delayIndex;
            if (delay === null || Math.ceil(delay / 60) <= 5) {
                noDelay = Math.ceil((nextArrival - GetFeedData.feed.header.timestamp.low) / 60);
            } else {
                yesDelay = Math.ceil(delay / 60);
            }
        },
        noDelay: noDelay,
        yesDelay: yesDelay,
        nextArrival: nextArrival
    };
})();

我试图做的是将我的功能分开，所以我可以在导出的函数中调用几个较短的函数，而不是一个或两个非常长的函数。因为我需要在导出的函数中调用几个变量 - GetFeedData.feed，ReverseStop.stopIdN和ReverseStop.stopIdS，所以我假设模块模式比使用回调更好。我完全错了。

在我的测试中，我尝试将noDelay，nextArrival和delay记录到控制台，以查看它们是否已定义。我使用Jest，如果这些信息有用。我现在暂时省略我测试的其他部分，因为它们看起来并不相关（如果错误，请纠正我），但是这部分是：

it('correctly takes input at beginning of api logic and outputs expected values at end', () => {
    IsDelayN.isDelay('L', 'Lorimer St');
    IsDelayS.isDelay('L', 'Lorimer St');

    expect(IsDelayN.noDelay).toBeTruthy();
    expect(IsDelayN.yesDelay).toBeFalsy();
    expect(IsDelayS.noDelay).toBeTruthy();
    expect(IsDelayS.yesDelay).toBeFalsy();
    console.log('IsDelayN noDelay: ' + IsDelayN.noDelay);
    console.log('IsDelayN nextArrival: ' + IsDelayN.nextArrival);
    console.log('IsDelayN delay: ' + IsDelayN.delay);
    console.log('IsDelayS noDelay: ' + IsDelayS.noDelay);
    console.log('IsDelayS nextArrival: ' + IsDelayS.nextArrival);
    console.log('IsDelayS delay: ' + IsDelayS.delay);
});

我的console.log()之前的测试都已通过，但每console.log()个undefined出现null。此外，我的React组件实际调用的脚本也会得到相同的结果。如果没有定义这些变量，我将我的组件集设置为呈现functions.php，而这正是发生的事情。

非常感谢任何理解这一点的帮助。