@anmiles/google-api-wrapper 7.0.6 → 8.0.0

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

@@ -1,6 +1,6 @@
 import { google } from 'googleapis';
 import type GoogleApis from 'googleapis';
-import logger from '../logger';
+import logger from '@anmiles/logger';
 import profiles from '../profiles';
 import secrets from '../secrets';
 
@@ -11,7 +11,7 @@ jest.mock<typeof auth>('../auth', () => ({
 	getAuth : jest.fn().mockImplementation(async () => googleAuth),
 }));
 
-jest.mock<Partial<typeof logger>>('../logger', () => ({
+jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
 	info : jest.fn(),
 	warn : jest.fn(),
 }));
@@ -56,95 +56,95 @@ describe('src/lib/auth', () => {
 	describe('login', () => {
 		it('should get profiles', async () => {
 			await original.login();
-			expect(profiles.getProfiles).toBeCalledWith();
+			expect(profiles.getProfiles).toHaveBeenCalledWith();
 		});
 
 		it('should auth all profiles', async () => {
 			await original.login();
 
 			allProfiles.forEach((profile) => {
-				expect(auth.getAuth).toBeCalledWith(profile, undefined);
+				expect(auth.getAuth).toHaveBeenCalledWith(profile, undefined);
 			});
 		});
 
 		it('should auth only specified profile', async () => {
 			await original.login('username1');
 
-			expect(auth.getAuth).toBeCalledWith('username1', undefined);
-			expect(auth.getAuth).not.toBeCalledWith('username2', undefined);
+			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).toBeCalledWith('username1', { temporary : true });
-			expect(auth.getAuth).toBeCalledWith('username2', { 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).toBeCalledWith('username1', { temporary : true });
-			expect(auth.getAuth).not.toBeCalledWith('username2', { 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).toBeCalledWith('username1 - logging in...');
-			expect(logger.warn).toBeCalledWith('username2 - logging in...');
-			expect(logger.info).toBeCalledWith('username1 - logged in successfully');
-			expect(logger.info).toBeCalledWith('username2 - logged in successfully');
+			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).toBeCalledWith('username1 - logging in...');
-			expect(logger.info).toBeCalledWith('username1 - logged in successfully');
+			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.toBeCalled();
+			expect(logger.info).not.toHaveBeenCalled();
 		});
 	});
 
 	describe('getAuth', () => {
 		it('should get secrets', async () => {
 			await original.getAuth(profile);
-			expect(secrets.getSecrets).toBeCalledWith(profile);
+			expect(secrets.getSecrets).toHaveBeenCalledWith(profile);
 		});
 
 		it('should get credentials', async () => {
 			await original.getAuth(profile);
-			expect(secrets.getCredentials).toBeCalledWith(profile, googleAuth, undefined);
+			expect(secrets.getCredentials).toHaveBeenCalledWith(profile, googleAuth, undefined);
 		});
 
 		it('should create OAuth2 instance', async () => {
 			await original.getAuth(profile);
-			expect(google.auth.OAuth2).toBeCalledWith(secretsObject.web.client_id, secretsObject.web.client_secret, secretsObject.web.redirect_uris[0]);
+			expect(google.auth.OAuth2).toHaveBeenCalledWith(secretsObject.web.client_id, secretsObject.web.client_secret, secretsObject.web.redirect_uris[0]);
 		});
 
 		it('should set credentials', async () => {
 			await original.getAuth(profile);
-			expect(googleAuth.setCredentials).toBeCalledWith(credentials);
+			expect(googleAuth.setCredentials).toHaveBeenCalledWith(credentials);
 		});
 
 		it('should pass temporariness', async () => {
 			await original.getAuth(profile, { temporary : true });
 
-			expect(secrets.getCredentials).toBeCalledWith(profile, googleAuth, { temporary : true });
+			expect(secrets.getCredentials).toHaveBeenCalledWith(profile, googleAuth, { temporary : true });
 		});
 
 		it('should set google auth', async () => {
 			await original.getAuth(profile);
 
-			expect(google.options).toBeCalledWith({ auth : googleAuth });
+			expect(google.options).toHaveBeenCalledWith({ auth : googleAuth });
 		});
 	});
 });

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

