@anmiles/google-api-wrapper 9.0.0 → 11.0.0

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

@@ -0,0 +1,206 @@
+import { google } from 'googleapis';
+import logger from '@anmiles/logger';
+import sleep from '@anmiles/sleep';
+import auth from '../auth';
+import secrets from '../secrets';
+import api from '../api';
+
+const items: Array<{ data: string}> = [
+	{ data : 'first' },
+	{ data : 'second' },
+	{ data : 'third' },
+	{ data : 'forth' },
+];
+
+const response = [
+	[ items[0], items[1] ],
+	null,
+	[ items[2], items[3] ],
+];
+
+const pageTokens = [
+	undefined,
+	'token1',
+	'token2',
+];
+
+const getAPI = <T>(items: Array<Array<T> | null>, pageTokens: Array<string | undefined>) => ({
+	list : jest.fn().mockImplementation(async ({ pageToken }: {pageToken?: string}) => {
+		const listException = getListException();
+
+		if (listException) {
+			throw listException;
+		}
+
+		const index = pageTokens.indexOf(pageToken);
+
+		return {
+			data : {
+				items         : items[index],
+				nextPageToken : pageTokens[index + 1],
+				pageInfo      : !items[index] ? null : {
+					totalResults : items.reduce((sum, list) => sum + (list?.length || 0), 0),
+				},
+			},
+		};
+	}),
+	update : jest.fn(),
+});
+
+const args = { key : 'value' };
+
+const profile     = 'username1';
+const calendarApi = {
+	calendarList : getAPI(response, pageTokens),
+};
+
+const googleAuth = {
+	revokeCredentials : jest.fn(),
+};
+
+const scopes = [ 'scope1', 'scope2' ];
+
+const getListException: jest.Mock<Error | undefined> = jest.fn();
+
+beforeEach(() => {
+	getListException.mockReturnValue(undefined);
+});
+
+jest.mock('googleapis', () => ({
+	google : {
+		calendar : jest.fn().mockImplementation(() => calendarApi),
+	},
+}));
+
+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(),
+}));
+
+jest.mock<Partial<typeof sleep>>('@anmiles/sleep', () => jest.fn());
+
+describe('src/lib/api', () => {
+	describe('getApi', () => {
+		it('should call getAuth', async () => {
+			await api.getApi('calendar', profile);
+
+			expect(auth.getAuth).toHaveBeenCalledWith(profile, undefined);
+		});
+
+		it('should pass temporariness and scopes', async () => {
+			await api.getApi('calendar', profile, { scopes, temporary : true });
+
+			expect(auth.getAuth).toHaveBeenCalledWith(profile, { scopes, temporary : true });
+		});
+
+		it('should get google api', async () => {
+			await api.getApi('calendar', profile);
+
+			expect(google.calendar).toHaveBeenCalledWith({ version : 'v3', auth : googleAuth });
+		});
+
+		it('should return instance wrapper for google api', async () => {
+			const instance = await api.getApi('calendar', profile, { scopes, temporary : true });
+
+			expect(instance).toEqual({ apiName : 'calendar', profile, authOptions : { scopes, temporary : true }, api : calendarApi, auth : googleAuth });
+		});
+	});
+
+	describe('Api', () => {
+		let instance: InstanceType<typeof api.Api<'calendar'>>;
+
+		beforeEach(async () => {
+			instance = await api.getApi('calendar', profile);
+		});
+
+		describe('constructor', () => {
+			it('should return instance', async () => {
+				const instance = new api.Api('calendar', profile, { scopes, temporary : true });
+
+				expect(instance).toEqual({ apiName : 'calendar', profile, authOptions : { scopes, temporary : true } });
+			});
+		});
+
+		describe('getItems', () => {
+			it('should call API list method for each page', async () => {
+				await instance.getItems((api) => api.calendarList, args);
+
+				pageTokens.forEach((pageToken) => {
+					expect(calendarApi.calendarList.list).toHaveBeenCalledWith({ ...args, pageToken });
+				});
+			});
+
+			it('should output progress by default', async () => {
+				await instance.getItems((api) => api.calendarList, args);
+
+				expect(logger.log).toHaveBeenCalledTimes(response.length);
+				expect(logger.log).toHaveBeenCalledWith('Getting items (2 of 4)...');
+				expect(logger.log).toHaveBeenCalledWith('Getting items (2 of many)...');
+				expect(logger.log).toHaveBeenCalledWith('Getting items (4 of 4)...');
+			});
+
+			it('should not output progress if hidden', async () => {
+				await instance.getItems((api) => api.calendarList, args, { hideProgress : true });
+
+				expect(logger.log).not.toHaveBeenCalled();
+			});
+
+			it('should sleep after reach request', async () => {
+				await instance.getItems((api) => api.calendarList, args);
+
+				expect(sleep).toHaveBeenCalledTimes(response.length);
+				expect(sleep).toHaveBeenCalledWith(300);
+			});
+
+			it('should be initialized and called once if no API error', async () => {
+				const getItemsSpy = jest.spyOn(instance, 'getItems');
+				await instance.getItems((api) => api.calendarList, args);
+				expect(auth.getAuth).toHaveBeenCalledTimes(1);
+				expect(getItemsSpy).toHaveBeenCalledTimes(1);
+			});
+
+			it('should delete credentials, re-initialize api and retry while API exception is invalid_grant', async () => {
+				const error = new Error('invalid_grant');
+				// fail twice
+				getListException.mockReturnValueOnce(error).mockReturnValueOnce(error);
+
+				const getItemsSpy = jest.spyOn(instance, 'getItems');
+				await instance.getItems((api) => api.calendarList, args);
+				expect(secrets.deleteCredentials).toHaveBeenCalledWith(profile);
+				expect(auth.getAuth).toHaveBeenCalledTimes(3);
+				expect(getItemsSpy).toHaveBeenCalledTimes(3);
+			});
+
+			it('should re-throw API exception if not invalid_grant', async () => {
+				const error = new Error('random exception');
+				getListException.mockReturnValueOnce(error);
+				await expect(instance.getItems((api) => api.calendarList, args)).rejects.toEqual(error);
+			});
+
+			it('should return items data', async () => {
+				const items = await instance.getItems((api) => api.calendarList, args);
+
+				expect(items).toEqual(items);
+			});
+		});
+
+		describe('revoke', () => {
+			it('should delete credentials file for current profile', async () => {
+				await instance.revoke();
+				expect(secrets.deleteCredentials).toHaveBeenCalledWith(profile);
+			});
+
+			it('should revoke credentials in google API', async () => {
+				await instance.revoke();
+				expect(googleAuth.revokeCredentials).toHaveBeenCalledWith();
+			});
+		});
+	});
+});

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

