SymphonyElectron/spec/appCacheHandler.spec.ts

import * as fs from 'fs';
import * as path from 'path';
import * as rimraf from 'rimraf';
import {
  cleanAppCacheOnInstall,
  cleanUpAppCache,
  createAppCacheFile,
} from '../src/app/app-cache-handler';
import { app, session } from './__mocks__/electron';

jest.mock('fs', () => ({
  writeFileSync: jest.fn(),
  existsSync: jest.fn(() => true),
  unlinkSync: jest.fn(),
  readdirSync: jest.fn(() => [
    'Cache',
    'GPUCache',
    'Symphony.config',
    'cloudConfig.config',
  ]),
  lstatSync: jest.fn(() => {
    return {
      isDirectory: jest.fn(() => true),
    };
  }),
}));

jest.mock('path', () => ({
  join: jest.fn(),
}));

jest.mock('rimraf', () => ({
  sync: jest.fn(),
}));

jest.mock('../src/common/logger', () => {
  return {
    logger: {
      error: jest.fn(),
      info: jest.fn(),
    },
  };
});

describe('app cache handler', () => {
  describe('check app cache file', () => {
    const cachePathExpected = path.join(app.getPath('userData'), 'CacheCheck');

    it('should call `cleanUpAppCache` correctly', () => {
      const spyFn = 'unlinkSync';
      const spy = jest.spyOn(fs, spyFn);
      cleanUpAppCache();
      expect(spy).toBeCalledWith(cachePathExpected);
    });

    it('should call `clearCache` when `session.defaultSession` is not null', () => {
      jest.spyOn(fs, 'existsSync').mockImplementation(() => false);
      const spyFn = 'clearCache';
      const spy = jest.spyOn(session.defaultSession, spyFn);
      cleanUpAppCache();
      expect(spy).toBeCalled();
    });

    it('should call `createAppCacheFile` correctly', () => {
      const spyFn = 'writeFileSync';
      const spy = jest.spyOn(fs, spyFn);
      createAppCacheFile();
      expect(spy).lastCalledWith(cachePathExpected, '');
    });
  });

  describe('clean app cache on install', () => {
    it('should clean app cache and cookies on install', () => {
      const pathSpy = jest.spyOn(path, 'join');

      const fsReadDirSpy = jest.spyOn(fs, 'readdirSync');
      const fsStatSpy = jest.spyOn(fs, 'lstatSync');
      const fsUnlinkSpy = jest.spyOn(fs, 'unlinkSync');

      const rimrafSpy = jest.spyOn(rimraf, 'sync');

      cleanAppCacheOnInstall();

      expect(pathSpy).toBeCalled();

      expect(fsReadDirSpy).toBeCalled();
      expect(fsStatSpy).toBeCalled();
      expect(fsUnlinkSpy).toBeCalled();

      expect(rimrafSpy).toBeCalled();
    });
  });
});