@@ -4,8 +4,6 @@ import path from 'path';
 import paths from '../paths';
 const original = jest.requireActual('../paths').default as typeof paths;
 jest.mock<typeof paths>('../paths', () => ({
-	ensureDir          : jest.fn().mockImplementation((dirPath) => dirPath),
-	ensureFile         : jest.fn().mockImplementation((filePath) => filePath),
 	getProfilesFile    : jest.fn().mockImplementation(() => profilesFile),
 	getScopesFile      : jest.fn().mockImplementation(() => scopesFile),
 	getSecretsFile     : jest.fn().mockImplementation(() => secretsFile),
@@ -23,10 +21,7 @@ jest.mock<Partial<typeof path>>('path', () => ({
 	dirname : jest.fn().mockImplementation((arg) => arg.split('/').slice(0, -1).join('/')),
 }));
 
-const profile  = 'username';
-const dirPath  = 'dirPath';
-const filePath = 'parentDir/filePath';
-
+const profile         = 'username';
 const profilesFile    = 'input/profiles.json';
 const scopesFile      = 'scopes.json';
 const secretsFile     = 'secrets/username.json';
@@ -35,63 +30,6 @@ const credentialsFile = 'secrets/username.credentials.json';
 let exists: boolean;
 
 describe('src/lib/paths', () => {
-
-	describe('ensureDir', () => {
-		it('should create empty dir if not exists', () => {
-			exists = false;
-
-			original.ensureDir(dirPath);
-
-			expect(fs.mkdirSync).toBeCalledWith(dirPath, { recursive : true });
-		});
-
-		it('should not create empty dir if already exists', () => {
-			exists = true;
-
-			original.ensureDir(dirPath);
-
-			expect(fs.writeFileSync).not.toBeCalled();
-		});
-
-		it('should return dirPath', () => {
-			const result = original.ensureDir(dirPath);
-
-			expect(result).toEqual(dirPath);
-		});
-	});
-
-	describe('ensureFile', () => {
-		it('should ensure parent dir', () => {
-			exists = false;
-
-			original.ensureFile(filePath);
-
-			expect(paths.ensureDir).toBeCalledWith('parentDir');
-		});
-
-		it('should create empty file if not exists', () => {
-			exists = false;
-
-			original.ensureFile(filePath);
-
-			expect(fs.writeFileSync).toBeCalledWith(filePath, '');
-		});
-
-		it('should not create empty file if already exists', () => {
-			exists = true;
-
-			original.ensureFile(filePath);
-
-			expect(fs.writeFileSync).not.toBeCalled();
-		});
-
-		it('should return filePath', () => {
-			const result = original.ensureFile(filePath);
-
-			expect(result).toEqual(filePath);
-		});
-	});
-
 	describe('getProfilesFile', () => {
 		it('should return profiles file', () => {
 			const result = original.getProfilesFile();

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

@@ -1,6 +1,5 @@
 import fs from 'fs';
-import jsonLib from '../jsonLib';
-import logger from '../logger';
+import logger from '@anmiles/logger';
 import paths from '../paths';
 
 import profiles from '../profiles';
@@ -18,17 +17,9 @@ jest.mock<Partial<typeof fs>>('fs', () => ({
 	existsSync    : jest.fn().mockImplementation((file) => existingFiles.includes(file)),
 }));
 
-jest.mock<Partial<typeof jsonLib>>('../jsonLib', () => ({
-	getJSON   : jest.fn().mockImplementation(() => json),
-	writeJSON : jest.fn(),
-}));
-
-jest.mock<Partial<typeof logger>>('../logger', () => ({
-	log   : jest.fn(),
-	warn  : jest.fn(),
-	error : jest.fn().mockImplementation((error) => {
-		throw error;
-	}) as jest.Mock<never, any>,
+jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
+	log  : jest.fn(),
+	warn : jest.fn(),
 }));
 
 jest.mock<Partial<typeof paths>>('../paths', () => ({
@@ -44,19 +35,32 @@ const allProfiles      = [ profile1, profile2 ];
 
 let existingFiles: string[] = [];
 
+let getJSONSpy: jest.SpyInstance;
+let writeJSONSpy: jest.SpyInstance;
+
+beforeAll(() => {
+	getJSONSpy   = jest.spyOn(fs, 'getJSON');
+	writeJSONSpy = jest.spyOn(fs, 'writeJSON');
+});
+
 beforeEach(() => {
+	getJSONSpy.mockImplementation(() => json);
+	writeJSONSpy.mockImplementation();
 	existingFiles = [];
 });
 
+afterAll(() => {
+	getJSONSpy.mockRestore();
+	writeJSONSpy.mockRestore();
+});
+
 describe('src/lib/profiles', () => {
 
 	describe('getProfiles', () => {
-		const getJSONSpy = jest.spyOn(jsonLib, 'getJSON');
-
 		it('should get json from profiles file', () => {
 			original.getProfiles();
 
-			expect(getJSONSpy).toBeCalled();
+			expect(getJSONSpy).toHaveBeenCalled();
 			expect(getJSONSpy.mock.calls[0][0]).toEqual(profilesFile);
 		});
 
@@ -79,7 +83,7 @@ describe('src/lib/profiles', () => {
 		it('should write json to profiles file', () => {
 			original.setProfiles(allProfiles);
 
-			expect(jsonLib.writeJSON).toBeCalledWith(profilesFile, allProfiles);
+			expect(writeJSONSpy).toHaveBeenCalledWith(profilesFile, allProfiles);
 		});
 	});
 
@@ -87,7 +91,7 @@ describe('src/lib/profiles', () => {
 		it('should output error and do nothing if profile is falsy', () => {
 			const func = () => original.createProfile('');
 
-			expect(func).toThrowError('Usage: `npm run create <profile>` where `profile` - is any profile name you want');
+			expect(func).toThrow('Usage: `npm run create <profile>` where `profile` - is any profile name you want');
 		});
 
 		it('should get profiles', () => {
@@ -95,7 +99,7 @@ describe('src/lib/profiles', () => {
 
 			original.createProfile(newProfile);
 
-			expect(profiles.getProfiles).toBeCalledWith();
+			expect(profiles.getProfiles).toHaveBeenCalledWith();
 		});
 
 		it('should not save profiles if profile already exists', () => {
@@ -103,7 +107,7 @@ describe('src/lib/profiles', () => {
 
 			original.createProfile(newProfile);
 
-			expect(profiles.setProfiles).not.toBeCalled();
+			expect(profiles.setProfiles).not.toHaveBeenCalled();
 		});
 
 		it('should add new profile if not exists', () => {
@@ -111,7 +115,7 @@ describe('src/lib/profiles', () => {
 
 			original.createProfile(newProfile);
 
-			expect(profiles.setProfiles).toBeCalledWith([ 'username1', 'username2', 'newProfile' ]);
+			expect(profiles.setProfiles).toHaveBeenCalledWith([ 'username1', 'username2', 'newProfile' ]);
 		});
 	});
 });