public void SearchRemotePackagesTest()
{
string wd = string.Empty;
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
string searchTerms = "search1";
List<NpmSearchResultPackage> expected = MockTestData.SearchResult1Expected();
IEnumerable<INpmSearchResultPackage> actual;
actual = target.SearchRemotePackages(searchTerms);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Count, actual.Count());
int index = 0;
foreach (INpmSearchResultPackage actualItem in actual)
{
Assert.AreEqual(expected[index], actualItem, "item value differs");
index++;
}
}
public void InstallPackageTest()
{
string wd = "c:\\root\\project1";
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
NpmPackage package = new NpmPackage("install1", null);
target.InstallPackage(package);
Assert.IsTrue(true); // no exception thrown
}
public void IsPackageInstalledFailTest()
{
string wd = "c:\\root\\project2";
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
NpmPackage package = MockTestData.List1MatchInstalledPackage();
NpmInstalledPackage expected = null;
INpmInstalledPackage actual;
actual = target.IsPackageInstalled(package);
if (expected == null)
{
Assert.AreEqual(expected, actual);
}
else
{
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual, "item value differs");
}
}
public void GetInstalledPackagesEmptyTest()
{
string wd = "c:\\root\\empty1";
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
List<NpmInstalledPackage> expected = MockTestData.ListEmptyExpected();
IEnumerable<INpmInstalledPackage> actual;
actual = target.GetInstalledPackages();
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Count, actual.Count());
int index = 0;
foreach (NpmInstalledPackage actualItem in actual)
{
Assert.AreEqual(expected[index], actualItem, "item value differs");
index++;
}
}
public void GetPackagesWithUpdatesTest()
{
string wd = "c:\\root\\update1";
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
List<NpmPackageDependency> expected = MockTestData.Outdated1Expected();
IEnumerable<INpmPackageDependency> actual;
actual = target.GetPackagesWithUpdates();
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Count, actual.Count());
int index = 0;
foreach (INpmPackageDependency actualItem in actual)
{
Assert.AreEqual(expected[index], actualItem, "item value differs");
index++;
}
}
public void InstallPackageFailureTest()
{
string wd = "c:\\root\\project1";
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
NpmPackage package = new NpmPackage("bogusmod", null);
NpmException expected = MockTestData.ErrorInstallExpected();
try
{
target.InstallPackage(package);
Assert.Fail("Expected exception");
}
catch (NpmException ex)
{
Assert.IsNotNull(ex);
Assert.AreEqual(expected.Message, ex.Message);
Assert.AreEqual(expected.NpmCode, ex.NpmCode);
Assert.AreEqual(expected.NpmErrno, ex.NpmErrno);
Assert.AreEqual(expected.NpmFile, ex.NpmFile);
Assert.AreEqual(expected.NpmPath, ex.NpmPath);
Assert.AreEqual(expected.NpmType, ex.NpmType);
Assert.AreEqual(expected.NpmSyscall, ex.NpmSyscall);
Assert.AreEqual(expected.NpmSystem, ex.NpmSystem);
Assert.AreEqual(expected.NpmCommand, ex.NpmCommand);
Assert.AreEqual(expected.NpmNodeVersion, ex.NpmNodeVersion);
Assert.AreEqual(expected.NpmNpmVersion, ex.NpmNpmVersion);
Assert.AreEqual(expected.NpmMessage, ex.NpmMessage);
Assert.AreEqual(expected.NpmArguments, ex.NpmArguments);
Assert.AreEqual(expected.NpmCwd, ex.NpmCwd);
Assert.AreEqual(expected.NpmVerbose, ex.NpmVerbose);
}
}
/// <summary>
/// Execute UninstallPackage
/// </summary>
/// <param name="npm">NpmPackageManager instance</param>
/// <param name="name">name of package</param>
private static void DoUninstall(NpmPackageManager npm, string name)
{
NpmPackage pkg = new NpmPackage(name, null);
npm.UninstallPackage(pkg);
}
public void NpmPackageManagerConstructorTest1()
{
string wd = string.Empty;
Uri registry = null;
NpmPackageManager target = new NpmPackageManager(wd, registry);
Assert.IsNotNull(target);
Assert.IsInstanceOfType(target, typeof(NpmPackageManager));
}
public void NpmPackageManagerConstructorTest2()
{
string wd = string.Empty; // TODO: Initialize to an appropriate value
NpmPackageManager target = new NpmPackageManager(wd);
Assert.IsNotNull(target);
Assert.IsInstanceOfType(target, typeof(NpmPackageManager));
}
/// <summary>
/// Exercise the NpmPackageManager class
/// </summary>
/// <param name="wd">working directory path</param>
/// <param name="installPath">node installation path</param>
/// <param name="module">module name to use</param>
/// <returns>true or false</returns>
public static bool RunSample(string wd, string installPath, string module)
{
NpmPackageManager npm = new NpmPackageManager(wd);
if (npm == null)
{
Console.WriteLine("Failed to create NpmPackageManager");
return false;
}
npm.NpmClient.InstallPath = installPath;
bool quit = false;
ShowUsage();
while (!quit)
{
try
{
Console.Write(">: ");
string cmd = Console.ReadLine();
char[] seps = new char[] { ' ' };
string[] tokens = cmd.Split(seps, StringSplitOptions.RemoveEmptyEntries);
int numTokens = tokens.Length;
if (numTokens > 0)
{
switch (tokens[0].ToLower())
{
case "q":
quit = true;
break;
case "list":
DoList(npm);
break;
case "install":
if (numTokens > 1)
{
DoInstall(npm, tokens[1]);
}
else
{
Console.WriteLine("install needs name of package");
}
break;
case "uninstall":
if (numTokens > 1)
{
DoUninstall(npm, tokens[1]);
}
else
{
Console.WriteLine("uninstall needs name of package");
}
break;
case "find":
if (numTokens > 1)
{
DoFind(npm, tokens[1]);
}
else
{
Console.WriteLine("find needs search term");
}
break;
case "depends":
DoDepends(npm);
break;
case "update":
if (numTokens > 1)
{
DoUpdate(npm, tokens[1]);
}
else
{
Console.WriteLine("update needs name of package");
}
break;
default:
ShowUsage();
break;
}
}
}
catch (NpmException ex)
{
Console.WriteLine("Npm failed with exception.");
Console.WriteLine("Message: " + ex.Message);
if (ex.InnerException != null)
{
Console.WriteLine("Inner message: " + ex.InnerException.Message);
}
else
{
if (ex.NpmCode != null)
{
Console.WriteLine("Code: " + ex.NpmCode);
}
if (ex.NpmCommand != null)
{
Console.WriteLine("calling: " + ex.NpmCommand);
}
}
}
}
return true;
}
/// <summary>
/// Exercise the NpmPackageManager class
/// </summary>
/// <param name="wd">working directory path</param>
/// <param name="installPath">node installation path</param>
/// <param name="module">module name to use</param>
/// <returns>true or false</returns>
public static bool RunSample(string wd, string installPath, string module)
{
try
{
NpmPackageManager npm = new NpmPackageManager(wd);
if (npm == null)
{
Console.WriteLine("Failed to create NpmPackageManager");
return false;
}
npm.NpmClient.InstallPath = installPath;
INpmSearchResultPackage found = null;
IEnumerable<INpmSearchResultPackage> searchResults = npm.SearchRemotePackages(module);
if (searchResults != null)
{
foreach (INpmSearchResultPackage result in searchResults)
{
if (result.Name == module)
{
found = result;
break;
}
}
}
if (found == null)
{
Console.WriteLine("SearchRemotePackages failed to find '{0}'", module);
return false;
}
// install module as a dependency
npm.InstallPackage(found);
// list packages at parent
IEnumerable<INpmInstalledPackage> installedPkg = npm.GetInstalledPackages();
if (installedPkg == null)
{
Console.WriteLine("GetInstalledPackages failed for {0}", found.Name);
return false;
}
// there should be at least 1 item since we installed one
if (installedPkg.Count() == 0)
{
Console.WriteLine("There are no packages listed");
return false;
}
// now call update
npm.UpdatePackage(found);
IEnumerable<INpmPackageDependency> outdated = npm.FindDependenciesToBeInstalled(found);
if (outdated != null && outdated.Count() > 0)
{
Console.WriteLine("Expected no outdated entry after update of {0}", module);
return false;
}
npm.UninstallPackage(installedPkg.First());
Console.WriteLine("Success! {0} was installed and uninstalled.", module);
return true;
}
catch (NpmException ex)
{
Console.WriteLine("Npm failed with exception.");
Console.WriteLine("Message: " + ex.Message);
if (ex.InnerException != null)
{
Console.WriteLine("Inner message: " + ex.InnerException.Message);
}
else
{
if (ex.NpmCode != null)
{
Console.WriteLine("Code: " + ex.NpmCode);
}
if (ex.NpmCommand != null)
{
Console.WriteLine("calling: " + ex.NpmCommand);
}
}
return false;
}
}
/// <summary>
/// Execute UpdatePackage
/// </summary>
/// <param name="npm">NpmPackageManager instance</param>
/// <param name="name">name of package</param>
private static void DoUpdate(NpmPackageManager npm, string name)
{
NpmPackage pkg = new NpmPackage(name, null);
npm.UpdatePackage(pkg);
}
/// <summary>
/// Execute GetPackagesWithUpdates
/// </summary>
/// <param name="npm">NpmPackageManager instance</param>
private static void DoDepends(NpmPackageManager npm)
{
IEnumerable<INpmPackageDependency> pkgs;
pkgs = npm.GetPackagesWithUpdates();
foreach (INpmPackageDependency pkg in pkgs)
{
Console.WriteLine(pkg.Name);
}
}
/// <summary>
/// Execute SearchRemotePackages
/// </summary>
/// <param name="npm">NpmPackageManager instance</param>
/// <param name="term">search term</param>
private static void DoFind(NpmPackageManager npm, string term)
{
IEnumerable<INpmSearchResultPackage> searchResults = npm.SearchRemotePackages(term);
if (searchResults != null)
{
foreach (INpmSearchResultPackage result in searchResults)
{
Console.WriteLine(result.Name);
}
}
}
public void UpdatePackageTest()
{
string wd = "c:\\root\\update1";
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
NpmPackage package = new NpmPackage("underscore", null);
target.UpdatePackage(package);
Assert.IsTrue(true); // no exception thrown
}
public void FindDependenciesToBeInstalledMultiTest()
{
string wd = "c:\\root\\outdatedmulti";
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
NpmPackage package = new NpmPackage("outdatedparent", null);
List<NpmPackageDependency> expected = MockTestData.OutdatedMultiExpected();
IEnumerable<INpmPackageDependency> actual;
actual = target.FindDependenciesToBeInstalled(package);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Count, actual.Count());
int index = 0;
foreach (INpmPackageDependency actualItem in actual)
{
Assert.AreEqual(expected[index], actualItem, "item value differs");
index++;
}
}
public void ApiClientTest()
{
string wd = string.Empty;
NpmPackageManager target = new NpmPackageManager(wd);
INpmApi expected = (INpmApi)new NpmApi(wd);
INpmApi actual;
target.ApiClient = expected;
actual = target.ApiClient;
Assert.AreEqual(expected, actual);
}
public void FindPackagesTest()
{
string wd = string.Empty;
Uri registry = null;
NpmFactory factory = new MockNpmFactory();
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
List<string> packageIds = new List<string>();
packageIds.Add("view1");
List<NpmRemotePackage> expected = new List<NpmRemotePackage>();
expected.Add(MockTestData.View1Expected());
IEnumerable<INpmRemotePackage> actual;
actual = target.FindPackages(packageIds);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Count, actual.Count());
int index = 0;
foreach (INpmRemotePackage actualItem in actual)
{
Assert.AreEqual(expected[index], actualItem, "item value differs");
index++;
}
}
public void NpmPackageManagerConstructorTest()
{
NpmFactory factory = new MockNpmFactory();
string wd = string.Empty;
Uri registry = null;
NpmPackageManager target = new NpmPackageManager(factory, wd, registry);
Assert.IsNotNull(target);
Assert.IsInstanceOfType(target, typeof(NpmPackageManager));
}
/// <summary>
/// Execute GetInstalledPackages
/// </summary>
/// <param name="npm">NpmPackageManager instance</param>
private static void DoList(NpmPackageManager npm)
{
IEnumerable<INpmInstalledPackage> installedPkg = npm.GetInstalledPackages();
if (installedPkg == null || installedPkg.Count() == 0)
{
Console.WriteLine("GetInstalledPackages returned nothing");
return;
}
foreach (INpmInstalledPackage pkg in installedPkg)
{
Console.WriteLine(pkg.Name);
}
}
