Increase build, check req, and versions code coverage

tests/spec/unit/build.spec.js

@@ -340,4 +340,174 @@ describe('build', function () {
             done();
         });
     });
+
+    describe('help method', () => {
+        it('should log a bunch of options', () => {
+            const logSpy = jasmine.createSpy();
+            const procStub = { exit: _ => null, cwd: _ => '', argv: ['', ''] };
+            build.__set__({ console: { log: logSpy }, process: procStub });
+
+            build.help();
+            expect(logSpy).toHaveBeenCalledWith(jasmine.stringMatching(/^Usage:/));
+        });
+    });
+
+    describe('run method', () => {
+        let rejectSpy;
+
+        beforeEach(() => {
+            rejectSpy = jasmine.createSpy('reject');
+
+            build.__set__('Q', {
+                reject: rejectSpy
+            });
+        });
+
+        it('should not accept debug and release options together', () => {
+            build.run({
+                debug: true,
+                release: true
+            });
+
+            expect(rejectSpy).toHaveBeenCalledWith('Cannot specify "debug" and "release" options together.');
+        });
+
+        it('should not accept device and emulator options together', () => {
+            build.run({
+                device: true,
+                emulator: true
+            });
+
+            expect(rejectSpy).toHaveBeenCalledWith('Cannot specify "device" and "emulator" options together.');
+        });
+
+        it('should reject when build config file missing', () => {
+            const existsSyncSpy = jasmine.createSpy('existsSync').and.returnValue(false);
+            build.__set__('fs', {
+                existsSync: existsSyncSpy
+            });
+
+            build.run({
+                buildConfig: './some/config/path'
+            });
+
+            expect(rejectSpy).toHaveBeenCalledWith(jasmine.stringMatching(/^Build config file does not exist:/));
+        });
+    });
+
+    describe('getDefaultSimulatorTarget method', () => {
+        it('should find iPhone X as the default simulator target.', (done) => {
+            const mockedEmulators = [{
+                name: 'iPhone 7',
+                identifier: 'com.apple.CoreSimulator.SimDeviceType.iPhone-7',
+                simIdentifier: 'iPhone-7'
+            },
+            {
+                name: 'iPhone 8',
+                identifier: 'com.apple.CoreSimulator.SimDeviceType.iPhone-8',
+                simIdentifier: 'iPhone-8'
+            },
+            {
+                name: 'iPhone X',
+                identifier: 'com.apple.CoreSimulator.SimDeviceType.iPhone-X',
+                simIdentifier: 'iPhone-X'
+            }];
+
+            // This method will require a module that supports the run method.
+            build.__set__('require', () => {
+                return {
+                    run: () => {
+                        return new Promise((resolve, reject) => {
+                            resolve(mockedEmulators);
+                        });
+                    }
+                };
+            });
+
+            const getDefaultSimulatorTarget = build.__get__('getDefaultSimulatorTarget');
+            const exec = getDefaultSimulatorTarget();
+
+            const expected = {
+                name: 'iPhone X',
+                identifier: 'com.apple.CoreSimulator.SimDeviceType.iPhone-X',
+                simIdentifier: 'iPhone-X'
+            };
+
+            exec.then((actual) => {
+                expect(actual).toEqual(expected);
+                done();
+            });
+        });
+    });
+
+    describe('findXCodeProjectIn method', () => {
+        let findXCodeProjectIn;
+        let shellLsSpy;
+        let rejectSpy;
+        let resolveSpy;
+        let emitSpy;
+        const fakePath = '/path/foobar';
+
+        beforeEach(() => {
+            findXCodeProjectIn = build.__get__('findXCodeProjectIn');
+
+            // Shell Spy
+            shellLsSpy = jasmine.createSpy('shellLsSpy');
+            build.__set__('shell', {
+                ls: shellLsSpy
+            });
+
+            // Q Spy
+            rejectSpy = jasmine.createSpy('rejectSpy');
+            resolveSpy = jasmine.createSpy('resolveSpy');
+            build.__set__('Q', {
+                reject: rejectSpy,
+                resolve: resolveSpy
+            });
+
+            // Events spy
+            emitSpy = jasmine.createSpy('emitSpy');
+            build.__set__('events', {
+                emit: emitSpy
+            });
+        });
+
+        it('should find not find Xcode project', () => {
+            shellLsSpy.and.returnValue(['README.md']);
+
+            findXCodeProjectIn(fakePath);
+
+            expect(rejectSpy).toHaveBeenCalledWith('No Xcode project found in ' + fakePath);
+        });
+
+        it('should emit finding multiple Xcode projects', () => {
+            shellLsSpy.and.returnValue(['Test1.xcodeproj', 'Test2.xcodeproj']);
+
+            findXCodeProjectIn(fakePath);
+
+            // Emit
+            let actualEmit = emitSpy.calls.argsFor(0)[1];
+            expect(emitSpy).toHaveBeenCalled();
+            expect(actualEmit).toContain('Found multiple .xcodeproj directories in');
+
+            // Resolve
+            let actualResolve = resolveSpy.calls.argsFor(0)[0];
+            expect(resolveSpy).toHaveBeenCalled();
+            expect(actualResolve).toContain('Test1');
+        });
+
+        it('should detect and return only one projects', () => {
+            shellLsSpy.and.returnValue(['Test1.xcodeproj']);
+
+            findXCodeProjectIn(fakePath);
+
+            // Emit
+            expect(emitSpy).not.toHaveBeenCalled();
+
+            // Resolve
+            let actualResolve = resolveSpy.calls.argsFor(0)[0];
+            expect(resolveSpy).toHaveBeenCalled();
+            expect(actualResolve).toContain('Test1');
+        });
+    });
 });

