cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From audre...@apache.org
Subject [1/3] cordova-lib git commit: CB-12361 : updated addHelper tests
Date Thu, 13 Jul 2017 18:01:40 GMT
Repository: cordova-lib
Updated Branches:
  refs/heads/master 96326bfad -> 01ae07220


CB-12361 : updated addHelper tests


Project: http://git-wip-us.apache.org/repos/asf/cordova-lib/repo
Commit: http://git-wip-us.apache.org/repos/asf/cordova-lib/commit/acda3f4b
Tree: http://git-wip-us.apache.org/repos/asf/cordova-lib/tree/acda3f4b
Diff: http://git-wip-us.apache.org/repos/asf/cordova-lib/diff/acda3f4b

Branch: refs/heads/master
Commit: acda3f4be22c4dbb69bde54adf42ccc185080ba2
Parents: 96326bf
Author: Audrey So <audreyso@apache.org>
Authored: Thu Jun 29 09:46:57 2017 -0700
Committer: Audrey So <audreyso@apache.org>
Committed: Thu Jun 29 09:46:57 2017 -0700

----------------------------------------------------------------------
 spec/cordova/platform/addHelper.spec.js | 475 +++++++++++++++++++++++++--
 src/cordova/platform/addHelper.js       |   1 +
 2 files changed, 451 insertions(+), 25 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/acda3f4b/spec/cordova/platform/addHelper.spec.js
----------------------------------------------------------------------
diff --git a/spec/cordova/platform/addHelper.spec.js b/spec/cordova/platform/addHelper.spec.js
index 8218d91..869f79d 100644
--- a/spec/cordova/platform/addHelper.spec.js
+++ b/spec/cordova/platform/addHelper.spec.js
@@ -16,34 +16,459 @@
 */
 /* eslint-env jasmine */
 
