public R Send <T>(T content)
{
PackageUtility.Check(expected: typeof(R), actual: typeof(T));
return((R)(object)content);
}
public void ExecuteMethodInvokeInstallScriptAndUninstallScript()
{
// Local repository contains Package A 1.0 and Package B
// Source repository contains Package A 2.0 and Package C
var packageA1 = PackageUtility.CreatePackage("A", "1.0", tools: new string[] { "uninstall.ps1" });
var packageA2 = PackageUtility.CreatePackage("A", "2.0", content: new string[] { "hello world" }, tools: new string[] { "install.ps1" });
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
// Arrange
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA1);
localRepository.AddPackage(packageB);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageC);
var project = new Mock <Project>();
var projectManager = CreateProjectManager(localRepository, sourceRepository);
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager);
packageManager.Setup(p => p.UpdatePackage(
projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), true, false, It.IsAny <ILogger>())).Callback(
() =>
{
projectManager.AddPackageReference("A", new SemanticVersion("2.0"), false, false);
});
var scriptExecutor = new Mock <IScriptExecutor>();
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateUpdatesProvider(packageManager.Object, localRepository, null, null, project.Object, scriptExecutor.Object, null, solutionManager.Object);
provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0];
var extensionA = new PackageItem(provider, packageA2);
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
try
{
scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "uninstall.ps1", packageA1, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "install.ps1", packageA2, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
}
finally
{
manualEvent.Set();
}
};
// Act
provider.Execute(extensionA);
// do not allow the method to return
manualEvent.WaitOne();
}
public void CallingEnableCurrentSolutionSetupEverythingCorrectly()
{
// Arrange
string tempSolutionPath = CreateTempFolder();
// setup SolutionManager
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.IsSolutionOpen).Returns(true);
solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath);
// setup file system
var fileSystem = new PhysicalFileSystem(tempSolutionPath);
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath, It.IsAny <bool>())).Returns(fileSystem);
var nugetFolderFileSystem = new PhysicalFileSystem(tempSolutionPath + "\\.nuget");
fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath + "\\.nuget", It.IsAny <bool>())).Returns(nugetFolderFileSystem);
// default app settings
var defaultAppSettings = new Mock <ISettings>();
defaultAppSettings.Setup(s => s.GetValue("packageRestore", "enabled")).Returns("false");
// setup DTE
var dte = new Mock <DTE>();
var projectItems = new Mock <ProjectItems>();
var solutionFolder = new Mock <Project>();
solutionFolder.Setup(s => s.Name).Returns(".nuget");
solutionFolder.SetupGet(s => s.ProjectItems).Returns(projectItems.Object);
var solution = new Mock <Solution>();
solution.As <Solution2>().Setup(p => p.AddSolutionFolder(".nuget")).Returns(solutionFolder.Object);
var projects = new MockProjects(new Project[0]);
solution.As <Solution2>().Setup(s => s.Projects).Returns(projects);
dte.SetupGet(p => p.Solution).Returns(solution.Object);
// setup package repository
var packageRepository = new MockPackageRepository();
packageRepository.Add(PackageUtility.CreatePackage(
"NuGet.Build",
version: "1.0",
tools: new string[] { "NuGet.targets" },
dependencies: new PackageDependency[] { new PackageDependency("NuGet.CommandLine") }));
packageRepository.Add(PackageUtility.CreatePackage(
"NuGet.CommandLine",
version: "1.0",
tools: new string[] { "NuGet.exe" }));
var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>();
packageRepositoryFactory.Setup(p => p.CreateRepository(NuGetConstants.DefaultFeedUrl)).Returns(packageRepository);
var packageSourceProvider = new Mock <IPackageSourceProvider>();
packageSourceProvider.Setup(p => p.LoadPackageSources()).Returns(new[]
{
new PackageSource(NuGetConstants.DefaultFeedUrl)
});
var packageRestore = CreateInstance(
dte.Object,
solutionManager.Object,
fileSystemProvider.Object,
packageRepositoryFactory.Object,
packageSourceProvider: packageSourceProvider.Object,
settings: defaultAppSettings.Object);
// Act
packageRestore.EnableCurrentSolutionForRestore(fromActivation: false);
// Assert
// verify that the files are copied to the .nuget sub folder under solution
Assert.True(Directory.Exists(Path.Combine(tempSolutionPath, ".nuget")));
Assert.True(File.Exists(Path.Combine(tempSolutionPath, ".nuget\\NuGet.exe")));
Assert.True(File.Exists(Path.Combine(tempSolutionPath, ".nuget\\NuGet.targets")));
// verify that solution folder 'nuget' is added to solution
solution.As <Solution2>().Verify(p => p.AddSolutionFolder(".nuget"));
projectItems.Verify(p => p.AddFromFile(tempSolutionPath + "\\.nuget\\NuGet.exe"));
projectItems.Verify(p => p.AddFromFile(tempSolutionPath + "\\.nuget\\NuGet.targets"));
// verify that the Source Control mode is disabled
var settings = new Settings(nugetFolderFileSystem);
Assert.True(settings.IsSourceControlDisabled());
// verify that package restore consent is not set
defaultAppSettings.Verify(
s => s.SetValue("packageRestore", "enabled", It.Is <string>(v => v == "true" || v == "1")), Times.Never());
// clean up
Directory.Delete(tempSolutionPath, recursive: true);
}
private static IEnumerable <IPackage> GetPackagesWithException()
{
yield return(PackageUtility.CreatePackage("Baz"));
throw new InvalidOperationException("Boom");
}
private async Task <bool> ProcessPackageDetailsViaStorageAsync(
string packageId,
string normalizedPackageVersion,
PackageDetailsCatalogLeaf catalogLeaf,
Dictionary <string, string> telemetryProperties,
CancellationToken cancellationToken)
{
if (_sourceStorage == null)
{
return(false);
}
var packageFileName = PackageUtility.GetPackageFileName(packageId, normalizedPackageVersion);
var sourceUri = _sourceStorage.ResolveUri(packageFileName);
var sourceBlob = await _sourceStorage.GetCloudBlockBlobReferenceAsync(sourceUri);
if (await sourceBlob.ExistsAsync(cancellationToken))
{
// It's possible (though unlikely) that the blob may change between reads. Reading a blob with a
// single GET request returns the whole blob in a consistent state, but we're reading the blob many
// different times. To detect the blob changing between reads, we check the ETag again later.
// If the ETag's differ, we'll fall back to using a single HTTP GET request.
var token1 = await _sourceStorage.GetOptimisticConcurrencyControlTokenAsync(sourceUri, cancellationToken);
telemetryProperties[TelemetryConstants.SizeInBytes] = sourceBlob.Length.ToString();
var nuspec = await GetNuspecAsync(sourceBlob, packageId, cancellationToken);
if (string.IsNullOrEmpty(nuspec))
{
_logger.LogWarning(
"No .nuspec available for {Id}/{Version}. Falling back to HTTP processing.",
packageId,
normalizedPackageVersion);
}
else
{
await _dnxMaker.AddPackageAsync(
_sourceStorage,
nuspec,
packageId,
normalizedPackageVersion,
catalogLeaf.IconFile,
cancellationToken);
var token2 = await _sourceStorage.GetOptimisticConcurrencyControlTokenAsync(sourceUri, cancellationToken);
if (token1 == token2)
{
_logger.LogInformation("Added .nupkg and .nuspec for package {Id}/{Version}", packageId, normalizedPackageVersion);
return(true);
}
else
{
_telemetryService.TrackMetric(
TelemetryConstants.BlobModified,
metric: 1,
properties: GetTelemetryProperties(packageId, normalizedPackageVersion));
}
}
}
else
{
_telemetryService.TrackMetric(
TelemetryConstants.NonExistentBlob,
metric: 1,
properties: GetTelemetryProperties(packageId, normalizedPackageVersion));
}
return(false);
}
public void SearchTreeNodeHonorsTheIncludePrereleaseAttribute(bool includePrerelease, string expectedVersion)
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("packageA", "1.0");
var packageA2 = PackageUtility.CreatePackage("packageA", "2.0-alpha");
var packageC = PackageUtility.CreatePackage("packageB", "3.0.0.0-rtm");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageA1);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA2);
var projectManager = new Mock <IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var project = new Mock <Project>();
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, project: project.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA2);
firstTreeNode.Repository.AddPackage(packageA1);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
mockPackageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
var manualEvent = new ManualResetEventSlim(false);
// Act 1
var treeNode = (PackagesTreeNodeBase)provider.Search("packageA");
Assert.NotNull(treeNode);
Exception exception = null;
treeNode.PackageLoadCompleted += (o, e) =>
{
try
{
var packages = treeNode.Extensions.OfType <PackageItem>().ToList();
Assert.Equal(1, packages.Count);
AssertPackage(packages[0].PackageIdentity, "packageA", expectedVersion);
}
catch (Exception ex)
{
exception = ex;
}
finally
{
manualEvent.Set();
}
};
// trigger loading packages
var extensions = treeNode.Extensions;
// do not allow the method to return
manualEvent.Wait();
if (exception != null)
{
throw exception;
}
}
public override void Execute()
{
if (!Package.ExecutionInfo.MakeBackup)
{
return;
}
//////////////////////////////////
// Copy files to the Backup directory
String dispIconFn = null;
String uninstallerPath = P.Combine(Package.ExecutionInfo.BackupDirectory.FullName, "Uninstall.exe");
String thisInstallerPath = Assembly.GetExecutingAssembly().Location;
File.Copy(thisInstallerPath, uninstallerPath, true);
if (!String.IsNullOrEmpty(DisplayIcon))
{
FileInfo iconSrc = Package.RootDirectory.GetFile(DisplayIcon);
if (iconSrc.Exists)
{
dispIconFn = PackageUtility.GetUnusedFileName(P.Combine(Package.ExecutionInfo.BackupDirectory.FullName, "DisplayIcon.ico"));
iconSrc.CopyTo(dispIconFn);
}
else
{
Package.Log.Add(Anolis.Core.Utility.LogSeverity.Error, "Could not find DisplayIcon: " + DisplayIcon);
}
}
//////////////////////////////////
// Add the registry key
RegistryKey uninstallKey = Registry.LocalMachine.CreateSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", RegistryKeyPermissionCheck.ReadWriteSubTree);
String regKeyName = "Anolis" + Package.ExecutionInfo.BackupDirectory.Name;
RegistryKey prodKey = uninstallKey.CreateSubKey(regKeyName);
prodKey.SetValue("DisplayName", Package.Name, RegistryValueKind.String);
if (dispIconFn != null)
{
prodKey.SetValue("DisplayIcon", dispIconFn, RegistryValueKind.String);
}
prodKey.SetValue("UninstallString", uninstallerPath + " /uninstall:package.xml", RegistryValueKind.String);
if (Package.Website != null)
{
prodKey.SetValue("HelpLink", Package.Website.OriginalString, RegistryValueKind.String);
}
prodKey.SetValue("Publisher", Package.Attribution, RegistryValueKind.String);
prodKey.SetValue("InstallDate", DateTime.Now.ToString("yyyyMMdd"), RegistryValueKind.String);
prodKey.SetValue("DisplayVersion", Package.Version.ToString(), RegistryValueKind.String);
prodKey.SetValue("Version", Package.Version.Major, RegistryValueKind.DWord); // I've no idea what the convention for the 'Version' value is
prodKey.SetValue("VersionMajor", Package.Version.Major, RegistryValueKind.DWord);
prodKey.SetValue("VersionMinor", Package.Version.Minor, RegistryValueKind.DWord);
String fullKeyPath = uninstallKey.Name + '\\' + regKeyName;
Backup(Package.ExecutionInfo.BackupGroup, fullKeyPath);
prodKey.Close();
uninstallKey.Close();
}
public override void Execute()
{
FileAssociations assoc = FileAssociations.GetAssociations();
Backup(assoc, Package.ExecutionInfo.BackupGroup);
List <String> extsToDeleteOnUninstall = new List <String>();
List <String> progidsToDeleteOnUninstall = new List <String>();
List <String> iconFilesToDeleteOnUninstall = new List <String>();
DirectoryInfo iconsDir = new DirectoryInfo(PackageUtility.ResolvePath(@"%windir%\Resources\Icons"));
if (!iconsDir.Exists)
{
iconsDir.Create();
}
foreach (FileTypeSetting setting in _types)
{
if (!setting.TypeExt.StartsWith(".", StringComparison.Ordinal))
{
Package.Log.Add(LogSeverity.Warning, "Invalid extension, must start with '.': " + setting.TypeExt);
continue;
}
FileType targetType = null;
FileExtension targetExtension = null;
// get the type for this extension
foreach (FileExtension ext in assoc.AllExtensions)
{
if (String.Equals(ext.Extension, setting.TypeExt, StringComparison.OrdinalIgnoreCase))
{
targetExtension = ext;
break;
}
}
if (targetExtension == null)
{
// create type and extension
Package.Log.Add(LogSeverity.Info, "Extension undefined: \"" + setting.TypeExt + "\". Creating FileType and FileExtension");
targetType = assoc.CreateFileType(assoc.GetUnusedProgIdForExtension(setting.TypeExt));
targetType.FriendlyName = setting.FriendlyName;
targetExtension = assoc.CreateFileExtension(setting.TypeExt);
targetExtension.FileType = targetType;
extsToDeleteOnUninstall.Add(targetExtension.Extension);
progidsToDeleteOnUninstall.Add(targetType.ProgId);
}
else
{
targetType = targetExtension.FileType;
if (targetType == null)
{
// create the type
Package.Log.Add(LogSeverity.Info, "Extension defined : \"" + setting.TypeExt + "\", but FileType undefined. Creating FileType");
String newProgid = assoc.GetUnusedProgIdForExtension(setting.TypeExt);
targetType = assoc.CreateFileType(newProgid);
targetType.FriendlyName = setting.FriendlyName;
targetExtension.FileType = targetType;
progidsToDeleteOnUninstall.Add(newProgid);
}
}
////////////////////////
// copy the icon files to %windir%\Resources\Icons
FileInfo iconFile = Package.RootDirectory.GetFile(setting.Icon);
String destinationFileName = P.Combine(iconsDir.FullName, iconFile.Name);
iconFile.CopyTo(destinationFileName, true);
iconFilesToDeleteOnUninstall.Add(destinationFileName);
targetType.DefaultIcon = destinationFileName;
targetType.IsDirty = true;
}
assoc.CommitChanges();
BackupPart2(Package.ExecutionInfo.BackupGroup, progidsToDeleteOnUninstall, extsToDeleteOnUninstall, iconFilesToDeleteOnUninstall);
}
public Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext)
{
var package = (Package)entity;
return(PackageUtility.GetPackageUrl(package.Id, package.Version, operationContext.AbsoluteServiceUri));
}
private async Task <PackageCatalogItem> GetPackageViaStorageAsync(
FeedPackageDetails packageItem,
CancellationToken cancellationToken)
{
PackageCatalogItem item = null;
var packageId = packageItem.PackageId.ToLowerInvariant();
var packageNormalizedVersion = packageItem.PackageNormalizedVersion.ToLowerInvariant();
var packageFileName = PackageUtility.GetPackageFileName(packageId, packageNormalizedVersion);
var blobUri = _storage.ResolveUri(packageFileName);
var blob = await _storage.GetCloudBlockBlobReferenceAsync(blobUri);
if (!await blob.ExistsAsync(cancellationToken))
{
_telemetryService.TrackMetric(
TelemetryConstants.NonExistentBlob,
metric: 1,
properties: GetProperties(packageId, packageNormalizedVersion, blob));
return(item);
}
using (_telemetryService.TrackDuration(
TelemetryConstants.PackageBlobReadSeconds,
GetProperties(packageId, packageNormalizedVersion, blob: null)))
{
await blob.FetchAttributesAsync(cancellationToken);
string packageHash = null;
var etag = blob.ETag;
var metadata = await blob.GetMetadataAsync(cancellationToken);
if (metadata.TryGetValue(Constants.Sha512, out packageHash))
{
using (var stream = await blob.GetStreamAsync(cancellationToken))
{
item = Utils.CreateCatalogItem(
packageItem.ContentUri.ToString(),
stream,
packageItem.CreatedDate,
packageItem.LastEditedDate,
packageItem.PublishedDate,
licenseNames: null,
licenseReportUrl: null,
packageHash: packageHash,
deprecationItem: packageItem.DeprecationInfo);
if (item == null)
{
_logger.LogWarning("Unable to extract metadata from: {PackageDetailsContentUri}", packageItem.ContentUri);
}
}
if (item != null)
{
// Since obtaining the ETag the first time, it's possible (though unlikely) that the blob may
// have changed. Although reading a blob with a single GET request should return the whole
// blob in a consistent state, we're reading the blob using ZipArchive and a seekable stream,
// which results in many GET requests. To guard against the blob having changed since we
// obtained the package hash, we check the ETag one more time. If this check fails, we'll
// fallback to using a single HTTP GET request.
await blob.FetchAttributesAsync(cancellationToken);
if (etag != blob.ETag)
{
item = null;
_telemetryService.TrackMetric(
TelemetryConstants.BlobModified,
metric: 1,
properties: GetProperties(packageId, packageNormalizedVersion, blob));
}
}
}
else
{
_telemetryService.TrackMetric(
TelemetryConstants.NonExistentPackageHash,
metric: 1,
properties: GetProperties(packageId, packageNormalizedVersion, blob));
}
}
return(item);
}
protected override Boolean PatchFile(String fileName)
{
List <PatchResource> patchResources = new List <PatchResource>();
foreach (PatchResourceSet set in _resourceSets)
{
if (EvaluatePatchResourceSet(set, fileName))
{
// HACK: This just adds them together into a massive list. If the same name is mentioned it'll be overwritten several times
// fortunately it isnt' very expensive as only the last "final" one counts, but could do with filtering at this stage maybe?
patchResources.AddRange(set.Resources);
}
else
{
Package.Log.Add(LogSeverity.Info, "Expression evaluation non-one: " + set.Condition.ExpressionString + ", did not process " + set.Resources.Count + " resources");
}
}
if (patchResources.Count == 0)
{
Package.Log.Add(LogSeverity.Warning, "No resources to patch: " + fileName);
return(false);
}
try {
// for now, use lazy-load under all circumstances. In future analyse the Resources list to see if it's necessary or not
// but the performance impact is minimal and it's the safest option, so keep it as it is
using (ResourceSource source = ResourceSource.Open(fileName, false, ResourceSourceLoadMode.LazyLoadData)) {
List <String> tempFiles = new List <String>();
foreach (PatchResource res in patchResources)
{
if (res.Source.StartsWith("comp:", StringComparison.OrdinalIgnoreCase))
{
CompositedImage comp = new CompositedImage(res.Source, Package.RootDirectory);
DirectoryInfo packageTempDirectory = new DirectoryInfo(P.Combine(Package.RootDirectory.FullName, "Temp"));
if (!packageTempDirectory.Exists)
{
packageTempDirectory.Create();
}
// I think not using the *.bmp extension messes up Bitmap import
String tempFileName = PackageUtility.GetUnusedFileName(P.Combine(packageTempDirectory.FullName, P.GetFileName(Path) + res.Name) + ".bmp");
comp.Save(tempFileName, System.Drawing.Imaging.ImageFormat.Bmp);
res.File = tempFileName;
tempFiles.Add(tempFileName);
}
else
{
res.File = res.Source;
}
if (!File.Exists(res.File))
{
Package.Log.Add(LogSeverity.Error, "Data File not found: " + res.File);
continue;
}
ResourceTypeIdentifier typeId = ResourceTypeIdentifier.CreateFromString(res.Type, true);
ResourceIdentifier nameId = ResourceIdentifier.CreateFromString(res.Name);
UInt16 langId = String.IsNullOrEmpty(res.Lang) ? UInt16.MaxValue : UInt16.Parse(res.Lang, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture);
if (langId == UInt16.MaxValue) // if the lang="" attribute was not specified
{
ResourceName name = source.GetName(typeId, nameId);
if (name == null) // if the specified name does not exist
{
if (res.Add)
{
UInt16 sysLang = (UInt16)CultureInfo.InvariantCulture.LCID;
ResourceData data = ResourceData.FromFileToAdd(res.File, sysLang, source);
source.Add(typeId, nameId, sysLang, data);
}
else
{
// Error
String sourcePath = source.Name;
Anolis.Core.Source.FileResourceSource frs = source as Anolis.Core.Source.FileResourceSource;
if (frs != null)
{
sourcePath = frs.FileInfo.FullName;
}
Package.Log.Add(LogSeverity.Warning, "Resource name not found: " + sourcePath + '\\' + typeId.ToString() + '\\' + nameId.FriendlyName);
}
}
else
{
foreach (ResourceLang lang in name.Langs)
{
ResourceData data = ResourceData.FromFileToUpdate(res.File, lang);
lang.SwapData(data);
}
}
}
else // if the lang="" attribute was specified
{
ResourceLang lang = source.GetLang(typeId, nameId, langId);
if (lang == null)
{
ResourceData data = ResourceData.FromFileToAdd(res.File, langId, source);
source.Add(typeId, nameId, langId, data);
}
else
{
ResourceData data = ResourceData.FromFileToUpdate(res.File, lang);
lang.SwapData(data);
}
}
} //foreach
// note that Win32ResourceSource now recomptues the PE checksum by itself
source.CommitChanges();
foreach (String tempFile in tempFiles)
{
File.Delete(tempFile);
}
return(true);
} //using source
} catch (AnolisException aex) {
Package.Log.Add(LogSeverity.Error, "Patch Exception: " + aex.Message);
if (File.Exists(fileName))
{
File.Delete(fileName);
}
throw;
}
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
packageManager.Verify(p => p.InstallPackage(
projectManager1.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
packageManager.Verify(p => p.InstallPackage(
projectManager2.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void SolutionInstalledProviderShowsAllVersions()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageA2);
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
firstTreeNode.IsSelected = true;
var mre = new ManualResetEventSlim(false);
firstTreeNode.PackageLoadCompleted += delegate
{
var allExtensions = firstTreeNode.Extensions;
// Assert
Assert.Equal(3, allExtensions.Count);
Assert.Equal("A", allExtensions[0].Id);
Assert.Equal("1.0", ((PackageItem)allExtensions[0]).Version);
Assert.Equal("A", allExtensions[1].Id);
Assert.Equal("2.0", ((PackageItem)allExtensions[1]).Version);
Assert.Equal("B", allExtensions[2].Id);
Assert.Equal("2.0", ((PackageItem)allExtensions[2]).Version);
mre.Set();
};
// Act
var ignore = firstTreeNode.Extensions;
mre.Wait();
}
/// <summary>
/// Runs candle.exe on the source files to generate a list of wixobj intermediate files.
/// </summary>
/// <param name="outputPane">The window to which to output build messages.</param>
/// <returns><see langword="true"/> if successful; otherwise, <see langword="false"/>.</returns>
private bool Compile(IVsOutputWindowPane outputPane)
{
Tracer.VerifyNonNullArgument(outputPane, "outputPane");
string projectRootDirectory = this.Project.RootDirectory;
// Get the list of source files that should be built
string[] sourceFiles = this.GetOutOfDateSourceFiles();
// If we don't have anything to compile, then just show a message indicating that
if (sourceFiles.Length == 0)
{
this.WriteLineToOutputWindow("Compile targets are up to date.");
this.WriteLineToOutputWindow();
return(true);
}
string[] objectFiles = this.Candle.GetOutputFiles(sourceFiles);
string candleParams = this.Candle.ConstructCommandLineParameters(projectRootDirectory, sourceFiles);
string toolsPath = WixPackage.Instance.Context.Settings.ToolsDirectory;
// Do not quote the path here. It will be quoted in the LaunchPad
string candleExePath = PackageUtility.CanonicalizeFilePath(Path.Combine(toolsPath, "candle.exe"));
// See if candle exists
if (!File.Exists(candleExePath))
{
this.WriteLineToOutputWindow("Error: Cannot find candle.exe at '{0}'.", candleExePath);
this.WriteLineToOutputWindow();
return(false);
}
// Create the launch pad used for compilation.
LaunchPad candleLaunchPad = new LaunchPad(candleExePath, candleParams);
candleLaunchPad.WorkingDirectory = projectRootDirectory;
// Output the candle command line to the build output window.
Tracer.WriteLineInformation(classType, "Compile", "Performing main compilation...");
this.WriteLineToOutputWindow("Performing main compilation...");
this.WriteLineToOutputWindow(candleLaunchPad.CommandLine);
this.WriteLineToOutputWindow();
// Tick once and see if we should continue.
if (!this.TickBuild())
{
return(false);
}
// Make sure the output directory exists.
string outputDir = this.Candle.AbsoluteOutputDirectory;
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
// Delete the existing .wixobj files if they exist.
this.CleanCompileOutput(sourceFiles);
// Execute candle.exe piping the output to the output build window and the task pane.
bool successful = (candleLaunchPad.ExecuteCommand(outputPane, this) == 0);
// Clean up the temporary candle files after the compile has completed.
this.Candle.CleanTemporaryFiles();
return(successful);
}
public void ExecuteMethodDoNotCallInstallPackageIfUserDoesNotSelectAnyProject()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
mockPackageManager.Verify(p => p.InstallPackage(
It.IsAny <IEnumerable <Project> >(),
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
false,
provider,
provider), Times.Never());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void ExecuteAllMethodCallUpdateAllPackageOnAllProjects(bool includePrerelease)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var packageB2 = PackageUtility.CreatePackage("B", "4.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageB2);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var extensionB2 = new PackageItem(provider, packageB2);
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
firstTreeNode.Extensions.Add(extensionB2);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation);
mockPackageManager.Verify(
p => p.UpdatePackages(true, includePrerelease, provider, provider),
Times.Once());
}
catch (Exception ex)
{
exception = ex;
}
finally
{
manualEvent.Set();
}
};
// Act
provider.Execute(item: null);
// do not allow the method to return
manualEvent.Wait();
Assert.Null(exception);
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager(bool includePrerelease)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager = new Mock <IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var project = new Mock <Project>();
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, project: project.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
mockPackageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
Assert.Equal(RepositoryOperationNames.Install, sourceRepository.LastOperation);
mockPackageManager.Verify(p => p.InstallPackage(projectManager.Object, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, includePrerelease, provider), Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.WaitOne();
}
public void ExecuteUninstallsSolutionLevelPackageWhenUpdating()
{
// Arrange
var packageA_10 = PackageUtility.CreatePackage("A", "1.0", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var packageA_12 = PackageUtility.CreatePackage("A", "1.2", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA_12);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA_10);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.LocalRepository).Returns(localRepository);
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(packageA_12)).Returns(false);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA_10);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
mockPackageManager.Verify(p => p.UpdatePackage(
new Project[0],
packageA_12,
new[] { new PackageOperation(packageA_10, PackageAction.Uninstall), new PackageOperation(packageA_12, PackageAction.Install) },
true,
false,
provider,
provider), Times.Once());
}
catch (Exception e)
{
exception = e;
}
finally
{
manualEvent.Set();
}
};
var extensionA_12 = new PackageItem(provider, packageA_12);
// Act
provider.Execute(extensionA_12);
// do not allow the method to return
manualEvent.Wait();
Assert.Null(exception);
}
public void ExecuteMethodInstallPackagesWithInitScript()
{
// source repo has A, B, C
// solution repo has A
// project repo has C
// install B
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0", content: new string[] { "hello world" }, tools: new string[] { "init.ps1" });
var packageC = PackageUtility.CreatePackage("C", "3.0");
var solutionRepository = new MockPackageRepository();
solutionRepository.AddPackage(packageA);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
var localRepository = new MockPackageRepository();
localRepository.Add(packageC);
var projectManager = CreateProjectManager(localRepository, solutionRepository);
var project = new Mock <Project>();
project.Setup(p => p.Properties.Item("TargetFrameworkMoniker").Value).Returns(".NETFramework, Version=4.0");
var scriptExecutor = new Mock <IScriptExecutor>();
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.LocalRepository).Returns(solutionRepository);
packageManager.Setup(p => p.InstallPackage(projectManager, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>())).
Raises(p => p.PackageInstalled += null, packageManager, new PackageOperationEventArgs(packageB, null, ""));
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var provider = CreateOnlineProvider(packageManager.Object, null, null, null, project.Object, scriptExecutor.Object, solutionManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
ManualResetEvent manualEvent = new ManualResetEvent(false);
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
// init.ps1 should be executed
scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), PowerShellScripts.Init, packageB, null, null, It.IsAny <ILogger>()), Times.Once());
// InstallPackage() should get called
packageManager.Verify(p => p.InstallPackage(
projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>()), Times.Once());
}
finally
{
manualEvent.Set();
}
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.WaitOne();
}
public static void MarkPackagesForReinstallationMarksPackagesProperly()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.0"" targetFramework=""net30""/>
<package id=""B"" version=""1.0""/>
<package id=""C"" version=""1.0"" targetFramework=""net40""/>
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
IList<IPackage> packagesToBeReinstalled = new List<IPackage>() { PackageUtility.CreatePackage("A", "1.0"), PackageUtility.CreatePackage("C", "1.0") };
// Act
ProjectRetargetingUtility.MarkPackagesForReinstallation(packageReferenceFile, packagesToBeReinstalled);
var packageReferences = packageReferenceFile.GetPackageReferences().ToList();
// Assert
Assert.Equal(3, packageReferences.Count);
Assert.Equal("A", packageReferences[0].Id);
Assert.Equal("B", packageReferences[1].Id);
Assert.Equal("C", packageReferences[2].Id);
Assert.True(packageReferences[0].RequireReinstallation);
Assert.False(packageReferences[1].RequireReinstallation);
Assert.True(packageReferences[2].RequireReinstallation);
}
private static IPackageRepositoryFactory GetFactory()
{
var repositoryA = new MockPackageRepository {
PackageUtility.CreatePackage("Foo"), PackageUtility.CreatePackage("Baz", "0.4"), PackageUtility.CreatePackage("Baz", "0.7")
};
var repositoryB = new MockPackageRepository {
PackageUtility.CreatePackage("Bar", "0.5"), PackageUtility.CreatePackage("Baz", "0.8.1-alpha")
};
var factory = new Mock <IPackageRepositoryFactory>();
factory.Setup(c => c.CreateRepository(It.Is <string>(f => f.Equals("Some source")))).Returns(repositoryA);
factory.Setup(c => c.CreateRepository(It.Is <string>(f => f.Equals("Some other source")))).Returns(repositoryB);
return(factory.Object);
}
public void FallbackRepositoryUsesDependencyResolverIfPrimaryRepositoryDoesNotHaveRequiredDependency()
{
// Arrange
IPackage packageA10 = PackageUtility.CreatePackage("M1", "1.0"), packageA11 = PackageUtility.CreatePackage("M2", "1.1");
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(packageA10);
var dependencyResolver = new MockPackageRepository();
dependencyResolver.AddPackage(packageA11);
var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec {
MinVersion = new SemanticVersion("1.0.1")
}), false, false);
// Assert
Assert.Same(resolvedPackage, packageA11);
}
private async Task <IEnumerable <CatalogEntry> > ProcessCatalogEntriesAsync(
CollectorHttpClient client,
IEnumerable <CatalogEntry> catalogEntries,
CancellationToken cancellationToken)
{
var processedCatalogEntries = new ConcurrentBag <CatalogEntry>();
await catalogEntries.ForEachAsync(_maxConcurrentCommitItemsWithinBatch, async catalogEntry =>
{
var packageId = catalogEntry.PackageId;
var normalizedPackageVersion = catalogEntry.NormalizedPackageVersion;
if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDetails.AbsoluteUri)
{
var telemetryProperties = GetTelemetryProperties(catalogEntry);
using (_telemetryService.TrackDuration(TelemetryConstants.ProcessPackageDetailsSeconds, telemetryProperties))
{
var packageFileName = PackageUtility.GetPackageFileName(
packageId,
normalizedPackageVersion);
var sourceUri = new Uri(_contentBaseAddress, packageFileName);
var destinationStorage = _storageFactory.Create(packageId);
var destinationRelativeUri = DnxMaker.GetRelativeAddressNupkg(
packageId,
normalizedPackageVersion);
var destinationUri = destinationStorage.GetUri(destinationRelativeUri);
var isNupkgSynchronized = await destinationStorage.AreSynchronized(sourceUri, destinationUri);
var isPackageInIndex = await _dnxMaker.HasPackageInIndexAsync(
destinationStorage,
packageId,
normalizedPackageVersion,
cancellationToken);
var areRequiredPropertiesPresent = await AreRequiredPropertiesPresentAsync(destinationStorage, destinationUri);
if (isNupkgSynchronized && isPackageInIndex && areRequiredPropertiesPresent)
{
_logger.LogInformation("No changes detected: {Id}/{Version}", packageId, normalizedPackageVersion);
return;
}
if ((isNupkgSynchronized && areRequiredPropertiesPresent) ||
await ProcessPackageDetailsAsync(
client,
packageId,
normalizedPackageVersion,
sourceUri,
catalogEntry.Uri,
telemetryProperties,
cancellationToken))
{
processedCatalogEntries.Add(catalogEntry);
}
}
}
else if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDelete.AbsoluteUri)
{
var properties = GetTelemetryProperties(catalogEntry);
using (_telemetryService.TrackDuration(TelemetryConstants.ProcessPackageDeleteSeconds, properties))
{
await ProcessPackageDeleteAsync(packageId, normalizedPackageVersion, cancellationToken);
processedCatalogEntries.Add(catalogEntry);
}
}
});
return(processedCatalogEntries);
}
private void SelectPackagePage_PageUnload(object sender, W3b.Wizards.PageChangeEventArgs e)
{
if (InstallerResources.IsCustomized && InstallerResources.CustomizedSettings.SimpleUI)
{
return;
}
if (e.PageToBeLoaded == Program.PageBMainAction)
{
return;
}
if (__embedRad.Checked)
{
if (__embedList.SelectedItem == null)
{
MessageBox.Show(this, InstallerResources.GetString("C_A_selectEmbeddedPackageFirst"), "Anolis Installer", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
e.Cancel = true;
return;
}
EmbeddedPackage package = __embedList.SelectedItem as EmbeddedPackage;
Stream stream = PackageUtility.GetEmbeddedPackage(package);
PackageInfo.Source = PackageSource.Embedded;
PackageInfo.SourcePath = package.Name;
PackageInfo.Archive = PackageArchive.FromStream(package.Name, PackageSubclass.LzmaTarball, stream);
}
else if (__packRad.Checked)
{
if (!File.Exists(__packFilename.Text))
{
String message = String.Format(CultureInfo.InvariantCulture, InstallerResources.GetString("C_A_notFileExists"), __anopFilename.Text);
MessageBox.Show(this, message, "Anolis Installer", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
e.Cancel = true;
return;
}
String packageName = new DirectoryInfo(Path.GetDirectoryName(__packFilename.Text)).Name;
PackageInfo.Source = PackageSource.File;
PackageInfo.SourcePath = __packFilename.Text;
}
else if (__anopRad.Checked)
{
if (!File.Exists(__anopFilename.Text))
{
String message = String.Format(CultureInfo.InvariantCulture, InstallerResources.GetString("C_A_notFileExists"), __anopFilename.Text);
MessageBox.Show(this, message, "Anolis Installer", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
e.Cancel = true;
return;
}
String packageName = Path.GetFileNameWithoutExtension(__anopFilename.Text);
Stream stream = File.OpenRead(__anopFilename.Text);
PackageInfo.Source = PackageSource.Archive;
PackageInfo.SourcePath = __anopFilename.Text;
PackageInfo.Archive = PackageArchive.FromStream(packageName, PackageSubclass.LzmaTarball, stream);
}
}
public void ExecuteAllMethodCallsUpdatePackagesMethodOnPackageManager(bool includePrerelease)
{
// Local repository contains Package A 1.0 and Package B
// Source repository contains Package A 2.0 and Package C
var packageA1 = PackageUtility.CreatePackage("A", "1.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
// Arrange
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA1);
localRepository.AddPackage(packageB);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageC);
var project = new Mock <Project>();
var projectManager = new Mock <IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(localRepository);
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object);
var mockWindowServices = new Mock <IUserNotifierServices>();
var provider = CreateUpdatesProvider(packageManager.Object, localRepository, project: project.Object, userNotifierServices: mockWindowServices.Object, solutionManager: solutionManager.Object);
provider.IncludePrerelease = includePrerelease;
var extensionA = new PackageItem(provider, packageA2);
var extensionC = new PackageItem(provider, packageC);
provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0];
var allExtensions = provider.SelectedNode.Extensions;
allExtensions.Add(extensionA);
allExtensions.Add(extensionC);
var manualEvent = new ManualResetEvent(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation);
mockWindowServices.Verify(p => p.ShowLicenseWindow(It.IsAny <IEnumerable <IPackage> >()), Times.Never());
packageManager.Verify(p => p.UpdatePackages(projectManager.Object, true, includePrerelease, provider), Times.Once());
}
catch (Exception ex)
{
exception = ex;
}
finally
{
manualEvent.Set();
}
};
// Act
provider.Execute(item: null);
// do not allow the method to return
manualEvent.WaitOne();
Assert.Null(exception);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
// Switches to the UI thread in order to consume some services used in command initialization
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
await RegisterVsServicesAsync();
mCommandController = new CommandController(this);
CommandTestUtility.CommandController = mCommandController;
var vsOutputWindow = VsServiceProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;
mOutputWindowController = new OutputWindowController();
mOutputWindowController.Initialize(this, vsOutputWindow);
mRunningDocTableEvents = new RunningDocTableEvents(this);
mErrorWindowController = new ErrorWindowController(this);
#region Get Pointer to IVsSolutionEvents
if (VsServiceProvider.TryGetService(typeof(SVsSolution), out object vsSolutionService))
{
var vsSolution = vsSolutionService as IVsSolution;
UnadviseSolutionEvents(vsSolution);
AdviseSolutionEvents(vsSolution);
}
#endregion
// Get the build and command events from DTE
if (VsServiceProvider.TryGetService(typeof(DTE), out object dte))
{
var dte2 = dte as DTE2;
mBuildEvents = dte2.Events.BuildEvents;
mCommandEvents = dte2.Events.CommandEvents;
mDteEvents = dte2.Events.DTEEvents;
}
DispatcherHandler.Initialize(dte as DTE2);
SettingsProvider.Initialize(this);
// Detect the first install
if (string.IsNullOrWhiteSpace(SettingsProvider.GeneralSettings.Version))
{
ShowToolbare(); // Show the toolbar on the first install
}
var currentVersion = PackageUtility.GetVersion();
if (!string.IsNullOrWhiteSpace(currentVersion) &&
0 > string.Compare(SettingsProvider.GeneralSettings.Version, currentVersion))
{
mOutputWindowController.Clear();
mOutputWindowController.Show();
mOutputWindowController.Write($"🎉\tClang Power Tools was upgraded to v{currentVersion}\n" +
$"\tCheck out what's new at http://www.clangpowertools.com/CHANGELOG");
SettingsProvider.GeneralSettings.Version = currentVersion;
System.Diagnostics.Process.Start(new ProcessStartInfo("https://clangpowertools.com/blog/future-of-clang-power-tools.html"));
}
SettingsHandler.SaveGeneralSettings();
await mCommandController.InitializeCommandsAsync(this);
mLicenseController = new LicenseController();
RegisterToEvents();
await mLicenseController.CheckLicenseAsync();
await base.InitializeAsync(cancellationToken, progress);
}
public void remove(RegistryApplicationKey key, ChocolateyConfiguration config, PackageResult packageResult, string packageCacheLocation)
{
var userProvidedUninstallArguments = string.Empty;
var userOverrideUninstallArguments = false;
var package = packageResult.Package;
if (package != null)
{
if (!PackageUtility.package_is_a_dependency(config, package.Id) || config.ApplyInstallArgumentsToDependencies)
{
userProvidedUninstallArguments = config.InstallArguments;
userOverrideUninstallArguments = config.OverrideArguments;
if (!string.IsNullOrWhiteSpace(userProvidedUninstallArguments))
{
this.Log().Debug(ChocolateyLoggers.Verbose, " Using user passed {2}uninstaller args for {0}:'{1}'".format_with(package.Id, userProvidedUninstallArguments.escape_curly_braces(), userOverrideUninstallArguments ? "overriding " : string.Empty));
}
}
}
//todo: if there is a local package, look to use it in the future
if (string.IsNullOrWhiteSpace(key.UninstallString))
{
this.Log().Info(" Skipping auto uninstaller - '{0}' does not have an uninstall string.".format_with(!string.IsNullOrEmpty(key.DisplayName.to_string()) ? key.DisplayName.to_string().escape_curly_braces() : "The application"));
return;
}
this.Log().Debug(() => " Preparing uninstall key '{0}' for '{1}'".format_with(key.UninstallString.to_string().escape_curly_braces(), key.DisplayName.to_string().escape_curly_braces()));
if ((!string.IsNullOrWhiteSpace(key.InstallLocation) && !_fileSystem.directory_exists(key.InstallLocation)) || !_registryService.installer_value_exists(key.KeyPath, ApplicationParameters.RegistryValueInstallLocation))
{
this.Log().Info(" Skipping auto uninstaller - '{0}' appears to have been uninstalled already by other means.".format_with(!string.IsNullOrEmpty(key.DisplayName.to_string()) ? key.DisplayName.to_string().escape_curly_braces() : "The application"));
this.Log().Debug(() => " Searched for install path '{0}' - found? {1}".format_with(key.InstallLocation.to_string().escape_curly_braces(), _fileSystem.directory_exists(key.InstallLocation)));
this.Log().Debug(() => " Searched for registry key '{0}' value '{1}' - found? {2}".format_with(key.KeyPath.escape_curly_braces(), ApplicationParameters.RegistryValueInstallLocation, _registryService.installer_value_exists(key.KeyPath, ApplicationParameters.RegistryValueInstallLocation)));
return;
}
// split on " /" and " -" for quite a bit more accuracy
IList <string> uninstallArgsSplit = key.UninstallString.to_string().Replace(""", "\"").Replace("'", "'").Split(new[] { " /", " -" }, StringSplitOptions.RemoveEmptyEntries).ToList();
var uninstallExe = uninstallArgsSplit.DefaultIfEmpty(string.Empty).FirstOrDefault().trim_safe();
if (uninstallExe.Count(u => u == '"') > 2)
{
uninstallExe = uninstallExe.Split(new [] { " \"" }, StringSplitOptions.RemoveEmptyEntries).First();
}
if (uninstallExe.Count(u => u == ':') > 1)
{
try
{
var firstMatch = Regex.Match(uninstallExe, @"\s+\w\:", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
uninstallExe = uninstallExe.Substring(0, firstMatch.Index);
}
catch (Exception ex)
{
this.Log().Debug("Error splitting the uninstall string:{0} {1}".format_with(Environment.NewLine, ex.to_string()));
}
}
var uninstallArgs = key.UninstallString.to_string().Replace(""", "\"").Replace("'", "'").Replace(uninstallExe.to_string(), string.Empty).trim_safe();
uninstallExe = uninstallExe.remove_surrounding_quotes();
this.Log().Debug(() => " Uninstaller path is '{0}'".format_with(uninstallExe));
if (uninstallExe.contains("\\") || uninstallExe.contains("/"))
{
if (!_fileSystem.file_exists(uninstallExe))
{
this.Log().Info(" Skipping auto uninstaller - The uninstaller file no longer exists. \"{0}\"".format_with(uninstallExe));
return;
}
}
IInstaller installer = get_installer_type(key, uninstallExe, uninstallArgs);
this.Log().Debug(() => " Installer type is '{0}'".format_with(installer.GetType().Name));
if (key.InstallerType == InstallerType.Msi)
{
// because sometimes the key is set with /i to allow for modify :/
uninstallArgs = uninstallArgs.Replace("/I{", "/X{");
uninstallArgs = uninstallArgs.Replace("/i{", "/X{");
uninstallArgs = uninstallArgs.Replace("/I ", "/X ");
uninstallArgs = uninstallArgs.Replace("/i ", "/X ");
}
if (!key.HasQuietUninstall)
{
//todo: ultimately we should merge keys
uninstallArgs += " " + installer.build_uninstall_command_arguments();
}
if (!string.IsNullOrWhiteSpace(userProvidedUninstallArguments))
{
if (userOverrideUninstallArguments)
{
this.Log().Debug(() => " Replacing original uninstall arguments of '{0}' with '{1}'".format_with(uninstallArgs.escape_curly_braces(), userProvidedUninstallArguments.escape_curly_braces()));
uninstallArgs = userProvidedUninstallArguments;
}
else
{
this.Log().Debug(() => " Appending original uninstall arguments with '{0}'".format_with(userProvidedUninstallArguments.escape_curly_braces()));
uninstallArgs += " " + userProvidedUninstallArguments;
}
}
this.Log().Debug(() => " Setting up uninstall logging directory at {0}".format_with(packageCacheLocation.escape_curly_braces()));
_fileSystem.create_directory_if_not_exists(_fileSystem.get_directory_name(packageCacheLocation));
uninstallArgs = uninstallArgs.Replace(InstallTokens.PACKAGE_LOCATION, packageCacheLocation);
uninstallArgs = uninstallArgs.Replace(InstallTokens.TEMP_LOCATION, packageCacheLocation);
this.Log().Debug(() => " Args are '{0}'".format_with(uninstallArgs.escape_curly_braces()));
if (!key.HasQuietUninstall && installer.GetType() == typeof(CustomInstaller))
{
if (!config.Information.IsLicensedVersion)
{
this.Log().Warn(@"
Did you know licensed versions of Chocolatey are 95% effective with
Automatic Uninstaller due to licensed enhancements and Package
Synchronizer?
");
}
var skipUninstaller = true;
var timeout = config.PromptForConfirmation ? 0 : 30;
var selection = InteractivePrompt.prompt_for_confirmation(
"Uninstall may not be silent (could not detect). Proceed?",
new[] { "yes", "no" },
defaultChoice: "no",
requireAnswer: true,
allowShortAnswer: true,
shortPrompt: true,
timeoutInSeconds: timeout
);
if (selection.is_equal_to("yes"))
{
skipUninstaller = false;
}
if (skipUninstaller)
{
this.Log().Info(" Skipping auto uninstaller - Installer type was not detected and no silent uninstall key exists.");
this.Log().Warn("If the application was not removed with a chocolateyUninstall.ps1,{0} please remove it from Programs and Features manually.".format_with(Environment.NewLine));
return;
}
}
var exitCode = _commandExecutor.execute(
uninstallExe,
uninstallArgs.trim_safe(),
config.CommandExecutionTimeoutSeconds,
(s, e) =>
{
if (e == null || string.IsNullOrWhiteSpace(e.Data))
{
return;
}
this.Log().Info(() => " [AutoUninstaller] {0}".format_with(e.Data.escape_curly_braces()));
},
(s, e) =>
{
if (e == null || string.IsNullOrWhiteSpace(e.Data))
{
return;
}
this.Log().Error(() => " [AutoUninstaller] {0}".format_with(e.Data.escape_curly_braces()));
},
updateProcessPath: false);
if (!installer.ValidUninstallExitCodes.Contains(exitCode))
{
Environment.ExitCode = exitCode;
string logMessage = " Auto uninstaller failed. Please remove machine installation manually.{0} Exit code was {1}".format_with(Environment.NewLine, exitCode);
this.Log().Error(() => logMessage.escape_curly_braces());
packageResult.Messages.Add(new ResultMessage(config.Features.FailOnAutoUninstaller ? ResultType.Error : ResultType.Warn, logMessage));
}
else
{
this.Log().Info(() => " Auto uninstaller has successfully uninstalled {0} or detected previous uninstall.".format_with(packageResult.Package.Id));
}
}
public void InstallPackageInvokeInstallScript()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0", tools: new[] { "install.ps1" });
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
var fileSystem = new Mock <IVsProjectSystem>();
fileSystem.SetupGet(f => f.UniqueName).Returns("Project1");
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager1.Setup(p => p.AddPackageReference(packageB, false, false))
.Raises(p => p.PackageReferenceAdded += (o, a) => { }, new PackageOperationEventArgs(packageB, fileSystem.As <IFileSystem>().Object, "x:\\nuget"));
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
packageManager.Setup(p => p.InstallPackage(
new[] { project1 },
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
false,
It.IsAny <ILogger>(),
It.IsAny <IPackageOperationEventListener>()))
.Callback(
(IEnumerable <Project> projects,
IPackage package,
IEnumerable <PackageOperation> operations,
bool ignoreDependencies,
bool allowPrereleaseVersions,
ILogger logger,
IPackageOperationEventListener eventListener) =>
{
eventListener.OnBeforeAddPackageReference(project1);
projectManager1.Object.AddPackageReference(packageB, false, false);
});
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var scriptExecutor = new Mock <IScriptExecutor>();
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, scriptExecutor: scriptExecutor.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception callbackException = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
scriptExecutor.Verify(p => p.Execute("x:\\nuget", "install.ps1", packageB, project1, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
}
catch (Exception exception)
{
callbackException = exception;
}
finally
{
manualEvent.Set();
}
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
if (callbackException != null)
{
throw callbackException;
}
}
public void CallingCheckForMissingPackagesRaisesThePackagesMissingStatusChangedEventWithFalseValue()
{
// Scenario:
// Project's packages.config specifies: A[1.0], B[1.2-alpha]
// The solution's packages folder contains only A[1.0], B[1.2-alpha]
// Arrange
string tempSolutionPath = "x:\\project1";
var project = new Mock <Project>();
// setup SolutionManager
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.IsSolutionOpen).Returns(true);
solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath);
solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object });
// setup file system
var fileSystem = new Mock <IFileSystem>();
fileSystem.Setup(p => p.DirectoryExists(".nuget")).Returns(true);
fileSystem.Setup(p => p.FileExists(".nuget\\nuget.exe")).Returns(true);
fileSystem.Setup(p => p.FileExists(".nuget\\nuget.targets")).Returns(true);
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath, It.IsAny <bool>())).Returns(fileSystem.Object);
// setup VsPackageManager
var projectFileSystem = new MockFileSystem();
projectFileSystem.AddFile("packages.config",
@"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.0.0.0"" />
<package id=""B"" version=""1.2-alpha"" />
</packages>");
var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, new Mock <ISharedPackageRepository>().Object);
var projectManager = new Mock <IProjectManager>();
projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
localRepository.AddPackage(PackageUtility.CreatePackage("B", "1.2-alpha"));
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object);
packageManager.Setup(p => p.LocalRepository).Returns(localRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object);
var packageRestore = CreateInstance(
fileSystemProvider: fileSystemProvider.Object,
solutionManager: solutionManager.Object,
packageManagerFactory: packageManagerFactory.Object);
bool?packagesMissing = null;
packageRestore.PackagesMissingStatusChanged += (o, e) =>
{
packagesMissing = e.PackagesMissing;
};
// Act
packageRestore.CheckForMissingPackages();
// Assert
Assert.Equal(false, packagesMissing);
}
private static IVsPackageManager GetPackageManager()
{
var fileSystem = new Mock <IFileSystem>();
var localRepo = new Mock <ISharedPackageRepository>();
var localPackages = new[] { PackageUtility.CreatePackage("P1", "0.9"), PackageUtility.CreatePackage("Pack2") };
localRepo.Setup(c => c.GetPackages()).Returns(localPackages.AsQueryable());
var remotePackages = new[] { PackageUtility.CreatePackage("P0", "1.1"), PackageUtility.CreatePackage("P1", "1.1"),
PackageUtility.CreatePackage("Pack2", "1.2"), PackageUtility.CreatePackage("P3") };
var remoteRepo = new Mock <IPackageRepository>();
remoteRepo.Setup(c => c.GetPackages()).Returns(remotePackages.AsQueryable());
return(new VsPackageManager(TestUtils.GetSolutionManager(), remoteRepo.Object, new Mock <IFileSystemProvider>().Object, fileSystem.Object, localRepo.Object, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object));
}