tests/spec/unit/lib/check_reqs.spec.js

@@ -0,0 +1,113 @@
+/**
+ 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.
+ */
+
+var rewire = require('rewire');
+var checkReqs = rewire('../../../../bin/templates/scripts/cordova/lib/check_reqs');
+
+describe('check_reqs', function () {
+    describe('checkTool method', () => {
+        const originalVersion = checkReqs.__get__('versions');
+        let shellWhichSpy;
+        let rejectSpy;
+        let resolveSpy;
+        let getToolVersionSpy;
+
+        beforeEach(() => {
+            // Shell Spy
+            shellWhichSpy = jasmine.createSpy('shellWhichSpy');
+            checkReqs.__set__('shell', {
+                which: shellWhichSpy
+            });
+
+            // Q Spy
+            rejectSpy = jasmine.createSpy('rejectSpy');
+            resolveSpy = jasmine.createSpy('resolveSpy');
+            checkReqs.__set__('Q', {
+                reject: rejectSpy,
+                resolve: resolveSpy
+            });
+
+            // Versions Spy
+            getToolVersionSpy = jasmine.createSpy('rejectSpy');
+        });
+
+        it('should not have found tool.', () => {
+            shellWhichSpy.and.returnValue(false);
+            const checkTool = checkReqs.__get__('checkTool');
+
+            checkTool('node', '1.0.0');
+
+            expect(rejectSpy).toHaveBeenCalledWith(jasmine.stringMatching(/^node was not found./));
+        });
+
+        it('should throw error because version is not following semver-notated.', (done) => {
+            shellWhichSpy.and.returnValue('/bin/node');
+            const checkTool = checkReqs.__get__('checkTool');
+
+            checkReqs.__set__('versions', {
+                get_tool_version: getToolVersionSpy.and.returnValue(new Promise((resolve) => {
+                    return resolve('1.0.0');
+                }).catch((error) => { console.log(error); })),
+                compareVersions: originalVersion.compareVersions
+            });
+
+            checkTool('node', 'v1.0.0').catch((error) => {
+                expect(error).toEqual('Version should contain only numbers and dots');
+                done();
+            });
+        });
+
+        it('should resolve passing back tool version.', (done) => {
+            shellWhichSpy.and.returnValue('/bin/node');
+            const checkTool = checkReqs.__get__('checkTool');
+
+            checkReqs.__set__('versions', {
+                get_tool_version: getToolVersionSpy.and.returnValue(new Promise((resolve) => {
+                    return resolve('1.0.0');
+                })),
+                compareVersions: originalVersion.compareVersions
+            });
+
+            checkTool('node', '1.0.0').then(() => {
+                let actual = resolveSpy.calls.argsFor(0)[0];
+                expect(actual).toEqual({version: '1.0.0'});
+                done();
+            });
+        });
+
+        it('should reject because tool does not meet minimum requirement.', (done) => {
+            shellWhichSpy.and.returnValue('/bin/node');
+            const checkTool = checkReqs.__get__('checkTool');
+
+            checkReqs.__set__('versions', {
+                get_tool_version: getToolVersionSpy.and.returnValue(new Promise((resolve) => {
+                    return resolve('1.0.0');
+                })),
+                compareVersions: originalVersion.compareVersions
+            });
+
+            checkTool('node', '1.0.1').then(() => {
+                let actual = rejectSpy.calls.argsFor(0)[0];
+                expect(actual).toContain('version 1.0.1 or greater');
+                expect(actual).toContain('you have version 1.0.0');
+                done();
+            });
+        });
+    });
+});

