| /* 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 rootDir = path.resolve(__dirname, '../../../..'); |
| |
| const Api = rewire(path.join(rootDir, 'lib/Api')); |
| const check_reqs = require(path.join(rootDir, 'lib/check_reqs')); |
| |
| describe('Testing build.js:', () => { |
| let build; |
| |
| beforeEach(() => { |
| build = rewire(path.join(rootDir, 'lib/build')); |
| }); |
| |
| 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 }); |
| spyOn(process, 'env'); |
| |
| 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, 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, 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, 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', category: 'Game' }, |
| 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, 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}', |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| const expectedLinux = { |
| target: [ |
| { target: 'package', arch: 'arch' }, |
| { target: 'package2', arch: 'arch' } |
| ], |
| icon: '${APP_INSTALLER_ICON}', |
| category: 'Game' |
| }; |
| |
| 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, 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}', |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| const expectedLinux = { |
| target: [ |
| { target: 'package', arch: 'arch' }, |
| { target: 'package2', arch: 'arch' } |
| ], |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| |
| 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(); |
| |
| const expected = { |
| linux: [], |
| mac: [], |
| win: [], |
| config: { |
| linux: { |
| icon: '${APP_INSTALLER_ICON}', |
| target: [ |
| { |
| target: 'tar.gz', |
| arch: ['arch1', 'arch2'] |
| } |
| ] |
| }, |
| mac: { |
| type: '${BUILD_TYPE}', |
| icon: '${APP_INSTALLER_ICON}', |
| target: [ |
| { |
| target: 'dmg', |
| arch: ['arch1', 'arch2'] |
| }, |
| { |
| target: 'zip', |
| arch: ['arch1', 'arch2'] |
| } |
| ] |
| }, |
| win: { |
| icon: '${APP_INSTALLER_ICON}', |
| 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, 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}', |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| const expectedLinux = { |
| target: [ |
| { target: 'package', arch: ['x64'] }, |
| { target: 'package2', arch: ['x64'] } |
| ], |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| |
| 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, 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}', |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| const expectedLinux = { |
| target: [ |
| { target: 'package', arch: 'arch' }, |
| { target: 'package2', arch: 'arch' } |
| ], |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| |
| 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, 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, 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(() => { 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, 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' } |
| ], |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.mac).toEqual(undefined); |
| expect(electronBuilder.userBuildSettings.config.linux).toEqual(undefined); |
| expect(electronBuilder.userBuildSettings.config.win).toEqual(expectedWin); |
| }); |
| |
| it('should append package top-level key options if the object is empty.', () => { |
| // mock platformConfig, buildConfig and buildOptions Objects |
| const platformConfig = { |
| mac: { package: ['pkg', { dmg: { } }], 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, 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: 'pkg', arch: 'arch' }, |
| { target: 'dmg', arch: 'arch' } |
| ], |
| type: '${BUILD_TYPE}', |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac); |
| expect(electronBuilder.userBuildSettings.config.dmg).toEqual({ }); |
| expect(electronBuilder.userBuildSettings.config.linux).toEqual(undefined); |
| expect(electronBuilder.userBuildSettings.config.windows).toEqual(undefined); |
| }); |
| |
| it('should append package top-level key options.', () => { |
| // mock platformConfig, buildConfig and buildOptions Objects |
| const platformConfig = { |
| mac: { package: ['pkg', { dmg: { format: 'UDZO' } }], 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, 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: 'pkg', arch: 'arch' }, |
| { target: 'dmg', arch: 'arch' } |
| ], |
| type: '${BUILD_TYPE}', |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| |
| const expectedDmgOptions = { |
| format: 'UDZO' |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac); |
| expect(electronBuilder.userBuildSettings.config.dmg).toEqual(expectedDmgOptions); |
| expect(electronBuilder.userBuildSettings.config.linux).toEqual(undefined); |
| expect(electronBuilder.userBuildSettings.config.windows).toEqual(undefined); |
| }); |
| |
| it('should append package top-level key nested options.', () => { |
| // mock platformConfig, buildConfig and buildOptions Objects |
| const platformConfig = { |
| mac: { package: ['pkg', { dmg: { format: { UDZO: '' } } }], 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, 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: 'pkg', arch: 'arch' }, |
| { target: 'dmg', arch: 'arch' } |
| ], |
| type: '${BUILD_TYPE}', |
| icon: '${APP_INSTALLER_ICON}' |
| }; |
| |
| const expectedDmgOptions = { |
| format: { UDZO: '' } |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac); |
| expect(electronBuilder.userBuildSettings.config.dmg).toEqual(expectedDmgOptions); |
| expect(electronBuilder.userBuildSettings.config.linux).toEqual(undefined); |
| expect(electronBuilder.userBuildSettings.config.windows).toEqual(undefined); |
| }); |
| |
| it('should set overridable per platform options.', () => { |
| // mock platformConfig, buildConfig and buildOptions Objects |
| const platformConfig = { |
| mac: { |
| package: ['package', 'package2'], |
| arch: 'arch', |
| appId: 'com.test.app', |
| artifactName: '${productName}-${version}.${ext}', |
| compression: 'normal', |
| files: [ |
| 'test/files/file1', |
| 'test/files/file2' |
| ], |
| extraResources: [ |
| 'test/resources/file1', |
| 'test/resources/file2' |
| ], |
| extraFiles: [ |
| 'test/extra/files/file1', |
| 'test/extra/files/file2' |
| ], |
| asar: false, |
| fileAssociations: [ |
| { |
| ext: 'png', |
| name: 'PNG' |
| } |
| ], |
| forceCodeSigning: false, |
| electronUpdaterCompatibility: '>=2.15', |
| publish: ['github', 'bintray'], |
| detectUpdateChannel: false, |
| generateUpdatesFilesForAllChannels: false |
| } |
| }; |
| 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, 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}', |
| icon: '${APP_INSTALLER_ICON}', |
| appId: 'com.test.app', |
| artifactName: '${productName}-${version}.${ext}', |
| compression: 'normal', |
| files: [ |
| 'test/files/file1', |
| 'test/files/file2' |
| ], |
| extraResources: [ |
| 'test/resources/file1', |
| 'test/resources/file2' |
| ], |
| extraFiles: [ |
| 'test/extra/files/file1', |
| 'test/extra/files/file2' |
| ], |
| asar: false, |
| fileAssociations: [ |
| { |
| ext: 'png', |
| name: 'PNG' |
| } |
| ], |
| forceCodeSigning: false, |
| electronUpdaterCompatibility: '>=2.15', |
| publish: ['github', 'bintray'], |
| detectUpdateChannel: false, |
| generateUpdatesFilesForAllChannels: false |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac); |
| }); |
| |
| it('should set top-level macOS specific.', () => { |
| // mock platformConfig, buildConfig and buildOptions Objects |
| const platformConfig = { |
| mac: { |
| package: ['package', 'package2'], |
| arch: 'arch', |
| category: 'public.app-category.developer-tools', |
| icon: 'build/icon.icns', |
| bundleVersion: 'CFBundleVersion', |
| bundleShortVersion: 'CFBundleShortVersionString', |
| darkModeSupport: true, |
| helperBundleId: '${appBundleIdentifier}.helper', |
| extendInfo: 'Info.plist', |
| binaries: [ |
| 'test/binaries/file1', |
| 'test/binaries/file2' |
| ], |
| minimumSystemVersion: '10.0.10', |
| electronLanguages: [ |
| 'en', |
| 'jp', |
| 'ru' |
| ], |
| extraDistFiles: [ |
| 'test/extraDist/file1', |
| 'test/extraDist/file2' |
| ] |
| } |
| }; |
| 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, 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}', |
| category: 'public.app-category.developer-tools', |
| icon: 'build/icon.icns', |
| bundleVersion: 'CFBundleVersion', |
| bundleShortVersion: 'CFBundleShortVersionString', |
| darkModeSupport: true, |
| helperBundleId: '${appBundleIdentifier}.helper', |
| extendInfo: 'Info.plist', |
| binaries: [ |
| 'test/binaries/file1', |
| 'test/binaries/file2' |
| ], |
| minimumSystemVersion: '10.0.10', |
| electronLanguages: [ |
| 'en', |
| 'jp', |
| 'ru' |
| ], |
| extraDistFiles: [ |
| 'test/extraDist/file1', |
| 'test/extraDist/file2' |
| ] |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.mac).toEqual(expectedMac); |
| }); |
| |
| it('should set top-level Windows specific.', () => { |
| // mock platformConfig, buildConfig and buildOptions Objects |
| const platformConfig = { |
| windows: { |
| package: ['package', 'package2'], |
| arch: 'arch', |
| icon: 'build/icon.icns', |
| legalTrademarks: 'trademarks and registered trademarks', |
| rfc3161TimeStampServer: 'http://timestamp.comodoca.com/rfc3161', |
| timeStampServer: 'http://timestamp.verisign.com/scripts/timstamp.dll', |
| publisherName: 'publisher name', |
| verifyUpdateCodeSignature: true, |
| requestedExecutionLevel: 'asInvoker', |
| signAndEditExecutable: true, |
| signDlls: false |
| } |
| }; |
| 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, 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 expectedWindows = { |
| target: [ |
| { target: 'package', arch: 'arch' }, |
| { target: 'package2', arch: 'arch' } |
| ], |
| icon: 'build/icon.icns', |
| legalTrademarks: 'trademarks and registered trademarks', |
| rfc3161TimeStampServer: 'http://timestamp.comodoca.com/rfc3161', |
| timeStampServer: 'http://timestamp.verisign.com/scripts/timstamp.dll', |
| publisherName: 'publisher name', |
| verifyUpdateCodeSignature: true, |
| requestedExecutionLevel: 'asInvoker', |
| signAndEditExecutable: true, |
| signDlls: false |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.win).toEqual(expectedWindows); |
| }); |
| |
| it('should set top-level Linux specific.', () => { |
| // mock platformConfig, buildConfig and buildOptions Objects |
| const platformConfig = { |
| linux: { |
| package: ['package', 'package2'], |
| arch: 'arch', |
| maintainer: 'maintainer', |
| vendor: 'vendor', |
| executableName: 'productName', |
| icon: 'path to icon set directory or one png file', |
| synopsis: 'short description', |
| description: 'description', |
| category: 'Utility', |
| mimeTypes: [ |
| 'type1', |
| 'type2' |
| ], |
| desktop: 'desktop file entries' |
| } |
| }; |
| 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, 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 expectedLinux = { |
| target: [ |
| { target: 'package', arch: 'arch' }, |
| { target: 'package2', arch: 'arch' } |
| ], |
| maintainer: 'maintainer', |
| vendor: 'vendor', |
| executableName: 'productName', |
| icon: 'path to icon set directory or one png file', |
| synopsis: 'short description', |
| description: 'description', |
| category: 'Utility', |
| mimeTypes: [ |
| 'type1', |
| 'type2' |
| ], |
| desktop: 'desktop file entries' |
| }; |
| |
| expect(electronBuilder.userBuildSettings.config.linux).toEqual(expectedLinux); |
| }); |
| |
| 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(() => { electronBuilder.fetchPlatformDefaults('name'); }).toThrow(new Error('Your platform "name" is not supported as a default target platform for Electron.')); |
| }); |
| |
| it('should __appendUserSigning 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, argv: [] }; |
| |
| // create spies |
| existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false); |
| build.__set__('fs', { existsSync: existsSyncSpy }); |
| |
| electronBuilder = new ElectronBuilder(buildOptions, api).__appendUserSigning('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 __appendUserSigning 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, argv: [], config: { mas: {} } }; |
| |
| // create spies |
| existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false); |
| build.__set__('fs', { existsSync: existsSyncSpy }); |
| |
| electronBuilder = new ElectronBuilder(buildOptions, api).__appendUserSigning('mac', platformConfig.mac.signing, buildOptions); |
| |
| expect(existsSyncSpy).toHaveBeenCalled(); |
| expect(buildOptions.buildConfig.electron.mac.signing.store.requirements).toBe(undefined); |
| }); |
| |
| it('should format nsis-web taget with nsisWeb top-level configs in __formatAppendUserSettings.', () => { |
| // Sample target configuration option |
| const appPackageUrl = 'https://foo.bar/apps/win/web'; |
| // The settings which will be populated by `__formatAppendUserSettings` |
| const userBuildSettings = {}; |
| // platform config partial from `build.json` |
| const platformConfig = { |
| package: [ |
| { 'nsis-web': { appPackageUrl } } |
| ] |
| }; |
| // the mock `build.json` |
| const buildConfig = { electron: { windows: platformConfig } }; |
| // the build options which is passed from CLI/Lib to Platform Build |
| const buildOptions = { argv: [], buildConfig }; |
| |
| // // create spies |
| existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false); |
| build.__set__('fs', { existsSync: existsSyncSpy }); |
| |
| electronBuilder = new ElectronBuilder(buildOptions, api) |
| .__formatAppendUserSettings('win', platformConfig, userBuildSettings); |
| |
| expect(existsSyncSpy).toHaveBeenCalled(); |
| expect(userBuildSettings.config.nsisWeb.appPackageUrl).toBe(appPackageUrl); |
| }); |
| |
| 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, argv: [] }; |
| |
| // create spies |
| existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false); |
| build.__set__('fs', { existsSync: existsSyncSpy }); |
| |
| electronBuilder = new ElectronBuilder(buildOptions, api).__appendUserSigning('win', platformConfig, buildOptions); |
| |
| expect(existsSyncSpy).toHaveBeenCalled(); |
| }); |
| |
| it('should set buildConfigs __appendMacUserSigning 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, 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).__appendMacUserSigning(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 __appendMacUserSigning 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, argv: [] }; |
| |
| const config = { |
| debug: 'debug', |
| release: 'release', |
| entitlements: 'entitlements', |
| entitlementsInherit: 'entitlementsInherit', |
| requirements: 'requirements', |
| provisioningProfile: 'provisioningProfile', |
| store: 'store' |
| }; |
| |
| // set process.env.CSC_LINK |
| process.env.CSC_LINK = 'csc_link'; |
| |
| // create spies |
| existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false); |
| build.__set__('fs', { existsSync: existsSyncSpy }); |
| |
| electronBuilder = new ElectronBuilder(buildOptions, api).__appendMacUserSigning(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 __appendMacUserSigning 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, argv: [] }; |
| |
| const config = { |
| debug: 'debug', |
| release: 'release', |
| entitlements: 'entitlements', |
| entitlementsInherit: 'entitlementsInherit', |
| requirements: 'requirements', |
| provisioningProfile: 'provisioningProfile', |
| store: 'store' |
| }; |
| |
| // set process.env.CSC_NAME |
| process.env.CSC_NAME = 'csc_name'; |
| |
| // create spies |
| existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false); |
| build.__set__('fs', { existsSync: existsSyncSpy }); |
| |
| electronBuilder = new ElectronBuilder(buildOptions, api).__appendMacUserSigning(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 __appendWindowsUserSigning 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, 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).__appendWindowsUserSigning(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 __appendWindowsUserSigning 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, 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 |
| process.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).__appendWindowsUserSigning(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 __appendWindowsUserSigning 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, 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).__appendWindowsUserSigning(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 __appendWindowsUserSigning 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, 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).__appendWindowsUserSigning(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', () => ({ |
| 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 check and thrown error.', () => { |
| const api = new Api(null); |
| const buildOptions = { debug: false, buildConfig: 'LOAD_MY_FAKE_DATA', argv: [] }; |
| const errorMsg = 'error'; |
| spyOn(check_reqs, 'run').and.callFake(() => Promise.reject(new Error(errorMsg))); |
| |
| return build.run(buildOptions, api).then( |
| () => fail('Unexpectedly resolved'), |
| error => { |
| expect(check_reqs.run).toHaveBeenCalled(); |
| expect(error.message).toBe(errorMsg); |
| } |
| ); |
| }); |
| }); |
| }); |
