public void InstallCommandUpdatesPackageIfAlreadyPresentAndNotUsingSideBySide()
{
// Arrange
var fileSystem = new MockFileSystem();
var repository = new MockPackageRepository();
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager)
{
Console = new MockConsole(),
ExcludeVersion = true,
Version = "0.4",
};
installCommand.Arguments.Add("Baz");
// Act - 1
installCommand.ExecuteCommand();
// Assert - 1
Assert.True(repository.Exists("Baz", new SemanticVersion("0.4")));
// Act - 2
installCommand.Version = null;
installCommand.Execute();
// Assert - 2
Assert.False(repository.Exists("Baz", new SemanticVersion("0.4")));
Assert.True(repository.Exists("Baz", new SemanticVersion("0.7")));
}
public void InstallCommandUsesRestoreOperationIfArgumentIsPackageReferenceFile()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"x:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.0"" />
</packages>");
var mockRepo = new MockPackageRepository()
{
PackageUtility.CreatePackage("Foo")
};
var mockFactory = new Mock <IPackageRepositoryFactory>();
mockFactory.Setup(r => r.CreateRepository(It.IsAny <string>())).Returns(mockRepo);
var installCommand = new TestInstallCommand(mockFactory.Object, GetSourceProvider(), fileSystem);
installCommand.Arguments.Add(@"x:\test\packages.config");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(RepositoryOperationNames.Restore, mockRepo.LastOperation);
}
public void AppendInstallResultVariable()
{
using (var ps = PS.Create())
{
var value = new Result()
{
RebootInitiated = true,
RebootRequired = true,
};
var variable = new PSVariable("a", value, ScopedItemOptions.AllScope);
ps.Runspace.SessionStateProxy.PSVariable.Set(variable);
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
ps.AddCommand("test-install").AddArgument("verbose").AddParameter("ResultVariable", "+a").Invoke();
variable = ps.Runspace.SessionStateProxy.PSVariable.Get("a");
Assert.IsNotNull(variable);
value = variable.Value as Result;
Assert.IsNotNull(value);
Assert.IsTrue(value.RebootInitiated);
Assert.IsTrue(value.RebootRequired);
}
}
public void InstallCommandNoOpsIfExcludingVersionAndALowerVersionOfThePackageIsAlreadyInstalled()
{
// Arrange
var fileSystem = new MockFileSystem();
var packages = new[] { PackageUtility.CreatePackage("A", "0.5") };
var repository = new Mock <LocalPackageRepository>(new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: false), fileSystem)
{
CallBase = true
};
repository.Setup(c => c.FindPackagesById("A")).Returns(packages);
repository.Setup(c => c.AddPackage(It.IsAny <IPackage>())).Throws(new Exception("Method should not be called"));
repository.Setup(c => c.RemovePackage(It.IsAny <IPackage>())).Throws(new Exception("Method should not be called"));
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var console = new MockConsole();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager)
{
Console = console,
ExcludeVersion = true,
Version = "0.4"
};
installCommand.Arguments.Add("A");
// Act
installCommand.ExecuteCommand();
// Assert
// Ensure packages were not removed.
Assert.Equal(1, packages.Length);
Assert.Equal("Package \"A\" is already installed." + Environment.NewLine, console.Output);
}
public void InstallCommandFromConfigIgnoresDependencies()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.0.0"" />
<package id=""Qux"" version=""2.3.56-beta"" />
</packages>");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock <IPackageManager>(MockBehavior.Strict);
var repository = new MockPackageRepository();
packageManager.Setup(p => p.InstallPackage("Foo", new SemanticVersion("1.0.0"), true, true)).Verifiable();
packageManager.Setup(p => p.InstallPackage("Qux", new SemanticVersion("2.3.56-beta"), true, true)).Verifiable();
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(new LocalPackageRepository(pathResolver, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = new Mock <IPackageSourceProvider>(MockBehavior.Strict);
// Act
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider.Object, fileSystem, packageManager.Object);
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.Execute();
// Assert
packageManager.Verify();
}
public void InstallCommandUpdatesPackagesFromPackagesConfigIfAlreadyPresentAndNotUsingSideBySide()
{
// Arrange
var fileSystem = new MockFileSystem();
var packages = new List <IPackage> {
PackageUtility.CreatePackage("Baz", "0.4")
};
var repository = new Mock <IPackageRepository>();
repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable());
repository.Setup(c => c.AddPackage(It.IsAny <IPackage>())).Callback <IPackage>(c => packages.Add(c)).Verifiable();
repository.Setup(c => c.RemovePackage(It.IsAny <IPackage>())).Callback <IPackage>(c => packages.Remove(c)).Verifiable();
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager);
installCommand.ExcludeVersion = true;
installCommand.Arguments.Add("Baz");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal("Baz", packages.Single().Id);
Assert.Equal(new SemanticVersion("0.7"), packages.Single().Version);
}
public void ExecuteSimulatedProgress()
{
using (var ps = PS.Create())
{
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
ps.AddCommand("test-install").AddArgument("progress").Invoke();
Assert.AreEqual <int>(8, ps.Streams.Progress.Count, "The number of progress messages returned is incorrect.");
// Phase 1: No product name or total tick count yet.
var progress = ps.Streams.Progress[0];
Assert.AreEqual("Testing", progress.Activity, "The phase 1 activity is incorrect.");
Assert.AreEqual("Please wait...", progress.StatusDescription, "The phase 1 status description is incorrect.");
// Phase 2: With product name, estimated tick count, generating script.
for (int i = 1; i < 4; ++i)
{
progress = ps.Streams.Progress[i];
Assert.AreEqual("Testing INSTALL", progress.Activity, "The phase 2 step {0:d} activity is incorrect.", i);
if (1 == i)
{
// ActionStart not run yet.
Assert.AreEqual("Please wait...", progress.StatusDescription, "The phase 2 step 1 activity is incorrect.");
}
else
{
Assert.AreEqual("Generating script...", progress.StatusDescription, "The phase 2 step {0:d} status description is incorrect.", i);
}
}
Assert.AreEqual <int>(0, ps.Streams.Progress[1].PercentComplete, "The phase 2 step 1 % complete is incorrect.");
Assert.AreEqual <int>(7, ps.Streams.Progress[2].PercentComplete, "The phase 2 step 2 % complete is incorrect.");
Assert.AreEqual <int>(5, ps.Streams.Progress[3].PercentComplete, "the phase 2 step 3 % complete is incorrect.");
// Phase 3: With product name, estimated tick count, executing script.
progress = ps.Streams.Progress[4];
Assert.AreEqual("Testing INSTALL", progress.Activity, "The phase 3 step 1 activity is incorrect.");
Assert.AreEqual("Generating script...", progress.StatusDescription, "The phase 3 step 1 status description is incorrect.");
Assert.AreEqual <int>(15, progress.PercentComplete, "The phase 3 step 1 % complete is incorrect.");
Assert.IsNull(progress.CurrentOperation, "The phase 3 step 1 operation is incorrect.");
progress = ps.Streams.Progress[5];
Assert.AreEqual("Testing INSTALL", progress.Activity, "The phase 3 step 2 activity is incorrect.");
Assert.AreEqual("Testing", progress.StatusDescription, "The phase 3 step 2 status description is incorrect.");
Assert.AreEqual <int>(15, progress.PercentComplete, "The phase 3 step 2 % complete is incorrect.");
Assert.IsNull(progress.CurrentOperation, "The phase 3 step 2 operation is incorrect.");
progress = ps.Streams.Progress[6];
Assert.AreEqual("Testing INSTALL", progress.Activity, "The phase 3 step 3 activity is incorrect.");
Assert.AreEqual("Testing", progress.StatusDescription, "The phase 3 step 3 status description is incorrect.");
Assert.AreEqual <int>(55, progress.PercentComplete, "The phase 3 step 3 % complete is incorrect.");
Assert.AreEqual("Testing: ActionData", progress.CurrentOperation, "The phase 3 step 2 operation is incorrect.");
// Make sure progress was completed.
Assert.AreEqual <ProgressRecordType>(ProgressRecordType.Completed, ps.Streams.Progress[7].RecordType, "Progress not completed.");
}
}
public void InstallCommandUsesCurrentDirectoryAsInstallPathIfNothingSpecified()
{
// Arrange
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider());
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(Directory.GetCurrentDirectory(), installPath);
}
public void InstallCommandThrowsIfConfigFileDoesNotExist()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add(@"x:\test\packages.config");
// Act and Assert
ExceptionAssert.Throws <FileNotFoundException>(() => installCommand.ExecuteCommand(), @"x:\test\packages.config not found.");
}
public void InstallCommandUsesOutputDirectoryAsInstallPathIfSpecified()
{
// Arrange
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider()) { OutputDirectory = @"Bar\Baz" };
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(@"Bar\Baz", installPath);
}
public void InstallCommandUsesCurrentDirectoryAsInstallPathIfNothingSpecified()
{
// Arrange
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider());
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(Directory.GetCurrentDirectory(), installPath);
}
public void ExecuteVerboseMessage()
{
using (var ps = PS.Create())
{
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
ps.AddCommand("test-install").AddArgument("verbose").AddParameter("verbose").Invoke();
Assert.AreEqual <int>(1, ps.Streams.Verbose.Count, "The number of verbose messages returned is incorrect.");
Assert.AreEqual("verbose", ps.Streams.Verbose[0].Message, "The verbose message is incorrect.");
}
}
public void InstallCommandPromptsForConsentIfRequireConsentIsSet()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Abc"" version=""1.0.0"" />
</packages>");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock <IPackageManager>(MockBehavior.Strict);
var repository = new MockPackageRepository {
PackageUtility.CreatePackage("Abc")
};
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(
new SharedPackageRepository(pathResolver, fileSystem, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = Mock.Of <IPackageSourceProvider>();
var console = new MockConsole();
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider, fileSystem, packageManager.Object, allowPackageRestore: false);
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.Console = console;
installCommand.RequireConsent = true;
// Act
var exception = Assert.Throws <AggregateException>(() => installCommand.ExecuteCommand());
// Assert
#pragma warning disable 0219
// mono compiler complains that innerException is assigned but not used.
var innerException = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerException);
#pragma warning restore 0219
// The culture can't be forced to en-US as the error message is generated in another thread.
// Hence, only check the error message if the language is english.
var culture = System.Globalization.CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
if (culture == "en" || culture == "iv") // english or invariant
{
string message = string.Format(
CultureInfo.CurrentCulture,
NuGetResources.InstallCommandPackageRestoreConsentNotFound,
NuGet.Resources.NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Assert.Equal(message, exception.InnerException.Message);
}
}
public void ExecuteWarningMessage()
{
using (var ps = PS.Create())
{
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
ps.AddCommand("test-install").AddArgument("warning").Invoke();
Assert.AreEqual <int>(1, ps.Streams.Warning.Count, "The number of warnings returned is incorrect.");
Assert.AreEqual("warning", ps.Streams.Warning[0].Message, "The warning message is incorrect.");
}
}
public void ExecuteQueuedActions()
{
using (var ps = PS.Create())
{
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
var objs = ps.AddScript("@('foo', 'bar')").AddCommand("test-install").Invoke();
Assert.AreEqual <int>(2, objs.Count, "The number of objects returned is incorrect.");
Assert.AreEqual <int>(2, (int)objs[0].BaseObject, "The execute count is incorrect.");
Assert.AreEqual <int>(1, (int)objs[1].BaseObject, "The maximum queue count is incorrect.");
}
}
public void InstallCommandUsesRepositoryPathFromConfigIfSpecified()
{
// Arrange
var fileSystem = GetFileSystemWithDefaultConfig();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem,
settings: Settings.LoadDefaultSettings(fileSystem));
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(@"C:\This\Is\My\Install\Path", installPath);
}
public void InstallCommandInstallsPackageIfArgumentIsNotPackageReferenceFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandCanUsePathsRelativeToConfigFile(string input, string expected)
{
// Arrange
var fileSystem = GetFileSystemWithDefaultConfig(input);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem,
settings: Settings.LoadDefaultSettings(fileSystem));
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(expected, installPath);
}
public void InstallCommandForPackageReferenceFileDoesNotThrowIfThereIsNoPackageToInstall()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"x:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
</packages>".AsStream());
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, allowPackageRestore: false);
installCommand.Arguments.Add(@"x:\test\packages.config");
// Act & Assert
installCommand.ExecuteCommand();
}
public void InstallCommandInstallsPackageSuccessfullyIfCacheRepositoryIsNotSet()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.True(fileSystem.FileExists(@"Foo.1.0\Foo.1.0.nupkg"));
}
public void InstallCommandUsesOutputDirectoryAsInstallPathIfSpecified()
{
// Arrange
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider())
{
OutputDirectory = @"Bar\Baz"
};
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(@"Bar\Baz", installPath);
}
public void InstallCommandInstallsPackageSuccessfullyIfCacheRepositoryIsNotSet()
{
// Arrange
var fileSystem = new MockFileSystem();
var packageManager = new Mock<IPackageManager>(MockBehavior.Strict);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandResolvesSourceName()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
installCommand.Source.Add("Some source name");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandInstallsPackageIfArgumentIsNotPackageReferenceFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandPromptsForConsentIfRequireConsentIsSet()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Abc"" version=""1.0.0"" />
</packages>");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock <IPackageManager>(MockBehavior.Strict);
var repository = new MockPackageRepository {
PackageUtility.CreatePackage("Abc")
};
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(new LocalPackageRepository(pathResolver, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = Mock.Of <IPackageSourceProvider>();
var console = new MockConsole();
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider, fileSystem, packageManager.Object, allowPackageRestore: false);
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.Console = console;
installCommand.RequireConsent = true;
// Act
var exception = Assert.Throws <AggregateException>(() => installCommand.ExecuteCommand());
// Assert
#pragma warning disable 0219
// mono compiler complains that innerException is assigned but not used.
var innerException = Assert.IsAssignableFrom <InvalidOperationException>(exception.InnerException);
#pragma warning restore 0219
// The culture can't be forced to en-US as the error message is generated in another thread.
// Hence, only check the error message if the language is english.
var culture = System.Globalization.CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
if (culture == "en" || culture == "iv") // english or invariant
{
Assert.Equal("Package restore is disabled by default. To give consent, open the Visual Studio Options dialog, click on Package Manager node and check 'Allow NuGet to download missing packages during build.' You can also give consent by setting the environment variable 'EnableNuGetPackageRestore' to 'true'.",
exception.InnerException.Message);
}
}
public void InstallCommandResolvesSourceName()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
installCommand.Source.Add("Some source name");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.Single().Key);
}
public void ExecuteErrorMessage()
{
using (var ps = PS.Create())
{
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
ps.AddCommand("test-install").AddArgument("error").Invoke();
Assert.AreEqual <int>(1, ps.Streams.Error.Count, "The number of errors returned is incorrect.");
var error = ps.Streams.Error[0];
Assert.AreEqual <ErrorCategory>(ErrorCategory.WriteError, error.CategoryInfo.Category, "The error category is incorrect.");
Assert.AreEqual("error", error.TargetObject as string, "The error target is incorrect.");
}
}
public void ExecuteInstallFailure()
{
using (var ps = PS.Create())
{
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
ps.AddCommand("test-install").AddArgument("fail").Invoke();
Assert.AreEqual <int>(1, ps.Streams.Error.Count, "The number of errors returned is incorrect.");
var error = ps.Streams.Error[0];
Assert.AreEqual <ErrorCategory>(ErrorCategory.NotSpecified, error.CategoryInfo.Category, "The error category is incorrect.");
Assert.AreEqual("Simulated install failure.", error.Exception.Message, "The exception message is incorrect.");
}
}
public void InstallCommandInstallsSatellitePackagesAfterCorePackages()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo.Fr"" version=""1.0.0"" />
<package id=""Foo"" version=""1.0.0"" />
</packages>");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock <IPackageManager>(MockBehavior.Strict);
var package1 = PackageUtility.CreatePackage("Foo", "1.0.0");
var package2 = PackageUtility.CreatePackage("Foo.Fr", "1.0.0", language: "fr",
dependencies: new[] { new PackageDependency("Foo", VersionUtility.ParseVersionSpec("[1.0.0]")) });
var repository = new MockPackageRepository {
package1, package2
};
// We *shouldn't* be testing if a sequence of operations worked rather that the outcome that satellite package was installed correctly,
// but doing so requires work with nice to have a unit test that tests it.
bool langPackInstalled = false;
packageManager.Setup(p => p.InstallPackage(package1, true, true)).Callback(() =>
{
if (langPackInstalled)
{
throw new Exception("Lang package installed first");
}
}).Verifiable();
packageManager.Setup(p => p.InstallPackage(package2, true, true)).Callback(() => langPackInstalled = true).Verifiable();
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(new LocalPackageRepository(pathResolver, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = Mock.Of <IPackageSourceProvider>();
// Act
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider, fileSystem, packageManager.Object);
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.Execute();
// Assert
packageManager.Verify();
}
public void InstallCommandUsesInstallOperationIfArgumentIsNotPackageReferenceFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var mockRepo = new MockPackageRepository() { PackageUtility.CreatePackage("Foo") };
var mockFactory = new Mock<IPackageRepositoryFactory>();
mockFactory.Setup(r => r.CreateRepository(It.IsAny<string>())).Returns(mockRepo);
var installCommand = new TestInstallCommand(mockFactory.Object, GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(RepositoryOperationNames.Install, mockRepo.LastOperation);
}
public void InstallCommandUsesMultipleSourcesIfSpecified()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Baz");
installCommand.Source.Add("Some Source name");
installCommand.Source.Add("Some other Source");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Baz.0.7\Baz.0.7.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandForPackageReferenceFileDoesNotThrowIfThereIsNoPackageToInstall()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"x:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
</packages>".AsStream());
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, allowPackageRestore: false);
installCommand.Arguments.Add(@"x:\test\packages.config");
// Act & Assert
installCommand.ExecuteCommand();
}
public void AppendNonexistentInstallResultVariable()
{
using (var ps = PS.Create())
{
TestInstallCommand.Register(ps.Runspace.RunspaceConfiguration);
ps.AddCommand("test-install").AddArgument("verbose").AddParameter("ResultVariable", "+a").Invoke();
var variable = ps.Runspace.SessionStateProxy.PSVariable.Get("a");
Assert.IsNotNull(variable);
var value = variable.Value as Result;
Assert.IsNotNull(value);
Assert.IsFalse(value.RebootInitiated);
Assert.IsFalse(value.RebootRequired);
}
}
public void InstallCommandOutPathTakesPrecedenceOverRepositoryPath()
{
// Arrange
var fileSystem = GetFileSystemWithDefaultConfig();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem,
settings: Settings.LoadDefaultSettings(fileSystem))
{
OutputDirectory = @"Bar\Baz"
};
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(@"Bar\Baz", installPath);
}
public void InstallCommandForPackageReferenceFileThrowIfThereIsPackageToInstallAndConsentIsNotGranted()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"x:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.0"" />
<package id=""Baz"" version=""0.7"" />
</packages>");
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, allowPackageRestore: false);
installCommand.Arguments.Add(@"x:\test\packages.config");
// Act & Assert
Assert.Throws<InvalidOperationException>(() => installCommand.ExecuteCommand());
Assert.Equal(1, fileSystem.Paths.Count);
Assert.Equal(@"x:\test\packages.config", fileSystem.Paths.ElementAt(0).Key);
}
public void InstallCommandUsesRemoteIfCacheHasOldDependencyVersion()
{
// Arrange
var newPackageDependency = PackageUtility.CreatePackage("Foo", "1.1");
var newPackage = PackageUtility.CreatePackage("Foo.UI", "1.1",
dependencies: new[] { new PackageDependency("Foo", VersionUtility.ParseVersionSpec("[1.1]")) });
var repository = new MockPackageRepository {
newPackageDependency, newPackage
};
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("Some source")).Returns(repository);
var fileSystem = new MockFileSystem();
var localCache = new Mock <IPackageRepository>(MockBehavior.Strict);
localCache.Setup(c => c.GetPackages()).Returns(new[] { PackageUtility.CreatePackage("Foo", "1.0") }.AsQueryable()).Verifiable();
var localRepository = new MockPackageRepository();
var installCommand = new TestInstallCommand(
repositoryFactory.Object,
GetSourceProvider(new[] { new PackageSource("Some source", "Some source name") }),
fileSystem,
machineCacheRepository: localCache.Object,
localRepository: localRepository)
{
NoCache = false,
Version = "1.1"
};
installCommand.Arguments.Add("Foo.UI");
installCommand.Source.Add("Some Source name");
// Act
installCommand.ExecuteCommand();
// Assert
var installedPackages = localRepository.GetPackages().ToList();
Assert.Equal(2, installedPackages.Count);
Assert.Same(newPackageDependency, installedPackages[0]);
Assert.Same(newPackage, installedPackages[1]);
localCache.Verify();
}
public void InstallCommandInstallsPrereleasePackageIfFlagIsSpecified()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem)
{
Prerelease = true
};
installCommand.Arguments.Add("Baz");
installCommand.Source.Add("Some Source name");
installCommand.Source.Add("Some other Source");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Baz.0.8.1-alpha\Baz.0.8.1-alpha.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandLogsWarningsForFailingRepositoriesIfNoSourcesAreSpecified()
{
// Arrange
MessageLevel?level = null;
string message = null;
var repositoryA = new MockPackageRepository();
repositoryA.AddPackage(PackageUtility.CreatePackage("Foo"));
var repositoryB = new Mock <IPackageRepository>();
repositoryB.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable());
var fileSystem = new MockFileSystem();
var console = new Mock <IConsole>();
console.Setup(c => c.Log(It.IsAny <MessageLevel>(), It.IsAny <string>(), It.IsAny <object[]>())).Callback((MessageLevel a, string b, object[] c) =>
{
if (a == MessageLevel.Warning)
{
level = a;
message = b;
}
});
var sourceProvider = GetSourceProvider(new[] { new PackageSource("A"), new PackageSource("B") });
var factory = new Mock <IPackageRepositoryFactory>();
factory.Setup(c => c.CreateRepository("A")).Returns(repositoryA);
factory.Setup(c => c.CreateRepository("B")).Returns(repositoryB.Object);
var installCommand = new TestInstallCommand(factory.Object, sourceProvider, fileSystem)
{
Console = console.Object
};
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal("Boom", message);
Assert.Equal(MessageLevel.Warning, level.Value);
}
public void InstallCommandUsesLocalCacheIfNoCacheIsFalse()
{
// Arrange
var fileSystem = new MockFileSystem();
var localCache = new Mock<IPackageRepository>(MockBehavior.Strict);
localCache.Setup(c => c.GetPackages()).Returns(new[] { PackageUtility.CreatePackage("Gamma") }.AsQueryable()).Verifiable();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, machineCacheRepository: localCache.Object)
{
NoCache = false
};
installCommand.Arguments.Add("Gamma");
installCommand.Source.Add("Some Source name");
installCommand.Source.Add("Some other Source");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Gamma.1.0\Gamma.1.0.nupkg", fileSystem.Paths.Single().Key);
localCache.Verify();
}
public void InstallCommandFromConfigIgnoresDependencies()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.0.0"" />
<package id=""Qux"" version=""2.3.56-beta"" />
</packages>");
var packageManager = new Mock<IPackageManager>(MockBehavior.Strict);
var package = PackageUtility.CreatePackage("Foo", "1.0.0");
packageManager.Setup(p => p.InstallPackage("Foo", new SemanticVersion("1.0.0"), true, true)).Verifiable();
packageManager.Setup(p => p.InstallPackage("Qux", new SemanticVersion("2.3.56-beta"), true, true)).Verifiable();
packageManager.SetupGet(p => p.PathResolver).Returns(new DefaultPackagePathResolver(fileSystem));
var repository = new MockPackageRepository();
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = new Mock<IPackageSourceProvider>(MockBehavior.Strict);
// Act
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider.Object, fileSystem, packageManager.Object);
installCommand.Arguments.Add("packages.config");
installCommand.Execute();
// Assert
packageManager.Verify();
}
public void InstallCommandWorksIfExcludedVersionsAndPackageIsNotFoundInRemoteRepository()
{
// Arrange
var fileSystem = new MockFileSystem();
var packages = new List<IPackage> { PackageUtility.CreatePackage("A", "0.5") };
var repository = new Mock<IPackageRepository>();
repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable());
repository.Setup(c => c.AddPackage(It.IsAny<IPackage>())).Throws(new Exception("Method should not be called"));
repository.Setup(c => c.RemovePackage(It.IsAny<IPackage>())).Throws(new Exception("Method should not be called"));
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager);
installCommand.ExcludeVersion = true;
installCommand.Arguments.Add("A");
// Act and Assert
ExceptionAssert.Throws<InvalidOperationException>(() => installCommand.ExecuteCommand(), "Unable to find package 'A'.");
// Ensure packages were not removed.
Assert.Equal(1, packages.Count);
}
public void InstallCommandUpdatesPackagesFromPackagesConfigIfAlreadyPresentAndNotUsingSideBySide()
{
// Arrange
var fileSystem = new MockFileSystem();
var packages = new List<IPackage> { PackageUtility.CreatePackage("Baz", "0.4") };
var repository = new Mock<IPackageRepository>();
repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable());
repository.Setup(c => c.AddPackage(It.IsAny<IPackage>())).Callback<IPackage>(c => packages.Add(c)).Verifiable();
repository.Setup(c => c.RemovePackage(It.IsAny<IPackage>())).Callback<IPackage>(c => packages.Remove(c)).Verifiable();
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager);
installCommand.ExcludeVersion = true;
installCommand.Arguments.Add("Baz");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal("Baz", packages.Single().Id);
Assert.Equal(new SemanticVersion("0.7"), packages.Single().Version);
}
public void InstallCommandNoOpsIfExcludingVersionAndALowerVersionOfThePackageIsAlreadyInstalled()
{
// Arrange
var fileSystem = new MockFileSystem();
var packages = new[] { PackageUtility.CreatePackage("A", "0.5") };
var repository = new Mock<LocalPackageRepository>(new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: false), fileSystem) { CallBase = true };
repository.Setup(c => c.FindPackagesById("A")).Returns(packages);
repository.Setup(c => c.AddPackage(It.IsAny<IPackage>())).Throws(new Exception("Method should not be called"));
repository.Setup(c => c.RemovePackage(It.IsAny<IPackage>())).Throws(new Exception("Method should not be called"));
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var console = new MockConsole();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager)
{
Console = console,
ExcludeVersion = true,
Version = "0.4"
};
installCommand.Arguments.Add("A");
// Act
installCommand.ExecuteCommand();
// Assert
// Ensure packages were not removed.
Assert.Equal(1, packages.Length);
Assert.Equal("Package \"A\" is already installed." + Environment.NewLine, console.Output);
}
public void InstallCommandCanUsePathsRelativeToConfigFile(string input, string expected)
{
// Arrange
var fileSystem = GetFileSystemWithDefaultConfig(input);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem,
settings: Settings.LoadDefaultSettings(fileSystem, null, null));
// Act
string installPath = installCommand.ResolveInstallPath();
// Assert
Assert.Equal(expected, installPath);
}
public void InstallCommandDoesNotUseLocalCacheIfNoCacheIsTrue()
{
// Arrange
var fileSystem = new MockFileSystem();
var localCache = new Mock<IPackageRepository>(MockBehavior.Strict);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, machineCacheRepository: localCache.Object)
{
NoCache = true
};
installCommand.Arguments.Add("Baz");
installCommand.Source.Add("Some Source name");
installCommand.Source.Add("Some other Source");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Baz.0.7\Baz.0.7.nupkg", fileSystem.Paths.Single().Key);
localCache.Verify(c => c.GetPackages(), Times.Never());
}
public void InstallCommandInstallsAllPackagesUsePackagesConfigByDefaultIfNoArgumentIsSpecified()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\test");
fileSystem.AddFile(@"packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.0"" />
<package id=""Baz"" version=""0.7"" />
</packages>");
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(3, fileSystem.Paths.Count);
Assert.Equal(@"packages.config", fileSystem.Paths.ElementAt(0).Key);
Assert.Contains(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.Keys);
Assert.Contains(@"Baz.0.7\Baz.0.7.nupkg", fileSystem.Paths.Keys);
}
public void InstallCommandUpdatesPackageIfAlreadyPresentAndNotUsingSideBySide()
{
// Arrange
var fileSystem = new MockFileSystem();
var repository = new MockPackageRepository();
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager)
{
Console = new MockConsole(),
ExcludeVersion = true,
Version = "0.4",
};
installCommand.Arguments.Add("Baz");
// Act - 1
installCommand.ExecuteCommand();
// Assert - 1
Assert.True(repository.Exists("Baz", new SemanticVersion("0.4")));
// Act - 2
installCommand.Version = null;
installCommand.ExecuteCommand();
// Assert - 2
Assert.False(repository.Exists("Baz", new SemanticVersion("0.4")));
Assert.True(repository.Exists("Baz", new SemanticVersion("0.7")));
}
public void InstallCommandUpdatesPackageFromPackagesConfigIfDifferentVersionAlreadyPresentAndNotUsingSideBySide()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"baz\baz.0.4.nupkg");
var baz40 = PackageUtility.CreatePackage("Baz", "0.4");
var packages = new List<IPackage> { baz40 };
var repository = new Mock<LocalPackageRepository>(new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: false), fileSystem) { CallBase = true };
repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable());
repository.Setup(c => c.Exists("Baz", new SemanticVersion("0.4"))).Returns(true);
repository.Setup(c => c.FindPackagesById("Baz")).Returns(packages);
repository.Setup(c => c.AddPackage(It.IsAny<IPackage>())).Callback<IPackage>(c => packages.Add(c)).Verifiable();
repository.Setup(c => c.RemovePackage(It.IsAny<IPackage>())).Callback<IPackage>(c => packages.Remove(c)).Verifiable();
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager)
{
Console = new MockConsole()
};
installCommand.ExcludeVersion = true;
installCommand.Arguments.Add("Baz");
// Act
installCommand.ExecuteCommand();
// Assert
repository.Verify();
Assert.Equal("Baz", packages.Single().Id);
Assert.Equal(new SemanticVersion("0.7"), packages.Single().Version);
}
public void InstallCommandPromptsForConsentIfRequireConsentIsSet()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Abc"" version=""1.0.0"" />
</packages>");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock<IPackageManager>(MockBehavior.Strict);
var repository = new MockPackageRepository { PackageUtility.CreatePackage("Abc") };
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(new LocalPackageRepository(pathResolver, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = Mock.Of<IPackageSourceProvider>();
var console = new MockConsole();
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider, fileSystem, packageManager.Object, allowPackageRestore: false);
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.Console = console;
installCommand.RequireConsent = true;
// Act
var exception = Assert.Throws<AggregateException>(() => installCommand.ExecuteCommand());
// Assert
#pragma warning disable 0219
// mono compiler complains that innerException is assigned but not used.
var innerException = Assert.IsAssignableFrom<InvalidOperationException>(exception.InnerException);
#pragma warning restore 0219
// The culture can't be forced to en-US as the error message is generated in another thread.
// Hence, only check the error message if the language is english.
var culture = System.Globalization.CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
if (culture == "en" || culture == "iv") // english or invariant
{
string message = string.Format(
CultureInfo.CurrentCulture,
NuGetResources.InstallCommandPackageRestoreConsentNotFound,
NuGet.Resources.NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Assert.Equal(message, exception.InnerException.Message);
}
}
public void InstallCommandDoesNotPromptForConsentIfRequireConsentIsNotSet()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Abc"" version=""1.0.0"" />
</packages>");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock<IPackageManager>(MockBehavior.Strict);
var package = PackageUtility.CreatePackage("Abc");
var repository = new MockPackageRepository { package };
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(new LocalPackageRepository(pathResolver, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
packageManager.Setup(p => p.InstallPackage(package, true, true, true)).Verifiable();
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = Mock.Of<IPackageSourceProvider>();
var console = new MockConsole();
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider, fileSystem, packageManager.Object, allowPackageRestore: false);
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.Console = console;
// Act
installCommand.ExecuteCommand();
// Assert
packageManager.Verify();
}
public void InstallCommandFromConfigPerformsQuickCheckForFiles()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.8.0"" />
<package id=""Qux"" version=""2.3.56-beta"" />
</packages>");
fileSystem.AddFile("Foo.1.8.nupkg");
var package = PackageUtility.CreatePackage("Qux", "2.3.56-beta");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock<IPackageManager>(MockBehavior.Strict);
var repository = new MockPackageRepository { package };
packageManager.Setup(p => p.InstallPackage(package, true, true, true)).Verifiable();
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(new LocalPackageRepository(pathResolver, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = Mock.Of<IPackageSourceProvider>();
// Act
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider, fileSystem, packageManager.Object)
{
Console = new MockConsole()
};
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.ExecuteCommand();
// Assert
packageManager.Verify();
}
public void InstallCommandLogsWarningsForFailingRepositoriesIfNoSourcesAreSpecified()
{
// Arrange
MessageLevel? level = null;
string message = null;
var repositoryA = new MockPackageRepository();
repositoryA.AddPackage(PackageUtility.CreatePackage("Foo"));
var repositoryB = new Mock<IPackageRepository>();
repositoryB.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable());
var fileSystem = new MockFileSystem();
var console = new Mock<IConsole>();
console.Setup(c => c.Log(It.IsAny<MessageLevel>(), It.IsAny<string>(), It.IsAny<object[]>())).Callback((MessageLevel a, string b, object[] c) =>
{
if (a == MessageLevel.Warning)
{
level = a;
message = b;
}
});
var sourceProvider = GetSourceProvider(new[] { new PackageSource("A"), new PackageSource("B") });
var factory = new Mock<IPackageRepositoryFactory>();
factory.Setup(c => c.CreateRepository("A")).Returns(repositoryA);
factory.Setup(c => c.CreateRepository("B")).Returns(repositoryB.Object);
var installCommand = new TestInstallCommand(factory.Object, sourceProvider, fileSystem)
{
Console = console.Object
};
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal("Boom", message);
Assert.Equal(MessageLevel.Warning, level.Value);
}
public void InstallCommandUsesMultipleSourcesIfSpecified()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Baz");
installCommand.Source.Add("Some Source name");
installCommand.Source.Add("Some other Source");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Baz.0.7\Baz.0.7.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandInstallsPrereleasePackageIfFlagIsSpecified()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem) { Prerelease = true };
installCommand.Arguments.Add("Baz");
installCommand.Source.Add("Some Source name");
installCommand.Source.Add("Some other Source");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Baz.0.8.1-alpha\Baz.0.8.1-alpha.nupkg", fileSystem.Paths.Single().Key);
}
public void InstallCommandInstallsSatellitePackagesAfterCorePackages()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"X:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo.Fr"" version=""1.0.0"" />
<package id=""Foo"" version=""1.0.0"" />
</packages>");
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageManager = new Mock<IPackageManager>(MockBehavior.Strict);
var package1 = PackageUtility.CreatePackage("Foo", "1.0.0");
var package2 = PackageUtility.CreatePackage("Foo.Fr", "1.0.0", language: "fr",
dependencies: new[] { new PackageDependency("Foo", VersionUtility.ParseVersionSpec("[1.0.0]")) });
var repository = new MockPackageRepository { package1, package2 };
// We *shouldn't* be testing if a sequence of operations worked rather that the outcome that satellite package was installed correctly,
// but doing so requires work with nice to have a unit test that tests it.
bool langPackInstalled = false;
packageManager.Setup(p => p.InstallPackage(package1, true, true, true)).Callback(() =>
{
if (langPackInstalled)
{
throw new Exception("Lang package installed first");
}
}).Verifiable();
packageManager.Setup(p => p.InstallPackage(package2, true, true)).Callback(() => langPackInstalled = true).Verifiable();
packageManager.SetupGet(p => p.PathResolver).Returns(pathResolver);
packageManager.SetupGet(p => p.LocalRepository).Returns(new LocalPackageRepository(pathResolver, fileSystem));
packageManager.SetupGet(p => p.FileSystem).Returns(fileSystem);
packageManager.SetupGet(p => p.SourceRepository).Returns(repository);
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(r => r.CreateRepository("My Source")).Returns(repository);
var packageSourceProvider = Mock.Of<IPackageSourceProvider>();
// Act
var installCommand = new TestInstallCommand(repositoryFactory.Object, packageSourceProvider, fileSystem, packageManager.Object);
installCommand.Arguments.Add(@"X:\test\packages.config");
installCommand.ExecuteCommand();
// Assert
packageManager.Verify();
}
public void InstallCommandNoOps_ExcludingVersionIsTrue_VersionIsEmpty_ExistingPackageIsNewerOrSame(
string installedVersion)
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"baz\baz.nupkg");
var baz = PackageUtility.CreatePackage("Baz", installedVersion);
var packages = new List<IPackage> { baz };
var repository = new Mock<LocalPackageRepository>(new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: false), fileSystem) { CallBase = true };
repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable());
repository.Setup(c => c.Exists("Baz", new SemanticVersion(installedVersion))).Returns(true);
repository.Setup(c => c.FindPackagesById("Baz")).Returns(packages);
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var console = new MockConsole();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager)
{
Console = console,
ExcludeVersion = true
};
installCommand.Arguments.Add("Baz");
// Act
installCommand.ExecuteCommand();
// Assert
repository.Verify();
Assert.Equal("Package \"Baz\" is already installed." + Environment.NewLine, console.Output);
}
public void InstallCommandInstallsPackageFromAllSourcesIfArgumentIsNotPackageReferenceFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add("Foo");
// Act
installCommand.ExecuteCommand();
installCommand.Arguments.Clear();
installCommand.Arguments.Add("Bar");
installCommand.Version = "0.5";
installCommand.ExecuteCommand();
// Assert
Assert.Equal(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.First().Key);
Assert.Equal(@"Bar.0.5\Bar.0.5.nupkg", fileSystem.Paths.Last().Key);
}
public void InstallCommandInstallsAllPackagesFromConfigFileIfSpecifiedAsArgument()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"dir\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.0"" />
<package id=""Baz"" version=""0.7"" />
</packages>");
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add(@"dir\packages.config");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(3, fileSystem.Paths.Count);
Assert.Equal(@"dir\packages.config", fileSystem.Paths.ElementAt(0).Key);
Assert.Equal(@"Foo.1.0\Foo.1.0.nupkg", fileSystem.Paths.ElementAt(1).Key);
Assert.Equal(@"Baz.0.7\Baz.0.7.nupkg", fileSystem.Paths.ElementAt(2).Key);
}
public void InstallCommandThrowsIfConfigFileDoesNotExist()
{
// Arrange
var fileSystem = new MockFileSystem();
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem);
installCommand.Arguments.Add(@"x:\test\packages.config");
// Act and Assert
ExceptionAssert.Throws<FileNotFoundException>(() => installCommand.ExecuteCommand(), @"x:\test\packages.config not found.");
}
public void InstallCommandUsesRestoreOperationIfArgumentIsPackageReferenceFile()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddFile(@"x:\test\packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""Foo"" version=""1.0"" />
</packages>");
var mockRepo = new MockPackageRepository() { PackageUtility.CreatePackage("Foo") };
var mockFactory = new Mock<IPackageRepositoryFactory>();
mockFactory.Setup(r => r.CreateRepository(It.IsAny<string>())).Returns(mockRepo);
var installCommand = new TestInstallCommand(mockFactory.Object, GetSourceProvider(), fileSystem);
installCommand.Arguments.Add(@"x:\test\packages.config");
// Act
installCommand.ExecuteCommand();
// Assert
Assert.Equal(RepositoryOperationNames.Restore, mockRepo.LastOperation);
}