tests/spec/unit/versions.spec.js

@@ -0,0 +1,91 @@
+/**
+ 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.
+ */
+
+var rewire = require('rewire');
+var versions = rewire('../../../bin/templates/scripts/cordova/lib/versions');
+
+// These tests can not run on windows.
+if (process.platform === 'darwin') {
+    describe('versions', function () {
+        describe('get_apple_ios_version method', () => {
+            it('should have found ios version.', (done) => {
+                let _console = versions.__get__('console');
+                let logSpy = jasmine.createSpy('logSpy');
+                versions.__set__('console', {log: logSpy});
+
+                versions.get_apple_ios_version().then(() => {
+                    expect(logSpy).not.toHaveBeenCalledWith(undefined);
+                    versions.__set__('console', _console);
+                    done();
+                });
+            });
+        });
+
+        describe('get_apple_osx_version method', () => {
+            it('should have found osx version.', (done) => {
+                let _console = versions.__get__('console');
+                let logSpy = jasmine.createSpy('logSpy');
+                versions.__set__('console', {log: logSpy});
+
+                versions.get_apple_osx_version().then(() => {
+                    expect(logSpy).not.toHaveBeenCalledWith(undefined);
+                    versions.__set__('console', _console);
+                    done();
+                });
+            });
+        });
+
+        describe('get_tool_version method', () => {
+            it('should not have found tool by name.', (done) => {
+                versions.get_tool_version('unknown').catch((error) => {
+                    expect(error).toContain('is not valid tool name');
+                    done();
+                });
+            });
+
+            it('should find xcodebuild version.', (done) => {
+                versions.get_tool_version('xcodebuild').then((version) => {
+                    expect(version).not.toBe(undefined);
+                    done();
+                });
+            });
+
+            it('should find ios-sim version.', (done) => {
+                versions.get_tool_version('ios-sim').then((version) => {
+                    expect(version).not.toBe(undefined);
+                    done();
+                });
+            });
+
+            it('should find ios-deploy version.', (done) => {
+                versions.get_tool_version('ios-deploy').then((version) => {
+                    expect(version).not.toBe(undefined);
+                    done();
+                });
+            });
+
+            it('should find pod version.', (done) => {
+                versions.get_tool_version('pod').then((version) => {
+                    expect(version).not.toBe(undefined);
+                    done();
+                });
+            });
+        });
+    });
+}