public void InstallUninstallMaxPathGlobalModule()
{
using (var manager = new TemporaryFileManager())
{
var rootDir = FilesystemPackageJsonTestHelpers.CreateRootPackage(manager, PkgSimple);
var controller = NpmControllerFactory.Create(rootDir, string.Empty);
using (var commander = controller.CreateNpmCommander())
{
commander.InstallPackageByVersionAsync("yo", "^1.2.0", DependencyType.Standard, false).Wait();
}
Assert.IsNotNull(controller.RootPackage, "Cannot retrieve packages after install");
Assert.IsTrue(controller.RootPackage.Modules.Contains("yo"), "Package failed to install");
using (var commander = controller.CreateNpmCommander())
{
commander.UninstallPackageAsync("yo").Wait();
}
// Command has completed, but need to wait for all files/folders to be deleted.
Thread.Sleep(5000);
Assert.IsNotNull(controller.RootPackage, "Cannot retrieve packages after uninstall");
Assert.IsFalse(controller.RootPackage.Modules.Contains("yo"), "Package failed to uninstall");
}
}
private static INpmController DefaultNpmController(string projectHome, NpmPathProvider pathProvider)
{
return(NpmControllerFactory.Create(
projectHome,
NodejsConstants.NpmCachePath,
false,
pathProvider));
}
private static INpmController DefaultNpmController(string projectHome, NpmPathProvider pathProvider)
{
return(NpmControllerFactory.Create(
projectHome,
NodejsConstants.NpmCachePath,
isProject: true,
showMissingDevOptionalSubPackages: false,
npmPathProvider: pathProvider));
}
public void AddPackageNoPackageJsonThenUninstall()
{
using (var manager = new TemporaryFileManager())
{
var rootDir = FilesystemPackageJsonTestHelpers.CreateRootPackage(manager, PkgSimple);
File.Delete(Path.Combine(rootDir, "package.json"));
var controller = NpmControllerFactory.Create(rootDir, string.Empty);
controller.Refresh();
var rootPackage = controller.RootPackage;
Assert.IsNotNull(rootPackage, "Root package with no dependencies should not be null.");
Assert.AreEqual(0, rootPackage.Modules.Count, "Should be no modules before package install.");
using (var commander = controller.CreateNpmCommander())
{
Task <bool> task = commander.InstallPackageByVersionAsync("sax", "*", DependencyType.Standard, true);
task.Wait();
}
Assert.AreNotEqual(
rootPackage,
controller.RootPackage,
"Root package should be different after package installed.");
rootPackage = controller.RootPackage;
Assert.IsNotNull(rootPackage, "Root package should not be null after package installed.");
Assert.AreEqual(1, rootPackage.Modules.Count, "Should be one module after package installed.");
var module = controller.RootPackage.Modules["sax"];
Assert.IsNotNull(module, "Installed package should not be null.");
Assert.AreEqual("sax", module.Name, "Module name mismatch.");
Assert.IsNotNull(module.PackageJson, "Module package.json should not be null.");
Assert.IsFalse(
module.IsListedInParentPackageJson,
"Should be listed as a dependency in parent package.json.");
Assert.IsFalse(module.IsMissing, "Should not be marked as missing.");
Assert.IsFalse(module.IsDevDependency, "Should not be marked as dev dependency.");
Assert.IsFalse(module.IsOptionalDependency, "Should not be marked as optional dependency.");
Assert.IsFalse(module.IsBundledDependency, "Should not be marked as bundled dependency.");
Assert.IsTrue(module.HasPackageJson, "Module should have its own package.json");
using (var commander = controller.CreateNpmCommander())
{
Task <bool> task = commander.UninstallPackageAsync("sax");
task.Wait();
}
Assert.AreNotEqual(
rootPackage,
controller.RootPackage,
"Root package should be different after package uninstalled.");
rootPackage = controller.RootPackage;
Assert.IsNotNull(rootPackage, "Root package should not be null after package uninstalled.");
Assert.AreEqual(0, rootPackage.Modules.Count, "Should be no modules after package installed.");
}
}
private INpmController CreateController(IWorkspace workspace)
{
var projectHome = workspace.Location;
var npmController = NpmControllerFactory.Create(
projectHome,
NodejsConstants.NpmCachePath);
npmController.ErrorLogged += this.WriteNpmOutput;
npmController.ExceptionLogged += this.WriteNpmException;
npmController.OutputLogged += this.WriteNpmOutput;
return(npmController);
}
private INpmController CreateNpmController()
{
if (null == _npmController)
{
_npmController = NpmControllerFactory.Create(
_projectNode.ProjectHome,
NodejsPackage.Instance.NpmOptionsPage.NpmCachePath,
false,
new NpmPathProvider(this));
_npmController.CommandStarted += NpmController_CommandStarted;
_npmController.OutputLogged += NpmController_OutputLogged;
_npmController.ErrorLogged += NpmController_ErrorLogged;
_npmController.ExceptionLogged += NpmController_ExceptionLogged;
_npmController.CommandCompleted += NpmController_CommandCompleted;
}
return(_npmController);
}
public void TestAngularFullstackScaffoldedProject()
{
var rootDir = CreateRootPackageDir();
var controller = NpmControllerFactory.Create(rootDir, string.Empty);
controller.OutputLogged += controller_OutputLogged;
controller.ErrorLogged += controller_OutputLogged;
controller.Refresh();
using (var commander = controller.CreateNpmCommander()) {
var task = commander.InstallGlobalPackageByVersionAsync("yo", "*");
task.Wait();
}
var info = new ProcessStartInfo();
// TODO!
}
private INpmController CreateController(string packageJsonPath)
{
Debug.Assert(Path.IsPathRooted(packageJsonPath));
Debug.Assert(PackageJsonFactory.IsPackageJsonFile(packageJsonPath));
var projectHome = Path.GetDirectoryName(packageJsonPath);
var npmController = NpmControllerFactory.Create(
projectHome,
NodejsConstants.NpmCachePath,
isProject: false);
npmController.ErrorLogged += this.WriteNpmOutput;
npmController.ExceptionLogged += this.WriteNpmException;
npmController.OutputLogged += this.WriteNpmOutput;
return(npmController);
}
public void TestInstallUninstallMaxPathGlobalModule()
{
var controller = NpmControllerFactory.Create(string.Empty, string.Empty);
using (var commander = controller.CreateNpmCommander()) {
commander.InstallGlobalPackageByVersionAsync("yo", "^1.2.0").Wait();
}
Assert.IsNotNull(controller.GlobalPackages, "Cannot retrieve global packages after install");
Assert.IsTrue(controller.GlobalPackages.Modules.Contains("yo"), "Global package failed to install");
using (var commander = controller.CreateNpmCommander()) {
commander.UninstallGlobalPackageAsync("yo").Wait();
}
// Command has completed, but need to wait for all files/folders to be deleted.
Thread.Sleep(5000);
Assert.IsNotNull(controller.GlobalPackages, "Cannot retrieve global packages after uninstall");
Assert.IsFalse(controller.GlobalPackages.Modules.Contains("yo"), "Global package failed to uninstall");
}
private AnalysisDriver(string[] packages, string packagePath, bool installMissingPackages, bool installAll, DependencyType depType, bool cleanup, bool wait, Random random, TextWriter logger, TextWriter htmlLogger, int?dumpMembers, bool lowAnalysis, Dictionary <string, RunStats> baselineStats)
{
_packages = packages;
_random = random;
_packagePath = packagePath;
_installMissingPackages = installMissingPackages;
_installAll = installAll;
_depType = depType;
_cleanup = cleanup;
_wait = wait;
_logger = logger;
_htmlLogger = htmlLogger;
_dumpMembers = dumpMembers;
_lowAnalysis = lowAnalysis;
_baselineStats = baselineStats;
WriteCsvHeader();
_jsonResults.Append("[");
_npmController = NpmControllerFactory.Create(packagePath, string.Empty);
_npmController.OutputLogged += NpmControllerOutputLogged;
_npmController.ErrorLogged += NpmControllerErrorLogged;
_npmController.Refresh();
if (_installAll)
{
foreach (var package in _packages)
{
if (!Directory.Exists(GetInstalledPackagePath(package.Split('@')[0])))
{
InstallPackage(package);
}
}
}
}
