@anmiles/google-api-wrapper 1.0.1

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

@@ -0,0 +1,165 @@
+import fs from 'fs';
+import logger from '../logger';
+import paths from '../paths';
+
+import jsonLib from '../jsonLib';
+const original = jest.requireActual('../jsonLib').default as typeof jsonLib;
+jest.mock<typeof jsonLib>('../jsonLib', () => ({
+	readJSON     : jest.fn().mockImplementation(() => json),
+	writeJSON    : jest.fn(),
+	getJSON      : jest.fn(),
+	getJSONAsync : jest.fn(),
+	checkJSON    : jest.fn(),
+}));
+
+jest.mock<Partial<typeof fs>>('fs', () => ({
+	readFileSync  : jest.fn().mockImplementation(() => jsonString),
+	writeFileSync : jest.fn(),
+	existsSync    : jest.fn().mockImplementation(() => fileExists),
+}));
+
+jest.mock<Partial<typeof logger>>('../logger', () => ({
+	error : jest.fn().mockImplementation((error) => {
+		throw error;
+	}) as jest.Mock<never, any>,
+}));
+
+jest.mock<Partial<typeof paths>>('../paths', () => ({
+	ensureFile : jest.fn(),
+}));
+
+const filename     = 'filename';
+const json         = { key : 'value' };
+const jsonString   = JSON.stringify(json, null, '    ');
+const fallbackJSON = { fallbackKey : 'fallbackValue' };
+
+const createCallback      = jest.fn().mockReturnValue(fallbackJSON);
+const createCallbackAsync = jest.fn().mockResolvedValue(fallbackJSON);
+
+let fileExists: boolean;
+
+describe('src/lib/jsonLib', () => {
+	describe('readJSON', () => {
+		it('should read specified file', () => {
+			original.readJSON(filename);
+
+			expect(fs.readFileSync).toBeCalledWith(filename);
+		});
+
+		it('should return parsed JSON', () => {
+			const result = original.readJSON(filename);
+
+			expect(result).toEqual(json);
+		});
+	});
+
+	describe('writeJSON', () => {
+		it('should write JSON into specified file', () => {
+			original.writeJSON(filename, json);
+
+			expect(fs.writeFileSync).toBeCalledWith(filename, jsonString);
+		});
+	});
+
+	describe('getJSON', () => {
+		it('should call readJSON if file exists', () => {
+			fileExists = true;
+
+			original.getJSON(filename, createCallback);
+
+			expect(jsonLib.readJSON).toBeCalledWith(filename);
+			expect(createCallback).not.toBeCalled();
+		});
+
+		it('should call createCallback if file not exists', () => {
+			fileExists = false;
+
+			original.getJSON(filename, createCallback);
+
+			expect(jsonLib.readJSON).not.toBeCalled();
+			expect(createCallback).toBeCalledWith();
+		});
+
+		it('should write fallback JSON back if file not exists', () => {
+			fileExists = false;
+
+			original.getJSON(filename, createCallback);
+
+			expect(jsonLib.checkJSON).toBeCalledWith(filename, fallbackJSON);
+			expect(paths.ensureFile).toBeCalledWith(filename);
+			expect(jsonLib.writeJSON).toBeCalledWith(filename, fallbackJSON);
+		});
+
+		it('should return JSON if file exists', () => {
+			fileExists = true;
+
+			const result = original.getJSON(filename, createCallback);
+
+			expect(result).toEqual(json);
+		});
+
+		it('should return fallback JSON if file not exists', () => {
+			fileExists = false;
+
+			const result = original.getJSON(filename, createCallback);
+
+			expect(result).toEqual(fallbackJSON);
+		});
+	});
+
+	describe('getJSONAsync', () => {
+		it('should call readJSON if file exists', async () => {
+			fileExists = true;
+
+			await original.getJSONAsync(filename, createCallbackAsync);
+
+			expect(jsonLib.readJSON).toBeCalledWith(filename);
+			expect(createCallbackAsync).not.toBeCalled();
+		});
+
+		it('should call createCallback if file not exists', async () => {
+			fileExists = false;
+
+			await original.getJSONAsync(filename, createCallbackAsync);
+
+			expect(jsonLib.readJSON).not.toBeCalled();
+			expect(createCallbackAsync).toBeCalledWith();
+		});
+
+		it('should write fallback JSON back if file not exists', async () => {
+			fileExists = false;
+
+			await original.getJSONAsync(filename, createCallbackAsync);
+
+			expect(jsonLib.checkJSON).toBeCalledWith(filename, fallbackJSON);
+			expect(jsonLib.writeJSON).toBeCalledWith(filename, fallbackJSON);
+		});
+
+		it('should return JSON if file exists', async () => {
+			fileExists = true;
+
+			const result = await original.getJSONAsync(filename, createCallbackAsync);
+
+			expect(result).toEqual(json);
+		});
+
+		it('should return fallback JSON if file not exists', async () => {
+			fileExists = false;
+
+			const result = await original.getJSONAsync(filename, createCallbackAsync);
+
+			expect(result).toEqual(fallbackJSON);
+		});
+	});
+
+	describe('checkJSON', () => {
+		it('should do nothing if json is truthy', () => {
+			original.checkJSON(filename, json);
+
+			expect(logger.error).not.toBeCalled();
+		});
+		it('should output error if json is falsy', () => {
+			expect(() => original.checkJSON(filename, '')).toThrowError(`File ${filename} doesn't exist and should be created with initial data, but function createCallback returned nothing`);
+		});
+	});
+});

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