@@ -4,6 +4,7 @@ import path from 'path';
 import open from 'open';
 import type GoogleApis from 'googleapis';
 import logger from '@anmiles/logger';
+import emitter from 'event-emitter';
 import paths from '../paths';
 import type { Secrets } from '../../types';
 import '@anmiles/prototypes';
@@ -16,26 +17,31 @@ jest.mock<typeof secrets>('../secrets', () => ({
 	getCredentials      : jest.fn(),
 	validateCredentials : jest.fn(),
 	createCredentials   : jest.fn().mockImplementation(() => credentialsJSON),
+	deleteCredentials   : jest.fn(),
 	checkSecrets        : jest.fn(),
 	getScopesError      : jest.fn().mockImplementation(() => scopesError),
 	getSecretsError     : jest.fn().mockImplementation(() => secretsError),
 }));
 
 jest.mock<Partial<typeof http>>('http', () => ({
-	createServer : jest.fn().mockImplementation((callback) => {
-		serverCallback = callback;
-
-		return {
-			on,
-			listen,
-			close,
-			destroy,
-		};
-	}),
+	createServer : jest.fn().mockImplementation(() => server),
 }));
 
+let server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+let response: http.ServerResponse;
+
+async function makeRequest(url: string | undefined) {
+	server.emit('request', {
+		url,
+		headers : {
+			host,
+		},
+	} as http.IncomingMessage, response);
+}
+
 jest.mock<Partial<typeof fs>>('fs', () => ({
 	existsSync : jest.fn().mockImplementation(() => exists),
+	rmSync     : jest.fn(),
 }));
 
 jest.mock<Partial<typeof path>>('path', () => ({
@@ -43,7 +49,7 @@ jest.mock<Partial<typeof path>>('path', () => ({
 }));
 
 jest.mock('open', () => jest.fn().mockImplementation((url: string) => {
-	willOpen(url.replace('http://localhost:6006', ''));
+	makeRequest(url.replace('http://localhost:6006', ''));
 }));
 
 jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
@@ -56,6 +62,12 @@ jest.mock<Partial<typeof paths>>('../paths', () => ({
 	getCredentialsFile : jest.fn().mockImplementation(() => credentialsFile),
 }));
 
+jest.useFakeTimers();
+
+const port        = 6006;
+const host        = `localhost:${port}`;
+const callbackURI = `http://${host}/oauthcallback`;
+
 const profile          = 'username1';
 const scopesFile       = 'scopes.json';
 const secretsFile      = 'secrets/username1.json';
@@ -79,7 +91,7 @@ const secretsJSON: Secrets = {
 		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               : [ 'http://localhost:6006/oauthcallback' ],
+		redirect_uris               : [ callbackURI ],
 		/* eslint-enable camelcase */
 	},
 };
@@ -98,46 +110,6 @@ const auth    = {
 	getToken        : jest.fn().mockResolvedValue({ tokens : credentialsJSON }),
 } as unknown as GoogleApis.Common.OAuth2Client;
 
-const response = {
-	end : jest.fn(),
-} as unknown as http.ServerResponse;
-
-let serverCallback: (
-	request: http.IncomingMessage,
-	response: http.ServerResponse
-) => Promise<typeof credentialsJSON>;
-
-function willOpen(url: string | undefined, timeout?: number) {
-	setTimeout(async () => {
-		await serverCallback({
-			url,
-			headers : {
-				host : 'localhost:6006',
-			},
-		} as http.IncomingMessage, response);
-	}, timeout || 0);
-}
-let closedTime: number;
-
-const on = jest.fn().mockImplementation((event: string, listener: (...args: any[]) => void) => {
-	if (event === 'connection') {
-		// always simulate opening several connections once connections are meant to be listened
-		connections.forEach((connection) => listener(connection));
-	}
-});
-
-const listen = jest.fn();
-const close  = jest.fn().mockImplementation(() => {
-	closedTime = new Date().getTime();
-});
-const destroy = jest.fn();
-
-const connections = [
-	{ remoteAddress : 'server', remotePort : '1001', on : jest.fn(), destroy : jest.fn() },
-	{ remoteAddress : 'server', remotePort : '1002', on : jest.fn(), destroy : jest.fn() },
-	{ remoteAddress : 'server', remotePort : '1003', on : jest.fn(), destroy : jest.fn() },
-];
-
 let exists: boolean;
 
 let getJSONSpy: jest.SpyInstance;
@@ -360,10 +332,38 @@ describe('src/lib/secrets', () => {
 	describe('createCredentials', () => {
 		const tokenUrl = `/request.url?code=${code}`;
 
-		it('should generate authUrl', async () => {
-			willOpen(tokenUrl, 100);
+		const connections = [
+			{ remoteAddress : 'server', remotePort : '1001', on : jest.fn(), destroy : jest.fn() },
+			{ remoteAddress : 'server', remotePort : '1002', on : jest.fn(), destroy : jest.fn() },
+			{ remoteAddress : 'server', remotePort : '1003', on : jest.fn(), destroy : jest.fn() },
+		];
+
+		let endSpy: jest.SpyInstance;
+
+		beforeEach(() => {
+			server = emitter({
+				listen : jest.fn().mockImplementation(() => {
+					// always simulate opening several connections once connections are meant to be listened
+					connections.forEach((connection) => server.emit('connection', connection));
+				}),
+				close   : jest.fn(),
+				destroy : jest.fn(),
+			}) as typeof server;
+
+			response = emitter({
+				end : jest.fn(),
+			}) as typeof response;
 
-			await original.createCredentials(profile, auth);
+			endSpy = jest.spyOn(response, 'end');
+		});
+
+		afterAll(() => {
+			endSpy.mockRestore();
+		});
+
+		it('should generate authUrl', async () => {
+			original.createCredentials(profile, auth);
+			await Promise.resolve();
 
 			expect(auth.generateAuthUrl).toHaveBeenCalledWith({
 				// eslint-disable-next-line camelcase
@@ -377,9 +377,8 @@ describe('src/lib/secrets', () => {
 		});
 
 		it('should generate authUrl and require consent if explicitly asked', async () => {
-			willOpen(tokenUrl, 100);
-
-			await original.createCredentials(profile, auth, { temporary : true }, 'consent');
+			original.createCredentials(profile, auth, { temporary : true }, 'consent');
+			await Promise.resolve();
 
 			expect(auth.generateAuthUrl).toHaveBeenCalledWith({
 				// eslint-disable-next-line camelcase
@@ -393,9 +392,8 @@ describe('src/lib/secrets', () => {
 		});
 
 		it('should generate authUrl with custom scopes', async () => {
-			willOpen(tokenUrl, 100);
-
-			await original.createCredentials(profile, auth, { scopes : [ 'scope1', 'scope2' ] });
+			original.createCredentials(profile, auth, { scopes : [ 'scope1', 'scope2' ] });
+			await Promise.resolve();
 
 			expect(auth.generateAuthUrl).toHaveBeenCalledWith({
 				// eslint-disable-next-line camelcase
@@ -406,39 +404,45 @@ describe('src/lib/secrets', () => {
 		});
 
 		it('should create server on 6006 port', async () => {
-			willOpen(tokenUrl, 100);
-
-			await original.createCredentials(profile, auth);
+			original.createCredentials(profile, auth);
+			await Promise.resolve();
 
 			expect(http.createServer).toHaveBeenCalled();
-			expect(listen).toHaveBeenCalledWith(6006);
+			expect(server.listen).toHaveBeenCalledWith(6006);
 		});
 
-		it('should open browser page and warn about it', async () => {
-			willOpen(tokenUrl, 100);
+		it('should open browser page and warn about it once listening', async () => {
+			original.createCredentials(profile, auth);
+			await Promise.resolve();
 
-			await original.createCredentials(profile, auth);
+			server.emit('listening');
 
 			expect(open).toHaveBeenCalledWith('http://localhost:6006/');
 			expect(logger.warn).toHaveBeenCalledWith('Please check your browser for further actions');
 		});
 
-		it('should show nothing on the browser page if request.url is empty', async () => {
-			willOpen('', 100);
-			willOpen(tokenUrl, 200);
+		it('should not open browser page and warn about it until listening', async () => {
+			original.createCredentials(profile, auth);
+			await Promise.resolve();
 
-			await original.createCredentials(profile, auth);
+			expect(open).not.toHaveBeenCalled();
+			expect(logger.warn).not.toHaveBeenCalled();
+		});
+
+		it('should show nothing on the browser page if request.url is empty', async () => {
+			original.createCredentials(profile, auth);
+			makeRequest('');
+			await Promise.resolve();
 
-			expect(response.end).toHaveBeenCalledWith('');
+			expect(endSpy).toHaveBeenCalledWith('');
 		});
 
 		it('should show opening instructions if opened the home page', async () => {
-			willOpen('/', 100);
-			willOpen(tokenUrl, 200);
+			original.createCredentials(profile, auth);
+			makeRequest('/');
+			await Promise.resolve();
 
-			await original.createCredentials(profile, auth);
-
-			expect(response.end).toHaveBeenCalledWith(`\
+			expect(endSpy).toHaveBeenCalledWith(`\
 <div style="width: 100%;height: 100%;display: flex;align-items: start;justify-content: center">\n\
 <div style="padding: 0 1em;border: 1px solid black;font-family: Arial, sans-serif;margin: 1em;">\n\
 <p>Please open <a href="${authUrl}">auth page</a> using <strong>${profile}</strong> google profile</p>\n\
@@ -449,11 +453,11 @@ describe('src/lib/secrets', () => {
 		});
 
 		it('should ask to close webpage', async () => {
-			willOpen(tokenUrl, 100);
-
-			await original.createCredentials(profile, auth);
+			original.createCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			await Promise.resolve();
 
-			expect(response.end).toHaveBeenCalledWith('\
+			expect(endSpy).toHaveBeenCalledWith('\
 <div style="width: 100%;height: 100%;display: flex;align-items: start;justify-content: center">\n\
 <div style="padding: 0 1em;border: 1px solid black;font-family: Arial, sans-serif;margin: 1em;">\n\
 <p>Please close this page and return to application</p>\n\
@@ -462,58 +466,72 @@ describe('src/lib/secrets', () => {
 		});
 
 		it('should close server and destroy all connections if request.url is truthy', async () => {
-			willOpen(tokenUrl, 100);
-
-			await original.createCredentials(profile, auth);
+			original.createCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			await Promise.resolve();
 
-			expect(close).toHaveBeenCalled();
+			expect(server.close).toHaveBeenCalled();
 
 			connections.forEach((connection) => expect(connection.destroy).toHaveBeenCalled());
 		});
 
-		it('should only resolve when request.url is truthy', async () => {
-			const emptyRequestTime = 100;
-			const requestTime      = 200;
-
-			const before = new Date().getTime();
-			willOpen(undefined, emptyRequestTime);
-			willOpen(tokenUrl, requestTime);
+		it('should close server and resolve if request.url is truthy', async () => {
+			const promise = original.createCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			const result = await Promise.resolve(promise);
+			expect(result).toEqual(credentialsJSON);
+			expect(server.close).toHaveBeenCalledTimes(1);
+		});
 
-			const result = await original.createCredentials(profile, auth);
-			const after  = new Date().getTime();
+		it('should not close server if request.url is falsy', async () => {
+			original.createCredentials(profile, auth);
+			makeRequest(undefined);
+			await Promise.resolve();
 
-			expect(close).toHaveBeenCalledTimes(1);
-			expect(closedTime - before).toBeGreaterThanOrEqual(requestTime - 1);
-			expect(after - before).toBeGreaterThanOrEqual(requestTime - 1);
-			expect(result).toEqual(credentialsJSON);
+			expect(server.close).not.toHaveBeenCalled();
 		});
 
-		it('should only resolve when request.url contains no code', async () => {
-			const noCodeRequestTime = 100;
-			const requestTime       = 200;
+		it('should re-throw a server error if error is not EADDRINUSE', () => {
+			const error = { code : 'RANDOM', message : 'random error' } as NodeJS.ErrnoException;
 
-			const before = new Date().getTime();
-			willOpen('/request.url?param=value', noCodeRequestTime);
-			willOpen(tokenUrl, requestTime);
+			original.createCredentials(profile, auth);
+			expect(() => server.emit('error', error)).toThrow(error.message);
+		});
 
-			const result = await original.createCredentials(profile, auth);
-			const after  = new Date().getTime();
+		it('should not re-throw a server error and try to listen again in 1000 seconds if error is EADDRINUSE', () => {
+			const error = { code : 'EADDRINUSE' } as NodeJS.ErrnoException;
 
-			expect(close).toHaveBeenCalledTimes(1);
-			expect(closedTime - before).toBeGreaterThanOrEqual(requestTime - 1);
-			expect(after - before).toBeGreaterThanOrEqual(requestTime - 1);
-			expect(result).toEqual(credentialsJSON);
+			original.createCredentials(profile, auth);
+			expect(server.listen).toHaveBeenCalledTimes(1);
+			expect(() => server.emit('error', error)).not.toThrow();
+			expect(server.listen).toHaveBeenCalledTimes(1);
+			jest.advanceTimersByTime(1000);
+			expect(server.listen).toHaveBeenCalledTimes(2);
 		});
 
 		it('should return credentials JSON', async () => {
-			willOpen(tokenUrl, 100);
-
-			const result = await original.createCredentials(profile, auth);
+			const promise = original.createCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			const result = await promise;
 
 			expect(result).toEqual(credentialsJSON);
 		});
 	});
 
+	describe('deleteCredentials', () => {
+		it('should delete credentials file if exists', () => {
+			exists = true;
+			original.deleteCredentials(profile);
+			expect(fs.rmSync).toHaveBeenCalledWith(credentialsFile);
+		});
+
+		it('should not do anything if credentials file does not exist', () => {
+			exists = false;
+			original.deleteCredentials(profile);
+			expect(fs.rmSync).not.toHaveBeenCalled();
+		});
+	});
+
 	describe('checkSecrets', () => {
 		it('should return true if redirect_uri is correct', () => {
 			const result = original.checkSecrets(profile, secretsJSON, secretsFile);