+var path = require('path');
+var fs = require('fs');
+var Q = require('q');
+var shell = require('shelljs');
+var events = require('cordova-common').events;
+var rewire = require('rewire');
+var platform_addHelper = rewire('../../../src/cordova/platform/addHelper');
+var platform_module = require('../../../src/cordova/platform');
+var platform_metadata = require('../../../src/cordova/platform_metadata');
+var cordova_util = require('../../../src/cordova/util');
+var cordova_config = require('../../../src/cordova/config');
+var plugman = require('../../../src/plugman/plugman');
+var fetch_metadata = require('../../../src/plugman/util/metadata');
+var lazy_load = require('../../../src/cordova/lazy_load');
+// require module here
+// spy on it and return 
+var cordova = require('../../../src/cordova/cordova');
+var prepare = require('../../../src/cordova/prepare');
+var gitclone = require('../../../src/gitclone');
+var fail;
+
 describe('cordova/platform/addHelper', function () {
+    var projectRoot = '/some/path';
+    // These _mock and _revert_mock objects use rewire as the modules these mocks replace
+    // during testing all return functions, which we cannot spy on using jasmine.
+    // Thus, we replace these modules inside the scope of addHelper.js using rewire, and
shim
+    // in these _mock test dummies. The test dummies themselves are constructed using
+    // jasmine.createSpy inside the first beforeEach.
+    var cfg_parser_mock = function () {};
+    var cfg_parser_revert_mock;
+    var hooks_mock;
+    var platform_api_mock;
+    var fetch_mock;
+    var fetch_revert_mock;
+    var prepare_mock;
+    var prepare_revert_mock;
+    var fake_platform = {
+        'platform': 'atari'
+    };
+    beforeEach(function () {
+        hooks_mock = jasmine.createSpyObj('hooksRunner mock', ['fire']);
+        hooks_mock.fire.and.returnValue(Q());
+        cfg_parser_mock.prototype = jasmine.createSpyObj('config parser mock', ['write',
'removeEngine', 'addEngine', 'getHookScripts']);
+        cfg_parser_revert_mock = platform_addHelper.__set__('ConfigParser', cfg_parser_mock);
+        fetch_mock = jasmine.createSpy('fetch mock').and.returnValue(Q());
+        fetch_revert_mock = platform_addHelper.__set__('fetch', fetch_mock);
+        prepare_mock = jasmine.createSpy('prepare mock').and.returnValue(Q());
+        prepare_mock.preparePlatforms = jasmine.createSpy('preparePlatforms mock').and.returnValue(Q());
+        prepare_revert_mock = platform_addHelper.__set__('prepare', prepare_mock);
+        spyOn(shell, 'mkdir');
+        spyOn(fs, 'existsSync').and.returnValue(false);
+        spyOn(fs, 'writeFileSync');
+        spyOn(cordova_util, 'projectConfig').and.returnValue(path.join(projectRoot, 'config.xml'));
+        spyOn(cordova_util, 'isDirectory').and.returnValue(false);
+        spyOn(cordova_util, 'fixRelativePath').and.callFake(function (input) { return input;
});
+        spyOn(cordova_util, 'isUrl').and.returnValue(false);
+        spyOn(cordova_util, 'hostSupports').and.returnValue(true);
+        spyOn(cordova_util, 'removePlatformPluginsJson');
+        spyOn(cordova_config, 'read').and.returnValue({});
+        // Fake platform details we will use for our mocks, returned by either
+        // getPlatfromDetailsFromDir (in the local-directory case), or
+        // downloadPlatform (in every other case)
+        spyOn(platform_module, 'getPlatformDetailsFromDir').and.returnValue(Q(fake_platform));
+        spyOn(platform_addHelper, 'downloadPlatform').and.returnValue(Q(fake_platform));
+        spyOn(platform_addHelper, 'getVersionFromConfigFile').and.returnValue(false);
+        spyOn(platform_addHelper, 'installPluginsForNewPlatform').and.returnValue(Q());
+        platform_api_mock = jasmine.createSpyObj('platform api mock', ['createPlatform',
'updatePlatform']);
+        platform_api_mock.createPlatform.and.returnValue(Q());
+        platform_api_mock.updatePlatform.and.returnValue(Q());
+        spyOn(cordova_util, 'getPlatformApiFunction').and.returnValue(platform_api_mock);
+        spyOn(platform_metadata, 'save');
+    });
+    afterEach(function () {
+        cfg_parser_revert_mock();
+        fetch_revert_mock();
+        prepare_revert_mock();
+    });
     describe('error/warning conditions', function () {
-        it('should require specifying at least one platform');
-        it('should warn if host OS does not support the specified platform');
+        it('should require specifying at least one platform', function (done) {
+            platform_addHelper('add', hooks_mock).then(function () {
+                fail('addHelper success handler unexpectedly invoked');
+            }).fail(function (e) {
+                expect(e.message).toContain('No platform specified.');
+            }).done(done);
+        });
+
+        it('should log if host OS does not support the specified platform', function () {
+            cordova_util.hostSupports.and.returnValue(false);
+            spyOn(events, 'emit');
+            platform_addHelper('add', hooks_mock, projectRoot, ['atari']);
+            expect(events.emit.calls.mostRecent().args[1]).toContain('can not be built on
this OS');
+        });
+
+        it('should throw if platform was already added before adding', function (done) {
+            fs.existsSync.and.returnValue('/some/path/platforms/ios');
+            spyOn(cordova_util, 'requireNoCache').and.returnValue(true);
+            platform_addHelper('add', hooks_mock, projectRoot, ['ios']).then(function ()
{
+                fail('addHelper should throw error');
+            }).fail(function (e) {
+                expect(e.message).toContain('already added.');
+            }).done(done);
+        });
+
+        it('should throw if platform was not added before updating', function(done) {
+            platform_addHelper('update', hooks_mock, projectRoot, ['atari']).then(function
() {
+                fail('addHelper should throw error');
+            }).fail(function (e) {
+                expect(e.message).toContain('Platform "atari" is not yet added. See `cordova
platform list`.');
+            }).done(done);
+        });
     });
     describe('happy path (success conditions)', function () {
-        it('should fire the before_platform_* hook');
-        it('should warn about deprecated platforms');
-        /*
-         * first "leg" (`then`) of the promise is platform "spec" support:
-         * - tries to infer spec from either package.json or config.xml
-         * - defaults to pinned version for platform.
-         * - downloads the platform, passing in spec.
-         * --> how to test: spy on downloadPlatform, validate spec passed.
-         * --> should mock out downloadPlatform completely for all happy path tests. this
would short-circuit the first addHelper promise `then`.
-         * second "leg" (`then`) of the promise:
-         * - checks for already-added or not-added platform requirements. TODO: couldnt we
move this up to before downloading, to the initial error/warning checks?
-         * - invokes platform api createPlatform or updatePlatform
-         * - if not restoring, runs a `prepare`
-         * - if just added, installsPluginsForNewPlatform (TODO for fil: familiarize yourself
why not just a regular "install plugin for platform" - why the 'newPlatform' API?)
-         * - if not restoring, run a prepare. TODO: didnt we just do this? we just installed
plugins, so maybe its needed, but couldnt we just run a single prepare after possibly installing
plugins?
-         * third `then`:
-         * - save particular platform version installed to platform metadata.
-         * - if autosaving or opts.save is provided, write platform to config.xml
-         * fourth `then`:
-         * - save added platform to package.json if exists.
-         * fifth `then`:
-         * - fire after_platform_add/update hook
-         */
+        it('should fire the before_platform_* hook', function () {
+            platform_addHelper('add', hooks_mock, projectRoot, ['atari']);
+            expect(hooks_mock.fire).toHaveBeenCalledWith('before_platform_add', jasmine.any(Object));
+        });
+
+        it('should warn about using deprecated platforms', function (done) {
+            spyOn(events, 'emit');
+            platform_addHelper('add', hooks_mock, projectRoot, ['ubuntu', 'blackberry10']);
+            process.nextTick(function () {
+                expect(events.emit).toHaveBeenCalledWith(jasmine.stringMatching(/has been
deprecated/));
+                done();
+            });
+        });
+        describe('platform spec inference', function () {
+            beforeEach(function () {
+                spyOn(cordova, 'prepare').and.returnValue(Q());
+                spyOn(prepare, 'preparePlatforms').and.returnValue(Q());
+            });
+
+            xit('should retrieve platform details from directories-specified-as-platforms
using getPlatformDetailsFromDir', function (done) {
+                cordova_util.isDirectory.and.returnValue(true);
+                var directory_to_platform = '/path/to/cordova-atari';
+                platform_addHelper('add', hooks_mock, projectRoot, [directory_to_platform]).then(function
() {
+                    expect(platform_module.getPlatformDetailsFromDir).toHaveBeenCalledWith(directory_to_platform,
null);
+                    expect(platform_addHelper.downloadPlatform).not.toHaveBeenCalled();
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                    console.error(e);
+                }).done(done);
+            });
+
+            xit('should retrieve platform details from URLs-specified-as-platforms using
downloadPlatform', function (done) {
+                cordova_util.isUrl.and.returnValue(true);
+                var url_to_platform = 'http://github.com/apache/cordova-atari';
+                platform_addHelper('add', hooks_mock, projectRoot, [url_to_platform]).then(function
() {
+                    expect(platform_addHelper.downloadPlatform).toHaveBeenCalledWith(projectRoot,
null, url_to_platform, jasmine.any(Object));
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                    console.error(e);
+                }).done(done);
+            });
+
+            xit('should attempt to retrieve from config.xml if exists and package.json does
not', function (done) {
+                platform_addHelper('add', hooks_mock, projectRoot, ['atari']).then(function()
{
+                    expect(platform_addHelper.getVersionFromConfigFile).toHaveBeenCalled();
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                    console.error(e);
+                }).done(done);
+            });
+
+            xit('should fall back to using pinned version if both package.json and config.xml
do not specify it', function (done) {
+                spyOn(events,'emit');
+                platform_addHelper('add', hooks_mock, projectRoot, ['ios']).then(function()
{
+                    expect(events.emit.calls.argsFor(1)[1]).toBe('Grabbing pinned version.');
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                    console.error(e);
+                }).done(done);
+            });
+
+            xit('should invoke fetch if provided as an option and spec is a directory', function
(done) {
+                cordova_util.isDirectory.and.returnValue(projectRoot);
+                cordova_util.fixRelativePath.and.returnValue(projectRoot);
+                spyOn(path, 'resolve').and.callThrough();
+                platform_addHelper('add', hooks_mock, projectRoot, ['ios'], {save:true, fetch:
true}).then(function() {
+                    expect(path.resolve).toHaveBeenCalled();
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                    console.error(e);
+                }).done(done);
+            });
+        });
+
+        describe('platform api invocation', function () {
+            beforeEach(function () {
+                spyOn(cordova, 'prepare').and.returnValue(Q());
+                spyOn(prepare, 'preparePlatforms').and.returnValue(Q());
+            });
+
+            xit('should invoke the createPlatform platform API method when adding a platform,
providing destination location, parsed config file and platform detail options as arguments',
function (done) {
+                platform_addHelper('add', hooks_mock, projectRoot, ['ios'], {save: true,
fetch: true}).then(function(result) {
+                    expect(platform_api_mock.createPlatform).toHaveBeenCalled();
+                }).fail(function (err) {
+                    fail('unexpected failure handler invoked!');
+                    console.error(err);
+                }).done(done);
+            });
+
+            xit('should invoke the update platform API method when updating a platform, providing
destination location and plaform detail options as arguments', function(done) {
+                spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+                cordova_util.isDirectory.and.returnValue(true);
+                fs.existsSync.and.returnValue(true);
+                platform_addHelper('update', hooks_mock, projectRoot, ['ios']).then(function(result)
{
+                    expect(platform_api_mock.updatePlatform).toHaveBeenCalled();
+                }).fail(function (err) {
+                    fail('unexpected failure handler invoked!');
+                    console.error(err);
+                }).done(done);
+            });
+        });
+
+        describe('after platform api invocation', function () {
+            beforeEach(function () {
+                spyOn(cordova, 'prepare').and.returnValue(Q());
+                spyOn(prepare, 'preparePlatforms').and.returnValue(Q());
+            });
+
+            describe('when the restoring option is not provided', function () {
+                xit('should invoke preparePlatforms twice (?!?), once before installPluginsForNewPlatforms
and once after... ?!', function (done) {
+                    platform_addHelper('add', hooks_mock, projectRoot, ['atari'], {save:
true, fetch: true}).then(function(result) {
+                        expect(prepare.preparePlatforms).toHaveBeenCalledWith([ 'atari' ],
'/some/path', Object({ searchpath: undefined }));
+                    }).fail(function (err) {
+                        fail('unexpected failure handler invoked!');
+                        console.error(err);
+                    }).done(done);
+                });
+            });
+
+            xit('should invoke the installPluginsForNewPlatforms method in the platform-add
case', function (done) {
+                platform_addHelper('add', hooks_mock, projectRoot, ['atari'], {save: true,
fetch: true}).then(function(result) {
+                    expect(platform_addHelper.installPluginsForNewPlatform).toHaveBeenCalled();
+                }).fail(function (err) {
+                    fail('unexpected failure handler invoked!');
+                    console.error(err);
+                }).done(done);
+            });
+
+            xit('should save the platform metadata', function (done) {
+                platform_addHelper('add', hooks_mock, projectRoot, ['atari'], {save: true,
fetch: true}).then(function(result) {
+                    expect(platform_metadata.save).toHaveBeenCalledWith('/some/path', 'atari',
undefined);
+                }).fail(function (err) {
+                    fail('unexpected failure handler invoked!');
+                    console.error(err);
+                }).done(done);
+            });
+
+            xit('should write out the version of platform just added/updated to config.xml
if the save option is provided', function (done) {
+                platform_addHelper('add', hooks_mock, projectRoot, ['ios'], {save: true}).then(function(result)
{
+                    expect(cfg_parser_mock.prototype.removeEngine).toHaveBeenCalled();
+                    expect(cfg_parser_mock.prototype.addEngine).toHaveBeenCalled();
+                    expect(cfg_parser_mock.prototype.write).toHaveBeenCalled();
+                }).fail(function (err) {
+                    fail('unexpected failure handler invoked!');
+                    console.error(err);
+                }).done(done);
+            });
+
+            describe('if the project contains a package.json', function () {
+                beforeEach(function () {
+                    var pkgJsonEmpty = {};
+                    //spy for package.json to exist
+                    fs.existsSync.and.callFake(function(filePath) {
+                        if(path.basename(filePath) === 'package.json') {
+                            return true;
+                        } else {
+                            return false;
+                        }
+                    });
+                    //require packge.json object
+                    spyOn(cordova_util, 'requireNoCache').and.returnValue(pkgJsonEmpty);
+                });
+
+                xit('should write out the platform just added/updated to the cordova.platforms
property of package.json',function (done) {
+                    platform_addHelper('add', hooks_mock, projectRoot, ['atari'], {save:
true}).then(function(result) {
+                        expect(fs.writeFileSync).toHaveBeenCalled();
+                    }).fail(function (err) {
+                        fail('unexpected failure handler invoked!');
+                        console.error(err);
+                    }).done(done);
+                });
+
+                xit('should only write the package.json file if it was modified', function
(done) {
+                    var pkgJsonFull = { 'cordova': {'platforms': ['atari']}};
+                    cordova_util.requireNoCache.and.returnValue(pkgJsonFull);
+                    platform_addHelper('add', hooks_mock, projectRoot, ['atari'], {save:
true}).then(function(result) {
+                        expect(fs.writeFileSync).not.toHaveBeenCalled();
+                    }).fail(function (err) {
+                        fail('unexpected failure handler invoked!');
+                        console.error(err);
+                    }).done(done);
+                });
+
+                xit('should file the after_platform_* hook',function (done) {
+                    platform_addHelper('add', hooks_mock, projectRoot, ['atari'], {save:
true}).then(function(result) {
+                        expect(hooks_mock.fire).toHaveBeenCalledWith( 'before_platform_add',
Object({ save: true, searchpath: undefined }));
+                    }).fail(function (err) {
+                        fail('unexpected failure handler invoked!');
+                        console.error(err);
+                    }).done(done);
+                });
+            });
+        });
+    });
+    describe('downloadPlatform', function () {
+        beforeEach(function () {
+            spyOn(Q, 'reject').and.callThrough();
+            platform_addHelper.downloadPlatform.and.callThrough();
+        });
+        describe('errors', function () {
+            it('should reject the promise should fetch fail', function (done) {
+                fetch_mock.and.returnValue(Q.reject('fetch has failed, rejecting promise'));
+                platform_addHelper.downloadPlatform(projectRoot, 'android', '67', {fetch:
true}).then(function () {
+                    fail('success handler unexpectedly invoked');
+                }).fail(function (e) {
+                    expect(e.message).toContain('fetch has failed, rejecting promise');
+                }).done(done);
+            });
+
+            it('should reject the promise should lazy_load.git_clone fail', function (done)
{
+                spyOn(events, 'emit');
+                spyOn(lazy_load, 'based_on_config').and.returnValue(false);
+                spyOn(lazy_load, 'git_clone').and.callThrough();
+                cordova_util.isUrl.and.returnValue(true);
+                platform_addHelper.downloadPlatform(projectRoot, 'android', 'https://github.com/apache/cordova-android',
{save: true}).then(function () {
+                    fail('success handler unexpectedly invoked');
+                }).fail(function (e) {
+                    expect(Q.reject).toHaveBeenCalled();
+                    expect(events.emit.calls.argsFor(2)[1].toString()).toContain('Cloning
failed. Let\'s try handling it as a tarball');
+                }).done(done);
+            },60000);
+
+            it('should reject the promise should lazy_load.based_on_config fail', function
(done) {
+                spyOn(gitclone, 'clone').and.callThrough();
+                spyOn(lazy_load, 'git_clone').and.returnValue(true);
+                spyOn(lazy_load, 'based_on_config').and.returnValue(false);
+                cordova_util.isUrl.and.returnValue(true);
+                platform_addHelper.downloadPlatform(projectRoot, 'android', 'https://github.com/apache/cordova-android',
{save: true}).then(function () {
+                    fail('success handler unexpectedly invoked');
+                }).fail(function (e) {
+                    expect(Q.reject).toHaveBeenCalled();
+                    expect(Q.reject.calls.allArgs().toString()).toContain('Failed to fetch
platform android@https://github.com/apache/cordova-android');
+                    expect(lazy_load.based_on_config).not.toHaveBeenCalled();
+                }).done(done);
+            },60000);
+
+            it('should reject the promise should both git_clone and based_on_config fail
after the latter was fallen back on', function (done) {
+                spyOn(lazy_load, 'git_clone').and.returnValue(Q.reject('git_clone failed'));
+                spyOn(lazy_load, 'based_on_config').and.returnValue(Q.reject('based_on_config
failed'));
+                cordova_util.isUrl.and.returnValue(true);
+                fetch_mock.and.returnValue(true);
+                platform_addHelper.downloadPlatform(projectRoot, 'android', 'https://github.com/apache/cordova-android',
{save: true}).then(function () {
+                    fail('success handler unexpectedly invoked');
+                }).fail(function (e) {
+                    expect(Q.reject).toHaveBeenCalled();
+                }).done(done);
+            },60000);
+        });
+        describe('happy path', function () {
+            it('should invoke cordova-fetch if fetch was provided as an option', function
(done) {
+                fetch_mock.and.returnValue(true);
+                platform_addHelper.downloadPlatform(projectRoot, 'android', '6.0.0', {fetch:
true}).then(function () {
+                    expect(fetch_mock).toHaveBeenCalledWith('cordova-android@6.0.0', projectRoot,
Object({ fetch: true }));
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                }).done(done);
+            });
+
+            it('should invoke lazy_load.git_clone if the version to download is a URL', function
(done) {
+                spyOn(lazy_load, 'git_clone').and.callThrough();
+                spyOn(gitclone, 'clone').and.returnValue(true);
+                spyOn(events, 'emit');
+                fetch_mock.and.returnValue(true);
+                cordova_util.isUrl.and.returnValue(true);
+                platform_addHelper.downloadPlatform(projectRoot, 'android', 'https://github.com/apache/cordova-android',
{save: true}).then(function () {
+                    expect(events.emit.calls.argsFor(0)[1]).toBe('git cloning: https://github.com/apache/cordova-android');
+                    expect(cordova_util.isUrl).toHaveBeenCalledWith('https://github.com/apache/cordova-android');
+                    expect(lazy_load.git_clone).toHaveBeenCalled();
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                }).done(done);
+            },60000);
+
+            it('should attempt to lazy_load.based_on_config if lazy_load.git_clone fails',
function (done) {
+                spyOn(events, 'emit');
+                spyOn(lazy_load, 'based_on_config');
+                cordova_util.isUrl.and.returnValue(true);
+                platform_addHelper.downloadPlatform(projectRoot, 'android', 'https://github.com/apache/cordova-android',
{save: true}).then(function () {
+                    expect(events.emit.calls.argsFor(1)[1]).toBe('"git" command line tool
is not installed: make sure it is accessible on your PATH.');
+                    expect(events.emit.calls.argsFor(2)[1]).toBe('Cloning failed. Let\'s
try handling it as a tarball');
+                    expect(lazy_load.based_on_config).toHaveBeenCalled();
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                }).done(done);
+            },60000);
+            
+            it('should by default attempt to lazy_load.based_on_config', function (done)
{
+                spyOn(lazy_load, 'based_on_config');
+                platform_addHelper.downloadPlatform(projectRoot, 'android', '6.0.0', {save:true}).then(function
() {
+                    expect(lazy_load.based_on_config).toHaveBeenCalledWith('/some/path',
'android@6.0.0', Object({ save: true }));
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                }).done(done);
+            },60000);
+
+            it('should pass along a libDir argument to getPlatformDetailsFromDir on a successful
platform download', function (done) {
+                cordova_util.isUrl.and.returnValue(true);
+                platform_addHelper.downloadPlatform(projectRoot, 'android', 'https://github.com/apache/cordova-android',
{save:true}).then(function () {
+                    expect(require('../../../src/cordova/platform/index').getPlatformDetailsFromDir).toHaveBeenCalled();
+                }).fail(function (e) {
+                    fail('fail handler unexpectedly invoked');
+                }).done(done);
+            },60000);
+        });
+    });
+    describe('installPluginsForNewPlatform', function () {
+        beforeEach(function () {
+            spyOn(events, 'emit');
+            spyOn(fetch_metadata, 'get_fetch_metadata');
+            spyOn(plugman, 'install').and.returnValue(Q());
+            platform_addHelper.installPluginsForNewPlatform.and.callThrough();
+        });
+
+        it('should immediately return if there are no plugins to install into the platform',
function (done) {
+            platform_addHelper.installPluginsForNewPlatform('android', projectRoot).then(function
() {
+                expect(plugman.install).not.toHaveBeenCalled();
+            }).fail(function (e) {
+                fail('fail handler unexpectedly invoked');
+            }).done(done);
+        });
+
+        it('should invoke plugman.install, giving correct platform, plugin and other arguments',
function (done) {
+            spyOn(cordova_util, 'findPlugins').and.returnValue(['cordova-plugin-whitelist']);
+            fetch_metadata.get_fetch_metadata.and.returnValue({ });
+            platform_addHelper.installPluginsForNewPlatform('browser', projectRoot, {save:true
, fetch:true}).then(function () {
+                expect(plugman.install).toHaveBeenCalled();
+                expect(events.emit.calls.argsFor(0)[1]).toContain('Installing plugin "cordova-plugin-whitelist"
following successful platform add of browser');
+            }).fail(function (e) {
+                fail('fail handler unexpectedly invoked');
+            }).done(done);
+        });
+
+        it('should include any plugin variables as options when invoking plugman install',
function (done) {
+            spyOn(cordova_util, 'findPlugins').and.returnValue(['cordova-plugin-camera']);
+            fetch_metadata.get_fetch_metadata.and.returnValue({ source: {}, variables: {}
});
+            platform_addHelper.installPluginsForNewPlatform('browser', projectRoot, {save:true
, fetch:true}).then(function () {
+                expect(plugman.install).toHaveBeenCalled();
+                expect(events.emit.calls.argsFor(1)[1]).toContain('Found variables for "cordova-plugin-camera".
Processing as cli_variables.');
+            }).fail(function (e) {
+                fail('fail handler unexpectedly invoked');
+            }).done(done);
+        });
     });
 });

http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/acda3f4b/src/cordova/platform/addHelper.js
----------------------------------------------------------------------
diff --git a/src/cordova/platform/addHelper.js b/src/cordova/platform/addHelper.js
index 4161900..8eb8e06 100644
--- a/src/cordova/platform/addHelper.js
+++ b/src/cordova/platform/addHelper.js
@@ -119,6 +119,7 @@ function addHelper (cmd, hooksRunner, projectRoot, targets, opts) {
 
                 // If spec still doesn't exist, try to use pinned version
                 if (!spec && platforms[platform]) {
+                    events.emit('verbose', 'Grabbing pinned version.');
                     spec = platforms[platform].version;
                 }
 


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message