You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by er...@apache.org on 2019/03/04 07:28:24 UTC
[cordova-electron] branch master updated: Refactor and test
build.js: (#35)
This is an automated email from the ASF dual-hosted git repository.
erisu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/cordova-electron.git
The following commit(s) were added to refs/heads/master by this push:
new 1cf1d26 Refactor and test build.js: (#35)
1cf1d26 is described below
commit 1cf1d263324da3ed7c0110ef0a519375603e6ef8
Author: Gedas Gardauskas <ge...@gmail.com>
AuthorDate: Mon Mar 4 16:28:21 2019 +0900
Refactor and test build.js: (#35)
- Implement unit tests for build.js
- Refactor build.js use throw Error instead of throw
- Fix platform mapping error
---
bin/templates/cordova/lib/build.js | 6 +-
.../spec/unit/templates/cordova/lib/build.spec.js | 1299 ++++++++++++++++++++
2 files changed, 1302 insertions(+), 3 deletions(-)
diff --git a/bin/templates/cordova/lib/build.js b/bin/templates/cordova/lib/build.js
index 77574eb..7b8e146 100644
--- a/bin/templates/cordova/lib/build.js
+++ b/bin/templates/cordova/lib/build.js
@@ -39,7 +39,7 @@ const PLATFORM_MAPPING = {
linux: 'linux',
mac: 'darwin',
windows: 'win32',
- win: 'win'
+ win: 'win32'
};
class ElectronBuilder {
@@ -83,7 +83,7 @@ class ElectronBuilder {
* If there is there are no valid properties
*/
if (!this.__validateUserPlatformBuildSettings(platformConfigs)) {
- throw `The platform "${platform}" contains an invalid property. Valid properties are: package, arch, signing`;
+ throw Error(`The platform "${platform}" contains an invalid property. Valid properties are: package, arch, signing`);
}
// Electron uses "win" as it's key, not "windows", so we will update here. We use windows in our settings for clarity.
@@ -276,7 +276,7 @@ class ElectronBuilder {
const platformFile = path.resolve(__dirname, `./build/${platform}.json`);
if (!fs.existsSync(platformFile)) {
- throw `Your platform "${platform}" is not supported as a default target platform for Electron.`;
+ throw Error(`Your platform "${platform}" is not supported as a default target platform for Electron.`);
}
return require(platformFile);
diff --git a/tests/spec/unit/templates/cordova/lib/build.spec.js b/tests/spec/unit/templates/cordova/lib/build.spec.js
new file mode 100644
index 0000000..5b0b51f
--- /dev/null
+++ b/tests/spec/unit/templates/cordova/lib/build.spec.js
@@ -0,0 +1,1299 @@
+/* eslint-disable no-template-curly-in-string */
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+const rewire = require('rewire');
+const path = require('path');
+const Api = rewire('../../../../../../bin/templates/cordova/Api');
+
+describe('Testing build.js:', () => {
+ let build;
+
+ beforeEach(() => {
+ build = rewire('../../../../../../bin/templates/cordova/lib/build');
+ });
+
+ describe('deepMerge method', () => {
+ it('should deep merge objects and arrays.', () => {
+ const deepMerge = build.__get__('deepMerge');
+
+ const mergeTo = { foo: 'bar', abc: [ 1, 2, 3 ] };
+ const mergeWith = { food: 'candy', abc: [ 5 ] };
+
+ const actual = deepMerge(mergeTo, mergeWith);
+ const expected = {
+ foo: 'bar',
+ food: 'candy',
+ abc: [ 1, 2, 3, 5 ]
+ };
+
+ expect(actual).toEqual(expected);
+ });
+ });
+
+ describe('Build class', () => {
+ let ElectronBuilder;
+ let electronBuilder;
+ let requireSpy;
+ let existsSyncSpy;
+ let emitSpy;
+
+ const emptyObj = {};
+ const api = new Api(null);
+
+ beforeEach(() => {
+ ElectronBuilder = build.__get__('ElectronBuilder');
+
+ build.__set__({ require: requireSpy });
+
+ emitSpy = jasmine.createSpy('emit');
+ build.__set__('events', { emit: emitSpy });
+ });
+
+ it('should should be defined.', () => {
+ expect(ElectronBuilder).toBeDefined();
+ });
+
+ it('should set isDevelopment to undefined and buildConfig to false, when buildOptions is empty.', () => {
+ electronBuilder = new ElectronBuilder(emptyObj, emptyObj);
+
+ expect(electronBuilder.api).toEqual(emptyObj);
+ expect(electronBuilder.isDevelopment).toEqual(undefined);
+ expect(electronBuilder.buildConfig).toEqual(false);
+ });
+
+ it('should set isDevelopment to true and buildConfig to false, when buildOptions is not empty.', () => {
+ // mock buildOptions Objecet
+ const buildOptions = { debug: true, argv: [] };
+
+ electronBuilder = new ElectronBuilder(buildOptions, emptyObj);
+
+ expect(electronBuilder.api).toEqual(emptyObj);
+ expect(electronBuilder.isDevelopment).toEqual(true);
+ expect(electronBuilder.buildConfig).toEqual(false);
+ });
+
+ it('should set isDevelopment to true and buildConfig to false, when buildOptions.buildCofing is defined, but does not exist.', () => {
+ // mock buildOptions Objecet
+ const buildOptions = { debug: true, buildConfig: 'build.xml', argv: [] };
+
+ // create spy
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, emptyObj);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(electronBuilder.api).toEqual(emptyObj);
+ expect(electronBuilder.isDevelopment).toEqual(true);
+ expect(electronBuilder.buildConfig).toEqual(false);
+ });
+
+ it('should set isDevelopment to true and buildConfig to true, when buildOptions.buildCofing is defined and does exist.', () => {
+ // mock buildOptions Objecet
+ const buildOptions = { debug: true, buildConfig: {}, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(true);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, emptyObj);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+ expect(electronBuilder.api).toEqual(emptyObj);
+ expect(electronBuilder.isDevelopment).toEqual(true);
+ expect(electronBuilder.buildConfig).toEqual(true);
+ });
+
+ it('should set isDevelopment is true and buildConfig to actual config, when buildOptions.buildCofing is actual cofing and does exist.', () => {
+ // mock BuildConfig and buildOptions Object
+ const buildConfig = {
+ electron: 'electron',
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: true, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configure();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+ expect(electronBuilder.buildSettings).toEqual(buildConfig);
+ });
+
+ it('should set isDevelopment to false and buildConfig to actual config, when buildOptions.buildCofing is actual cofing and does exist.', () => {
+ // mock BuildConfig and buildOptions Object
+ const buildConfig = {
+ electron: 'electron',
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configure();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+ expect(electronBuilder.buildSettings).toEqual(buildConfig);
+ });
+
+ it('should set isDevelopment to false and buildConfig to actual config, when buildOptions.buildCofing file does not exist.', () => {
+ // mock BuildConfig and buildOptions Object
+ const buildConfig = {
+ electron: 'electron',
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ expect(() => {
+ electronBuilder = new ElectronBuilder(buildOptions, api).configure();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(electronBuilder.buildSettings).toEqual(buildConfig);
+ }).toThrowError(/not supported as a default target platform/);
+ });
+
+ it('should set configureUserBuildSettings (release mode) for all 3 platforms and one invalid one.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { package: ['package', 'package2'], arch: 'arch', signing: { debug: 'debug', release: 'release', store: 'store' } },
+ win: { package: ['package', 'package2'], arch: 'arch', signing: { debug: 'debug', release: 'release' } },
+ linux: { package: ['package', 'package2'], arch: 'arch' },
+ darwin: {}
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+
+ const expectedMac = {
+ target: [
+ { target: 'package', arch: 'arch' },
+ { target: 'package2', arch: 'arch' }
+ ],
+ type: '${BUILD_TYPE}'
+ };
+ const expectedLinux = {
+ target: [
+ { target: 'package', arch: 'arch' },
+ { target: 'package2', arch: 'arch' }
+ ]
+ };
+
+ expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac);
+ expect(electronBuilder.userBuildSettings.config.linux).toEqual(expectedLinux);
+ expect(electronBuilder.userBuildSettings.config.win).toEqual(undefined);
+ });
+
+ it('should continue to use defaults with supplied valid configs.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { signing: { provisioningProfile: 'release' } }
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: 'LOAD_MY_FAKE_DATA', argv: [] };
+
+ // create spies
+ build.__set__('fs', {
+ existsSync: jasmine.createSpy('existsSync').and.returnValue(true)
+ });
+
+ build.__set__('require', (file) => {
+ if (file === 'LOAD_MY_FAKE_DATA') return buildConfig;
+ return require(file);
+ });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ const expectedMac = [
+ { target: 'dmg', arch: ['x64'] },
+ { target: 'zip', arch: ['x64'] }
+ ];
+
+ expect(electronBuilder.userBuildSettings.config.mac.target).toEqual(expectedMac);
+ });
+
+ it('should use all default options when no options supplied.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { }
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: 'LOAD_MY_FAKE_DATA', argv: [] };
+
+ // create spies
+ build.__set__('fs', {
+ existsSync: jasmine.createSpy('existsSync').and.returnValue(true)
+ });
+
+ build.__set__('require', (file) => {
+ if (file === 'LOAD_MY_FAKE_DATA') return buildConfig;
+ return require(file);
+ });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ const expectedMac = [
+ { target: 'dmg', arch: ['x64'] },
+ { target: 'zip', arch: ['x64'] }
+ ];
+
+ expect(electronBuilder.userBuildSettings.config.mac.target).toEqual(expectedMac);
+ });
+
+ it('should set configureUserBuildSettings (debug mode) for all 3 platforms and one invalid one.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { package: ['package', 'package2'], arch: 'arch', signing: { debug: 'debug', release: 'release', store: 'store' } },
+ win: { package: ['package', 'package2'], arch: 'arch', signing: { debug: 'debug', release: 'release' } },
+ linux: { package: ['package', 'package2'], arch: 'arch' },
+ darwin: {}
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: true, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+
+ const expectedMac = {
+ target: [
+ { target: 'package', arch: 'arch' },
+ { target: 'package2', arch: 'arch' }
+ ],
+ type: '${BUILD_TYPE}'
+ };
+ const expectedLinux = {
+ target: [
+ { target: 'package', arch: 'arch' },
+ { target: 'package2', arch: 'arch' }
+ ]
+ };
+
+ expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac);
+ expect(electronBuilder.userBuildSettings.config.linux).toEqual(expectedLinux);
+ expect(electronBuilder.userBuildSettings.config.win).toEqual(undefined);
+ });
+
+ it('should set configureUserBuildSettings for all 3 platforms without package.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { arch: [ 'arch1', 'arch2' ], signing: { debug: 'debug', release: 'release', store: 'store' } },
+ windows: { arch: [ 'arch1', 'arch2' ], signing: { debug: 'debug', release: 'release' } },
+ linux: { arch: [ 'arch1', 'arch2' ] }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: 'LOAD_MY_FAKE_DATA', argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ // requireSpy = jasmine.createSpy('require').and.returnValue();
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ build.__set__('require', (file) => {
+ if (file === 'LOAD_MY_FAKE_DATA') return buildConfig;
+ return require(file);
+ });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ // expect(requireSpy).toHaveBeenCalled();
+
+ const expected = {
+ linux: [],
+ mac: [],
+ win: [],
+ config: {
+ linux: {
+ target: [
+ {
+ target: 'tar.gz',
+ arch: [ 'arch1', 'arch2' ]
+ }
+ ]
+ },
+ mac: {
+ type: '${BUILD_TYPE}',
+ target: [
+ {
+ target: 'dmg',
+ arch: [ 'arch1', 'arch2' ]
+ },
+ {
+ target: 'zip',
+ arch: [ 'arch1', 'arch2' ]
+ }
+ ]
+ },
+ win: {
+ target: [
+ {
+ target: 'nsis',
+ arch: [ 'arch1', 'arch2' ]
+ }
+ ]
+ }
+ }
+ };
+
+ expect(electronBuilder.userBuildSettings).toEqual(expected);
+ });
+
+ it('should not set this.userBuildSettings.', () => {
+ const buildConfig = {
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: 'LOAD_MY_FAKE_DATA', argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ // requireSpy = jasmine.createSpy('require').and.returnValue();
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ build.__set__('require', (file) => {
+ if (file === 'LOAD_MY_FAKE_DATA') return buildConfig;
+ return require(file);
+ });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(electronBuilder.userBuildSettings).toBe(undefined);
+ });
+
+ it('should set configureUserBuildSettings for all 3 platforms without arch.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: 'store' } },
+ win: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release' } },
+ linux: { package: ['package', 'package2'] }
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+
+ const expectedMac = {
+ target: [
+ { target: 'package', arch: [ 'x64' ] },
+ { target: 'package2', arch: [ 'x64' ] }
+ ],
+ type: '${BUILD_TYPE}'
+ };
+ const expectedLinux = {
+ target: [
+ { target: 'package', arch: [ 'x64' ] },
+ { target: 'package2', arch: [ 'x64' ] }
+ ]
+ };
+
+ expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac);
+ expect(electronBuilder.userBuildSettings.config.linux).toEqual(expectedLinux);
+ expect(electronBuilder.userBuildSettings.config.win).toEqual(undefined);
+ });
+
+ it('should set configureUserBuildSettings for all 3 platforms without signing.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { package: ['package', 'package2'], arch: 'arch' },
+ win: { package: ['package', 'package2'], arch: 'arch' },
+ linux: { package: ['package', 'package2'], arch: 'arch' }
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: true, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+
+ const expectedMac = {
+ target: [
+ { target: 'package', arch: 'arch' },
+ { target: 'package2', arch: 'arch' }
+ ],
+ type: '${BUILD_TYPE}'
+ };
+ const expectedLinux = {
+ target: [
+ { target: 'package', arch: 'arch' },
+ { target: 'package2', arch: 'arch' }
+ ]
+ };
+
+ expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac);
+ expect(electronBuilder.userBuildSettings.config.linux).toEqual(expectedLinux);
+ expect(electronBuilder.userBuildSettings.config.win).toEqual(undefined);
+ });
+
+ it('should set configureUserBuildSettings for mac when platform configs is empty.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: {}
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+ });
+
+ it('should throw new Error mac with incorrect platform build properties.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { pack: ['package', 'package2'], architecture: 'arch', sign: 'signing' }
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+ expect(function () { electronBuilder.configureUserBuildSettings(); }).toThrow(
+ new Error('The platform "mac" contains an invalid property. Valid properties are: package, arch, signing')
+ );
+ });
+
+ it('should set configureUserBuildSettings for when using windows instead of win.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ windows: { package: ['mas', 'package2'], arch: 'arch', signing: 'signing' }
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(buildConfig);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ const __validateUserPlatformBuildSettingsSpy = jasmine.createSpy('__validateUserPlatformBuildSettings').and.returnValue(true);
+ build.__set__({ __validateUserPlatformBuildSettings: __validateUserPlatformBuildSettingsSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).configureUserBuildSettings();
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+
+ const expectedWin = {
+ target: [
+ { target: 'mas', arch: 'arch' },
+ { target: 'package2', arch: 'arch' }
+ ]
+ };
+
+ expect(electronBuilder.userBuildSettings.config.mac).toEqual(undefined);
+ expect(electronBuilder.userBuildSettings.config.linux).toEqual(undefined);
+ expect(electronBuilder.userBuildSettings.config.win).toEqual(expectedWin);
+ });
+
+ it('should fetchPlatformDefaults true.', () => {
+ // mock buildOptions Objecet and platformFile path
+ const buildOptions = { debug: true, buildConfig: 'build.xml', argv: [] };
+ const platformFile = path.join(__dirname, 'build', 'platform.json');
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ requireSpy = jasmine.createSpy('require').and.returnValue(platformFile);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+ build.__set__({ require: requireSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).fetchPlatformDefaults('electron');
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(requireSpy).toHaveBeenCalled();
+ expect(electronBuilder).toEqual(platformFile);
+ });
+
+ it('should fetchPlatformDefaults false.', () => {
+ // mock buildOptions Object
+ const buildOptions = { debug: true, buildConfig: 'build.xml', argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+
+ expect(function () { electronBuilder.fetchPlatformDefaults('name'); }).toThrow(new Error('Your platform "name" is not supported as a default target platform for Electron.'));
+ });
+
+ it('should __appendUserSingning linux signing.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ linux: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release' } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendUserSingning('linux', platformConfig.linux.signing, buildOptions);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(emitSpy).toHaveBeenCalled();
+ const actual = emitSpy.calls.argsFor(0)[1];
+ const expected = 'The provided signing information for the Linux platform is ignored. Linux does not support signing.';
+ expect(actual).toEqual(expected);
+ });
+
+ it('should __appendUserSingning mac with masconfig.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ mac: { package: ['package', 'package2'], signing: { store: { requirements: 'requirements' } } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ // config.mas is appeneded to build options to spoof what __formatAppendUserSettings method would have performed.
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [], config: { mas: {} } };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendUserSingning('mac', platformConfig.mac.signing, buildOptions);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(buildOptions.buildConfig.electron.mac.signing.store.requirements).toBe(undefined);
+ });
+
+ it('should append user singing for windows', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ win: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release' } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendUserSingning('win', platformConfig, buildOptions);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ });
+
+ it('should set buildConfigs __appendMacUserSingning when files exist.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ darwin: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: { requirements: 'requirements' } } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ const config = {
+ debug: 'debug',
+ release: 'release',
+ identity: 'identify',
+ entitlements: 'entitlements',
+ entitlementsInherit: 'entitlementsInherit',
+ requirements: 'requirements',
+ provisioningProfile: 'provisioningProfile',
+ store: 'store'
+ };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendMacUserSingning(config, buildConfig);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(buildConfig.identity).toEqual(config.identity);
+ expect(buildConfig.entitlements).toEqual(config.entitlements);
+ expect(buildConfig.entitlementsInherit).toEqual(config.entitlementsInherit);
+ expect(buildConfig.requirements).toEqual(config.requirements);
+ expect(buildConfig.provisioningProfile).toEqual(config.provisioningProfile);
+ });
+
+ it('should emit warning when in __appendMacUserSingning when files does not exist and set identity to process env link.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ darwin: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: { requirements: 'requirements' } } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ const config = {
+ debug: 'debug',
+ release: 'release',
+ entitlements: 'entitlements',
+ entitlementsInherit: 'entitlementsInherit',
+ requirements: 'requirements',
+ provisioningProfile: 'provisioningProfile',
+ store: 'store'
+ };
+
+ // set process.env.CSC_LINK
+ build.__set__('process', Object.assign({}, { env: { CSC_LINK: 'csc_link' } }));
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendMacUserSingning(config, buildConfig);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(emitSpy).toHaveBeenCalled();
+
+ expect(buildConfig.identity).toEqual('csc_link');
+ expect(buildConfig.entitlements).toEqual(undefined);
+ expect(buildConfig.entitlementsInherit).toEqual(undefined);
+ expect(buildConfig.requirements).toEqual(undefined);
+ expect(buildConfig.provisioningProfile).toEqual(undefined);
+
+ const actualEntitlements = emitSpy.calls.argsFor(0)[1];
+ const expectedEntitlements = 'The provided entitlements file does not exist';
+ expect(actualEntitlements).toContain(expectedEntitlements);
+
+ const actualEntitlementsInherits = emitSpy.calls.argsFor(1)[1];
+ const expectedEntitlementsInherits = 'The provided entitlements inherit file does not exist';
+ expect(actualEntitlementsInherits).toContain(expectedEntitlementsInherits);
+
+ const actualRequirements = emitSpy.calls.argsFor(2)[1];
+ const expectedRequirements = 'The provided requirements file does not exist';
+ expect(actualRequirements).toContain(expectedRequirements);
+
+ const actualProvisioningProfile = emitSpy.calls.argsFor(3)[1];
+ const expectedProvisioningProfiles = 'The provided provisioning profile does not exist';
+ expect(actualProvisioningProfile).toContain(expectedProvisioningProfiles);
+ });
+
+ it('should emit warning when in __appendMacUserSingning when files does not exist and set identity to process env name.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ darwin: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: { requirements: 'requirements' } } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ const config = {
+ debug: 'debug',
+ release: 'release',
+ entitlements: 'entitlements',
+ entitlementsInherit: 'entitlementsInherit',
+ requirements: 'requirements',
+ provisioningProfile: 'provisioningProfile',
+ store: 'store'
+ };
+
+ // set process.env.CSC_NAME
+ build.__set__('process', Object.assign({}, { env: { CSC_NAME: 'csc_name' } }));
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendMacUserSingning(config, buildConfig);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(emitSpy).toHaveBeenCalled();
+
+ expect(buildConfig.identity).toEqual('csc_name');
+ expect(buildConfig.entitlements).toEqual(undefined);
+ expect(buildConfig.entitlementsInherit).toEqual(undefined);
+ expect(buildConfig.requirements).toEqual(undefined);
+ expect(buildConfig.provisioningProfile).toEqual(undefined);
+
+ const actualEntitlements = emitSpy.calls.argsFor(0)[1];
+ const expectedEntitlements = 'The provided entitlements file does not exist';
+ expect(actualEntitlements).toContain(expectedEntitlements);
+
+ const actualEntitlementsInherits = emitSpy.calls.argsFor(1)[1];
+ const expectedEntitlementsInherits = 'The provided entitlements inherit file does not exist';
+ expect(actualEntitlementsInherits).toContain(expectedEntitlementsInherits);
+
+ const actualRequirements = emitSpy.calls.argsFor(2)[1];
+ const expectedRequirements = 'The provided requirements file does not exist';
+ expect(actualRequirements).toContain(expectedRequirements);
+
+ const actualProvisioningProfile = emitSpy.calls.argsFor(3)[1];
+ const expectedProvisioningProfiles = 'The provided provisioning profile does not exist';
+ expect(actualProvisioningProfile).toContain(expectedProvisioningProfiles);
+ });
+
+ it('should set buildConfigs in __appendWindowsUserSingning for windows singning when files exist.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ windows: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: 'requirements' } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ const config = {
+ debug: 'debug',
+ release: 'release',
+ identity: 'identify',
+ certificateFile: 'certificateFile',
+ certificatePassword: 'certificatePassword',
+ certificateSubjectName: 'certificateSubjectName',
+ certificateSha1: 'certificateSha1',
+ signingHashAlgorithms: 'signingHashAlgorithms',
+ additionalCertificateFile: 'additionalCertificateFile'
+ };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendWindowsUserSingning(config, buildConfig);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+
+ expect(buildConfig.certificateFile).toEqual(config.certificateFile);
+ expect(buildConfig.certificatePassword).toEqual(config.certificatePassword);
+ expect(buildConfig.certificateSubjectName).toEqual(config.certificateSubjectName);
+ expect(buildConfig.certificateSha1).toEqual(config.certificateSha1);
+ expect(buildConfig.signingHashAlgorithms).toEqual(config.signingHashAlgorithms);
+ expect(buildConfig.additionalCertificateFile).toEqual(config.additionalCertificateFile);
+ });
+
+ it('should set buildConfigs in __appendWindowsUserSingning for windows singning when files exist, but certificate password does not.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ windows: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: 'requirements' } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ const config = {
+ debug: 'debug',
+ release: 'release',
+ identity: 'identify',
+ certificateFile: 'certificateFile',
+ certificateSubjectName: 'certificateSubjectName',
+ certificateSha1: 'certificateSha1',
+ signingHashAlgorithms: 'signingHashAlgorithms',
+ additionalCertificateFile: 'additionalCertificateFile'
+ };
+
+ // set process.env.CSC_KEY_PASSWORD
+ build.__set__('process', Object.assign({}, { env: { CSC_KEY_PASSWORD: 'csc_key_password' } }));
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendWindowsUserSingning(config, buildConfig);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+
+ expect(buildConfig.certificateFile).toEqual(config.certificateFile);
+ expect(buildConfig.certificatePassword).toEqual('csc_key_password');
+ expect(buildConfig.certificateSubjectName).toEqual(config.certificateSubjectName);
+ expect(buildConfig.certificateSha1).toEqual(config.certificateSha1);
+ expect(buildConfig.signingHashAlgorithms).toEqual(config.signingHashAlgorithms);
+ expect(buildConfig.additionalCertificateFile).toEqual(config.additionalCertificateFile);
+ });
+
+ it('should set buildConfigs in __appendWindowsUserSingning for windows singning when files exist, but certificate and process env password does not.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ windows: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: 'requirements' } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ const config = {
+ debug: 'debug',
+ release: 'release',
+ identity: 'identify',
+ certificateFile: 'certificateFile',
+ certificateSubjectName: 'certificateSubjectName',
+ certificateSha1: 'certificateSha1',
+ signingHashAlgorithms: 'signingHashAlgorithms',
+ additionalCertificateFile: 'additionalCertificateFile'
+ };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendWindowsUserSingning(config, buildConfig);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+
+ expect(buildConfig.certificateFile).toEqual(config.certificateFile);
+ expect(buildConfig.certificatePassword).toEqual(undefined);
+ expect(buildConfig.certificateSubjectName).toEqual(config.certificateSubjectName);
+ expect(buildConfig.certificateSha1).toEqual(config.certificateSha1);
+ expect(buildConfig.signingHashAlgorithms).toEqual(config.signingHashAlgorithms);
+ expect(buildConfig.additionalCertificateFile).toEqual(config.additionalCertificateFile);
+ });
+
+ it('should set buildConfigs in __appendWindowsUserSingning for windows singning when files does not exist.', () => {
+ // mock platformConfig, buildConfig and buildOptions Objects
+ const platformConfig = {
+ windows: { package: ['package', 'package2'], signing: { debug: 'debug', release: 'release', store: 'requirements' } }
+ };
+
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: buildConfig, argv: [] };
+
+ const config = {
+ debug: 'debug',
+ release: 'release',
+ identity: 'identify',
+ certificateFile: 'certificateFile',
+ certificatePassword: 'certificatePassword',
+ certificateSubjectName: 'certificateSubjectName',
+ certificateSha1: 'certificateSha1',
+ signingHashAlgorithms: 'signingHashAlgorithms',
+ additionalCertificateFile: 'additionalCertificateFile'
+ };
+
+ // create spies
+ existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).__appendWindowsUserSingning(config, buildConfig);
+
+ expect(existsSyncSpy).toHaveBeenCalled();
+ expect(emitSpy).toHaveBeenCalled();
+
+ expect(buildConfig.certificateFile).toEqual(undefined);
+ expect(buildConfig.certificatePassword).toEqual(undefined);
+ expect(buildConfig.certificateSubjectName).toEqual(config.certificateSubjectName);
+ expect(buildConfig.certificateSha1).toEqual(config.certificateSha1);
+ expect(buildConfig.signingHashAlgorithms).toEqual(config.signingHashAlgorithms);
+ expect(buildConfig.additionalCertificateFile).toEqual(undefined);
+
+ const actualCertificateFile = emitSpy.calls.argsFor(0)[1];
+ const expectedCertificateFile = 'The provided certificate file does not exist';
+ expect(actualCertificateFile).toContain(expectedCertificateFile);
+
+ const actualAdditionalCertificateFile = emitSpy.calls.argsFor(1)[1];
+ const expectedAdditionalCertificateFile = 'The provided addition certificate file does not exist';
+ expect(actualAdditionalCertificateFile).toContain(expectedAdditionalCertificateFile);
+ });
+
+ it('should call build method.', () => {
+ // mock buildOptions Objecet
+ const buildOptions = { debug: true, buildConfig: 'build.xml', argv: [] };
+
+ // create spies
+ const buildSpy = jasmine.createSpy('build');
+ build.__set__('require', () => {
+ return { build: buildSpy };
+ });
+
+ electronBuilder = new ElectronBuilder(buildOptions, api).build();
+
+ expect(buildSpy).toHaveBeenCalled();
+ });
+ });
+
+ describe('Module exports run', () => {
+ it('should have called configure and build.', () => {
+ const api = new Api(null);
+ const platformConfig = {
+ mac: { arch: [ 'x64' ] }
+ };
+ const buildConfig = {
+ electron: platformConfig,
+ author: 'Apache',
+ name: 'Guy',
+ displayName: 'HelloWorld',
+ APP_BUILD_DIR: api.locations.build,
+ APP_BUILD_RES_DIR: api.locations.buildRes,
+ APP_WWW_DIR: api.locations.www
+ };
+
+ const buildOptions = { debug: false, buildConfig: 'LOAD_MY_FAKE_DATA', argv: [] };
+
+ // create spies
+ const existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(true);
+ build.__set__('fs', { existsSync: existsSyncSpy });
+
+ build.__set__('require', (file) => {
+ if (file === 'LOAD_MY_FAKE_DATA') return buildConfig;
+ if (file === './check_reqs') return { run: () => Promise.resolve([]) };
+ return require(file);
+ });
+
+ const configureSpy = jasmine.createSpy('configure');
+ const buildSpy = jasmine.createSpy('build');
+
+ class ElectronBuilderMock {
+ configure () {
+ configureSpy();
+ return this;
+ }
+
+ build () {
+ buildSpy();
+ return this;
+ }
+ }
+
+ build.__set__('ElectronBuilder', ElectronBuilderMock);
+
+ build.run(buildOptions, api).then(() => {
+ expect(configureSpy).toHaveBeenCalled();
+ expect(buildSpy).toHaveBeenCalled();
+ });
+ });
+
+ it('should have failed requirement and console log error.', () => {
+ const api = new Api(null);
+ const buildOptions = { debug: false, buildConfig: 'LOAD_MY_FAKE_DATA', argv: [] };
+
+ // create spies
+ const logSpy = jasmine.createSpy('emit');
+ build.__set__('console', { log: logSpy });
+
+ build.__set__('require', (file) => {
+ // if (file === 'LOAD_MY_FAKE_DATA') return buildConfig;
+ if (file === './check_reqs') return { run: () => Promise.reject(new Error('Error')) };
+ return require(file);
+ });
+
+ build.run(buildOptions, api).then(() => {
+ expect(logSpy).toHaveBeenCalled();
+ });
+ });
+ });
+
+ describe('Module exports help', () => {
+ it('should display help usage.', () => {
+ let help = build.__get__('module.exports.help');
+
+ const argv = { binPath: 'bin' };
+
+ const logSpy = jasmine.createSpy('log');
+ build.__set__('console', { log: logSpy });
+
+ help(argv);
+
+ expect(logSpy).toHaveBeenCalled();
+
+ const actual = logSpy.calls.argsFor(0)[0];
+ expect(actual).toContain('--debug');
+ expect(actual).toContain('--release');
+ expect(actual).toContain('--nobuild');
+
+ });
+ });
+});
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org