Тестирование функции, которая вызывает другую функцию ⇐ Javascript

[Anonymous]

У меня есть функция getissuestistworklogs, которая возвращает массив объектов. У каждого объекта есть полевые работы, которые представляют собой массив.
После получения результатов invokewithratelimit («getissues»), массив иер, и если у конкретного объекта есть рабочие места. с принятым параметром третьего результата. Функция fetchadditionalworklogs не называется, а реальной. Может быть, я должен переписать тест по -другому, или есть способ это исправить? < /P>

Код: Выделить всё

export const getIssuesWithWorklogs = async (jqlQuery, fields, reportName, changelog, progressCallback) => {
try {
const totalNumberOfIssues = await invokeWithRateLimit("getTotalNumberIssues", {
jqlQuery: jqlQuery,
fields: fields,
reportName: reportName,
changelog
});
if (totalNumberOfIssues === 0) return [];
await progressCallback(0, totalNumberOfIssues);
const point = 100;
const numberOfApiCalls = Math.ceil(totalNumberOfIssues / point);
const rerenderInterval = Math.ceil(totalNumberOfIssues / MAX_PROGRESSBAR_UPDATES);
let issuesLoaded = 0;
let issuesLoadedByResponses = 0;
const apiCallPromises = [];
for (let i = 0; i < numberOfApiCalls; i++) {
const startAtIssues = i * point;
const promise = invokeWithRateLimit("getIssues", {
jqlQuery: jqlQuery,
fields: fields,
reportName: reportName ? reportName : "",
startAtIssues: startAtIssues,
maxResults: 100,
totalNumber: totalNumberOfIssues,
changelog
})
.then(async (issues) => {
for (const issue of issues) {
if (issue.fields.worklog && issue.fields.worklog.total > 20) {
const additionalWorklogs = await fetchAllWorklogs(issue.id);

console.log("Fetching ended", additionalWorklogs);

issue.fields.worklog.worklogs = [...issue.fields.worklog.worklogs, ...additionalWorklogs];
}
}

issuesLoadedByResponses += issues.length;
progressCallback(Math.min(issuesLoadedByResponses, totalNumberOfIssues), totalNumberOfIssues);
return issues;
})
.catch((error) => {
console.error("Error in getIssues:", error);

throw error;
});
apiCallPromises.push(promise);
await delay(30);
issuesLoaded += point;
}
const responses = await Promise.all(apiCallPromises);
let response = [];
responses.forEach((issues) => {
response = response.concat(issues);
});
return response;
} catch (error) {
console.error("Error in getIssues:", error, jqlQuery, fields);
throw error;
}
};

export const fetchAllWorklogs = async (issueId) => {
const worklogs = [];
let startAt = 20;

try {
const response = await invokeWithRateLimit("getIssueWorklogs", {
issueId: issueId,
startAt: startAt
});

worklogs.push(...response.worklogs);
} catch (error) {
console.error(`Error fetching worklogs for issue ${issueId}:`, error);
}

return worklogs;
};

import invokeWithRateLimit from "utils/invokeWithRateLImit";

import { mockParametersForReports, mockReportsResults, mockWorklogsForTimesheet } from "../__mocks__/mockData";
import * as JiraUtils from "../src/services/JiraUtils";
import { getIssuesWithWorklogs } from "../src/services/JiraUtils";

jest.mock("../src/services/JiraUtils", () => {
const actual = jest.requireActual("../src/services/JiraUtils");
return {
...jest.genMockFromModule("../src/services/JiraUtils"), // Generate mocks for all functions
getIssuesWithWorklogs: actual.getIssuesWithWorklogs // Keep this function real
};
});

jest.mock("@forge/bridge", () => ({
invoke: jest.fn()
}));

jest.mock("../src/utils/invokeWithRateLImit.js", () => jest.fn());
jest.mock("constants", () => require("../src/constants"));

describe("getIssuesWithWorklogs", () => {
let mockProgressCallback;

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

test("Should return issues with worklogs when totalNumberOfIssues = 3", async () => {
const mockedParameters = mockParametersForReports["Timesheet"];

invokeWithRateLimit.mockResolvedValueOnce(3).mockResolvedValueOnce(mockReportsResults["Timesheet"]);
invokeWithRateLimit.mockResolvedValueOnce({
worklogs: [{ id: "18920", issueId: "13202", timeSpent: "1h"  }]
});

JiraUtils.fetchAllWorklogs.mockResolvedValue(mockWorklogsForTimesheet);

const result = await getIssuesWithWorklogs(
mockedParameters.jqlQuery,
mockedParameters.fields,
mockedParameters.reportName,
mockedParameters.changelog,
mockProgressCallback
);
expect(result).toHaveLength(3);
expect(result[2].fields.worklog.worklogs).toContainEqual(mockWorklogsForTimesheet[0]);

expect(mockProgressCallback).toHaveBeenCalledTimes(2);
expect(mockProgressCallback).toHaveBeenCalledWith(0, 3);
expect(mockProgressCallback).toHaveBeenCalledWith(3, 3);

expect(invokeWithRateLimit).toHaveBeenNthCalledWith(1, "getTotalNumberIssues", {
jqlQuery: mockedParameters.jqlQuery,
fields: mockedParameters.fields,
reportName: mockedParameters.reportName,
changelog: mockedParameters.changelog
});
expect(invokeWithRateLimit).toHaveBeenNthCalledWith(2, "getIssues", {
jqlQuery: mockedParameters.jqlQuery,
fields: mockedParameters.fields,
reportName: mockedParameters.reportName,
startAtIssues: 0,
maxResults: 100,
totalNumber: 3,
changelog: mockedParameters.changelog
});
console.log(result[2].id);
console.log("Mock calls:", JiraUtils.fetchAllWorklogs.mock.calls);
await new Promise((resolve) => setTimeout(resolve, 100));
await expect(JiraUtils.fetchAllWorklogs).toHaveBeenCalledWith(result[2].id);

expect(invokeWithRateLimit).toHaveBeenCalledTimes(2);
});

< /code>
Вот мои журналы и сообщение об ошибке:
console.log
Извлечение окончания [{id: '18920', wealsid: '13202', timespent: '1h'}] < /p>
  at log (src/services/JiraUtils.js:427:23)
< /code>
console.log
13202 < /p>
  at Object.log (__tests__/jiraUtils.test.js:176:13)
< /code>
console.log
Mock Calls: [] < /p>
  at Object.log (__tests__/jiraUtils.test.js:177:13)
< /code>
Fail  tests < /strong> /jirautils.test.js
getissueswithwithlogs
× должен возвращать проблемы с рабочими, когда TotalNumberOfissues = 3 (167 мс) < /p>
● 3 < /p>
expect(jest.fn()).toHaveBeenCalledWith(...expected)

Expected: "13202"

Number of calls: 0

177 |     console.log("Mock calls:", JiraUtils.fetchAllWorklogs.mock.calls);
178 |     await new Promise((resolve) => setTimeout(resolve, 100));
> 179 |     await expect(JiraUtils.fetchAllWorklogs).toHaveBeenCalledWith(result[2].id);
|                                              ^
180 |
181 |     expect(invokeWithRateLimit).toHaveBeenCalledTimes(2);
182 |   });

at Object.toHaveBeenCalledWith (__tests__/jiraUtils.test.js:179:46)

Я также пробовал функцию шпионов

Подробнее здесь: https://stackoverflow.com/questions/795 ... r-function