[ci]: Made various changes for the electron app:

- Support for multiple electron targe per platform.
 - Removed packager CLI. Changed the logic we calculate the app name.
 - Fixed various OS-specific tests: stubbed `os`.
 - Restructured the final ZIP formats for Windows and Linux.
 - Added packager tests.
 - Switched from `@grpc/grpc-js` to native `grpc`.
 - Updated the version from 0.0.5 to 0.0.6.

Signed-off-by: Akos Kitta <kittaakos@typefox.io>

electron/packager/test/utils.test.js

@@ -0,0 +1,119 @@
+const fs = require('fs');
+const path = require('path');
+const expect = require('chai').expect;
+const track = require('temp').track();
+const unpack = require('../utils').unpack;
+const testMe = require('../utils');
+const sinon = require('sinon');
+
+describe('utils', () => {
+
+    describe('adjustArchiveStructure', () => {
+
+        let consoleStub;
+
+        beforeEach(() => {
+            consoleStub = sinon.stub(console, 'log').value(() => { });
+        });
+
+        afterEach(() => {
+            consoleStub.reset();
+            track.cleanupSync();
+        });
+
+        it('should reject when not a zip file', async () => {
+            try {
+                const invalid = path.join(__dirname, 'resources', 'not-a-zip.dmg');
+                await testMe.adjustArchiveStructure(invalid, track.mkdirSync());
+                throw new Error('Expected a rejection');
+            } catch (e) {
+                expect(e).to.be.an.instanceOf(Error);
+                expect(e.message).to.be.equal('Expected a ZIP file.');
+            }
+        });
+
+        it('should reject when target directory does not exist', async () => {
+            try {
+                const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
+                await testMe.adjustArchiveStructure(zip, path.join(__dirname, 'some', 'missing', 'path'));
+                throw new Error('Expected a rejection');
+            } catch (e) {
+                expect(e).to.be.an.instanceOf(Error);
+                expect(e.message.endsWith('does not exist.')).to.be.true;
+            }
+        });
+
+        it('should reject when target is a file', async () => {
+            try {
+                const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
+                await testMe.adjustArchiveStructure(zip, path.join(__filename));
+                throw new Error('Expected a rejection');
+            } catch (e) {
+                expect(e).to.be.an.instanceOf(Error);
+                expect(e.message.endsWith('is not a directory.')).to.be.true;
+            }
+        });
+
+        it('should be a NOOP when the zip already has the desired base folder', async () => {
+            const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
+            const actual = await testMe.adjustArchiveStructure(zip, track.mkdirSync());
+            expect(actual).to.be.equal(zip);
+        });
+
+        it('should handle whitespace in file path gracefully', async () => {
+            const zip = path.join(__dirname, 'resources', 'zip with whitespace.zip');
+            const out = track.mkdirSync();
+            const actual = await testMe.adjustArchiveStructure(zip, out, true);
+            expect(actual).to.be.equal(path.join(out, 'zip with whitespace.zip'));
+            console.log(actual);
+            expect(fs.existsSync(actual)).to.be.true;
+
+            const verifyOut = track.mkdirSync();
+            await unpack(actual, verifyOut);
+
+            const root = path.join(verifyOut, 'zip with whitespace');
+            expect(fs.existsSync(root)).to.be.true;
+            expect(fs.lstatSync(root).isDirectory()).to.be.true;
+            const subs = fs.readdirSync(root);
+            expect(subs).to.have.lengthOf(3);
+            expect(subs.sort()).to.be.deep.equal(['a.txt', 'b.txt', 'foo']);
+        });
+
+        it('should keep the symlinks after ZIP adjustments', async function () {
+            if (process.platform === 'win32') {
+                this.skip();
+            }
+            const zip = path.join(__dirname, 'resources', 'zip-with-symlink.zip');
+            const out = track.mkdirSync();
+            const actual = await testMe.adjustArchiveStructure(zip, out, true);
+            expect(actual).to.be.equal(path.join(out, 'zip-with-symlink.zip'));
+            console.log(actual);
+            expect(fs.existsSync(actual)).to.be.true;
+
+            const verifyOut = track.mkdirSync();
+            await unpack(actual, verifyOut);
+            expect(fs.lstatSync(path.join(verifyOut, 'zip-with-symlink', 'folder', 'symlinked-sub')).isSymbolicLink()).to.be.true;
+        });
+
+        it('should adjust the archive structure if base folder is not present', async () => {
+            const zip = path.join(__dirname, 'resources', 'zip-without-symlink.zip');
+            const out = track.mkdirSync();
+            const actual = await testMe.adjustArchiveStructure(zip, out, true);
+            expect(actual).to.be.equal(path.join(out, 'zip-without-symlink.zip'));
+            console.log(actual);
+            expect(fs.existsSync(actual)).to.be.true;
+
+            const verifyOut = track.mkdirSync();
+            await unpack(actual, verifyOut);
+
+            const root = path.join(verifyOut, 'zip-without-symlink');
+            expect(fs.existsSync(root)).to.be.true;
+            expect(fs.lstatSync(root).isDirectory()).to.be.true;
+            const subs = fs.readdirSync(root);
+            expect(subs).to.have.lengthOf(3);
+            expect(subs.sort()).to.be.deep.equal(['a.txt', 'b.txt', 'foo']);
+        });
+
+    });
+
+});