8584042517

Committed 06 Apr 2024 10:00PM UTC coverage: 95.205% (+0.09%) from 95.112%

Build # 8584042517

Build Type

push

github

Committed by

web-flow

Commit Message

feat(discussions): default to discussion author (#964)

* fix(discussions): default to discussion author when there are no comments/replies

Run Details

362 of 380 branches covered (95.26%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

8 existing lines in 2 files now uncovered.

869 of 913 relevant lines covered (95.18%)

16.62 hits per line

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

74.47

/src/context/App.tsx

import React, {
  createContext,
  useCallback,
  useEffect,
  useMemo,
  useState,
} from 'react';

import { useInterval } from '../hooks/useInterval';
import { useNotifications } from '../hooks/useNotifications';
import {
  AccountNotifications,
  Theme,
  AuthOptions,
  AuthState,
  AuthTokenOptions,
  SettingsState,
} from '../types';
import { apiRequestAuth } from '../utils/api-requests';
import { setTheme } from '../utils/theme';
import { addAccount, authGitHub, getToken, getUserData } from '../utils/auth';
import { setAutoLaunch, updateTrayTitle } from '../utils/comms';
import Constants from '../utils/constants';
import { generateGitHubAPIUrl } from '../utils/helpers';
import { clearState, loadState, saveState } from '../utils/storage';
import { getNotificationCount } from '../utils/notifications';

const defaultAccounts: AuthState = {
  token: null,
  enterpriseAccounts: [],
  user: null,
};

export const defaultSettings: SettingsState = {
  participating: false,
  playSound: true,
  showNotifications: true,
  showBots: true,
  showNotificationsCountInTray: false,
  openAtStartup: false,
  theme: Theme.SYSTEM,
  colors: null,
  markAsDoneOnOpen: false,
  showAccountHostname: false,
};

interface AppContextState {
  accounts: AuthState;
  isLoggedIn: boolean;
  login: () => void;
  loginEnterprise: (data: AuthOptions) => void;
  validateToken: (data: AuthTokenOptions) => void;
  logout: () => void;

  notifications: AccountNotifications[];
  isFetching: boolean;
  requestFailed: boolean;
  removeNotificationFromState: (id: string, hostname: string) => void;
  fetchNotifications: () => Promise<void>;
  markNotificationRead: (id: string, hostname: string) => Promise<void>;
  markNotificationDone: (id: string, hostname: string) => Promise<void>;
  unsubscribeNotification: (id: string, hostname: string) => Promise<void>;
  markRepoNotifications: (id: string, hostname: string) => Promise<void>;
  markRepoNotificationsDone: (id: string, hostname: string) => Promise<void>;

  settings: SettingsState;
  updateSetting: (name: keyof SettingsState, value: any) => void;
}

export const AppContext = createContext<Partial<AppContextState>>({});

export const AppProvider = ({ children }: { children: React.ReactNode }) => {
  const [accounts, setAccounts] = useState<AuthState>(defaultAccounts);
  const [settings, setSettings] = useState<SettingsState>(defaultSettings);
  const {
    fetchNotifications,
    notifications,
    requestFailed,
    isFetching,
    removeNotificationFromState,
    markNotificationRead,
    markNotificationDone,
    unsubscribeNotification,
    markRepoNotifications,
    markRepoNotificationsDone,
  } = useNotifications(settings.colors);

  useEffect(() => {
    restoreSettings();
  }, []);

  useEffect(() => {
    setTheme(settings.theme as Theme);
  }, [settings.theme]);

  useEffect(() => {
    fetchNotifications(accounts, settings);
  }, [settings.participating, settings.showBots]);

  useEffect(() => {
    fetchNotifications(accounts, settings);
  }, [accounts.token, accounts.enterpriseAccounts.length]);

  useEffect(() => {
    const count = getNotificationCount(notifications);

    if (settings.showNotificationsCountInTray && count > 0) {
      updateTrayTitle(count.toString());
    } else {
      updateTrayTitle();
    }
  }, [settings.showNotificationsCountInTray, notifications]);

  useInterval(() => {
    fetchNotifications(accounts, settings);
  }, 60000);

  const updateSetting = useCallback(
    (name: keyof SettingsState, value: boolean | Theme) => {
      if (name === 'openAtStartup') {
        setAutoLaunch(value as boolean);
      }

      const newSettings = { ...settings, [name]: value };
      setSettings(newSettings);
      saveState(accounts, newSettings);
    },
    [accounts, settings],
  );

  const isLoggedIn = useMemo(() => {
    return !!accounts.token || accounts.enterpriseAccounts.length > 0;
  }, [accounts]);

  const login = useCallback(async () => {
    const { authCode } = await authGitHub();
    const { token } = await getToken(authCode);
    const hostname = Constants.DEFAULT_AUTH_OPTIONS.hostname;
    const user = await getUserData(token, hostname);
    const updatedAccounts = addAccount(accounts, token, hostname, user);
    setAccounts(updatedAccounts);
    saveState(updatedAccounts, settings);
  }, [accounts, settings]);

  const loginEnterprise = useCallback(
    async (data: AuthOptions) => {
      const { authOptions, authCode } = await authGitHub(data);
      const { token, hostname } = await getToken(authCode, authOptions);
      const updatedAccounts = addAccount(accounts, token, hostname);
      setAccounts(updatedAccounts);
      saveState(updatedAccounts, settings);
    },
    [accounts, settings],
  );

  const validateToken = useCallback(
    async ({ token, hostname }: AuthTokenOptions) => {
      await apiRequestAuth(
        `${generateGitHubAPIUrl(hostname)}notifications`,
        'HEAD',
        token,
      );
      const user = await getUserData(token, hostname);
      const updatedAccounts = addAccount(accounts, token, hostname, user);
      setAccounts(updatedAccounts);
      saveState(updatedAccounts, settings);
    },
    [accounts, settings],
  );

  const logout = useCallback(() => {
    setAccounts(defaultAccounts);
    clearState();
  }, []);

  const restoreSettings = useCallback(() => {
    const existing = loadState();

    if (existing.accounts) {
      setAccounts({ ...defaultAccounts, ...existing.accounts });
    }

    if (existing.settings) {
      setSettings({ ...defaultSettings, ...existing.settings });
      return existing.settings;
    }
  }, []);

  const fetchNotificationsWithAccounts = useCallback(
    async () => await fetchNotifications(accounts, settings),
    [accounts, settings, notifications],
  );

  const markNotificationReadWithAccounts = useCallback(
    async (id: string, hostname: string) =>
      await markNotificationRead(accounts, id, hostname),
    [accounts, notifications],
  );

  const markNotificationDoneWithAccounts = useCallback(
    async (id: string, hostname: string) =>
      await markNotificationDone(accounts, id, hostname),
    [accounts, notifications],
  );

  const unsubscribeNotificationWithAccounts = useCallback(
    async (id: string, hostname: string) =>
      await unsubscribeNotification(accounts, id, hostname),
    [accounts, notifications],
  );

  const markRepoNotificationsWithAccounts = useCallback(
    async (repoSlug: string, hostname: string) =>
      await markRepoNotifications(accounts, repoSlug, hostname),
    [accounts, notifications],
  );

  const markRepoNotificationsDoneWithAccounts = useCallback(
    async (repoSlug: string, hostname: string) =>
      await markRepoNotificationsDone(accounts, repoSlug, hostname),
    [accounts, notifications],
  );

  return (
    <AppContext.Provider
      value={{
        accounts,
        isLoggedIn,
        login,
        loginEnterprise,
        validateToken,
        logout,

        notifications,
        isFetching,
        requestFailed,
        removeNotificationFromState,
        fetchNotifications: fetchNotificationsWithAccounts,
        markNotificationRead: markNotificationReadWithAccounts,
        markNotificationDone: markNotificationDoneWithAccounts,
        unsubscribeNotification: unsubscribeNotificationWithAccounts,
        markRepoNotifications: markRepoNotificationsWithAccounts,
        markRepoNotificationsDone: markRepoNotificationsDoneWithAccounts,

        settings,
        updateSetting,
      }}
    >
      {children}
    </AppContext.Provider>
  );
};

1	import React, {	22✔
2	createContext,
3	useCallback,
4	useEffect,
5	useMemo,
6	useState,
7	} from 'react';
8
9	import { useInterval } from '../hooks/useInterval';	22✔
10	import { useNotifications } from '../hooks/useNotifications';	22✔
11	import {	22✔
12	AccountNotifications,
13	Theme,
14	AuthOptions,
15	AuthState,
16	AuthTokenOptions,
17	SettingsState,
18	} from '../types';
19	import { apiRequestAuth } from '../utils/api-requests';	22✔
20	import { setTheme } from '../utils/theme';	22✔
21	import { addAccount, authGitHub, getToken, getUserData } from '../utils/auth';	22✔
22	import { setAutoLaunch, updateTrayTitle } from '../utils/comms';	22✔
23	import Constants from '../utils/constants';	22✔
24	import { generateGitHubAPIUrl } from '../utils/helpers';	22✔
25	import { clearState, loadState, saveState } from '../utils/storage';	22✔
26	import { getNotificationCount } from '../utils/notifications';	22✔
27
28	const defaultAccounts: AuthState = {	22✔
29	token: null,
30	enterpriseAccounts: [],
31	user: null,
32	};
33
34	export const defaultSettings: SettingsState = {	22✔
35	participating: false,
36	playSound: true,
37	showNotifications: true,
38	showBots: true,
39	showNotificationsCountInTray: false,
40	openAtStartup: false,
41	theme: Theme.SYSTEM,
42	colors: null,
43	markAsDoneOnOpen: false,
44	showAccountHostname: false,
45	};
46
47	interface AppContextState {
48	accounts: AuthState;
49	isLoggedIn: boolean;
50	login: () => void;
51	loginEnterprise: (data: AuthOptions) => void;
52	validateToken: (data: AuthTokenOptions) => void;
53	logout: () => void;
54
55	notifications: AccountNotifications[];
56	isFetching: boolean;
57	requestFailed: boolean;
58	removeNotificationFromState: (id: string, hostname: string) => void;
59	fetchNotifications: () => Promise<void>;
60	markNotificationRead: (id: string, hostname: string) => Promise<void>;
61	markNotificationDone: (id: string, hostname: string) => Promise<void>;
62	unsubscribeNotification: (id: string, hostname: string) => Promise<void>;
63	markRepoNotifications: (id: string, hostname: string) => Promise<void>;
64	markRepoNotificationsDone: (id: string, hostname: string) => Promise<void>;
65
66	settings: SettingsState;
67	updateSetting: (name: keyof SettingsState, value: any) => void;
68	}
69
70	export const AppContext = createContext<Partial<AppContextState>>({});	22✔
71
72	export const AppProvider = ({ children }: { children: React.ReactNode }) => {	22✔
73	const [accounts, setAccounts] = useState<AuthState>(defaultAccounts);	24✔
74	const [settings, setSettings] = useState<SettingsState>(defaultSettings);	24✔
75	const {
76	fetchNotifications,
77	notifications,
78	requestFailed,
79	isFetching,
80	removeNotificationFromState,
81	markNotificationRead,
82	markNotificationDone,
83	unsubscribeNotification,
84	markRepoNotifications,
85	markRepoNotificationsDone,
86	} = useNotifications(settings.colors);	24✔
87
88	useEffect(() => {	24✔
89	restoreSettings();	20✔
90	}, []);
91
92	useEffect(() => {	24✔
93	setTheme(settings.theme as Theme);	20✔
94	}, [settings.theme]);
95
96	useEffect(() => {	24✔
97	fetchNotifications(accounts, settings);	22✔
98	}, [settings.participating, settings.showBots]);
99
100	useEffect(() => {	24✔
101	fetchNotifications(accounts, settings);	20✔
102	}, [accounts.token, accounts.enterpriseAccounts.length]);
103
104	useEffect(() => {	24✔
105	const count = getNotificationCount(notifications);	20✔
106
107	if (settings.showNotificationsCountInTray && count > 0) {	20!
UNCOV 108	updateTrayTitle(count.toString());	×
109	} else {
110	updateTrayTitle();	20✔
111	}
112	}, [settings.showNotificationsCountInTray, notifications]);
113
114	useInterval(() => {	24✔
115	fetchNotifications(accounts, settings);	6✔
116	}, 60000);
117
118	const updateSetting = useCallback(	24✔
119	(name: keyof SettingsState, value: boolean \| Theme) => {
120	if (name === 'openAtStartup') {	4✔
121	setAutoLaunch(value as boolean);	2✔
122	}
123
124	const newSettings = { ...settings, [name]: value };	4✔
125	setSettings(newSettings);	4✔
126	saveState(accounts, newSettings);	4✔
127	},
128	[accounts, settings],
129	);
130
131	const isLoggedIn = useMemo(() => {	24✔
132	return !!accounts.token \|\| accounts.enterpriseAccounts.length > 0;	20✔
133	}, [accounts]);
134
135	const login = useCallback(async () => {	24✔
136	const { authCode } = await authGitHub();	×
137	const { token } = await getToken(authCode);	×
138	const hostname = Constants.DEFAULT_AUTH_OPTIONS.hostname;	×
139	const user = await getUserData(token, hostname);	×
140	const updatedAccounts = addAccount(accounts, token, hostname, user);	×
141	setAccounts(updatedAccounts);	×
UNCOV 142	saveState(updatedAccounts, settings);	×
143	}, [accounts, settings]);
144
145	const loginEnterprise = useCallback(	24✔
146	async (data: AuthOptions) => {
147	const { authOptions, authCode } = await authGitHub(data);	×
148	const { token, hostname } = await getToken(authCode, authOptions);	×
149	const updatedAccounts = addAccount(accounts, token, hostname);	×
150	setAccounts(updatedAccounts);	×
UNCOV 151	saveState(updatedAccounts, settings);	×
152	},
153	[accounts, settings],
154	);
155
156	const validateToken = useCallback(	24✔
157	async ({ token, hostname }: AuthTokenOptions) => {
158	await apiRequestAuth(	2✔
159	`${generateGitHubAPIUrl(hostname)}notifications`,
160	'HEAD',
161	token,
162	);
163	const user = await getUserData(token, hostname);	2✔
164	const updatedAccounts = addAccount(accounts, token, hostname, user);	×
165	setAccounts(updatedAccounts);	×
UNCOV 166	saveState(updatedAccounts, settings);	×
167	},
168	[accounts, settings],
169	);
170
171	const logout = useCallback(() => {	24✔
172	setAccounts(defaultAccounts);	2✔
173	clearState();	2✔
174	}, []);
175
176	const restoreSettings = useCallback(() => {	24✔
177	const existing = loadState();	20✔
178
179	if (existing.accounts) {	20!
UNCOV 180	setAccounts({ ...defaultAccounts, ...existing.accounts });	×
181	}
182
183	if (existing.settings) {	20!
184	setSettings({ ...defaultSettings, ...existing.settings });	×
UNCOV 185	return existing.settings;	×
186	}
187	}, []);
188
189	const fetchNotificationsWithAccounts = useCallback(	24✔
190	async () => await fetchNotifications(accounts, settings),	2✔
191	[accounts, settings, notifications],
192	);
193
194	const markNotificationReadWithAccounts = useCallback(	24✔
195	async (id: string, hostname: string) =>
196	await markNotificationRead(accounts, id, hostname),	2✔
197	[accounts, notifications],
198	);
199
200	const markNotificationDoneWithAccounts = useCallback(	24✔
201	async (id: string, hostname: string) =>
202	await markNotificationDone(accounts, id, hostname),	2✔
203	[accounts, notifications],
204	);
205
206	const unsubscribeNotificationWithAccounts = useCallback(	24✔
207	async (id: string, hostname: string) =>
208	await unsubscribeNotification(accounts, id, hostname),	2✔
209	[accounts, notifications],
210	);
211
212	const markRepoNotificationsWithAccounts = useCallback(	24✔
213	async (repoSlug: string, hostname: string) =>
214	await markRepoNotifications(accounts, repoSlug, hostname),	2✔
215	[accounts, notifications],
216	);
217
218	const markRepoNotificationsDoneWithAccounts = useCallback(	24✔
219	async (repoSlug: string, hostname: string) =>
UNCOV 220	await markRepoNotificationsDone(accounts, repoSlug, hostname),	×
221	[accounts, notifications],
222	);
223
224	return (	24✔
225	<AppContext.Provider
226	value={{
227	accounts,
228	isLoggedIn,
229	login,
230	loginEnterprise,
231	validateToken,
232	logout,
233
234	notifications,
235	isFetching,
236	requestFailed,
237	removeNotificationFromState,
238	fetchNotifications: fetchNotificationsWithAccounts,
239	markNotificationRead: markNotificationReadWithAccounts,
240	markNotificationDone: markNotificationDoneWithAccounts,
241	unsubscribeNotification: unsubscribeNotificationWithAccounts,
242	markRepoNotifications: markRepoNotificationsWithAccounts,
243	markRepoNotificationsDone: markRepoNotificationsDoneWithAccounts,
244
245	settings,
246	updateSetting,
247	}}
248	>
249	{children}
250	</AppContext.Provider>
251	);
252	};

gitify-app / gitify / 8584042517

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