8580878397

Committed 06 Apr 2024 11:43AM UTC coverage: 94.345% (-0.8%) from 95.105%

Build # 8580878397

Build Type

Pull #965

github

Committed by

web-flow

Commit Message

Merge 595e07447 into e57800051

Pull Request Pull Request #965: feat: detailed error handling

Run Details

371 of 395 branches covered (93.92%)

Branch coverage included in aggregate %.

50 of 58 new or added lines in 8 files covered. (86.21%)

11 existing lines in 3 files now uncovered.

897 of 949 relevant lines covered (94.52%)

17.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.72

/src/utils/subject.ts

import { fetchDiscussion, getLatestDiscussionComment } from './helpers';
import {
  CheckSuiteAttributes,
  CheckSuiteStatus,
  DiscussionStateType,
  GitifySubject,
  Issue,
  IssueComments,
  Notification,
  PullRequest,
  PullRequestStateType,
  ReleaseComments,
  SubjectUser,
  User,
  WorkflowRunAttributes,
} from '../typesGithub';
import { apiRequestAuth } from './api-requests';

export async function getGitifySubjectDetails(
  notification: Notification,
  token: string,
): Promise<GitifySubject> {
  switch (notification.subject.type) {
    case 'CheckSuite':
      return getGitifySubjectForCheckSuite(notification);
    case 'Discussion':
      return await getGitifySubjectForDiscussion(notification, token);
    case 'Issue':
      return await getGitifySubjectForIssue(notification, token);
    case 'PullRequest':
      return await getGitifySubjectForPullRequest(notification, token);
    case 'Release':
      return await getGitifySubjectForRelease(notification, token);
    case 'WorkflowRun':
      return getGitifySubjectForWorkflowRun(notification);
    default:
      return null;
  }
}

/**
 * Ideally we would be using a GitHub API to fetch the CheckSuite / WorkflowRun state,
 * but there isn't an obvious/clean way to do this currently.
 */