@@ -0,0 +1,57 @@
+import * as colorette from 'colorette';
+
+import logger from '../logger';
+
+const text = 'text';
+
+const originalConsole = global.console;
+global.console.log    = jest.fn();
+global.console.info   = jest.fn();
+global.console.warn   = jest.fn();
+global.console.error  = jest.fn();
+
+const exit = jest.spyOn(process, 'exit').mockImplementation();
+
+afterAll(() => {
+	global.console = originalConsole;
+});
+
+describe('src/lib/logger', () => {
+	describe('log', () => {
+		it('should call console.log with original text', () => {
+			logger.log(text);
+
+			expect(global.console.log).toBeCalledWith(text);
+		});
+	});
+
+	describe('info', () => {
+		it('should call console.info with bright green text', () => {
+			logger.info(text);
+
+			expect(global.console.log).toBeCalledWith(colorette.greenBright(text));
+		});
+	});
+
+	describe('warn', () => {
+		it('should call console.warn with bright yellow text', () => {
+			logger.warn(text);
+
+			expect(global.console.warn).toBeCalledWith(colorette.yellowBright(text));
+		});
+	});
+
+	describe('error', () => {
+		it('should call console.error with bright red text and newline', () => {
+			logger.error(text);
+
+			expect(global.console.error).toBeCalledWith(`${colorette.redBright(text)}\n`);
+		});
+
+		it('should exit the process with code 1', () => {
+			logger.error(text);
+
+			expect(exit).toBeCalledWith(1);
+		});
+	});
+});

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

@@ -0,0 +1,116 @@
+import fs from 'fs';
+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),
+	getSecretsFile     : jest.fn().mockImplementation(() => secretsFile),
+	getCredentialsFile : jest.fn().mockImplementation(() => credentialsFile),
+}));
+
+jest.mock<Partial<typeof fs>>('fs', () => ({
+	mkdirSync     : jest.fn(),
+	writeFileSync : jest.fn(),
+	existsSync    : jest.fn().mockImplementation(() => exists),
+}));
+
+jest.mock<Partial<typeof path>>('path', () => ({
+	join    : jest.fn().mockImplementation((...args) => args.join('/')),
+	dirname : jest.fn().mockImplementation((arg) => arg.split('/').slice(0, -1).join('/')),
+}));
+
+const profile  = 'username';
+const dirPath  = 'dirPath';
+const filePath = 'parentDir/filePath';
+
+const profilesFile    = 'input/profiles.json';
+const secretsFile     = 'secrets/username.json';
+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();
+
+			expect(result).toEqual(profilesFile);
+		});
+	});
+
+	describe('getSecretsFile', () => {
+		it('should return secrets file', () => {
+			const result = original.getSecretsFile(profile);
+
+			expect(result).toEqual(secretsFile);
+		});
+	});
+
+	describe('getCredentialsFile', () => {
+		it('should return credentials file', () => {
+			const result = original.getCredentialsFile(profile);
+
+			expect(result).toEqual(credentialsFile);
+		});
+	});
+});

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

@@ -0,0 +1,117 @@
+import fs from 'fs';
+import jsonLib from '../jsonLib';
+import logger from '../logger';
+import paths from '../paths';
+
+import profiles from '../profiles';
+const original = jest.requireActual('../profiles').default as typeof profiles;
+jest.mock<typeof profiles>('../profiles', () => ({
+	getProfiles   : jest.fn().mockImplementation(() => existingProfiles),
+	setProfiles   : jest.fn(),
+	createProfile : jest.fn(),
+}));
+
+jest.mock<Partial<typeof fs>>('fs', () => ({
+	mkdirSync     : jest.fn(),
+	renameSync    : jest.fn(),
+	writeFileSync : jest.fn(),
+	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 paths>>('../paths', () => ({
+	getProfilesFile : jest.fn().mockImplementation(() => profilesFile),
+}));
+
+const json             = { key : 'value' };
+const existingProfiles = [ 'username1', 'username2' ];
+const profilesFile     = 'profilesFile';
+const profile1         = 'username1';
+const profile2         = 'username2';
+const allProfiles      = [ profile1, profile2 ];
+
+let existingFiles: string[] = [];
+
+beforeEach(() => {
+	existingFiles = [];
+});
+
+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.mock.calls[0][0]).toEqual(profilesFile);
+		});
+
+		it('should fallback to empty profiles array', () => {
+			original.getProfiles();
+
+			const fallback = getJSONSpy.mock.calls[0][1];
+
+			expect(fallback()).toEqual([]);
+		});
+
+		it('should return JSON', () => {
+			const result = original.getProfiles();
+
+			expect(result).toEqual(json);
+		});
+	});
+
+	describe('setProfiles', () => {
+		it('should write json to profiles file', () => {
+			original.setProfiles(allProfiles);
+
+			expect(jsonLib.writeJSON).toBeCalledWith(profilesFile, allProfiles);
+		});
+	});
+
+	describe('createProfile', () => {
+		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');
+		});
+
+		it('should get profiles', () => {
+			const newProfile = 'username1';
+
+			original.createProfile(newProfile);
+
+			expect(profiles.getProfiles).toBeCalledWith();
+		});
+
+		it('should not save profiles if profile already exists', () => {
+			const newProfile = 'username1';
+
+			original.createProfile(newProfile);
+
+			expect(profiles.setProfiles).not.toBeCalled();
+		});
+
+		it('should add new profile if not exists', () => {
+			const newProfile = 'newProfile';
+
+			original.createProfile(newProfile);
+
+			expect(profiles.setProfiles).toBeCalledWith([ 'username1', 'username2', 'newProfile' ]);
+		});
+	});
+});