@anmiles/google-api-wrapper 7.0.6 → 8.0.0

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

@@ -1,12 +1,12 @@
+import fs from 'fs';
 import http from 'http';
 import path from 'path';
-import * as colorette from 'colorette';
 import open from 'open';
 import type GoogleApis from 'googleapis';
-import jsonLib from '../jsonLib';
-import logger from '../logger';
+import logger from '@anmiles/logger';
 import paths from '../paths';
 import type { Secrets } from '../../types';
+import '@anmiles/prototypes';
 
 import secrets from '../secrets';
 const original = jest.requireActual('../secrets').default as typeof secrets;
@@ -34,36 +34,26 @@ jest.mock<Partial<typeof http>>('http', () => ({
 	}),
 }));
 
-jest.mock<Partial<typeof path>>('path', () => ({
-	join : jest.fn().mockImplementation((...args) => args.join('/')),
+jest.mock<Partial<typeof fs>>('fs', () => ({
+	existsSync : jest.fn().mockImplementation(() => exists),
 }));
 
-jest.mock<Partial<typeof colorette>>('colorette', () => ({
-	yellow : jest.fn().mockImplementation((text) => `yellow:${text}`),
+jest.mock<Partial<typeof path>>('path', () => ({
+	join : jest.fn().mockImplementation((...args) => args.join('/')),
 }));
 
 jest.mock('open', () => jest.fn().mockImplementation((url: string) => {
 	willOpen(url.replace('http://localhost:6006', ''));
 }));
 
-jest.mock<Partial<typeof jsonLib>>('../jsonLib', () => ({
-	getJSON      : jest.fn().mockImplementation(() => json),
-	getJSONAsync : jest.fn().mockImplementation(async () => json),
-	readJSON     : jest.fn().mockImplementation(async () => json),
-}));
-
-jest.mock<Partial<typeof logger>>('../logger', () => ({
-	warn  : jest.fn(),
-	error : jest.fn().mockImplementation((error) => {
-		throw error;
-	}) as jest.Mock<never, any>,
+jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
+	warn : jest.fn(),
 }));
 
 jest.mock<Partial<typeof paths>>('../paths', () => ({
 	getScopesFile      : jest.fn().mockImplementation(() => scopesFile),
 	getSecretsFile     : jest.fn().mockImplementation(() => secretsFile),
 	getCredentialsFile : jest.fn().mockImplementation(() => credentialsFile),
-	ensureFile         : jest.fn().mockImplementation(() => fileExists),
 }));
 
 const profile          = 'username1';
@@ -148,164 +138,180 @@ const connections = [
 	{ remoteAddress : 'server', remotePort : '1003', on : jest.fn(), destroy : jest.fn() },
 ];
 
-let fileExists: boolean;
+let exists: boolean;
+
+let getJSONSpy: jest.SpyInstance;
+let getJSONAsyncSpy: jest.SpyInstance;
+let readJSONSpy: jest.SpyInstance;
+
+beforeAll(() => {
+	getJSONSpy      = jest.spyOn(fs, 'getJSON');
+	getJSONAsyncSpy = jest.spyOn(fs, 'getJSONAsync');
+	readJSONSpy     = jest.spyOn(fs, 'readJSON');
+});
+
+beforeEach(() => {
+	getJSONSpy.mockImplementation(() => json);
+	getJSONAsyncSpy.mockImplementation(() => json);
+	readJSONSpy.mockImplementation(() => json);
+});
+
+afterAll(() => {
+	getJSONSpy.mockRestore();
+	getJSONAsyncSpy.mockRestore();
+	readJSONSpy.mockRestore();
+});
 
 describe('src/lib/secrets', () => {
 	describe('getScopes', () => {
-		const getJSONSpy = jest.spyOn(jsonLib, 'getJSON');
-
 		beforeEach(() => {
 			json = scopesJSON;
 		});
 
-		it('should get json from scopes file', async () => {
-			await original.getScopes();
+		it('should get json from scopes file', () => {
+			original.getScopes();
 
-			expect(getJSONSpy).toBeCalled();
+			expect(getJSONSpy).toHaveBeenCalled();
 			expect(getJSONSpy.mock.calls[0][0]).toEqual(scopesFile);
 		});
 
-		it('should fallback to error', async () => {
-			await original.getScopes();
+		it('should fallback to error', () => {
+			original.getScopes();
 
-			expect(getJSONSpy.mock.calls[0][1]).toThrowError(scopesError);
+			expect(getJSONSpy.mock.calls[0][1]).toThrow(scopesError);
 		});
 
-		it('should return scopes', async () => {
-			const result = await original.getScopes();
+		it('should return scopes', () => {
+			const result = original.getScopes();
 
 			expect(result).toEqual(scopesJSON);
 		});
 	});
 
 	describe('getSecrets', () => {
-		const getJSONSpy = jest.spyOn(jsonLib, 'getJSON');
-
 		beforeEach(() => {
 			json = secretsJSON;
 		});
 
-		it('should get json from secrets file', async () => {
-			await original.getSecrets(profile);
+		it('should get json from secrets file', () => {
+			original.getSecrets(profile);
 
-			expect(getJSONSpy).toBeCalled();
+			expect(getJSONSpy).toHaveBeenCalled();
 			expect(getJSONSpy.mock.calls[0][0]).toEqual(secretsFile);
 		});
 
-		it('should fallback to error', async () => {
-			await original.getSecrets(profile);
+		it('should fallback to error', () => {
+			original.getSecrets(profile);
 
-			expect(getJSONSpy.mock.calls[0][1]).toThrowError(secretsError);
+			expect(getJSONSpy.mock.calls[0][1]).toThrow(secretsError);
 		});
 
-		it('should check secrets', async () => {
-			await original.getSecrets(profile);
+		it('should check secrets', () => {
+			original.getSecrets(profile);
 
-			expect(secrets.checkSecrets).toBeCalledWith(profile, json, secretsFile);
+			expect(secrets.checkSecrets).toHaveBeenCalledWith(profile, json, secretsFile);
 		});
 
-		it('should return secrets', async () => {
-			const result = await original.getSecrets(profile);
+		it('should return secrets', () => {
+			const result = original.getSecrets(profile);
 
 			expect(result).toEqual(secretsJSON);
 		});
 	});
 
 	describe('getCredentials', () => {
-		const getJSONAsyncSpy = jest.spyOn(jsonLib, 'getJSONAsync');
-
 		beforeEach(() => {
-			json       = credentialsJSON;
-			fileExists = false;
+			json   = credentialsJSON;
+			exists = false;
 		});
 
 		it('should get json from credentials file by default', async () => {
 			await original.getCredentials(profile, auth);
 
-			expect(getJSONAsyncSpy).toBeCalled();
+			expect(getJSONAsyncSpy).toHaveBeenCalled();
 			expect(getJSONAsyncSpy.mock.calls[0][0]).toEqual(credentialsFile);
 		});
 
 		it('should get json from credentials file if temporariness not set', async () => {
 			await original.getCredentials(profile, auth, { temporary : false });
 
-			expect(getJSONAsyncSpy).toBeCalled();
+			expect(getJSONAsyncSpy).toHaveBeenCalled();
 			expect(getJSONAsyncSpy.mock.calls[0][0]).toEqual(credentialsFile);
 		});
 
 		it('should not get json from credentials file if temporariness set', async () => {
 			await original.getCredentials(profile, auth, { temporary : true });
 
-			expect(getJSONAsyncSpy).not.toBeCalled();
+			expect(getJSONAsyncSpy).not.toHaveBeenCalled();
 		});
 
 		it('should call createCredentials with consent in fallback if no existing credentials', async () => {
-			fileExists = false;
+			exists = false;
 
 			await original.getCredentials(profile, auth);
 
-			expect(secrets.createCredentials).not.toBeCalled();
+			expect(secrets.createCredentials).not.toHaveBeenCalled();
 
 			const fallback = getJSONAsyncSpy.mock.calls[0][1];
 			const result   = await fallback();
 
-			expect(jsonLib.readJSON).not.toBeCalled();
-			expect(secrets.createCredentials).toBeCalledWith(profile, auth, undefined, 'consent');
+			expect(readJSONSpy).not.toHaveBeenCalled();
+			expect(secrets.createCredentials).toHaveBeenCalledWith(profile, auth, undefined, 'consent');
 			expect(result).toEqual(credentialsJSON);
 		});
 
 		it('should call createCredentials with consent in fallback if no existing credentials and pass temporariness', async () => {
-			fileExists = false;
+			exists = false;
 
 			await original.getCredentials(profile, auth, { temporary : false });
 
-			expect(secrets.createCredentials).not.toBeCalled();
+			expect(secrets.createCredentials).not.toHaveBeenCalled();
 
 			const fallback = getJSONAsyncSpy.mock.calls[0][1];
 			const result   = await fallback();
 
-			expect(jsonLib.readJSON).not.toBeCalled();
-			expect(secrets.createCredentials).toBeCalledWith(profile, auth, { temporary : false }, 'consent');
+			expect(readJSONSpy).not.toHaveBeenCalled();
+			expect(secrets.createCredentials).toHaveBeenCalledWith(profile, auth, { temporary : false }, 'consent');
 			expect(result).toEqual(credentialsJSON);
 		});
 
 		it('should call createCredentials with consent in fallback if existing credentials do not have refresh token', async () => {
-			fileExists = true;
+			exists = true;
 
 			await original.getCredentials(profile, auth);
 
-			expect(secrets.createCredentials).not.toBeCalled();
+			expect(secrets.createCredentials).not.toHaveBeenCalled();
 
 			const fallback = getJSONAsyncSpy.mock.calls[0][1];
 			const result   = await fallback();
 
-			expect(jsonLib.readJSON).toBeCalledWith(credentialsFile);
-			expect(secrets.createCredentials).toBeCalledWith(profile, auth, undefined, 'consent');
+			expect(readJSONSpy).toHaveBeenCalledWith(credentialsFile);
+			expect(secrets.createCredentials).toHaveBeenCalledWith(profile, auth, undefined, 'consent');
 			expect(result).toEqual(credentialsJSON);
 		});
 
 		it('should call createCredentials without consent in fallback and replace refresh_token if existing credentials have refresh token', async () => {
-			fileExists = true;
+			exists = true;
 			// eslint-disable-next-line camelcase
-			jest.spyOn(jsonLib, 'readJSON').mockReturnValueOnce({ ...credentialsJSON, refresh_token : 'refresh_token' });
+			readJSONSpy.mockReturnValueOnce({ ...credentialsJSON, refresh_token : 'refresh_token' });
 
 			await original.getCredentials(profile, auth);
 
-			expect(secrets.createCredentials).not.toBeCalled();
+			expect(secrets.createCredentials).not.toHaveBeenCalled();
 
 			const fallback = getJSONAsyncSpy.mock.calls[0][1];
 			const result   = await fallback();
 
-			expect(jsonLib.readJSON).toBeCalledWith(credentialsFile);
-			expect(secrets.createCredentials).toBeCalledWith(profile, auth, undefined, undefined);
+			expect(readJSONSpy).toHaveBeenCalledWith(credentialsFile);
+			expect(secrets.createCredentials).toHaveBeenCalledWith(profile, auth, undefined, undefined);
 			// eslint-disable-next-line camelcase
 			expect(result).toEqual({ ... credentialsJSON, refresh_token : 'refresh_token' });
 		});
 
 		it('should call createCredentials without consent in fallback and leave refresh token if existing credentials have refresh token', async () => {
-			fileExists = true;
+			exists = true;
 			// eslint-disable-next-line camelcase
-			jest.spyOn(jsonLib, 'readJSON').mockReturnValueOnce({ ...credentialsJSON, refresh_token : 'refresh_token' });
+			readJSONSpy.mockReturnValueOnce({ ...credentialsJSON, refresh_token : 'refresh_token' });
 			// eslint-disable-next-line camelcase
 			jest.spyOn(secrets, 'createCredentials').mockResolvedValueOnce({ ...credentialsJSON, refresh_token : 'refresh_token_exists' });
 
@@ -314,8 +320,8 @@ describe('src/lib/secrets', () => {
 			const fallback = getJSONAsyncSpy.mock.calls[0][1];
 			const result   = await fallback();
 
-			expect(jsonLib.readJSON).toBeCalledWith(credentialsFile);
-			expect(secrets.createCredentials).toBeCalledWith(profile, auth, undefined, undefined);
+			expect(readJSONSpy).toHaveBeenCalledWith(credentialsFile);
+			expect(secrets.createCredentials).toHaveBeenCalledWith(profile, auth, undefined, undefined);
 			// eslint-disable-next-line camelcase
 			expect(result).toEqual({ ...credentialsJSON, refresh_token : 'refresh_token_exists' });
 		});
@@ -323,31 +329,31 @@ describe('src/lib/secrets', () => {
 
 	describe('validateCredentials', () => {
 		it('should return false if no access token', async () => {
-			expect(await original.validateCredentials({})).toEqual(false);
+			expect(await original.validateCredentials({})).toEqual({ isValid : false, validationError : 'Credentials does not have access_token' });
 		});
 
-		it('should return true if no refresh token', async () => {
+		it('should return false if no refresh token', async () => {
 			// eslint-disable-next-line camelcase
-			expect(await original.validateCredentials({ access_token : 'token' })).toEqual(false);
+			expect(await original.validateCredentials({ access_token : 'token' })).toEqual({ isValid : false, validationError : 'Credentials does not have refresh_token' });
 		});
 
-		it('should return true if no expiration', async () => {
+		it('should return false if no expiration date', async () => {
 			// eslint-disable-next-line camelcase
-			expect(await original.validateCredentials({ access_token : 'token', refresh_token : 'token' })).toEqual(true);
+			expect(await original.validateCredentials({ access_token : 'token', refresh_token : 'token' })).toEqual({ isValid : false, validationError : 'Credentials does not have expiry_date' });
 		});
 
 		it('should return true if credentials are not more than 1 week ago', async () => {
 			const expiryDate = new Date();
 			expiryDate.setDate(expiryDate.getDate() - 6);
 			// eslint-disable-next-line camelcase
-			expect(await original.validateCredentials({ access_token : 'token', refresh_token : 'token', expiry_date : expiryDate.getTime() })).toEqual(true);
+			expect(await original.validateCredentials({ access_token : 'token', refresh_token : 'token', expiry_date : expiryDate.getTime() })).toEqual({ isValid : true });
 		});
 
-		it('should return true if credentials are more than 1 week ago', async () => {
+		it('should return false if credentials are more than 1 week ago', async () => {
 			const expiryDate = new Date();
 			expiryDate.setDate(expiryDate.getDate() - 8);
 			// eslint-disable-next-line camelcase
-			expect(await original.validateCredentials({ access_token : 'token', refresh_token : 'token', expiry_date : expiryDate.getTime() })).toEqual(false);
+			expect(await original.validateCredentials({ access_token : 'token', refresh_token : 'token', expiry_date : expiryDate.getTime() })).toEqual({ isValid : false, validationError : 'Credentials expired' });
 		});
 	});
 
@@ -359,7 +365,7 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth);
 
-			expect(auth.generateAuthUrl).toBeCalledWith({
+			expect(auth.generateAuthUrl).toHaveBeenCalledWith({
 				// eslint-disable-next-line camelcase
 				access_type : 'offline',
 				prompt      : undefined,
@@ -375,7 +381,7 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth, { temporary : true }, 'consent');
 
-			expect(auth.generateAuthUrl).toBeCalledWith({
+			expect(auth.generateAuthUrl).toHaveBeenCalledWith({
 				// eslint-disable-next-line camelcase
 				access_type : 'offline',
 				prompt      : 'consent',
@@ -391,7 +397,7 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth, { scopes : [ 'scope1', 'scope2' ] });
 
-			expect(auth.generateAuthUrl).toBeCalledWith({
+			expect(auth.generateAuthUrl).toHaveBeenCalledWith({
 				// eslint-disable-next-line camelcase
 				access_type : 'offline',
 				prompt      : undefined,
@@ -404,8 +410,8 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth);
 
-			expect(http.createServer).toBeCalled();
-			expect(listen).toBeCalledWith(6006);
+			expect(http.createServer).toHaveBeenCalled();
+			expect(listen).toHaveBeenCalledWith(6006);
 		});
 
 		it('should open browser page and warn about it', async () => {
@@ -413,8 +419,8 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth);
 
-			expect(open).toBeCalledWith('http://localhost:6006/');
-			expect(logger.warn).toBeCalledWith('Please check your browser for further actions');
+			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 () => {
@@ -423,7 +429,7 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth);
 
-			expect(response.end).toBeCalledWith('');
+			expect(response.end).toHaveBeenCalledWith('');
 		});
 
 		it('should show opening instructions if opened the home page', async () => {
@@ -432,7 +438,7 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth);
 
-			expect(response.end).toBeCalledWith(`\
+			expect(response.end).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\
@@ -447,7 +453,7 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth);
 
-			expect(response.end).toBeCalledWith('\
+			expect(response.end).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\
@@ -460,9 +466,9 @@ describe('src/lib/secrets', () => {
 
 			await original.createCredentials(profile, auth);
 
-			expect(close).toBeCalled();
+			expect(close).toHaveBeenCalled();
 
-			connections.forEach((connection) => expect(connection.destroy).toBeCalled());
+			connections.forEach((connection) => expect(connection.destroy).toHaveBeenCalled());
 		});
 
 		it('should only resolve when request.url is truthy', async () => {
@@ -476,7 +482,7 @@ describe('src/lib/secrets', () => {
 			const result = await original.createCredentials(profile, auth);
 			const after  = new Date().getTime();
 
-			expect(close).toBeCalledTimes(1);
+			expect(close).toHaveBeenCalledTimes(1);
 			expect(closedTime - before).toBeGreaterThanOrEqual(requestTime - 1);
 			expect(after - before).toBeGreaterThanOrEqual(requestTime - 1);
 			expect(result).toEqual(credentialsJSON);
@@ -493,7 +499,7 @@ describe('src/lib/secrets', () => {
 			const result = await original.createCredentials(profile, auth);
 			const after  = new Date().getTime();
 
-			expect(close).toBeCalledTimes(1);
+			expect(close).toHaveBeenCalledTimes(1);
 			expect(closedTime - before).toBeGreaterThanOrEqual(requestTime - 1);
 			expect(after - before).toBeGreaterThanOrEqual(requestTime - 1);
 			expect(result).toEqual(credentialsJSON);
@@ -520,7 +526,7 @@ describe('src/lib/secrets', () => {
 			wrongSecretsJSON.web.redirect_uris[0] = wrongRedirectURI;
 			const func                            = () => original.checkSecrets(profile, wrongSecretsJSON, secretsFile);
 
-			expect(func).toThrowError('Error in credentials file: redirect URI should be http://localhost:6006/oauthcallback.\nsecretsError');
+			expect(func).toThrow('Error in credentials file: redirect URI should be http://localhost:6006/oauthcallback.\nsecretsError');
 		});
 	});
 

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

@@ -21,19 +21,19 @@ describe('src/lib/api/calendar', () => {
 		it('should call getAuth', async () => {
 			await getAPI(profile);
 
-			expect(auth.getAuth).toBeCalledWith(profile, undefined);
+			expect(auth.getAuth).toHaveBeenCalledWith(profile, undefined);
 		});
 
 		it('should pass temporariness', async () => {
 			await getAPI(profile, { temporary : true });
 
-			expect(auth.getAuth).toBeCalledWith(profile, { temporary : true });
+			expect(auth.getAuth).toHaveBeenCalledWith(profile, { temporary : true });
 		});
 
 		it('should get calendar api', async () => {
 			await getAPI(profile);
 
-			expect(google.calendar).toBeCalledWith({ version : 'v3', auth : googleAuth });
+			expect(google.calendar).toHaveBeenCalledWith({ version : 'v3', auth : googleAuth });
 		});
 
 		it('should return calendar api', async () => {

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

@@ -1,5 +1,5 @@
-import logger from '../../logger';
-import sleep from '../../sleep';
+import logger from '@anmiles/logger';
+import sleep from '@anmiles/sleep';
 import shared from '../shared';
 
 const original = jest.requireActual('../shared').default as typeof shared;
@@ -7,13 +7,11 @@ jest.mock<Partial<typeof shared>>('../shared', () => ({
 	getItems : jest.fn().mockImplementation(async () => items),
 }));
 
-jest.mock<Partial<typeof logger>>('../../logger', () => ({
+jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
 	log : jest.fn(),
 }));
 
-jest.mock<Partial<typeof sleep>>('../../sleep', () => ({
-	sleep : jest.fn(),
-}));
+jest.mock<Partial<typeof sleep>>('@anmiles/sleep', () => jest.fn());
 
 const items: Array<{ data: string}> = [
 	{ data : 'first' },
@@ -60,30 +58,30 @@ describe('src/lib/api/shared', () => {
 			await original.getItems(api, args);
 
 			pageTokens.forEach((pageToken) => {
-				expect(api.list).toBeCalledWith({ ...args, pageToken });
+				expect(api.list).toHaveBeenCalledWith({ ...args, pageToken });
 			});
 		});
 
 		it('should output progress by default', async () => {
 			await original.getItems(api, args);
 
-			expect(logger.log).toBeCalledTimes(response.length);
-			expect(logger.log).toBeCalledWith('Getting items (2 of 4)...');
-			expect(logger.log).toBeCalledWith('Getting items (2 of many)...');
-			expect(logger.log).toBeCalledWith('Getting items (4 of 4)...');
+			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 original.getItems(api, args, { hideProgress : true });
 
-			expect(logger.log).not.toBeCalled();
+			expect(logger.log).not.toHaveBeenCalled();
 		});
 
 		it('should sleep after reach request', async () => {
 			await original.getItems(api, args);
 
-			expect(sleep.sleep).toBeCalledTimes(response.length);
-			expect(sleep.sleep).toBeCalledWith(300);
+			expect(sleep).toHaveBeenCalledTimes(response.length);
+			expect(sleep).toHaveBeenCalledWith(300);
 		});
 
 		it('should return items data', async () => {

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

@@ -21,19 +21,19 @@ describe('src/lib/api/youtube', () => {
 		it('should call getAuth', async () => {
 			await getAPI(profile);
 
-			expect(auth.getAuth).toBeCalledWith(profile, undefined);
+			expect(auth.getAuth).toHaveBeenCalledWith(profile, undefined);
 		});
 
 		it('should pass temporariness', async () => {
 			await getAPI(profile, { temporary : true });
 
-			expect(auth.getAuth).toBeCalledWith(profile, { temporary : true });
+			expect(auth.getAuth).toHaveBeenCalledWith(profile, { temporary : true });
 		});
 
 		it('should get youtube api', async () => {
 			await getAPI(profile);
 
-			expect(google.youtube).toBeCalledWith({ version : 'v3', auth : googleAuth });
+			expect(google.youtube).toHaveBeenCalledWith({ version : 'v3', auth : googleAuth });
 		});
 
 		it('should return youtube api', async () => {

package/src/lib/api/shared.ts

@@ -1,7 +1,7 @@
 import type GoogleApis from 'googleapis';
+import { log } from '@anmiles/logger';
+import sleep from '@anmiles/sleep';
 import type { CommonOptions } from '../../types';
-import { log } from '../logger';
-import { sleep } from '../sleep';
 
 export { getItems };
 export default { getItems };

package/src/lib/auth.ts

@@ -1,7 +1,7 @@
 import { google } from 'googleapis';
 import type GoogleApis from 'googleapis';
+import { info, warn } from '@anmiles/logger';
 import type { CommonOptions, AuthOptions } from '../types';
-import { info, warn } from './logger';
 import { getProfiles } from './profiles';
 import { getCredentials, getSecrets } from './secrets';
 

package/src/lib/paths.ts

@@ -1,31 +1,13 @@
-import fs from 'fs';
 import path from 'path';
-import paths from './paths';
 
-export { ensureDir, ensureFile, getProfilesFile, getScopesFile, getSecretsFile, getCredentialsFile };
-export default { ensureDir, ensureFile, getProfilesFile, getScopesFile, getSecretsFile, getCredentialsFile };
+export { getProfilesFile, getScopesFile, getSecretsFile, getCredentialsFile };
+export default { getProfilesFile, getScopesFile, getSecretsFile, getCredentialsFile };
 
 const dirPaths = {
 	input   : 'input',
 	secrets : 'secrets',
 };
 
-function ensureDir(dirPath: string) {
-	if (!fs.existsSync(dirPath)) {
-		fs.mkdirSync(dirPath, { recursive : true });
-	}
-	return dirPath;
-}
-
-function ensureFile(filePath: string) {
-	paths.ensureDir(path.dirname(filePath));
-
-	if (!fs.existsSync(filePath)) {
-		fs.writeFileSync(filePath, '');
-	}
-	return filePath;
-}
-
 function getProfilesFile() {
 	return path.join(dirPaths.input, 'profiles.json');
 }

package/src/lib/profiles.ts

@@ -1,5 +1,5 @@
-import { getJSON, writeJSON } from './jsonLib';
-import { error } from './logger';
+import fs from 'fs';
+import '@anmiles/prototypes';
 import { getProfilesFile } from './paths';
 
 import profiles from './profiles';
@@ -9,17 +9,17 @@ export default { getProfiles, setProfiles, createProfile };
 
 function getProfiles(): string[] {
 	const profilesFile = getProfilesFile();
-	return getJSON(profilesFile, () => []);
+	return fs.getJSON(profilesFile, () => []);
 }
 
 function setProfiles(profiles: string[]): void {
 	const profilesFile = getProfilesFile();
-	writeJSON(profilesFile, profiles);
+	fs.writeJSON(profilesFile, profiles);
 }
 
 function createProfile(profile: string): void {
 	if (!profile) {
-		error('Usage: `npm run create <profile>` where `profile` - is any profile name you want');
+		throw 'Usage: `npm run create <profile>` where `profile` - is any profile name you want';
 	}
 
 	const existingProfiles = profiles.getProfiles();