feat: bump minimum node version to 16 and add tests (#86)

* build: add tests

* build: bump deps

* sigh

* build: install rosetta on m1

test/asar-utils.spec.ts

@@ -0,0 +1,26 @@
+import * as path from 'path';
+
+import { AsarMode, detectAsarMode, generateAsarIntegrity } from '../src/asar-utils';
+
+const asarsPath = path.resolve(__dirname, 'fixtures', 'asars');
+const appsPath = path.resolve(__dirname, 'fixtures', 'apps');
+
+describe('asar-utils', () => {
+  describe('detectAsarMode', () => {
+    it('should correctly detect an asar enabled app', async () => {
+      expect(await detectAsarMode(path.resolve(appsPath, 'Asar.app'))).toBe(AsarMode.HAS_ASAR);
+    });
+
+    it('should correctly detect an app without an asar', async () => {
+      expect(await detectAsarMode(path.resolve(appsPath, 'NoAsar.app'))).toBe(AsarMode.NO_ASAR);
+    });
+  });
+
+  describe('generateAsarIntegrity', () => {
+    it('should deterministically hash an asar header', async () => {
+      expect(generateAsarIntegrity(path.resolve(asarsPath, 'app.asar')).hash).toEqual(
+        '85fff474383bd8df11cd9c5784e8fcd1525af71ff140a8a882e1dc9d5b39fcbf',
+      );
+    });
+  });
+});

test/file-utils.spec.ts

@@ -0,0 +1,61 @@
+import * as path from 'path';
+
+import { AppFile, AppFileType, getAllAppFiles } from '../src/file-utils';
+
+const appsPath = path.resolve(__dirname, 'fixtures', 'apps');
+
+describe('file-utils', () => {
+  describe('getAllAppFiles', () => {
+    let asarFiles: AppFile[];
+    let noAsarFiles: AppFile[];
+
+    beforeAll(async () => {
+      asarFiles = await getAllAppFiles(path.resolve(appsPath, 'Asar.app'));
+      noAsarFiles = await getAllAppFiles(path.resolve(appsPath, 'NoAsar.app'));
+    });
+
+    it('should correctly identify plist files', async () => {
+      expect(asarFiles.find((f) => f.relativePath === 'Contents/Info.plist')?.type).toBe(
+        AppFileType.INFO_PLIST,
+      );
+    });
+
+    it('should correctly identify asar files as app code', async () => {
+      expect(asarFiles.find((f) => f.relativePath === 'Contents/Resources/app.asar')?.type).toBe(
+        AppFileType.APP_CODE,
+      );
+    });
+
+    it('should correctly identify non-asar code files as plain text', async () => {
+      expect(
+        noAsarFiles.find((f) => f.relativePath === 'Contents/Resources/app/index.js')?.type,
+      ).toBe(AppFileType.PLAIN);
+    });
+
+    it('should correctly identify the Electron binary as Mach-O', async () => {
+      expect(noAsarFiles.find((f) => f.relativePath === 'Contents/MacOS/Electron')?.type).toBe(
+        AppFileType.MACHO,
+      );
+    });
+
+    it('should correctly identify the Electron Framework as Mach-O', async () => {
+      expect(
+        noAsarFiles.find(
+          (f) =>
+            f.relativePath ===
+            'Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework',
+        )?.type,
+      ).toBe(AppFileType.MACHO);
+    });
+
+    it('should correctly identify the v8 context snapshot', async () => {
+      expect(
+        noAsarFiles.find(
+          (f) =>
+            f.relativePath ===
+            'Contents/Frameworks/Electron Framework.framework/Versions/A/Resources/v8_context_snapshot.arm64.bin',
+        )?.type,
+      ).toBe(AppFileType.SNAPSHOT);
+    });
+  });
+});

test/fixtures/asars/app/index.js

@@ -0,0 +1,2 @@
+console.log('I am an app folder', process.arch);
+process.exit(0);

test/fixtures/asars/app/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "app",
+  "main": "index.js"
+}

test/fixtures/tohash

@@ -0,0 +1 @@
+hello there

test/index.spec.ts

@@ -0,0 +1,40 @@
+import { spawn } from '@malept/cross-spawn-promise';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+import { makeUniversalApp } from '../src/index';
+
+const appsPath = path.resolve(__dirname, 'fixtures', 'apps');
+
+async function ensureUniversal(app: string) {
+  const exe = path.resolve(app, 'Contents', 'MacOS', 'Electron');
+  const result = await spawn(exe);
+  expect(result).toContain('arm64');
+  const result2 = await spawn('arch', ['-x86_64', exe]);
+  expect(result2).toContain('x64');
+}
+
+describe('makeUniversalApp', () => {
+  it('should correctly merge two identical asars', async () => {
+    const out = path.resolve(appsPath, 'MergedAsar.app');
+    await makeUniversalApp({
+      x64AppPath: path.resolve(appsPath, 'X64Asar.app'),
+      arm64AppPath: path.resolve(appsPath, 'Asar.app'),
+      outAppPath: out,
+    });
+    await ensureUniversal(out);
+    // Only a single asar as they were identical
+    expect(
+      (await fs.readdir(path.resolve(out, 'Contents', 'Resources'))).filter((p) =>
+        p.endsWith('asar'),
+      ),
+    ).toEqual(['app.asar']);
+  }, 60000);
+
+  // TODO: Add tests for
+  // * different asar files
+  // * identical app dirs
+  // * different app dirs
+  // * different app dirs with different macho files
+  // * identical app dirs with universal macho files
+});

test/sha.spec.ts

@@ -0,0 +1,11 @@
+import * as path from 'path';
+
+import { sha } from '../src/sha';
+
+describe('sha', () => {
+  it('should correctly hash a file', async () => {
+    expect(await sha(path.resolve(__dirname, 'fixtures', 'tohash'))).toEqual(
+      '12998c017066eb0d2a70b94e6ed3192985855ce390f321bbdb832022888bd251',
+    );
+  });
+});