mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
239 lines
10 KiB
JavaScript
239 lines
10 KiB
JavaScript
const { recordRuleExitStatus } = require("./configParameters.js");
|
|
|
|
/** Check that there are valid JIRA links in MR description.
|
|
*
|
|
* This check extracts the "Related" section from the MR description and
|
|
* searches for JIRA ticket references in the format "Closes [JIRA ticket key]".
|
|
*
|
|
* It then extracts the closing GitHub links from the corresponding JIRA tickets and
|
|
* checks if the linked GitHub issues are still in open state.
|
|
*
|
|
* Finally, it checks if the required GitHub closing links are present in the MR's commit messages.
|
|
*
|
|
*/
|
|
module.exports = async function () {
|
|
const ruleName = 'Jira ticket references';
|
|
const axios = require("axios");
|
|
const mrDescription = danger.gitlab.mr.description;
|
|
const mrCommitMessages = danger.gitlab.commits.map(
|
|
(commit) => commit.message
|
|
);
|
|
const jiraTicketRegex = /[A-Z0-9]+-[0-9]+/;
|
|
|
|
let partMessages = []; // Create a blank field for future records of individual issues
|
|
|
|
// Parse section "Related" from MR Description
|
|
const sectionRelated = extractSectionRelated(mrDescription);
|
|
|
|
if (
|
|
!sectionRelated.header || // No section Related in MR description or ...
|
|
!jiraTicketRegex.test(sectionRelated.content) // no Jira links in section Related
|
|
) {
|
|
recordRuleExitStatus(ruleName, 'Passed (with suggestions)');
|
|
return message(
|
|
"Please consider adding references to JIRA issues in the `Related` section of the MR description."
|
|
);
|
|
}
|
|
|
|
// Get closing (only) JIRA tickets
|
|
const jiraTickets = findClosingJiraTickets(sectionRelated.content);
|
|
|
|
for (const ticket of jiraTickets) {
|
|
ticket.jiraUIUrl = `https://jira.espressif.com:8443/browse/${ticket.ticketName}`;
|
|
|
|
if (!ticket.correctFormat) {
|
|
partMessages.push(
|
|
`- closing ticket \`${ticket.record}\` seems to be in the wrong format (or inaccessible to Jira DangerBot).. The correct format is for example \`- Closes JIRA-123\`.`
|
|
);
|
|
}
|
|
|
|
// Get closing GitHub issue links from JIRA tickets
|
|
const closingGithubLink = await getGitHubClosingLink(ticket.ticketName);
|
|
if (closingGithubLink) {
|
|
ticket.closingGithubLink = closingGithubLink;
|
|
} else if (closingGithubLink === null) {
|
|
partMessages.push(
|
|
`- the Jira issue number [\`${ticket.ticketName}\`](${ticket.jiraUIUrl}) seems to be invalid (please check if the ticket number is correct)`
|
|
);
|
|
continue; // Handle unreachable JIRA tickets; skip the following checks
|
|
} else {
|
|
continue; // Jira ticket have no GitHub closing link; skip the following checks
|
|
}
|
|
|
|
// Get still open GitHub issues
|
|
const githubIssueStatusOpen = await isGithubIssueOpen(
|
|
ticket.closingGithubLink
|
|
);
|
|
ticket.isOpen = githubIssueStatusOpen;
|
|
if (githubIssueStatusOpen === null) {
|
|
// Handle unreachable GitHub issues
|
|
partMessages.push(
|
|
`- the GitHub issue [\`${ticket.closingGithubLink}\`](${ticket.closingGithubLink}) does not seem to exist on GitHub (referenced from JIRA ticket [\`${ticket.ticketName}\`](${ticket.jiraUIUrl}) )`
|
|
);
|
|
continue; // skip the following checks
|
|
}
|
|
|
|
// Search in commit message if there are all GitHub closing links (from Related section) for still open GH issues
|
|
if (ticket.isOpen) {
|
|
if (
|
|
!mrCommitMessages.some((item) =>
|
|
item.includes(`Closes ${ticket.closingGithubLink}`)
|
|
)
|
|
) {
|
|
partMessages.push(
|
|
`- please add \`Closes ${ticket.closingGithubLink}\` to the commit message`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create report / DangerJS check feedback if issues with Jira links found
|
|
if (partMessages.length) {
|
|
createReport();
|
|
}
|
|
|
|
// At this point, the rule has passed
|
|
recordRuleExitStatus(ruleName, 'Passed');
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
/**
|
|
* This function takes in a string mrDescription which contains a Markdown-formatted text
|
|
* related to a Merge Request (MR) in a GitLab repository. It searches for a section titled "Related"
|
|
* and extracts the content of that section. If the section is not found, it returns an object
|
|
* indicating that the header and content are null. If the section is found but empty, it returns
|
|
* an object indicating that the header is present but the content is null. If the section is found
|
|
* with content, it returns an object indicating that the header is present and the content of the
|
|
* "Related" section.
|
|
*
|
|
* @param {string} mrDescription - The Markdown-formatted text related to the Merge Request.
|
|
* @returns {{
|
|
* header: string | boolean | null,
|
|
* content: string | null
|
|
* }} - An object containing the header and content of the "Related" section, if present.
|
|
*/
|
|
|
|
function extractSectionRelated(mrDescription) {
|
|
const regexSectionRelated = /## Related([\s\S]*?)(?=## |$)/;
|
|
const sectionRelated = mrDescription.match(regexSectionRelated);
|
|
if (!sectionRelated) {
|
|
return { header: null, content: null }; // Section "Related" is missing
|
|
}
|
|
|
|
const content = sectionRelated[1].replace(/(\r\n|\n|\r)/gm, ""); // Remove empty lines
|
|
if (!content.length) {
|
|
return { header: true, content: null }; // Section "Related" is present, but empty
|
|
}
|
|
|
|
return { header: true, content: sectionRelated[1] }; // Found section "Related" with content
|
|
}
|
|
|
|
/**
|
|
* Finds all JIRA tickets that are being closed in the given sectionRelatedcontent.
|
|
* The function searches for lines that start with - Closes and have the format Closes [uppercase letters]-[numbers].
|
|
* @param {string} sectionRelatedcontent - A string that contains lines with mentions of JIRA tickets
|
|
* @returns {Array} An array of objects with ticketName property that has the correct format
|
|
*/
|
|
|
|
function findClosingJiraTickets(sectionRelatedcontent) {
|
|
let closingTickets = [];
|
|
const lines = sectionRelatedcontent.split("\n");
|
|
for (const line of lines) {
|
|
if (!line.startsWith("- Closes")) {
|
|
continue; // Not closing-type ticket, skip
|
|
}
|
|
|
|
const correctJiraClosingLinkFormat = new RegExp(
|
|
`^- Closes ${jiraTicketRegex.source}$`
|
|
);
|
|
const matchedJiraTicket = line.match(jiraTicketRegex);
|
|
if (matchedJiraTicket) {
|
|
if (!correctJiraClosingLinkFormat.test(line)) {
|
|
closingTickets.push({
|
|
record: line,
|
|
ticketName: matchedJiraTicket[0],
|
|
correctFormat: false,
|
|
});
|
|
} else {
|
|
closingTickets.push({
|
|
record: line,
|
|
ticketName: matchedJiraTicket[0],
|
|
correctFormat: true,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return closingTickets;
|
|
}
|
|
|
|
/**
|
|
* This function takes a JIRA issue key and retrieves the description from JIRA's API.
|
|
* It then searches the description for a GitHub closing link in the format "Closes https://github.com/owner/repo/issues/123".
|
|
* If a GitHub closing link is found, it is returned. If no GitHub closing link is found, it returns null.
|
|
* @param {string} jiraIssueKey - The key of the JIRA issue to search for the GitHub closing link.
|
|
* @returns {Promise<string|null>} - A promise that resolves to a string containing the GitHub closing link if found,
|
|
* or null if not found.
|
|
*/
|
|
async function getGitHubClosingLink(jiraIssueKey) {
|
|
let jiraDescription = "";
|
|
|
|
// Get JIRA ticket description content
|
|
try {
|
|
const response = await axios({
|
|
url: `https://jira.espressif.com:8443/rest/api/latest/issue/${jiraIssueKey}`,
|
|
auth: {
|
|
username: process.env.DANGER_JIRA_USER,
|
|
password: process.env.DANGER_JIRA_PASSWORD,
|
|
},
|
|
});
|
|
jiraDescription = response.data.fields.description
|
|
? response.data.fields.description
|
|
: ""; // if the Jira ticket has an unfilled Description, the ".description" property is missing in API response - in that case set "jiraDescription" to an empty string
|
|
} catch (error) {
|
|
return null;
|
|
}
|
|
|
|
// Find GitHub closing link in description
|
|
const regexClosingGhLink =
|
|
/Closes\s+(https:\/\/github.com\/\S+\/\S+\/issues\/\d+)/;
|
|
const closingGithubLink = jiraDescription.match(regexClosingGhLink);
|
|
|
|
if (closingGithubLink) {
|
|
return closingGithubLink[1];
|
|
} else {
|
|
return false; // Jira issue has no GitHub closing link in description
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if a GitHub issue linked in a merge request is still open.
|
|
*
|
|
* @param {string} link - The link to the GitHub issue.
|
|
* @returns {Promise<boolean>} A promise that resolves to a boolean indicating if the issue is open.
|
|
* @throws {Error} If the link is invalid or if there was an error fetching the issue.
|
|
*/
|
|
async function isGithubIssueOpen(link) {
|
|
const parsedUrl = new URL(link);
|
|
const [owner, repo] = parsedUrl.pathname.split("/").slice(1, 3);
|
|
const issueNumber = parsedUrl.pathname.split("/").slice(-1)[0];
|
|
|
|
try {
|
|
const response = await axios.get(
|
|
`https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`
|
|
);
|
|
return response.data.state === "open"; // return True if GitHub issue is open
|
|
} catch (error) {
|
|
return null; // GET request to issue fails
|
|
}
|
|
}
|
|
|
|
function createReport() {
|
|
partMessages.sort();
|
|
let dangerMessage = `Some issues found for the related JIRA tickets in this MR:\n${partMessages.join(
|
|
"\n"
|
|
)}`;
|
|
recordRuleExitStatus(ruleName, "Failed");
|
|
return warn(dangerMessage);
|
|
}
|
|
};
|