| /* 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('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}', |
| 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 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}', |
| 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: 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: 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: 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' } |
| ], |
| 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 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'); |
| |
| }); |
| }); |
| }); |
