9295963224

Committed 30 May 2024 02:18AM UTC coverage: 96.787%. Remained the same

Build # 9295963224

Build Type

push

github

Committed by

web-flow

Commit Message

refactor: continued renaming of accounts to auth (#1156)

Run Details

401 of 412 branches covered (97.33%)

Branch coverage included in aggregate %.

14 of 23 new or added lines in 3 files covered. (60.87%)

1 existing line in 1 file now uncovered.

1045 of 1082 relevant lines covered (96.58%)

21.0 hits per line

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

74.73

/src/context/App.tsx

import {
  type ReactNode,
  createContext,
  useCallback,
  useEffect,
  useMemo,
  useState,
} from 'react';
import { useInterval } from '../hooks/useInterval';
import { useNotifications } from '../hooks/useNotifications';
import {
  type AccountNotifications,
  type AuthOptions,
  type AuthState,
  type AuthTokenOptions,
  type GitifyError,
  type SettingsState,
  type Status,
  Theme,
} from '../types';
import { headNotifications } from '../utils/api/client';
import { addAccount, authGitHub, getToken, getUserData } from '../utils/auth';
import { setAutoLaunch, updateTrayTitle } from '../utils/comms';
import Constants from '../utils/constants';
import { getNotificationCount } from '../utils/notifications';
import { clearState, loadState, saveState } from '../utils/storage';
import { setTheme } from '../utils/theme';

const defaultAuth: 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,
  detailedNotifications: true,
  markAsDoneOnOpen: false,
  showAccountHostname: false,
  delayNotificationState: false,
};

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

  notifications: AccountNotifications[];
  status: Status;
  errorDetails: GitifyError;
  removeNotificationFromState: (
    settings: SettingsState,
    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: boolean | Theme | string | null,
  ) => void;
}

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

export const AppProvider = ({ children }: { children: ReactNode }) => {
  const [auth, setAuth] = useState<AuthState>(defaultAuth);
  const [settings, setSettings] = useState<SettingsState>(defaultSettings);
  const {
    fetchNotifications,
    notifications,
    errorDetails,
    status,
    removeNotificationFromState,
    markNotificationRead,
    markNotificationDone,
    unsubscribeNotification,
    markRepoNotifications,
    markRepoNotificationsDone,
  } = useNotifications();

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

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

  // biome-ignore lint/correctness/useExhaustiveDependencies: We only want fetchNotifications to be called for certain account or setting changes.
  useEffect(() => {
    fetchNotifications(auth, settings);
  }, [
    settings.participating,
    settings.showBots,
    settings.detailedNotifications,
    auth.token,
    auth.enterpriseAccounts.length,
  ]);

  useInterval(() => {
    fetchNotifications(auth, settings);
  }, Constants.FETCH_INTERVAL);

  // biome-ignore lint/correctness/useExhaustiveDependencies: We need to update tray title when settings or notifications changes.
  useEffect(() => {
    const count = getNotificationCount(notifications);

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

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

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

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

  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 updatedAuth = addAccount(auth, token, hostname, user);
    setAuth(updatedAuth);
    saveState({ auth: updatedAuth, settings });
  }, [auth, settings]);

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

  const validateToken = useCallback(
    async ({ token, hostname }: AuthTokenOptions) => {
      await headNotifications(hostname, token);

      const user = await getUserData(token, hostname);
      const updatedAccounts = addAccount(auth, token, hostname, user);
      setAuth(updatedAccounts);
      saveState({ auth: updatedAccounts, settings });
    },
    [auth, settings],
  );

  const logout = useCallback(() => {
    setAuth(defaultAuth);
    clearState();
  }, []);

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

    if (existing.auth) {
      setAuth({ ...defaultAuth, ...existing.auth });
    }

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

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

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

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

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

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

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

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

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

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

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

gitify-app / gitify / 9295963224

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