@anmiles/google-api-wrapper 18.0.2 → 19.0.0

package/src/lib/__tests__/api.test.ts

@@ -1,18 +1,26 @@
+import logger from '@anmiles/logger';
+import sleep from '@anmiles/sleep';
 import type GoogleApis from 'googleapis';
 import type { calendar_v3 } from 'googleapis/build/src/apis/calendar';
 import { calendar } from 'googleapis/build/src/apis/calendar';
-import logger from '@anmiles/logger';
-import sleep from '@anmiles/sleep';
-import auth from '../auth';
-import secrets from '../secrets';
+
+import { API,  getAPI } from '../api';
 import type { CommonResponse } from '../api';
-import api from '../api';
+import { getAuth } from '../auth';
+import { deleteCredentials } from '../credentials';
+
+jest.mock('@anmiles/logger');
+jest.mock('@anmiles/sleep');
+jest.mock('googleapis/build/src/apis/calendar');
+
+jest.mock('../auth');
+jest.mock('../credentials');
 
-const items: Array<{ data : string }> = [
-	{ data : 'first' },
-	{ data : 'second' },
-	{ data : 'third' },
-	{ data : 'forth' },
+const items: Array<{ data: string }> = [
+	{ data: 'first' },
+	{ data: 'second' },
+	{ data: 'third' },
+	{ data: 'forth' },
 ];
 
 const response = [
@@ -27,11 +35,11 @@ const pageTokens = [
 	'token2',
 ];
 
-const getAPI = <T>(items: Array<Array<T> | null>, pageTokens: Array<string | undefined>): {
-	list   : jest.Mock;
-	update : jest.Mock;
+const getCalendarAPI = <T>(items: Array<Array<T> | null>, pageTokens: Array<string | undefined>): {
+	list: jest.Mock;
+	update: jest.Mock;
 } => ({
-	list : jest.fn().mockImplementation(({ pageToken }: { pageToken? : string }): Pick<GoogleApis.Common.GaxiosResponse<CommonResponse<unknown>>, 'data'> => {
+	list: jest.fn().mockImplementation(({ pageToken }: { pageToken?: string }): Pick<GoogleApis.Common.GaxiosResponse<CommonResponse<unknown>>, 'data'> => {
 		const listException = getListException();
 
 		if (listException) {
@@ -41,107 +49,96 @@ const getAPI = <T>(items: Array<Array<T> | null>, pageTokens: Array<string | und
 		const index = pageTokens.indexOf(pageToken);
 
 		return {
-			data : {
-				items         : items[index]!,
-				nextPageToken : pageTokens[index + 1],
-				pageInfo      : {
-					totalResults : !items[index]
+			data: {
+				items        : items[index]!,
+				nextPageToken: pageTokens[index + 1],
+				pageInfo     : {
+					totalResults: !items[index]
 						? null
 						: items.reduce((sum, list) => sum + (list?.length ?? 0), 0),
 				},
 			},
 		};
 	}),
-	update : jest.fn(),
+	update: jest.fn(),
 });
 
-const params = { key : 'value' };
+const params = { key: 'value' };
 
-const profile = 'username1';
-const apis    = {
-	calendarList : getAPI(response, pageTokens),
+const profile      = 'username1';
+const calendarList = getCalendarAPI(response, pageTokens);
+const calendarApis = {
+	calendarList,
 };
 
-const googleAuth = 'googleAuth';
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+const googleAuth = {} as GoogleApis.Common.OAuth2Client;
 
 const scopes = [ 'scope1', 'scope2' ];
 
-const getListException = jest.fn() as jest.Mock<Error | undefined>;
+const getListException = jest.mocked(jest.fn());
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+jest.mocked(calendar).mockImplementation(() => calendarApis as unknown as GoogleApis.calendar_v3.Calendar);
+jest.mocked(getAuth).mockResolvedValue(googleAuth);
 
 beforeEach(() => {
 	getListException.mockReturnValue(undefined);
 });
 
-jest.mock<{ calendar : typeof calendar }>('googleapis/build/src/apis/calendar', () => ({
-	calendar : jest.fn().mockImplementation(() => apis),
-}));
-
-jest.mock<Partial<typeof auth>>('../auth', () => ({
-	getAuth : jest.fn().mockImplementation(() => googleAuth),
-}));
-
-jest.mock<Partial<typeof secrets>>('../secrets', () => ({
-	deleteCredentials : jest.fn(),
-}));
-
-jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
-	log  : jest.fn(),
-	warn : jest.fn(),
-}));
-
-jest.mock<Partial<typeof sleep>>('@anmiles/sleep', () => jest.fn());
-
 describe('src/lib/api', () => {
 	describe('getAPI', () => {
 		it('should call getAuth', async () => {
-			await api.getAPI((auth) => calendar({ version : 'v3', auth }), profile);
+			await getAPI((auth) => calendar({ version: 'v3', auth }), profile);
 
-			expect(auth.getAuth).toHaveBeenCalledWith(profile, undefined);
+			expect(getAuth).toHaveBeenCalledWith(profile, undefined);
 		});
 
 		it('should pass temporariness and scopes', async () => {
-			await api.getAPI((auth) => calendar({ version : 'v3', auth }), profile, { scopes, temporary : true });
+			await getAPI((auth) => calendar({ version: 'v3', auth }), profile, { scopes, temporary: true });
 
-			expect(auth.getAuth).toHaveBeenCalledWith(profile, { scopes, temporary : true });
+			expect(getAuth).toHaveBeenCalledWith(profile, { scopes, temporary: true });
 		});
 
 		it('should warn when creating permanent credentials using non-readonly scopes', async () => {
-			await api.getAPI((auth) => calendar({ version : 'v3', auth }), profile, { scopes });
+			await getAPI((auth) => calendar({ version: 'v3', auth }), profile, { scopes });
 
-			expect(logger.warn).toHaveBeenCalledWith('WARNING: trying to create permanent credentials using non-readonly scopes (scope1, scope2). Permanent credentials will be stored in the file and potentially might be re-used to modify your data');
+			expect(logger.warn).toHaveBeenCalledWith('\
+WARNING: trying to create permanent credentials using non-readonly scopes (scope1, scope2). \
+Permanent credentials will be stored in the file and potentially might be re-used to modify your data');
 		});
 
 		it('should not warn when creating temporary credentials using non-readonly scopes', async () => {
-			await api.getAPI((auth) => calendar({ version : 'v3', auth }), profile, { scopes, temporary : true });
+			await getAPI((auth) => calendar({ version: 'v3', auth }), profile, { scopes, temporary: true });
 
 			expect(logger.warn).not.toHaveBeenCalled();
 		});
 
 		it('should not warn when creating permanent credentials using readonly scopes only', async () => {
-			await api.getAPI((auth) => calendar({ version : 'v3', auth }), profile, { scopes : [ 'scope1.readonly', 'scope2.readonly' ], temporary : true });
+			await getAPI((auth) => calendar({ version: 'v3', auth }), profile, { scopes: [ 'scope1.readonly', 'scope2.readonly' ], temporary: true });
 
 			expect(logger.warn).not.toHaveBeenCalled();
 		});
 	});
 
 	describe('API', () => {
-		let instance: InstanceType<typeof api.API<calendar_v3.Calendar>>;
+		let instance: InstanceType<typeof API<calendar_v3.Calendar>>;
 
 		beforeEach(async () => {
-			instance = await api.getAPI((auth) => calendar({ version : 'v3', auth }), profile);
+			instance = await getAPI((auth) => calendar({ version: 'v3', auth }), profile);
 		});
 
 		describe('getItems', () => {
 			it('should call API list method for each page', async () => {
-				await instance.getItems((api) => api.calendarList, params);
+				await instance.getItems(() => calendarList, params);
 
 				pageTokens.forEach((pageToken) => {
-					expect(apis.calendarList.list).toHaveBeenCalledWith({ ...params, pageToken });
+					expect(calendarApis.calendarList.list).toHaveBeenCalledWith({ ...params, pageToken });
 				});
 			});
 
 			it('should output progress by default', async () => {
-				await instance.getItems((api) => api.calendarList, params);
+				await instance.getItems(() => calendarList, params);
 
 				expect(logger.log).toHaveBeenCalledTimes(response.length);
 				expect(logger.log).toHaveBeenCalledWith('Getting items (2 of 4)...');
@@ -150,25 +147,24 @@ describe('src/lib/api', () => {
 			});
 
 			it('should not output progress if hidden', async () => {
-				await instance.getItems((api) => api.calendarList, params, { hideProgress : true });
+				await instance.getItems(() => calendarList, params, { hideProgress: true });
 
 				expect(logger.log).not.toHaveBeenCalled();
 			});
 
 			it('should sleep after reach request', async () => {
-				await instance.getItems((api) => api.calendarList, params);
+				await instance.getItems(() => calendarList, params);
 
 				expect(sleep).toHaveBeenCalledTimes(response.length);
 				expect(sleep).toHaveBeenCalledWith(300);
 			});
 
 			it('should be initialized and called once if no API error', async () => {
-				const getAuthSpy  = jest.spyOn(auth, 'getAuth');
 				const getItemsSpy = jest.spyOn(instance, 'getItems');
 
-				await instance.getItems((api) => api.calendarList, params);
+				await instance.getItems(() => calendarList, params);
 
-				expect(getAuthSpy).toHaveBeenCalledTimes(1);
+				expect(getAuth).toHaveBeenCalledTimes(1);
 				expect(getItemsSpy).toHaveBeenCalledTimes(1);
 			});
 
@@ -178,16 +174,15 @@ describe('src/lib/api', () => {
 					// fail twice
 					getListException.mockReturnValueOnce(error).mockReturnValueOnce(error);
 
-					const getAuthSpy  = jest.spyOn(auth, 'getAuth');
 					const getItemsSpy = jest.spyOn(instance, 'getItems');
-					getAuthSpy.mockClear();
+					jest.mocked(getAuth).mockClear();
 					getItemsSpy.mockClear();
 
-					await instance.getItems((api) => api.calendarList, params);
+					await instance.getItems(() => calendarList, params);
 
 					expect(logger.warn).toHaveBeenCalledWith('Access token stored is invalid, re-creating...');
-					expect(secrets.deleteCredentials).toHaveBeenCalledWith(profile);
-					expect(getAuthSpy).toHaveBeenCalledTimes(2);
+					expect(deleteCredentials).toHaveBeenCalledWith(profile);
+					expect(getAuth).toHaveBeenCalledTimes(2);
 					expect(getItemsSpy).toHaveBeenCalledTimes(3);
 				}
 			});
@@ -198,27 +193,30 @@ describe('src/lib/api', () => {
 					// fail twice
 					getListException.mockReturnValueOnce(error);
 
-					const instance = await api.getAPI((auth) => calendar({ version : 'v3', auth }), profile, { temporary : true });
-					await expect(instance.getItems((api) => api.calendarList, params)).rejects.toEqual(error);
+					const instance = await getAPI((auth) => calendar({ version: 'v3', auth }), profile, { temporary: true });
+					await expect(instance.getItems(() => calendarList, params))
+						.rejects.toEqual(error);
 				}
 			});
 
 			it('should re-throw API exception if not invalid_grant or Invalid credentials', async () => {
 				const error = new Error('random exception');
 				getListException.mockReturnValueOnce(error);
-				await expect(instance.getItems((api) => api.calendarList, params)).rejects.toEqual(error);
+				await expect(instance.getItems(() => calendarList, params))
+					.rejects.toEqual(error);
 			});
 
 			it('should return items data', async () => {
-				const returnedItems = await instance.getItems((api) => api.calendarList, params);
+				const returnedItems = await instance.getItems(() => calendarList, params);
 
 				expect(returnedItems).toEqual(items);
 			});
 
 			it('should throw if api was not initialized before getting items', async () => {
-				instance = new api.API((auth) => calendar({ version : 'v3', auth }), profile);
+				instance = new API((auth) => calendar({ version: 'v3', auth }), profile);
 
-				await expect(async () => instance.getItems((api) => api.calendarList, params)).rejects.toEqual(new Error('API is not initialized. Call `init` before getting items.'));
+				await expect(async () => instance.getItems(() => calendarList, params))
+					.rejects.toEqual(new Error('API is not initialized. Call `init` before getting items.'));
 			});
 		});
 	});

package/src/lib/__tests__/auth.test.ts

@@ -1,149 +1,73 @@
 import { google } from 'googleapis';
 import type GoogleApis from 'googleapis';
-import logger from '@anmiles/logger';
-import profiles from '../profiles';
-import secrets from '../secrets';
 
-import auth from '../auth';
+import type { Secrets } from '../../types/secrets';
+import { getAuth } from '../auth';
+import { getCredentials } from '../credentials';
+import { getSecrets } from '../secrets';
 
-const original = jest.requireActual<{ default : typeof auth }>('../auth').default;
-jest.mock<typeof auth>('../auth', () => ({
-	login   : jest.fn(),
-	getAuth : jest.fn().mockImplementation(() => googleAuth),
-}));
-
-jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
-	info : jest.fn(),
-	warn : jest.fn(),
-}));
-
-jest.mock<Partial<typeof profiles>>('../profiles', () => ({
-	getProfiles : jest.fn().mockImplementation(() => allProfiles),
-}));
-
-jest.mock<Partial<typeof secrets>>('../secrets', () => ({
-	getSecrets     : jest.fn().mockImplementation(() => secretsObject),
-	getCredentials : jest.fn().mockImplementation(() => credentials),
-}));
-
-jest.mock('googleapis', () => ({
-	google : {
-		auth : {
-			OAuth2 : jest.fn().mockImplementation(() => googleAuth),
-		},
-		options : jest.fn(),
-	},
-}));
+jest.mock('googleapis');
+jest.mock('@anmiles/logger');
+jest.mock('../credentials');
+jest.mock('../secrets');
 
 const profile     = 'username';
-const allProfiles = [ 'username1', 'username2' ];
-const credentials = 'credentials' as GoogleApis.Auth.Credentials;
+const credentials = 'credentials' as GoogleApis.Auth.Credentials; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
 const googleAuth = {
-	setCredentials : jest.fn(),
-};
-
-const secretsObject = {
-	web : {
-		client_id     : 'client_id',
-		client_secret : 'client_secret',
-		redirect_uris : [ 'redirect_uri' ],
+	setCredentials: jest.fn(),
+} as unknown as GoogleApis.Common.OAuth2Client;
+
+const secrets: Secrets = {
+	web: {
+		client_id                  : 'client_id.apps.googleusercontent.com',
+		project_id                 : 'project_id',
+		auth_uri                   : 'https://accounts.google.com/o/oauth2/auth',
+		token_uri                  : 'https://oauth2.googleapis.com/token',
+		auth_provider_x509_cert_url: 'https://www.googleapis.com/oauth2/v1/certs',
+		client_secret              : 'client_secret',
+		redirect_uris              : [ 'redirect_uri' ],
 	},
 };
 
-describe('src/lib/auth', () => {
-	describe('login', () => {
-		it('should get profiles', async () => {
-			await original.login();
-			expect(profiles.getProfiles).toHaveBeenCalledWith();
-		});
-
-		it('should auth all profiles', async () => {
-			await original.login();
-
-			allProfiles.forEach((profile) => {
-				expect(auth.getAuth).toHaveBeenCalledWith(profile, undefined);
-			});
-		});
-
-		it('should auth only specified profile', async () => {
-			await original.login('username1');
-
-			expect(auth.getAuth).toHaveBeenCalledWith('username1', undefined);
-			expect(auth.getAuth).not.toHaveBeenCalledWith('username2', undefined);
-		});
-
-		it('should pass temporariness for all profiles', async () => {
-			await original.login(undefined, { temporary : true });
-
-			expect(auth.getAuth).toHaveBeenCalledWith('username1', { temporary : true });
-			expect(auth.getAuth).toHaveBeenCalledWith('username2', { temporary : true });
-
-		});
-
-		it('should pass temporariness only for specified profile', async () => {
-			await original.login('username1', { temporary : true });
-
-			expect(auth.getAuth).toHaveBeenCalledWith('username1', { temporary : true });
-			expect(auth.getAuth).not.toHaveBeenCalledWith('username2', { temporary : true });
-
-		});
-
-		it('should show auth progress for all profiles by default', async () => {
-			await original.login();
-
-			expect(logger.warn).toHaveBeenCalledWith('username1 - logging in...');
-			expect(logger.warn).toHaveBeenCalledWith('username2 - logging in...');
-			expect(logger.info).toHaveBeenCalledWith('username1 - logged in successfully');
-			expect(logger.info).toHaveBeenCalledWith('username2 - logged in successfully');
-		});
-
-		it('should show auth progress for specified profile by default', async () => {
-			await original.login('username1');
-
-			expect(logger.warn).toHaveBeenCalledWith('username1 - logging in...');
-			expect(logger.info).toHaveBeenCalledWith('username1 - logged in successfully');
-		});
-
-		it('should not show auth progress if hidden', async () => {
-			await original.login(undefined, { hideProgress : true });
-			await original.login('username1', { hideProgress : true });
-
-			expect(logger.info).not.toHaveBeenCalled();
-		});
-	});
+jest.mocked(getCredentials).mockResolvedValue(credentials);
+jest.mocked(getSecrets).mockReturnValue(secrets);
+jest.mocked(google.auth.OAuth2).mockReturnValue(googleAuth);
 
+describe('src/lib/auth', () => {
 	describe('getAuth', () => {
 		it('should get secrets', async () => {
-			await original.getAuth(profile);
-			expect(secrets.getSecrets).toHaveBeenCalledWith(profile);
+			await getAuth(profile);
+			expect(getSecrets).toHaveBeenCalledWith(profile);
 		});
 
 		it('should get credentials', async () => {
-			await original.getAuth(profile);
-			expect(secrets.getCredentials).toHaveBeenCalledWith(profile, googleAuth, undefined);
+			await getAuth(profile);
+			expect(getCredentials).toHaveBeenCalledWith(profile, googleAuth, undefined);
 		});
 
 		it('should create OAuth2 instance', async () => {
-			await original.getAuth(profile);
-			expect(google.auth.OAuth2).toHaveBeenCalledWith(secretsObject.web.client_id, secretsObject.web.client_secret, secretsObject.web.redirect_uris[0]);
+			await getAuth(profile);
+			expect(google.auth.OAuth2).toHaveBeenCalledWith(secrets.web.client_id, secrets.web.client_secret, secrets.web.redirect_uris[0]);
 		});
 
 		it('should set credentials', async () => {
-			await original.getAuth(profile);
+			await getAuth(profile);
+			// eslint-disable-next-line @typescript-eslint/unbound-method
 			expect(googleAuth.setCredentials).toHaveBeenCalledWith(credentials);
 		});
 
 		it('should pass temporariness', async () => {
-			await original.getAuth(profile, { temporary : true });
+			await getAuth(profile, { temporary: true });
 
-			expect(secrets.getCredentials).toHaveBeenCalledWith(profile, googleAuth, { temporary : true });
+			expect(getCredentials).toHaveBeenCalledWith(profile, googleAuth, { temporary: true });
 		});
 
 		it('should set google auth', async () => {
-			await original.getAuth(profile);
+			await getAuth(profile);
 
-			expect(google.options).toHaveBeenCalledWith({ auth : googleAuth });
+			expect(google.options).toHaveBeenCalledWith({ auth: googleAuth }); // eslint-disable-line @typescript-eslint/unbound-method
 		});
 	});
 });

package/src/lib/__tests__/login.test.ts

@@ -0,0 +1,71 @@
+import logger from '@anmiles/logger';
+
+import { getAuth } from '../auth';
+import { login } from '../login';
+import { getProfiles } from '../profiles';
+
+const profiles = [ 'username1', 'username2' ];
+
+jest.mock('@anmiles/logger');
+jest.mock('../auth');
+jest.mock('../profiles');
+
+jest.mocked(getProfiles).mockReturnValue(profiles);
+
+describe('src/lib/login', () => {
+	describe('login', () => {
+		it('should auth all profiles', async () => {
+			await login();
+
+			profiles.forEach((profile) => {
+				expect(getAuth).toHaveBeenCalledWith(profile, undefined);
+			});
+		});
+
+		it('should auth only specified profile', async () => {
+			await login('username1');
+
+			expect(getAuth).toHaveBeenCalledWith('username1', undefined);
+			expect(getAuth).not.toHaveBeenCalledWith('username2', undefined);
+		});
+
+		it('should pass temporariness for all profiles', async () => {
+			await login(undefined, { temporary: true });
+
+			expect(getAuth).toHaveBeenCalledWith('username1', { temporary: true });
+			expect(getAuth).toHaveBeenCalledWith('username2', { temporary: true });
+
+		});
+
+		it('should pass temporariness only for specified profile', async () => {
+			await login('username1', { temporary: true });
+
+			expect(getAuth).toHaveBeenCalledWith('username1', { temporary: true });
+			expect(getAuth).not.toHaveBeenCalledWith('username2', { temporary: true });
+
+		});
+
+		it('should show auth progress for all profiles by default', async () => {
+			await login();
+
+			expect(logger.warn).toHaveBeenCalledWith('username1 - logging in...');
+			expect(logger.warn).toHaveBeenCalledWith('username2 - logging in...');
+			expect(logger.info).toHaveBeenCalledWith('username1 - logged in successfully');
+			expect(logger.info).toHaveBeenCalledWith('username2 - logged in successfully');
+		});
+
+		it('should show auth progress for specified profile by default', async () => {
+			await login('username1');
+
+			expect(logger.warn).toHaveBeenCalledWith('username1 - logging in...');
+			expect(logger.info).toHaveBeenCalledWith('username1 - logged in successfully');
+		});
+
+		it('should not show auth progress if hidden', async () => {
+			await login(undefined, { hideProgress: true });
+			await login('username1', { hideProgress: true });
+
+			expect(logger.info).not.toHaveBeenCalled();
+		});
+	});
+});