/// <summary>
/// Checks and installs nuget packages in the project
/// </summary>
/// <param name="packageSource">The source of the package</param>
/// <param name="packageName">The name of the package to be installed</param>
public async Task CheckAndInstallNuGetPackageAsync(string packageSource, string packageName)
{
if (PackageInstallerServices != null)
{
try
{
if (!PackageInstallerServices.IsPackageInstalled(this.Project, packageName))
{
Version packageVersion = null;
PackageInstaller.InstallPackage(packageSource, this.Project, packageName, packageVersion, false);
await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Information, $"Nuget Package \"{packageName}\" for OData client was added.")).ConfigureAwait(false);
}
else
{
await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Information, $"Nuget Package \"{packageName}\" for OData client already installed.")).ConfigureAwait(false);
}
}
catch (Exception ex)
{
await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Error, $"Nuget Package \"{packageName}\" for OData client not installed. Error: {ex.Message}.")).ConfigureAwait(false);
}
}
else
{
await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Error, $"The packages were not installed. An error occurred during the installation of packages.")).ConfigureAwait(false);
}
}
public ExecutionResult Install(InstallDto installOptions)
{
var logger = new StringLogger();
try
{
var packageInfo = new PackageInfo();
packageInfo.Configuration = installOptions.Configuration;
packageInfo.InstallationDirectory = installOptions.Directory;
packageInfo.Name = installOptions.Application;
packageInfo.Version = installOptions.Version;
var PackageInstaller = new PackageInstaller();
PackageInstaller.Logger = logger;
PackageInstaller.Install(packageInfo, new string[] { installOptions.Repository }, installOptions.AdditionalParameters, installOptions.InstallScript, installOptions.ConfigurationFile, installOptions.ConfigurationTransform);
return(new ExecutionResult()
{
Success = logger.Logs.All(x => !x.Error),
Log = logger.Logs
});
}
catch (Exception e)
{
logger.Log(e.InnerException != null ? e.InnerException.Message : e.Message, true);
return(new ExecutionResult()
{
Success = false,
Exception = e.InnerException != null ? e.InnerException.Message : e.Message,
Log = logger.Logs
});
}
}
public void PerformOperation_ShouldMultiplyBy2DownloadAndRemoveCallTimes_WhenInstallPassedAndDependenciesListIsNotEmpty()
{
var downloaderMock = new Mock <IDownloader>();
var projectMock = new Mock <IProject>();
var packageMock = new Mock <IPackage>();
var packageDependencyMock = new Mock <IPackage>();
projectMock.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>());
packageDependencyMock.Setup(x => x.Dependencies).Returns(new List <IPackage>());
packageMock.Setup(x => x.Dependencies).Returns(new List <IPackage>()
{
packageDependencyMock.Object
});
var installer = new PackageInstaller(downloaderMock.Object, projectMock.Object);
installer.Operation = Enums.InstallerOperation.Install;
//Act
installer.PerformOperation(packageMock.Object);
//Assert
downloaderMock.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2));
downloaderMock.Verify(x => x.Download(It.IsAny <string>()), Times.Exactly(4));
}
public void CallProjectRemoveMultipleTimes_WhenThereAreDependencies()
{
// Arrange
var downloaderMock = new Mock <IDownloader>();
var projectMock = new Mock <IProject>();
var packageMock = new Mock <IPackage>();
var dependencyPackageMock = new Mock <IPackage>();
dependencyPackageMock.Setup(x => x.Dependencies.Count).Returns(0);
packageMock.Setup(x => x.Dependencies.Count).Returns(1);
packageMock.Setup(x => x.Dependencies).Returns(new List <IPackage>()
{
dependencyPackageMock.Object
});
projectMock.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>()
{
packageMock.Object
});
downloaderMock.Setup(x => x.Remove(It.IsAny <string>()));
// Act
var packageInstaller = new PackageInstaller(downloaderMock.Object, projectMock.Object);
// Assert
// 4 times as there is only one dependency
downloaderMock.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2));
}
public async override Task AddNugetPackages()
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Adding Nuget Packages");
var wcfDSInstallLocation = CodeGeneratorUtils.GetWCFDSInstallLocation();
var packageSource = Path.Combine(wcfDSInstallLocation, @"bin\NuGet");
if (Directory.Exists(packageSource))
{
var files = Directory.EnumerateFiles(packageSource, "*.nupkg").ToList();
foreach (var nugetPackage in Common.Constants.V3NuGetPackages)
{
if (!files.Any(f => Regex.IsMatch(f, nugetPackage + @"(.\d){2,4}.nupkg")))
{
packageSource = Common.Constants.NuGetOnlineRepository;
}
}
}
else
{
packageSource = Common.Constants.NuGetOnlineRepository;
}
if (!PackageInstallerServices.IsPackageInstalled(this.Project, this.ClientNuGetPackageName))
{
Version packageVersion = null;
PackageInstaller.InstallPackage(Common.Constants.NuGetOnlineRepository, this.Project, this.ClientNuGetPackageName, packageVersion, false);
}
}
private static void CheckPackage()
{
if (!EditorPreferences.Get($"{nameof(SDKPackageInstaller)}.Assets", false))
{
EditorPreferences.Set($"{nameof(SDKPackageInstaller)}.Assets", PackageInstaller.TryInstallAssets(DefaultSdkAssets));
}
}
// Internal for testing
internal void AddRecipePackageAndSetTheme()
{
if (Recipe == null && !string.IsNullOrEmpty(RecipeName))
{
KnownRecipe knownRecipe;
if (KnownRecipe.Values.TryGetValue(RecipeName, out knownRecipe))
{
Trace.Verbose($"Recipe {RecipeName} was in the lookup of known recipes");
// Make sure we're not ignoring packages
if (!IgnoreKnownRecipePackages)
{
// Add the package, but only if it wasn't added manually
if (!string.IsNullOrEmpty(knownRecipe.PackageId) && !PackageInstaller.ContainsPackage(knownRecipe.PackageId))
{
PackageInstaller.AddPackage(knownRecipe.PackageId);
}
}
else
{
Trace.Verbose("Ignoring known recipe packages");
}
// Set the theme if we don't already have one
if (string.IsNullOrEmpty(Theme))
{
Theme = knownRecipe.DefaultTheme;
}
}
else
{
Trace.Verbose($"Recipe {RecipeName} is not in the lookup of known recipes");
}
}
}
static UltraleapPackageInstaller()
{
if (!EditorPreferences.Get($"{nameof(UltraleapPackageInstaller)}", false))
{
EditorPreferences.Set($"{nameof(UltraleapPackageInstaller)}", PackageInstaller.TryInstallAssets(HiddenPath, DefaultPath));
}
}
public void CallDownloadFourTimesAndRemoveTwoTimes_WithOneDependencyInTheList()
{
// Arrange
var downloaderMock = new Mock <IDownloader>();
var projectMock = new Mock <IProject>();
var packageMock = new Mock <IPackage>();
var packageDependencyMock = new Mock <IPackage>();
projectMock.Setup(p => p.PackageRepository.GetAll()).Returns(new List <IPackage>());
packageDependencyMock.Setup(p => p.Dependencies).Returns(new List <IPackage>());
packageMock.Setup(p => p.Dependencies).Returns(new List <IPackage>()
{
packageDependencyMock.Object
});
PackageInstaller packageInstaller = new PackageInstaller(downloaderMock.Object, projectMock.Object);
packageInstaller.Operation = InstallerOperation.Install;
// Act
packageInstaller.PerformOperation(packageMock.Object);
// Assert
downloaderMock.Verify(d => d.Download(It.IsAny <string>()), Times.Exactly(4));
downloaderMock.Verify(d => d.Remove(It.IsAny <string>()), Times.Exactly(2));
}
private static void CheckPackage()
{
if (!EditorPreferences.Get($"{nameof(LuminPackageInstaller)}.Profiles", false))
{
EditorPreferences.Set($"{nameof(LuminPackageInstaller)}.Profiles", PackageInstaller.TryInstallAssets(HiddenPath, $"{DefaultPath}{Path.DirectorySeparatorChar}Profiles"));
}
}
public void CallTwoTimesRemoveOfDownloader_WhenThereIsOnlyOnePackageToRestoreWithOneDependencyOnTheChain()
{
// arrange
var downloaderStub = new Mock <IDownloader>();
var projectStub = new Mock <IProject>();
downloaderStub.Setup(x => x.Remove(It.IsAny <string>()));
var packageStub = new Mock <IPackage>();
var dependencyPackage = new Mock <IPackage>();
var dependenciesOfDependency = new List <IPackage>();
dependencyPackage.Setup(x => x.Dependencies).Returns(dependenciesOfDependency);
var dependenciesList = new List <IPackage>()
{
dependencyPackage.Object
};
packageStub.Setup(x => x.Dependencies).Returns(dependenciesList);
projectStub.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>());
var installer = new PackageInstaller(downloaderStub.Object, projectStub.Object);
installer.Operation = InstallerOperation.Install;
// act
installer.PerformOperation(packageStub.Object);
// assert
downloaderStub.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2));
}
public void ShouldShowErrorIfOneOfPackagesFail()
{
var callbacks = new List <string>();
var provider = new Mock <IInstallationProvider>();
provider.Setup(
i => i.InstallPackage(It.IsAny <IPackageReference>(), It.IsAny <bool>(), It.IsAny <Action <string> >()))
.Returns(true);
provider.Setup(
i => i.InstallPackage(It.Is <IPackageReference>(x => x.PackageId == "testId"), It.IsAny <bool>(), It.IsAny <Action <string> >()))
.Returns(false);
var references = new List <IPackageReference> {
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")),
new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")),
new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0"))
};
var installer = new PackageInstaller(provider.Object);
installer.InstallPackages(references, true, msg => callbacks.Add(msg));
provider.Verify(i => i.InstallPackage(It.IsAny <IPackageReference>(), It.IsAny <bool>(), It.IsAny <Action <string> >()), Times.Exactly(3));
callbacks.Count.ShouldEqual(1);
callbacks.Count(x => x.EndsWith("unsuccessful.")).ShouldEqual(1);
}
public void InstallPackageWithDependenciesCountEqualsOne_WhenPerformOperationIsCalledWithInstallOption()
{
// Arrange
var downloaderMock = new Mock <IDownloader>();
var projectMock = new Mock <IProject>();
var packageMock = new Mock <IPackage>();
var packageDependencyMock = new Mock <IPackage>();
projectMock.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>());
packageDependencyMock.SetupGet(x => x.Dependencies).Returns(new List <IPackage>());
packageMock.Setup(x => x.Dependencies).Returns(new List <IPackage>()
{
packageDependencyMock.Object
});
var installer = new PackageInstaller(downloaderMock.Object, projectMock.Object);
installer.Operation = InstallerOperation.Install;
// Act
installer.PerformOperation(packageMock.Object);
// Assert
downloaderMock.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2));
downloaderMock.Verify(x => x.Download(It.IsAny <string>()), Times.Exactly(4));
}
private void ThreadProc()
{
try
{
using (var installer = new PackageInstaller(SetupConfiguration, new Progress(this)))
{
installer.Install();
}
BeginInvoke(new Action(() => MainForm.SetStep(1)));
}
catch (Exception ex)
{
BeginInvoke(new Action(() =>
{
MessageBox.Show(
this,
String.Format(
Labels.UnexpectedSituation,
ex.Message
),
Program.Configuration.Title,
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
MainForm.Dispose();
}));
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The InstallPackages method installs the packages
/// </summary>
/// -----------------------------------------------------------------------------
private void InstallPackages(ref bool clearClientCache)
{
//Iterate through all the Packages
for (int index = 0; index <= Packages.Count - 1; index++)
{
PackageInstaller installer = Packages.Values[index];
//Check if package is valid
if (installer.Package.IsValid)
{
if (installer.Package.InstallerInfo.Installed || installer.Package.InstallerInfo.RepairInstall)
{
clearClientCache = true;
}
InstallerInfo.Log.AddInfo(Util.INSTALL_Start + " - " + installer.Package.Name);
installer.Install();
if (InstallerInfo.Log.Valid)
{
InstallerInfo.Log.AddInfo(Util.INSTALL_Success + " - " + installer.Package.Name);
}
else
{
InstallerInfo.Log.AddInfo(Util.INSTALL_Failed + " - " + installer.Package.Name);
}
}
else
{
InstallerInfo.Log.AddFailure(Util.INSTALL_Aborted + " - " + installer.Package.Name);
}
}
}
protected PackageInstaller CreatePackageInstaller(string filename)
{
var installer = new PackageInstaller(this.TestContext, filename);
this.Installers.Push(installer);
return(installer);
}
private async Task AddNuGetPackagesAsync(ConnectedServiceHandlerContext context, Project currentProject, Version version)
{
await context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Adding Nuget Packages");
Version packageVersion = null;
if (version.Major.Equals(3))
{
var wcfDSInstallLocation = CodeGeneratorUtils.GetWCFDSInstallLocation();
var packageSource = Path.Combine(wcfDSInstallLocation, @"bin\NuGet");
if (Directory.Exists(packageSource))
{
var files = Directory.EnumerateFiles(packageSource, "*.nupkg").ToList();
foreach (var nugetPackage in Common.Constants.V3NuGetPackages)
{
if (!files.Any(f => Regex.IsMatch(f, nugetPackage + @"(.\d){2,4}.nupkg")))
{
packageSource = Common.Constants.NuGetOnlineRepository;
}
}
}
else
{
packageSource = Common.Constants.NuGetOnlineRepository;
}
if (!PackageInstallerServices.IsPackageInstalled(currentProject, Common.Constants.V3ClientNuGetPackage))
{
PackageInstaller.InstallPackage(packageSource, currentProject, Common.Constants.V3ClientNuGetPackage, packageVersion, false);
}
}
}
public void PerformOperation_WithInstallCommandAndEmptyDependencies_ShouldCallDownloadTwiceAndRemoveOnce()
{
// Arrange
var downloadMock = new Mock <IDownloader>();
downloadMock.Setup(d => d.Download(It.IsAny <string>()));
downloadMock.Setup(d => d.Remove(It.IsAny <string>()));
var packageDependencyMock = new Mock <IPackage>();
var packageMock = new Mock <IPackage>();
packageMock.SetupGet(p => p.Name).Returns("Name");
packageMock.SetupGet(p => p.Url).Returns("URLURL");
packageMock.SetupGet(p => p.Dependencies).Returns(new HashSet <IPackage>()
{
});
var packageRepo = new List <IPackage>();
var projectMock = new Mock <IProject>();
projectMock.Setup(p => p.PackageRepository.GetAll()).Returns(new List <IPackage>()
{
packageMock.Object
});
projectMock.Setup(p => p.PackageRepository.Add(It.IsAny <IPackage>()));
// Act
var packageInstaller = new PackageInstaller(downloadMock.Object, projectMock.Object);
// Assert
downloadMock.Verify(d => d.Download(It.IsAny <string>()), Times.Exactly(2));
downloadMock.Verify(d => d.Remove(It.IsAny <string>()), Times.Once);
}
public ExecutionResult Update(InstallDto installOptions)
{
var logger = new StringLogger();
try
{
var files = Directory.GetFiles(installOptions.Directory, "*.nupkg");
if (files.Count() == 0)
{
logger.Log("No package to uninstall found, proceeding with a normal install.");
}
if (files.Count() >= 1)
{
var filename = PackageHelpers.ExtractPackageName(files.First()).Trim();
var packageInfo = new PackageInfo()
{
Name = filename.Substring(filename.LastIndexOf("\\") + 1),
Version = PackageHelpers.ExtractPackageVersion(files.First()).Trim(),
InstallationDirectory = installOptions.Directory,
Configuration = installOptions.Configuration
};
var packageRemover = new PackageRemover();
packageRemover.Logger = logger;
var additionalParams = installOptions.AdditionalParameters;
packageRemover.Remove(packageInfo, new string[] { installOptions.Directory }, additionalParams, installOptions.UninstallScript);
}
var packageInfo2 = new PackageInfo()
{
Configuration = installOptions.Configuration,
InstallationDirectory = installOptions.Directory,
Name = installOptions.Application,
Version = installOptions.Version
};
var PackageInstaller = new PackageInstaller();
PackageInstaller.Logger = logger;
PackageInstaller.Install(packageInfo2, new string[] { installOptions.Repository }, installOptions.AdditionalParameters, installOptions.InstallScript, installOptions.ConfigurationFile, installOptions.ConfigurationTransform);
return(new ExecutionResult()
{
Success = logger.Logs.All(x => !x.Error),
Log = logger.Logs
});
}
catch (Exception e)
{
logger.Log(e.InnerException != null ? e.InnerException.Message : e.Message, true);
return(new ExecutionResult()
{
Success = false,
Exception = e.InnerException != null ? e.InnerException.Message : e.Message,
Log = logger.Logs
});
}
}
public void Given_A_Valid_String_List_When_ValidateList_Then_Returns_True()
{
var installer = new PackageInstaller();
var result = installer.ValidateList(validPackages);
result.Should().BeTrue();
}
public void Given_A_ValidPackage_List_When_ExtractDependencyOrder_Then_Returns_Install_Order_List()
{
var installer = new PackageInstaller();
var result = installer.ExtractDependencyOrder(validPackages);
result.Should().Match("KittenService, Ice, Cyberportal, CamelCaser, Leetmeme, Fraudstream");
}
public void Given_A_Valid_String_When_ValidateInput_Then_Returns_True()
{
var installer = new PackageInstaller();
var result = installer.ValidateInput(simplePackages.First());
result.Should().BeTrue();
}
public void AreFilesOutOfDate_LocalLessThan_Current()
{
PackageInstaller pkgInstaller = new PackageInstaller();
IInstallSettings currentSettings = pkgInstaller.ReadInstallSettings(Consts.settingsXml01);
string filePath = this.WriteTextToTempFile(Consts.settingsXml_Version05);
bool result = pkgInstaller.AreExistingFilesOutOfDate(currentSettings, filePath);
Assert.IsTrue(result);
}
public string Execute([NotNull] string data, [NotNull] string fileName)
{
var packagePath = Upload(data, fileName);
var installer = new PackageInstaller(packagePath);
installer.Install();
return(string.Empty);
}
public override async Task AddNugetPackages()
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Adding Nuget Packages");
if (!PackageInstallerServices.IsPackageInstalled(this.Project, this.ClientNuGetPackageName))
{
Version packageVersion = null;
PackageInstaller.InstallPackage(Common.Constants.NuGetOnlineRepository, this.Project, this.ClientNuGetPackageName, packageVersion, false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Configurator"/> class. This overload
/// allows passing in a <see cref="Preprocessor"/> that can be reused and pre-configured
/// with directives not sourced from the script.
/// </summary>
/// <param name="engine">The engine to configure.</param>
/// <param name="preprocessor">The preprocessor.</param>
public Configurator(Engine engine, Preprocessor preprocessor)
{
_engine = engine;
_preprocessor = preprocessor;
_assemblyResolver = new AssemblyResolver(_scriptManager);
AssemblyLoader = new AssemblyLoader(engine.FileSystem, _assemblyResolver);
PackageInstaller = new PackageInstaller(engine.FileSystem, AssemblyLoader);
ClassCatalog = new ClassCatalog();
engine.Namespaces.Add(typeof(ScriptBase).Namespace);
}
private void InstallPackages()
{
System.Diagnostics.Stopwatch stopwatch = System.Diagnostics.Stopwatch.StartNew();
using (Trace.WithIndent().Information("Installing NuGet packages"))
{
PackageInstaller.InstallPackages();
stopwatch.Stop();
Trace.Information($"NuGet packages installed in {stopwatch.ElapsedMilliseconds} ms");
}
}
private void InstallPackages(FilePath configFilePath)
{
Stopwatch stopwatch = Stopwatch.StartNew();
using (Trace.WithIndent().Information("Installing NuGet packages"))
{
PackageInstaller.InstallPackages(configFilePath);
stopwatch.Stop();
Trace.Information($"NuGet packages installed in {stopwatch.ElapsedMilliseconds} ms");
}
}
public Configurator(Engine engine, Preprocessor preprocessor)
{
_engine = engine;
AssemblyLoader = new AssemblyLoader(_compilation, engine.FileSystem, engine.Assemblies, engine.Namespaces);
PackageInstaller = new PackageInstaller(engine.FileSystem, AssemblyLoader);
_preprocessor = preprocessor;
// Add the config namespace and assembly
engine.Namespaces.Add(typeof(ConfigScriptBase).Namespace);
engine.Assemblies.Add(typeof(ConfigScriptBase).Assembly);
}
public override async Task AddNugetPackagesAsync()
{
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Adding Nuget Packages...").ConfigureAwait(false);
foreach (var nugetPackage in Common.Constants.V3NuGetPackages)
{
await PackageInstaller.CheckAndInstallNuGetPackageAsync(Common.Constants.NuGetOnlineRepository, nugetPackage).ConfigureAwait(false);
}
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Nuget Packages were installed.").ConfigureAwait(false);
}
public PackageInstallerTests()
{
_mockLogger = new Mock<ILogger>();
_mockApp = new Mock<IApplicationEnvironment>();
_mockFileSystem = new MockFileSystem();
var applicationBasePath = @"C:\App";
_projectJsonPath = Path.Combine(applicationBasePath, "project.json");
_mockApp.Setup(app => app.ApplicationBasePath)
.Returns(applicationBasePath);
_packageInstaller = new PackageInstaller(_mockLogger.Object, _mockApp.Object, _mockFileSystem);
}
public void ShouldNotInstallExistingPackages()
{
var provider = new Mock<IInstallationProvider>();
provider.Setup(
i => i.IsInstalled(It.Is<IPackageReference>(x => x.PackageId == "testId"), It.IsAny<bool>()))
.Returns(true);
var references = new List<IPackageReference> {
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")),
new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")),
new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0"))
};
var installer = new PackageInstaller(provider.Object);
installer.InstallPackages(references);
provider.Verify(i => i.InstallPackage(It.Is<IPackageReference>(x => x.PackageId == "testId"), It.IsAny<bool>(), It.IsAny<Action<string>>()), Times.Never());
}
public void ShouldThrowArgumentNullExWhenNoPackageIdsPassed()
{
var installer = new PackageInstaller(new Mock<IInstallationProvider>().Object);
Assert.Throws<ArgumentNullException>(() => installer.InstallPackages(null));
}
public void ShouldShowSuccessIfNoneOfPackagesFail()
{
var callbacks = new List<string>();
var provider = new Mock<IInstallationProvider>();
provider.Setup(
i => i.InstallPackage(It.IsAny<IPackageReference>(), It.IsAny<bool>(), It.IsAny<Action<string>>()))
.Returns(true);
var references = new List<IPackageReference> {
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")),
new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")),
new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0"))
};
var installer = new PackageInstaller(provider.Object);
installer.InstallPackages(references, true, msg => callbacks.Add(msg));
callbacks.Count.ShouldEqual(1);
callbacks.Count(x => x.EndsWith("successful.")).ShouldEqual(1);
}
