integration-tests/plugman_uninstall.spec.js - cordova-lib - Git at Google

 /**
     Licensed to the Apache Software Foundation (ASF) under one
     or more contributor license agreements.  See the NOTICE file
     distributed with this work for additional information
     regarding copyright ownership.  The ASF licenses this file
     to you under the Apache License, Version 2.0 (the
     "License"); you may not use this file except in compliance
     with the License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing,
     software distributed under the License is distributed on an
     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     KIND, either express or implied.  See the License for the
     specific language governing permissions and limitations
     under the License.
 */

 const fs = require('node:fs');
 const path = require('node:path');
 const rewire = require('rewire');

 const { PluginInfo, events } = require('cordova-common');
 const common = require('../spec/common');
 const install = require('../src/plugman/install');
 const platforms = require('../src/platforms/platforms');
 const { tmpDir: getTmpDir, getFixture } = require('../spec/helpers.js');

 const tmpDir = getTmpDir('plugman_uninstall_test');
 const projectsPath = path.join(tmpDir, 'projects');
 const project = path.join(tmpDir, 'project');
 const plugins_install_dir = path.join(project, 'cordova/plugins');

 const plugins_dir = path.join(__dirname, '../spec/plugman/plugins');
 const plugins = {
     'org.test.plugins.dummyplugin': path.join(plugins_dir, 'org.test.plugins.dummyplugin'),
     A: path.join(plugins_dir, 'dependencies', 'A'),
     C: path.join(plugins_dir, 'dependencies', 'C')
 };

 function setupProject (name) {
     const projectPath = path.join(projectsPath, name);
     fs.cpSync(projectPath, project, { recursive: true });
 }

 describe('plugman/uninstall', () => {
     let uninstall, emit;

     beforeAll(() => {
         const project1 = path.join(projectsPath, 'uninstall.test');
         const project2 = path.join(projectsPath, 'uninstall.test2');
         const project3 = path.join(projectsPath, 'uninstall.test3');

         return Promise.resolve()
             .then(_ => getFixture('androidApp').copyTo(project1))
             .then(_ => getFixture('androidApp').copyTo(project2))
             .then(_ => getFixture('androidApp').copyTo(project3))
             .then(function () {
                 return install('android', project1, plugins['org.test.plugins.dummyplugin']);
             }).then(function () {
                 return install('android', project1, plugins.A);
             }).then(function () {
                 return install('android', project2, plugins.C);
             }).then(function () {
                 return install('android', project2, plugins.A);
             }).then(function () {
                 return install('android', project3, plugins.A);
             }).then(function () {
                 return install('android', project3, plugins.C);
             }).then(function (result) {
                 expect(result).toEqual(true);
             });
     }, 20000);

     beforeEach(() => {
         uninstall = rewire('../src/plugman/uninstall');
         uninstall.__set__('npmUninstall', jasmine.createSpy().and.returnValue(Promise.resolve()));

         emit = spyOn(events, 'emit');
     });

     afterEach(() => {
         // Just so everything fails if someone does not setup their project
         fs.rmSync(project, { recursive: true, force: true });
     });

     afterAll(() => {
         fs.rmSync(tmpDir, { recursive: true, force: true });
     });

     describe('uninstallPlatform', function () {
         const dummy_id = 'org.test.plugins.dummyplugin';

         beforeEach(function () {
             setupProject('uninstall.test');
         });

         describe('success', function () {
             it('Test 002 : should get PlatformApi instance for platform and invoke its\' removePlugin method', function () {
                 const platformApi = { removePlugin: jasmine.createSpy('removePlugin').and.returnValue(Promise.resolve()) };
                 const getPlatformApi = spyOn(platforms, 'getPlatformApi').and.returnValue(platformApi);

                 return uninstall.uninstallPlatform('android', project, dummy_id)
                     .then(function () {
                         expect(getPlatformApi).toHaveBeenCalledWith('android', project);
                         expect(platformApi.removePlugin).toHaveBeenCalled();
                     });
             });

             it('Test 003 : should return propagate value returned by PlatformApi removePlugin method', function () {
                 const platformApi = { removePlugin: jasmine.createSpy('removePlugin') };
                 spyOn(platforms, 'getPlatformApi').and.returnValue(platformApi);

                 const existsSyncOrig = fs.existsSync;
                 spyOn(fs, 'existsSync').and.callFake(function (file) {
                     if (file.indexOf(dummy_id) >= 0) return true;
                     return existsSyncOrig.call(fs, file);
                 });

                 const fakeProvider = jasmine.createSpyObj('fakeProvider', ['get']);
                 const dummyPluginInfo = new PluginInfo(plugins['org.test.plugins.dummyplugin']);
                 fakeProvider.get.and.returnValue(dummyPluginInfo);

                 function validateReturnedResultFor (values, expectedResult) {
                     return values.reduce(function (promise, value) {
                         return promise
                             .then(function () {
                                 platformApi.removePlugin.and.returnValue(Promise.resolve(value));
                                 return uninstall.uninstallPlatform('android', project, dummy_id, null,
                                     { pluginInfoProvider: fakeProvider, platformVersion: '9.9.9' });
                             })
                             .then(function (result) {
                                 expect(!!result).toEqual(expectedResult);
                             }, function (err) {
                                 expect(err).toBeUndefined();
                             });
                     }, Promise.resolve());
                 }

                 return validateReturnedResultFor([true, {}, [], 'foo', function () {}], true)
                     .then(function () {
                         return validateReturnedResultFor([false, null, undefined, ''], false);
                     });
             });

             it('Test 014 : should uninstall dependent plugins', function () {
                 return uninstall.uninstallPlatform('android', project, 'A')
                     .then(function (result) {
                         expect(emit).toHaveBeenCalledWith('log', 'Uninstalling 2 dependent plugins.');
                     });
             });
         });

         describe('failure ', function () {
             it('Test 004 : should throw if platform is unrecognized', function () {
                 return expectAsync(
                     uninstall.uninstallPlatform('atari', project, 'SomePlugin')
                 ).toBeRejectedWithError('Platform "atari" not supported.');
             });

             it('Test 005 : should throw if plugin is missing', function () {
                 return expectAsync(
                     uninstall.uninstallPlatform('android', project, 'SomePluginThatDoesntExist')
                 ).toBeRejectedWithError(
                     'Plugin "SomePluginThatDoesntExist" not found. Already uninstalled?'
                 );
             });
         });
     });

     describe('uninstallPlugin', function () {
         describe('with dependencies', function () {
             it('Test 006 : should delete all dependent plugins', function () {
                 setupProject('uninstall.test');

                 return uninstall.uninstallPlugin('A', plugins_install_dir)
                     .then(function (result) {
                         const del = common.spy.getDeleted(emit);
                         expect(del).toEqual([
                             'Deleted plugin "C"',
                             'Deleted plugin "D"',
                             'Deleted plugin "A"'
                         ]);
                     });
             });

             it('Test 007 : should fail if plugin is a required dependency', function () {
                 setupProject('uninstall.test');

                 return expectAsync(
                     uninstall.uninstallPlugin('C', plugins_install_dir)
                 ).toBeRejectedWithError(
                     'Plugin "C" is required by (A) and cannot be removed (hint: use -f or --force)'
                 );
             });

             it('Test 008 : allow forcefully removing a plugin', function () {
                 setupProject('uninstall.test');

                 return uninstall.uninstallPlugin('C', plugins_install_dir, { force: true })
                     .then(function () {
                         const del = common.spy.getDeleted(emit);
                         expect(del).toEqual(['Deleted plugin "C"']);
                     });
             });

             it('Test 009 : never remove top level plugins if they are a dependency', function () {
                 setupProject('uninstall.test2');

                 return uninstall.uninstallPlugin('A', plugins_install_dir)
                     .then(function () {
                         const del = common.spy.getDeleted(emit);
                         expect(del).toEqual([
                             'Deleted plugin "D"',
                             'Deleted plugin "A"'
                         ]);
                     });
             });

             it('Test 010 : should not remove dependent plugin if it was installed after as top-level', function () {
                 setupProject('uninstall.test3');

                 return uninstall.uninstallPlugin('A', plugins_install_dir)
                     .then(function () {
                         const del = common.spy.getDeleted(emit);
                         expect(del).toEqual([
                             'Deleted plugin "D"',
                             'Deleted plugin "A"'
                         ]);
                     });
             });
         });
     });

     describe('uninstall', function () {
         beforeEach(() => {
             setupProject('uninstall.test');
         });

         describe('failure', function () {
             it('Test 011 : should throw if platform is unrecognized', function () {
                 return expectAsync(
                     uninstall('atari', project, 'SomePlugin')
                 ).toBeRejectedWithError('Platform "atari" not supported.');
             });

             it('Test 012 : should throw if plugin is missing', function () {
                 return expectAsync(
                     uninstall('android', project, 'SomePluginThatDoesntExist')
                 ).toBeRejectedWithError(
                     'Plugin "SomePluginThatDoesntExist" not found. Already uninstalled?'
                 );
             });
         });
     });

     describe('end', function () {
         // TODO this was some test/teardown hybrid.
         // We should either add more expectations or get rid of it
         it('Test 013 : end', function () {
             setupProject('uninstall.test');

             return uninstall('android', project, plugins['org.test.plugins.dummyplugin'])
                 .then(function () {
                     // Fails... A depends on
                     return uninstall('android', project, plugins.C);
                 }).catch(function (err) {
                     expect(err.stack).toMatch(/The plugin 'C' is required by \(A\), skipping uninstallation./);
                 }).then(function () {
                     // dependencies on C,D ... should this only work with --recursive? prompt user..?
                     return uninstall('android', project, plugins.A);
                 });
         });
     });
 });
	/**
	Licensed to the Apache Software Foundation (ASF) under one
	or more contributor license agreements. See the NOTICE file
	distributed with this work for additional information
	regarding copyright ownership. The ASF licenses this file
	to you under the Apache License, Version 2.0 (the
	"License"); you may not use this file except in compliance
	with the License. You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing,
	software distributed under the License is distributed on an
	"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	KIND, either express or implied. See the License for the
	specific language governing permissions and limitations
	under the License.
	*/

	const fs = require('node:fs');
	const path = require('node:path');
	const rewire = require('rewire');

	const { PluginInfo, events } = require('cordova-common');
	const common = require('../spec/common');
	const install = require('../src/plugman/install');
	const platforms = require('../src/platforms/platforms');
	const { tmpDir: getTmpDir, getFixture } = require('../spec/helpers.js');

	const tmpDir = getTmpDir('plugman_uninstall_test');
	const projectsPath = path.join(tmpDir, 'projects');
	const project = path.join(tmpDir, 'project');
	const plugins_install_dir = path.join(project, 'cordova/plugins');

	const plugins_dir = path.join(__dirname, '../spec/plugman/plugins');
	const plugins = {
	'org.test.plugins.dummyplugin': path.join(plugins_dir, 'org.test.plugins.dummyplugin'),
	A: path.join(plugins_dir, 'dependencies', 'A'),
	C: path.join(plugins_dir, 'dependencies', 'C')
	};

	function setupProject (name) {
	const projectPath = path.join(projectsPath, name);
	fs.cpSync(projectPath, project, { recursive: true });
	}

	describe('plugman/uninstall', () => {
	let uninstall, emit;

	beforeAll(() => {
	const project1 = path.join(projectsPath, 'uninstall.test');
	const project2 = path.join(projectsPath, 'uninstall.test2');
	const project3 = path.join(projectsPath, 'uninstall.test3');

	return Promise.resolve()
	.then(_ => getFixture('androidApp').copyTo(project1))
	.then(_ => getFixture('androidApp').copyTo(project2))
	.then(_ => getFixture('androidApp').copyTo(project3))
	.then(function () {
	return install('android', project1, plugins['org.test.plugins.dummyplugin']);
	}).then(function () {
	return install('android', project1, plugins.A);
	}).then(function () {
	return install('android', project2, plugins.C);
	}).then(function () {
	return install('android', project2, plugins.A);
	}).then(function () {
	return install('android', project3, plugins.A);
	}).then(function () {
	return install('android', project3, plugins.C);
	}).then(function (result) {
	expect(result).toEqual(true);
	});
	}, 20000);

	beforeEach(() => {
	uninstall = rewire('../src/plugman/uninstall');
	uninstall.__set__('npmUninstall', jasmine.createSpy().and.returnValue(Promise.resolve()));

	emit = spyOn(events, 'emit');
	});

	afterEach(() => {
	// Just so everything fails if someone does not setup their project
	fs.rmSync(project, { recursive: true, force: true });
	});

	afterAll(() => {
	fs.rmSync(tmpDir, { recursive: true, force: true });
	});

	describe('uninstallPlatform', function () {
	const dummy_id = 'org.test.plugins.dummyplugin';

	beforeEach(function () {
	setupProject('uninstall.test');
	});

	describe('success', function () {
	it('Test 002 : should get PlatformApi instance for platform and invoke its\' removePlugin method', function () {
	const platformApi = { removePlugin: jasmine.createSpy('removePlugin').and.returnValue(Promise.resolve()) };
	const getPlatformApi = spyOn(platforms, 'getPlatformApi').and.returnValue(platformApi);

	return uninstall.uninstallPlatform('android', project, dummy_id)
	.then(function () {
	expect(getPlatformApi).toHaveBeenCalledWith('android', project);
	expect(platformApi.removePlugin).toHaveBeenCalled();
	});
	});

	it('Test 003 : should return propagate value returned by PlatformApi removePlugin method', function () {
	const platformApi = { removePlugin: jasmine.createSpy('removePlugin') };
	spyOn(platforms, 'getPlatformApi').and.returnValue(platformApi);

	const existsSyncOrig = fs.existsSync;
	spyOn(fs, 'existsSync').and.callFake(function (file) {
	if (file.indexOf(dummy_id) >= 0) return true;
	return existsSyncOrig.call(fs, file);
	});

	const fakeProvider = jasmine.createSpyObj('fakeProvider', ['get']);
	const dummyPluginInfo = new PluginInfo(plugins['org.test.plugins.dummyplugin']);
	fakeProvider.get.and.returnValue(dummyPluginInfo);

	function validateReturnedResultFor (values, expectedResult) {
	return values.reduce(function (promise, value) {
	return promise
	.then(function () {
	platformApi.removePlugin.and.returnValue(Promise.resolve(value));
	return uninstall.uninstallPlatform('android', project, dummy_id, null,
	{ pluginInfoProvider: fakeProvider, platformVersion: '9.9.9' });
	})
	.then(function (result) {
	expect(!!result).toEqual(expectedResult);
	}, function (err) {
	expect(err).toBeUndefined();
	});
	}, Promise.resolve());
	}

	return validateReturnedResultFor([true, {}, [], 'foo', function () {}], true)
	.then(function () {
	return validateReturnedResultFor([false, null, undefined, ''], false);
	});
	});

	it('Test 014 : should uninstall dependent plugins', function () {
	return uninstall.uninstallPlatform('android', project, 'A')
	.then(function (result) {
	expect(emit).toHaveBeenCalledWith('log', 'Uninstalling 2 dependent plugins.');
	});
	});
	});

	describe('failure ', function () {
	it('Test 004 : should throw if platform is unrecognized', function () {
	return expectAsync(
	uninstall.uninstallPlatform('atari', project, 'SomePlugin')
	).toBeRejectedWithError('Platform "atari" not supported.');
	});

	it('Test 005 : should throw if plugin is missing', function () {
	return expectAsync(
	uninstall.uninstallPlatform('android', project, 'SomePluginThatDoesntExist')
	).toBeRejectedWithError(
	'Plugin "SomePluginThatDoesntExist" not found. Already uninstalled?'
	);
	});
	});
	});

	describe('uninstallPlugin', function () {
	describe('with dependencies', function () {
	it('Test 006 : should delete all dependent plugins', function () {
	setupProject('uninstall.test');

	return uninstall.uninstallPlugin('A', plugins_install_dir)
	.then(function (result) {
	const del = common.spy.getDeleted(emit);
	expect(del).toEqual([
	'Deleted plugin "C"',
	'Deleted plugin "D"',
	'Deleted plugin "A"'
	]);
	});
	});

	it('Test 007 : should fail if plugin is a required dependency', function () {
	setupProject('uninstall.test');

	return expectAsync(
	uninstall.uninstallPlugin('C', plugins_install_dir)
	).toBeRejectedWithError(
	'Plugin "C" is required by (A) and cannot be removed (hint: use -f or --force)'
	);
	});

	it('Test 008 : allow forcefully removing a plugin', function () {
	setupProject('uninstall.test');

	return uninstall.uninstallPlugin('C', plugins_install_dir, { force: true })
	.then(function () {
	const del = common.spy.getDeleted(emit);
	expect(del).toEqual(['Deleted plugin "C"']);
	});
	});

	it('Test 009 : never remove top level plugins if they are a dependency', function () {
	setupProject('uninstall.test2');

	return uninstall.uninstallPlugin('A', plugins_install_dir)
	.then(function () {
	const del = common.spy.getDeleted(emit);
	expect(del).toEqual([
	'Deleted plugin "D"',
	'Deleted plugin "A"'
	]);
	});
	});

	it('Test 010 : should not remove dependent plugin if it was installed after as top-level', function () {
	setupProject('uninstall.test3');

	return uninstall.uninstallPlugin('A', plugins_install_dir)
	.then(function () {
	const del = common.spy.getDeleted(emit);
	expect(del).toEqual([
	'Deleted plugin "D"',
	'Deleted plugin "A"'
	]);
	});
	});
	});
	});

	describe('uninstall', function () {
	beforeEach(() => {
	setupProject('uninstall.test');
	});

	describe('failure', function () {
	it('Test 011 : should throw if platform is unrecognized', function () {
	return expectAsync(
	uninstall('atari', project, 'SomePlugin')
	).toBeRejectedWithError('Platform "atari" not supported.');
	});

	it('Test 012 : should throw if plugin is missing', function () {
	return expectAsync(
	uninstall('android', project, 'SomePluginThatDoesntExist')
	).toBeRejectedWithError(
	'Plugin "SomePluginThatDoesntExist" not found. Already uninstalled?'
	);
	});
	});
	});

	describe('end', function () {
	// TODO this was some test/teardown hybrid.
	// We should either add more expectations or get rid of it
	it('Test 013 : end', function () {
	setupProject('uninstall.test');

	return uninstall('android', project, plugins['org.test.plugins.dummyplugin'])
	.then(function () {
	// Fails... A depends on
	return uninstall('android', project, plugins.C);
	}).catch(function (err) {
	expect(err.stack).toMatch(/The plugin 'C' is required by \(A\), skipping uninstallation./);
	}).then(function () {
	// dependencies on C,D ... should this only work with --recursive? prompt user..?
	return uninstall('android', project, plugins.A);
	});
	});
	});
	});