refactor: modify InstallState to be an enum (#33)

Author: aryanshridhar

dist/fiddle-core.d.ts

@@ -129,7 +129,13 @@ export declare class Installer extends EventEmitter {
  * See {@link Installer.state} to get this value.
  * See Installer.on('state-changed') to watch for state changes.
  */
-export declare type InstallState = 'missing' | 'downloading' | 'downloaded' | 'installing' | 'installed';
+export declare enum InstallState {
+    missing = 'missing',
+    downloading = 'downloading',
+    downloaded = 'downloaded',
+    installing = 'installing',
+    installed = 'installed',
+}
 
 export declare interface InstallStateEvent {
     version: string;

src/installer.ts

@@ -19,12 +19,13 @@ type ProgressObject = { percent: number };
  * See {@link Installer.state} to get this value.
  * See Installer.on('state-changed') to watch for state changes.
  */
-export type InstallState =
-  | 'missing'
-  | 'downloading'
-  | 'downloaded'
-  | 'installing'
-  | 'installed';
+export enum InstallState {
+  missing = 'missing',
+  downloading = 'downloading',
+  downloaded = 'downloaded',
+  installing = 'installing',
+  installed = 'installed',
+}
 
 export interface InstallStateEvent {
   version: string;
@@ -79,14 +80,14 @@ export class Installer extends EventEmitter {
   }
 
   public state(version: string): InstallState {
-    return this.stateMap.get(version) || 'missing';
+    return this.stateMap.get(version) || InstallState.missing;
   }
 
   private setState(version: string, state: InstallState) {
     const d = debug('fiddle-core:Installer:setState');
     const oldState = this.state(version);
 
-    if (state === 'missing') {
+    if (state === InstallState.missing) {
       this.stateMap.delete(version);
     } else {
       this.stateMap.set(version, state);
@@ -108,13 +109,13 @@ export class Installer extends EventEmitter {
     try {
       const versionFile = path.join(this.paths.electronInstall, 'version');
       const version = fs.readFileSync(versionFile, 'utf8');
-      this.setState(version, 'installed');
+      this.setState(version, InstallState.installed);
     } catch {
       // no current version
     }
 
     if (this.installing) {
-      this.setState(this.installing, 'installing');
+      this.setState(this.installing, InstallState.installing);
     }
 
     // already downloaded...
@@ -123,15 +124,15 @@ export class Installer extends EventEmitter {
     try {
       for (const file of fs.readdirSync(this.paths.electronDownloads)) {
         const match = reg.exec(file);
-        if (match) this.setState(match[1], 'downloaded');
+        if (match) this.setState(match[1], InstallState.downloaded);
       }
     } catch {
       // no download directory yet
     }
 
     // being downloaded now...
     for (const version of this.downloading.keys()) {
-      this.setState(version, 'downloading');
+      this.setState(version, InstallState.downloading);
     }
   }
 
@@ -187,7 +188,7 @@ export class Installer extends EventEmitter {
     }
 
     if (isZipDeleted && isBinaryDeleted) {
-      this.setState(version, 'missing');
+      this.setState(version, InstallState.missing);
     } else {
       // Ideally the execution shouldn't reach this point
       console.warn(`Installer: Failed to remove version ${version}`);
@@ -197,7 +198,7 @@ export class Installer extends EventEmitter {
   /** The current Electron installation, if any. */
   public get installedVersion(): string | undefined {
     for (const [version, state] of this.stateMap)
-      if (state === 'installed') return version;
+      if (state === InstallState.installed) return version;
   }
 
   private async download(
@@ -240,13 +241,13 @@ export class Installer extends EventEmitter {
     const zipFile = path.join(electronDownloads, getZipName(version));
 
     const state = this.state(version);
-    if (state === 'missing') {
+    if (state === InstallState.missing) {
       d(`"${zipFile}" does not exist; downloading now`);
-      this.setState(version, 'downloading');
+      this.setState(version, InstallState.downloading);
       const tempFile = await this.download(version, opts);
       await fs.ensureDir(electronDownloads);
       await fs.move(tempFile, zipFile);
-      this.setState(version, 'downloaded');
+      this.setState(version, InstallState.downloaded);
       d(`"${zipFile}" downloaded`);
     } else {
       d(`"${zipFile}" exists; no need to download`);
@@ -293,7 +294,7 @@ export class Installer extends EventEmitter {
       d(`already installed`);
     } else {
       const zipFile = await this.ensureDownloaded(version, opts);
-      this.setState(version, 'installing');
+      this.setState(version, InstallState.installing);
       d(`installing from "${zipFile}"`);
       await fs.emptyDir(electronInstall);
       // FIXME(anyone) is there a less awful way to wrangle asar
@@ -307,8 +308,9 @@ export class Installer extends EventEmitter {
         // @ts-ignore: yes, I know noAsar isn't defined in process
         process.noAsar = noAsar; // eslint-disable-line
       }
-      if (installedVersion) this.setState(installedVersion, 'downloaded');
-      this.setState(version, 'installed');
+      if (installedVersion)
+        this.setState(installedVersion, InstallState.downloaded);
+      this.setState(version, InstallState.installed);
     }
 
     delete this.installing;

tests/installer.test.ts

@@ -3,13 +3,20 @@ import * as os from 'os';
 import * as path from 'path';
 import nock, { Scope } from 'nock';
 
-import { InstallStateEvent, Installer, Paths } from '../src/index';
+import {
+  InstallStateEvent,
+  Installer,
+  Paths,
+  InstallState,
+} from '../src/index';
 
 describe('Installer', () => {
   let tmpdir: string;
   let paths: Partial<Paths>;
   let nockScope: Scope;
   let installer: Installer;
+  const { missing, downloading, downloaded, installing, installed } =
+    InstallState;
   const version12 = '12.0.15' as const;
   const version13 = '13.1.7' as const;
   const version = version13;
@@ -65,7 +72,7 @@ describe('Installer', () => {
     const func = () => installer.remove(version);
     const { events } = await listenWhile(installer, func);
 
-    expect(installer.state(version)).toBe('missing');
+    expect(installer.state(version)).toBe(missing);
 
     return { events };
   }
@@ -77,15 +84,15 @@ describe('Installer', () => {
     };
 
     // Version is already downloaded and present in local
-    if (installer.state(version) !== 'missing') {
+    if (installer.state(version) !== missing) {
       isDownloaded = true;
     }
     const func = () => installer.install(version, { progressCallback });
     const { events, result } = await listenWhile(installer, func);
     const exec = result as string;
 
     expect(isDownloaded).toBe(true);
-    expect(installer.state(version)).toBe('installed');
+    expect(installer.state(version)).toBe(installed);
     expect(installer.installedVersion).toBe(version);
 
     return { events, exec };
@@ -98,7 +105,7 @@ describe('Installer', () => {
     };
 
     // Version is already downloaded and present in local
-    if (installer.state(version) !== 'missing') {
+    if (installer.state(version) !== missing) {
       isDownloaded = true;
     }
     const func = () =>
@@ -110,7 +117,7 @@ describe('Installer', () => {
 
     expect(isDownloaded).toBe(true);
     expect(fs.existsSync(zipfile)).toBe(true);
-    expect(installer.state(version)).toBe('downloaded');
+    expect(installer.state(version)).toBe(downloaded);
 
     return { events, zipfile };
   }
@@ -134,13 +141,13 @@ describe('Installer', () => {
   describe('ensureDownloaded()', () => {
     it('downloads the version if needed', async () => {
       // setup: version is not installed
-      expect(installer.state(version)).toBe('missing');
+      expect(installer.state(version)).toBe(missing);
 
       // test that the zipfile was downloaded
       const { events } = await doDownload(installer, version);
       expect(events).toStrictEqual([
-        { version, state: 'downloading' },
-        { version, state: 'downloaded' },
+        { version, state: downloading },
+        { version, state: downloaded },
       ]);
     });
 
@@ -163,12 +170,12 @@ describe('Installer', () => {
       await doDownload(installer, version);
 
       const { events } = await doRemove(installer, version);
-      expect(events).toStrictEqual([{ version, state: 'missing' }]);
+      expect(events).toStrictEqual([{ version, state: missing }]);
     });
 
     it('does nothing if the version is missing', async () => {
       // setup: version is not installed
-      expect(installer.state(version)).toBe('missing');
+      expect(installer.state(version)).toBe(missing);
 
       const { events } = await doRemove(installer, version);
       expect(events).toStrictEqual([]);
@@ -179,35 +186,35 @@ describe('Installer', () => {
       await doInstall(installer, version);
 
       const { events } = await doRemove(installer, version);
-      expect(events).toStrictEqual([{ version, state: 'missing' }]);
+      expect(events).toStrictEqual([{ version, state: missing }]);
       expect(installer.installedVersion).toBe(undefined);
     });
   });
 
   describe('install()', () => {
     it('downloads a version if necessary', async () => {
       // setup: version is not downloaded
-      expect(installer.state(version)).toBe('missing');
+      expect(installer.state(version)).toBe(missing);
       expect(installer.installedVersion).toBe(undefined);
 
       const { events } = await doInstall(installer, version);
       expect(events).toStrictEqual([
-        { version, state: 'downloading' },
-        { version, state: 'downloaded' },
-        { version, state: 'installing' },
-        { version, state: 'installed' },
+        { version, state: downloading },
+        { version, state: downloaded },
+        { version, state: installing },
+        { version, state: installed },
       ]);
     });
 
     it('unzips a version if necessary', async () => {
       // setup: version is downloaded but not installed
       await doDownload(installer, version);
-      expect(installer.state(version)).toBe('downloaded');
+      expect(installer.state(version)).toBe(downloaded);
 
       const { events } = await doInstall(installer, version);
       expect(events).toStrictEqual([
-        { version, state: 'installing' },
-        { version, state: 'installed' },
+        { version, state: installing },
+        { version, state: installed },
       ]);
     });
 
@@ -224,11 +231,11 @@ describe('Installer', () => {
       const { events } = await doInstall(installer, version13);
 
       expect(events).toStrictEqual([
-        { version: version13, state: 'downloading' },
-        { version: version13, state: 'downloaded' },
-        { version: version13, state: 'installing' },
-        { version: version12, state: 'downloaded' },
-        { version: version13, state: 'installed' },
+        { version: version13, state: downloading },
+        { version: version13, state: downloaded },
+        { version: version13, state: installing },
+        { version: version12, state: downloaded },
+        { version: version13, state: installed },
       ]);
     });
   });
@@ -248,16 +255,16 @@ describe('Installer', () => {
   describe('state()', () => {
     it("returns 'installed' if the version is installed", async () => {
       await doInstall(installer, version);
-      expect(installer.state(version)).toBe('installed');
+      expect(installer.state(version)).toBe(installed);
     });
 
     it("returns 'downloaded' if the version is downloaded", async () => {
       await doDownload(installer, version);
-      expect(installer.state(version)).toBe('downloaded');
+      expect(installer.state(version)).toBe(downloaded);
     });
 
     it("returns 'missing' if the version is not downloaded", () => {
-      expect(installer.state(version)).toBe('missing');
+      expect(installer.state(version)).toBe(missing);
     });
   });
 });