[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[asfgit]

Github user asfgit closed the pull request at:

https://github.com/apache/cordova-lib/pull/573


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---

-
To unsubscribe, e-mail: dev-unsubscr...@cordova.apache.org
For additional commands, e-mail: dev-h...@cordova.apache.org

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[audreyso]

Github user audreyso commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r127110528
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[audreyso]

Github user audreyso commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r127066391
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r127055093
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+ 

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[purplecabbage]

Github user purplecabbage commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r127039183
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r127032404
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+ 

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[audreyso]

Github user audreyso commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r127008421
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[audreyso]

Github user audreyso commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r127007878
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r126843121
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+ 

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r126842836
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+ 

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r126844076
  
--- Diff: spec/cordova/platform/addHelper.spec.js ---
@@ -16,34 +16,439 @@
 */
 /* 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');
+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'
+};
+var package_json_mock;
+package_json_mock = jasmine.createSpyObj('package json mock', 
['cordova', 'dependencies']);
+package_json_mock.dependencies = {};
+package_json_mock.cordova = {};
+
+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({});
+spyOn(events, 'emit');
+// 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');
+spyOn(cordova_util, 'requireNoCache').and.returnValue({});
+});
+afterEach(function () {
+cfg_parser_revert_mock();
+ 

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124893454
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124892113
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124880319
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124881373
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124879975
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124891852
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124893969
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124894106
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124863854
  
--- Diff: 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
--- End diff --

don't need these comments I take it. 


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---

-
To unsubscribe, e-mail: dev-unsubscr...@cordova.apache.org
For additional commands, e-mail: dev-h...@cordova.apache.org

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124890998
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124873252
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124871034
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124867315
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124868182
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124874233
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124881302
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124878766
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124879465
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124878233
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[stevengill]

Github user stevengill commented on a diff in the pull request:

https://github.com/apache/cordova-lib/pull/573#discussion_r124878443
  
--- Diff: 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');
-   

[GitHub] cordova-lib pull request #573: CB-12361 : updated addHelper tests

[audreyso]

GitHub user audreyso opened a pull request:

https://github.com/apache/cordova-lib/pull/573

CB-12361 : updated addHelper tests



### Platforms affected


### What does this PR do?
updated addHelper tests

### What testing has been done on this change?


### Checklist
- [X] [Reported an issue](http://cordova.apache.org/contribute/issues.html) 
in the JIRA database
- [X] Commit message follows the format: "CB-3232: (android) Fix bug with 
resolving file paths", where CB- is the JIRA ID & "android" is the platform 
affected.
- [X] Added automated test coverage as appropriate for this change.


You can merge this pull request into a Git repository by running:

$ git pull https://github.com/audreyso/cordova-lib CB-12361-6

Alternatively you can review and apply these changes as the patch at:

https://github.com/apache/cordova-lib/pull/573.patch

To close this pull request, make a commit to your master/trunk branch
with (at least) the following in the commit message:

This closes #573


commit acda3f4be22c4dbb69bde54adf42ccc185080ba2
Author: Audrey So 
Date:   2017-06-29T16:46:57Z

CB-12361 : updated addHelper tests




---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---

-
To unsubscribe, e-mail: dev-unsubscr...@cordova.apache.org
For additional commands, e-mail: dev-h...@cordova.apache.org