export function getCheckSuiteAttributes(
  notification: Notification,
): CheckSuiteAttributes | null {
  const regexPattern =
    /^(?<workflowName>.*?) workflow run(, Attempt #(?<attemptNumber>\d+))? (?<statusDisplayName>.*?) for (?<branchName>.*?) branch$/;

  const matches = regexPattern.exec(notification.subject.title);

  if (matches) {
    const { groups } = matches;

    return {
      workflowName: groups.workflowName,
      attemptNumber: groups.attemptNumber
        ? parseInt(groups.attemptNumber)
        : null,
      status: getCheckSuiteStatus(groups.statusDisplayName),
      statusDisplayName: groups.statusDisplayName,
      branchName: groups.branchName,
    };
  }

  return null;
}

function getCheckSuiteStatus(statusDisplayName: string): CheckSuiteStatus {
  switch (statusDisplayName) {
    case 'cancelled':
      return 'cancelled';
    case 'failed':
      return 'failure';
    case 'skipped':
      return 'skipped';
    case 'succeeded':
      return 'success';
    default:
      return null;
  }
}

function getGitifySubjectForCheckSuite(
  notification: Notification,
): GitifySubject {
  return {
    state: getCheckSuiteAttributes(notification)?.status,
    user: null,
  };
}

async function getGitifySubjectForDiscussion(
  notification: Notification,
  token: string,
): Promise<GitifySubject> {
  const discussion = await fetchDiscussion(notification, token);
  let discussionState: DiscussionStateType = 'OPEN';

  if (discussion) {
    if (discussion.isAnswered) {
      discussionState = 'ANSWERED';
    }

    if (discussion.stateReason) {
      discussionState = discussion.stateReason;
    }
  }

  const latestDiscussionComment = getLatestDiscussionComment(
    discussion.comments.nodes,
  );
  let discussionUser: SubjectUser = null;
  if (latestDiscussionComment) {
    discussionUser = {
      login: latestDiscussionComment.author.login,
      html_url: latestDiscussionComment.author.url,
      type: latestDiscussionComment.bot?.login ? 'Bot' : 'User',
    };
  }

  return {
    state: discussionState,
    user: discussionUser,
  };
}

async function getGitifySubjectForIssue(
  notification: Notification,
  token: string,
): Promise<GitifySubject> {
  try {
    const issue: Issue = (
      await apiRequestAuth(notification.subject.url, 'GET', token)
    ).data;

    const issueCommentUser = await getLatestCommentUser(notification, token);

    return {
      state: issue.state_reason ?? issue.state,
      user: {
        login: issueCommentUser?.login ?? issue.user.login,
        html_url: issueCommentUser?.html_url ?? issue.user.html_url,
        type: issueCommentUser?.type ?? issue.user.type,
      },
    };
  } catch (err) {
    console.error('Issue subject retrieval failed');
  }
}

async function getGitifySubjectForPullRequest(
  notification: Notification,
  token: string,
): Promise<GitifySubject> {
  try {
    const pr: PullRequest = (
      await apiRequestAuth(notification.subject.url, 'GET', token)
    ).data;

    let prState: PullRequestStateType = pr.state;
    if (pr.merged) {
      prState = 'merged';
    } else if (pr.draft) {
      prState = 'draft';
    }

    const prCommentUser = await getLatestCommentUser(notification, token);

    return {
      state: prState,
      user: {
        login: prCommentUser?.login ?? pr.user.login,
        html_url: prCommentUser?.html_url ?? pr.user.html_url,
        type: prCommentUser?.type ?? pr.user.type,
      },
    };
  } catch (err) {
    console.error('Pull Request subject retrieval failed');
  }
}

async function getGitifySubjectForRelease(
  notification: Notification,
  token: string,
): Promise<GitifySubject> {
  const releaseCommentUser = await getLatestCommentUser(notification, token);

  return {
    state: null,
    user: {
      login: releaseCommentUser.login,
      html_url: releaseCommentUser.html_url,
      type: releaseCommentUser.type,
    },
  };
}

function getGitifySubjectForWorkflowRun(
  notification: Notification,
): GitifySubject {
  return {
    state: getWorkflowRunAttributes(notification)?.status,
    user: null,
  };
}

/**
 * Ideally we would be using a GitHub API to fetch the CheckSuite / WorkflowRun state,
 * but there isn't an obvious/clean way to do this currently.
 */
export function getWorkflowRunAttributes(
  notification: Notification,
): WorkflowRunAttributes | null {
  const regexPattern =
    /^(?<user>.*?) requested your (?<statusDisplayName>.*?) to deploy to an environment$/;

  const matches = regexPattern.exec(notification.subject.title);

  if (matches) {
    const { groups } = matches;

    return {
      user: groups.user,
      status: getWorkflowRunStatus(groups.statusDisplayName),
      statusDisplayName: groups.statusDisplayName,
    };
  }

  return null;
}

function getWorkflowRunStatus(statusDisplayName: string): CheckSuiteStatus {
  switch (statusDisplayName) {
    case 'review':
      return 'waiting';
    default:
      return null;
  }
}

async function getLatestCommentUser(
  notification: Notification,
  token: string,
): Promise<User> | null {
  if (!notification.subject.latest_comment_url) {
    return null;
  }

  try {
    const response: IssueComments | ReleaseComments = (
      await apiRequestAuth(
        notification.subject.latest_comment_url,
        'GET',
        token,
      )
    )?.data;

    return (
      (response as IssueComments)?.user ?? (response as ReleaseComments).author
    );
  } catch (err) {
    console.error('Discussion latest comment retrieval failed');
  }
}

1	import { fetchDiscussion, getLatestDiscussionComment } from './helpers';	32✔
2	import {
3	CheckSuiteAttributes,
4	CheckSuiteStatus,
5	DiscussionStateType,
6	GitifySubject,
7	Issue,
8	IssueComments,
9	Notification,
10	PullRequest,
11	PullRequestStateType,
12	ReleaseComments,
13	SubjectUser,
14	User,
15	WorkflowRunAttributes,
16	} from '../typesGithub';
17	import { apiRequestAuth } from './api-requests';	32✔
18
19	export async function getGitifySubjectDetails(	32✔
20	notification: Notification,
21	token: string,
22	): Promise<GitifySubject> {
23	switch (notification.subject.type) {	54✔
24	case 'CheckSuite':
25	return getGitifySubjectForCheckSuite(notification);	2✔
26	case 'Discussion':
27	return await getGitifySubjectForDiscussion(notification, token);	16✔
28	case 'Issue':
29	return await getGitifySubjectForIssue(notification, token);	16✔
30	case 'PullRequest':
31	return await getGitifySubjectForPullRequest(notification, token);	14✔
32	case 'Release':
33	return await getGitifySubjectForRelease(notification, token);	2✔
34	case 'WorkflowRun':
35	return getGitifySubjectForWorkflowRun(notification);	2✔
36	default:
37	return null;	2✔
38	}
39	}
40
41	/**
42	* Ideally we would be using a GitHub API to fetch the CheckSuite / WorkflowRun state,
43	* but there isn't an obvious/clean way to do this currently.
44	*/
45	export function getCheckSuiteAttributes(	32✔
46	notification: Notification,
47	): CheckSuiteAttributes \| null {
48	const regexPattern =
49	/^(?<workflowName>.?) workflow run(, Attempt #(?<attemptNumber>\d+))? (?<statusDisplayName>.?) for (?<branchName>.*?) branch$/;	30✔
50
51	const matches = regexPattern.exec(notification.subject.title);	30✔
52
53	if (matches) {	30✔
54	const { groups } = matches;	22✔
55
56	return {	22✔
57	workflowName: groups.workflowName,
58	attemptNumber: groups.attemptNumber	11✔
59	? parseInt(groups.attemptNumber)
60	: null,
61	status: getCheckSuiteStatus(groups.statusDisplayName),
62	statusDisplayName: groups.statusDisplayName,
63	branchName: groups.branchName,
64	};
65	}
66
67	return null;	8✔
68	}
69
70	function getCheckSuiteStatus(statusDisplayName: string): CheckSuiteStatus {
71	switch (statusDisplayName) {	22✔
72	case 'cancelled':
73	return 'cancelled';	2✔
74	case 'failed':
75	return 'failure';	8✔
76	case 'skipped':
77	return 'skipped';	4✔
78	case 'succeeded':
79	return 'success';	4✔
80	default:
81	return null;	4✔
82	}
83	}
84
85	function getGitifySubjectForCheckSuite(
86	notification: Notification,
87	): GitifySubject {
88	return {	2✔
89	state: getCheckSuiteAttributes(notification)?.status,
90	user: null,
91	};
92	}
93
94	async function getGitifySubjectForDiscussion(
95	notification: Notification,
96	token: string,
97	): Promise<GitifySubject> {
98	const discussion = await fetchDiscussion(notification, token);	16✔
99	let discussionState: DiscussionStateType = 'OPEN';	16✔
100
101	if (discussion) {	16✔
102	if (discussion.isAnswered) {	16✔
103	discussionState = 'ANSWERED';	4✔
104	}
105
106	if (discussion.stateReason) {	16✔
107	discussionState = discussion.stateReason;	8✔
108	}
109	}
110
111	const latestDiscussionComment = getLatestDiscussionComment(	16✔
112	discussion.comments.nodes,
113	);
114	let discussionUser: SubjectUser = null;	16✔
115	if (latestDiscussionComment) {	16✔
116	discussionUser = {	2✔
117	login: latestDiscussionComment.author.login,
118	html_url: latestDiscussionComment.author.url,
119	type: latestDiscussionComment.bot?.login ? 'Bot' : 'User',	1!
120	};
121	}
122
123	return {	16✔
124	state: discussionState,
125	user: discussionUser,
126	};
127	}
128
129	async function getGitifySubjectForIssue(
130	notification: Notification,
131	token: string,
132	): Promise<GitifySubject> {
133	try {	16✔
134	const issue: Issue = (	16✔
135	await apiRequestAuth(notification.subject.url, 'GET', token)
136	).data;
137
138	const issueCommentUser = await getLatestCommentUser(notification, token);	16✔
139
140	return {	16✔
141	state: issue.state_reason ?? issue.state,	13✔
142	user: {
143	login: issueCommentUser?.login ?? issue.user.login,	10✔
144	html_url: issueCommentUser?.html_url ?? issue.user.html_url,	15✔
145	type: issueCommentUser?.type ?? issue.user.type,	15✔
146	},
147	};
148	} catch (err) {
NEW 149	console.error('Issue subject retrieval failed');	×
150	}
151	}
152
153	async function getGitifySubjectForPullRequest(
154	notification: Notification,
155	token: string,
156	): Promise<GitifySubject> {
157	try {	14✔
158	const pr: PullRequest = (	14✔
159	await apiRequestAuth(notification.subject.url, 'GET', token)
160	).data;
161
162	let prState: PullRequestStateType = pr.state;	14✔
163	if (pr.merged) {	14✔
164	prState = 'merged';	2✔
165	} else if (pr.draft) {	12✔
166	prState = 'draft';	2✔
167	}
168
169	const prCommentUser = await getLatestCommentUser(notification, token);	14✔
170
171	return {	14✔
172	state: prState,
173	user: {
174	login: prCommentUser?.login ?? pr.user.login,	9✔
175	html_url: prCommentUser?.html_url ?? pr.user.html_url,	13✔
176	type: prCommentUser?.type ?? pr.user.type,	13✔
177	},
178	};
179	} catch (err) {
NEW 180	console.error('Pull Request subject retrieval failed');	×
181	}
182	}
183
184	async function getGitifySubjectForRelease(
185	notification: Notification,
186	token: string,
187	): Promise<GitifySubject> {
188	const releaseCommentUser = await getLatestCommentUser(notification, token);	2✔
189
190	return {	2✔
191	state: null,
192	user: {
193	login: releaseCommentUser.login,
194	html_url: releaseCommentUser.html_url,
195	type: releaseCommentUser.type,
196	},
197	};
198	}
199
200	function getGitifySubjectForWorkflowRun(
201	notification: Notification,
202	): GitifySubject {
203	return {	2✔
204	state: getWorkflowRunAttributes(notification)?.status,
205	user: null,
206	};
207	}
208
209	/**
210	* Ideally we would be using a GitHub API to fetch the CheckSuite / WorkflowRun state,
211	* but there isn't an obvious/clean way to do this currently.
212	*/
213	export function getWorkflowRunAttributes(	32✔
214	notification: Notification,
215	): WorkflowRunAttributes \| null {
216	const regexPattern =
217	/^(?<user>.?) requested your (?<statusDisplayName>.?) to deploy to an environment$/;	14✔
218
219	const matches = regexPattern.exec(notification.subject.title);	14✔
220
221	if (matches) {	14✔
222	const { groups } = matches;	8✔
223
224	return {	8✔
225	user: groups.user,
226	status: getWorkflowRunStatus(groups.statusDisplayName),
227	statusDisplayName: groups.statusDisplayName,
228	};
229	}
230
231	return null;	6✔
232	}
233
234	function getWorkflowRunStatus(statusDisplayName: string): CheckSuiteStatus {
235	switch (statusDisplayName) {	8✔
236	case 'review':
237	return 'waiting';	4✔
238	default:
239	return null;	4✔
240	}
241	}
242
243	async function getLatestCommentUser(
244	notification: Notification,
245	token: string,
246	): Promise<User> \| null {
247	if (!notification.subject.latest_comment_url) {	32✔
248	return null;	8✔
249	}
250
251	try {	24✔
252	const response: IssueComments \| ReleaseComments = (	24✔
253	await apiRequestAuth(
254	notification.subject.latest_comment_url,
255	'GET',
256	token,
257	)
258	)?.data;
259
260	return (	24✔
261	(response as IssueComments)?.user ?? (response as ReleaseComments).author	13✔
262	);
263	} catch (err) {
NEW 264	console.error('Discussion latest comment retrieval failed');	×
265	}
266	}

gitify-app / gitify / 8580878397

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous