@anmiles/google-api-wrapper 18.0.3 → 19.0.1

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

@@ -1,150 +1,107 @@
 import fs from 'fs';
-import type logger from '@anmiles/logger';
-import type paths from '../paths';
-
-import profiles from '../profiles';
-
-const original = jest.requireActual<{ default : typeof profiles }>('../profiles').default;
-jest.mock<typeof profiles>('../profiles', () => ({
-	getProfiles    : jest.fn().mockImplementation(() => existingProfiles),
-	setProfiles    : jest.fn(),
-	createProfile  : jest.fn(),
-	filterProfiles : jest.fn(),
-}));
-
-jest.mock<Partial<typeof fs>>('fs', () => ({
-	mkdirSync     : jest.fn(),
-	renameSync    : jest.fn(),
-	writeFileSync : jest.fn(),
-	existsSync    : jest.fn().mockImplementation((file: string) => existingFiles.includes(file)),
-}));
-
-jest.mock<Partial<typeof logger>>('@anmiles/logger', () => ({
-	log  : jest.fn(),
-	warn : jest.fn(),
-}));
-
-jest.mock<Partial<typeof paths>>('../paths', () => ({
-	getProfilesFile : jest.fn().mockImplementation(() => profilesFile),
-}));
-
-const json         = { key : 'value' };
-const profilesFile = 'profilesFile';
-const profile1     = 'username1';
-const profile2     = 'username2';
-const allProfiles  = [ profile1, profile2 ];
-
-let existingProfiles: string[];
-let existingFiles: string[] = [];
-
-const getJSONSpy   = jest.spyOn(fs, 'getJSON').mockImplementation(() => json);
-const writeJSONSpy = jest.spyOn(fs, 'writeJSON').mockImplementation();
+
+import '@anmiles/prototypes';
+import mockFs from 'mock-fs';
+
+import { createProfile, filterProfiles, getProfiles, setProfiles } from '../profiles';
+import { getProfilesFile } from '../utils/paths';
+
+jest.mock('@anmiles/logger');
+
+const profilesFile = getProfilesFile();
+
+const profile1 = 'username1';
+const profile2 = 'username2';
+const profiles = [ profile1, profile2 ];
 
 beforeEach(() => {
-	existingFiles    = [];
-	existingProfiles = [ 'username1', 'username2' ];
+	mockFs({
+		[profilesFile]: JSON.stringify(profiles),
+	});
+});
+
+afterAll(() => {
+	mockFs.restore();
 });
 
 describe('src/lib/profiles', () => {
 
 	describe('getProfiles', () => {
-		it('should get json from profiles file', () => {
-			original.getProfiles();
+		it('should return profiles', () => {
+			const result = getProfiles();
 
-			expect(getJSONSpy).toHaveBeenCalled();
-			expect(getJSONSpy.mock.calls[0]?.[0]).toEqual(profilesFile);
+			expect(result).toEqual(profiles);
 		});
 
-		it('should fallback to empty profiles array', () => {
-			original.getProfiles();
-
-			const fallback = getJSONSpy.mock.calls[0]?.[1];
-
-			expect(fallback?.()).toEqual([]);
-		});
+		it('should return empty array and create profiles file if not exists', () => {
+			mockFs({});
 
-		it('should return JSON', () => {
-			const result = original.getProfiles();
+			const result = getProfiles();
 
-			expect(result).toEqual(json);
+			expect(result).toEqual([]);
+			expect(fs.existsSync(profilesFile)).toBe(true);
 		});
 	});
 
 	describe('setProfiles', () => {
 		it('should write json to profiles file', () => {
-			original.setProfiles(allProfiles);
+			setProfiles(profiles);
 
-			expect(writeJSONSpy).toHaveBeenCalledWith(profilesFile, allProfiles);
+			expect(fs.getJSON(profilesFile, () => [])).toEqual([ 'username1', 'username2' ]);
 		});
 	});
 
 	describe('createProfile', () => {
 		it('should output error and do nothing if profile is falsy', () => {
-			const func = (): void => {
-				original.createProfile('');
-			};
+			const func = (): void => createProfile('');
 
 			expect(func).toThrow('Usage: `npm run create <profile>` where `profile` - is any profile name you want');
 		});
 
-		it('should get profiles', () => {
-			const newProfile = 'username1';
+		it('should add new profile if not exists', () => {
+			const newProfile = 'newProfile';
 
-			original.createProfile(newProfile);
+			createProfile(newProfile);
 
-			expect(profiles.getProfiles).toHaveBeenCalledWith();
+			expect(fs.getJSON(profilesFile, () => [])).toEqual([ 'username1', 'username2', 'newProfile' ]);
 		});
 
-		it('should not save profiles if profile already exists', () => {
+		it('should not add duplicate', () => {
 			const newProfile = 'username1';
 
-			original.createProfile(newProfile);
+			createProfile(newProfile);
 
-			expect(profiles.setProfiles).not.toHaveBeenCalled();
-		});
-
-		it('should add new profile if not exists', () => {
-			const newProfile = 'newProfile';
-
-			original.createProfile(newProfile);
-
-			expect(profiles.setProfiles).toHaveBeenCalledWith([ 'username1', 'username2', 'newProfile' ]);
+			expect(fs.getJSON(profilesFile, () => [])).toEqual([ 'username1', 'username2' ]);
 		});
 	});
 
 	describe('filterProfiles', () => {
-		it('should get profiles', () => {
-			original.filterProfiles();
+		it('should return all profiles', () => {
+			const result = filterProfiles();
 
-			expect(profiles.getProfiles).toHaveBeenCalled();
+			expect(result).toEqual([ 'username1', 'username2' ]);
 		});
 
-		it('should output error if no profiles', () => {
-			existingProfiles = [];
+		it('should return array with requested profile if exists', () => {
+			const result = filterProfiles(profile1);
 
-			const func = (): string[] => original.filterProfiles();
-
-			expect(func).toThrow(new Error('Please `npm run create` at least one profile'));
+			expect(result).toEqual([ profile1 ]);
 		});
 
 		it('should output error if profile does not exist', () => {
 			const newProfile = 'newProfile';
 
-			const func = (): string[] => original.filterProfiles(newProfile);
+			const func = (): string[] => filterProfiles(newProfile);
 
 			expect(func).toThrow(new Error(`Profile '${newProfile}' does not exist`));
 		});
 
-		it('should return array with requested profile if it exists', () => {
-			const found = original.filterProfiles(profile1);
-
-			expect(found).toEqual([ profile1 ]);
-		});
+		it('should output error if no profiles', () => {
+			mockFs({});
 
-		it('should return all profiles if nothing requested', () => {
-			const found = original.filterProfiles();
+			const func = (): string[] => filterProfiles();
 
-			expect(found).toEqual(existingProfiles);
+			expect(func).toThrow(new Error('Please `npm run create` at least one profile'));
 		});
 	});
 });

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

@@ -1,48 +1,4 @@
-import fs from 'fs';
-import type path from 'path';
-import type paths from '../paths';
-import type renderer from '../renderer';
-
-const original = jest.requireActual<{ default : typeof renderer }>('../renderer').default;
-
-type TemplateName = keyof typeof original.templates;
-type GetFileName<T extends TemplateName> = `${T}.html`;
-
-type FileName = GetFileName<TemplateName>;
-type GetTemplateName<F> = F extends `${infer T}.html` ? T : never;
-
-function getFileName<T extends TemplateName>(templateName: T):  GetFileName<T> {
-	return `${templateName}.html`;
-}
-
-function getTemplateName<F extends FileName>(file: F):  GetTemplateName<F> {
-	return file.replace('.html', '') as GetTemplateName<F>;
-}
-
-jest.mock<Partial<typeof renderer>>('../renderer', () => ({
-	getTemplate : jest.fn().mockImplementation((templateName: TemplateName) => mockTemplates[templateName]),
-}));
-
-jest.mock<Partial<typeof fs>>('fs', () => ({
-	readFileSync : jest.fn().mockImplementation((file: FileName) => mockTemplates[getTemplateName(file)] || ''),
-}));
-
-jest.mock<Partial<typeof path>>('path', () => ({
-	join : jest.fn().mockImplementation((...paths: string[]) => paths.join('/')),
-}));
-
-jest.mock<Partial<typeof paths>>('../paths', () => ({
-	getTemplateFile : jest.fn().mockImplementation((templateName) => getFileName(templateName)),
-}));
-
-const mockTemplates: Record<TemplateName, string> = {
-	index : 'index page = (${page})',
-	page  : 'page css = (${css}) content = (${content})',
-	css   : 'css',
-	auth  : 'auth profile = (${profile}) authUrl = (${authUrl}) scopesList = (${scopesList})',
-	scope : 'scope type = (${type}) title = (${title}) name = (${name})',
-	done  : 'done profile = (${profile})',
-};
+import { renderAuth, renderDone } from '../renderer';
 
 const authUrl = 'https://authUrl';
 const profile = 'username';
@@ -51,60 +7,31 @@ const scope   = [ 'namespace/scope1.readonly', 'namespace/scope2' ];
 describe('src/lib/renderer', () => {
 	describe('renderAuth', () => {
 		it('should return auth page', () => {
-			const result = original.renderAuth({ authUrl, profile, scope });
-			expect(result).toEqual('index page = (page css = (css) content = (auth profile = (username) authUrl = (https://authUrl) scopesList = (scope type = (readonly) title = (Readonly (cannot change or delete your data)) name = (scope1.readonly)\nscope type = () title = (Writable (can change or delete your data)) name = (scope2))))');
-		});
-	});
+			const result = renderAuth({ profile, authUrl, scope });
 
-	describe('renderDone', () => {
-		it('should return done page', () => {
-			const result = original.renderDone({ profile });
-			expect(result).toEqual('index page = (page css = (css) content = (done profile = (username)))');
-		});
-	});
-
-	describe('render', () => {
-		it('should replace all template variables with their values', () => {
-			const values = { type : 'readonly', title : 'Readonly scope', name : 'scope.readonly' };
-
-			const result = original.render('scope', values);
-
-			expect(result).toEqual('scope type = (readonly) title = (Readonly scope) name = (scope.readonly)');
+			expect(result).toMatchSnapshot();
 		});
 
-		it('should replace non-existing template variable with empty string', () => {
-			const values = { name : 'scope.readonly', type : undefined, title : undefined };
+		it('should throw error if property missing', () => {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+			const func = (): string => renderAuth({ scope } as unknown as Parameters<typeof renderAuth>[0]);
 
-			const result = original.render('scope', values);
-
-			expect(result).toEqual('scope type = () title = () name = (scope.readonly)');
+			expect(func).toThrow('Missing required value \'profile\' while rendering template \'auth\'');
 		});
 	});
 
-	describe('getTemplate', () => {
-		for (const templateName in original.templates) {
-			it(`should return contents of '${templateName}' template file`, () => {
-				const template = original.getTemplate(templateName as TemplateName);
-				expect(fs.readFileSync).toHaveBeenCalledTimes(1);
-				expect(fs.readFileSync).toHaveBeenCalledWith(`${templateName}.html`);
-				expect(template).toEqual(mockTemplates[templateName as TemplateName]);
-			});
-		}
-
-		it('should cache templates', () => {
-			original.getTemplate('template1' as TemplateName);
-
-			original.getTemplate('template2' as TemplateName);
-			original.getTemplate('template2' as TemplateName);
-			original.getTemplate('template2' as TemplateName);
+	describe('renderDone', () => {
+		it('should return done page', () => {
+			const result = renderDone({ profile });
 
-			original.getTemplate('template3' as TemplateName);
+			expect(result).toMatchSnapshot();
+		});
 
-			expect(fs.readFileSync).toHaveBeenCalledWith('template1.html');
-			expect(fs.readFileSync).toHaveBeenCalledWith('template2.html');
-			expect(fs.readFileSync).toHaveBeenCalledWith('template3.html');
+		it('should throw error if property missing', () => {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+			const func = (): string => renderDone({} as unknown as Parameters<typeof renderAuth>[0]);
 
-			expect(fs.readFileSync).toHaveBeenCalledTimes(3);
+			expect(func).toThrow('Missing required value \'profile\' while rendering template \'done\'');
 		});
 	});
 });

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

@@ -0,0 +1,41 @@
+import '@anmiles/prototypes';
+import mockFs from 'mock-fs';
+
+import { getScopes } from '../scopes';
+import { getScopesFile } from '../utils/paths';
+
+const scopesFile = getScopesFile();
+
+const scopes = [
+	'https://www.googleapis.com/auth/calendar.calendars.readonly',
+	'https://www.googleapis.com/auth/calendar.events',
+];
+
+beforeEach(() => {
+	mockFs({
+		[scopesFile]: JSON.stringify(scopes),
+	});
+});
+
+afterAll(() => {
+	mockFs.restore();
+});
+
+describe('src/lib/scopes', () => {
+	describe('getScopes', () => {
+
+		it('should return scopes', () => {
+			const result = getScopes();
+
+			expect(result).toEqual(scopes);
+		});
+
+		it('should throw if scopes file does not exist', () => {
+			mockFs({});
+
+			const func = (): string[] => getScopes();
+
+			expect(func).toThrowErrorMatchingSnapshot();
+		});
+	});
+});