public static void GetPackagesToBeReinstalledReturnsPackagesInstalledAgainstDifferentProjectFrameworks()
{
// Create packageA and packageB
// packageA has files targeting net35 and was installed against net30
// packageB has files targeting net40 and was installed against net45
// current targetFramework of the project they are installed in is net35
// They should BOTH be reinstalled
// Arrange
IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, assemblyReferences: new[] { @"lib\net35\foo.dll" });
IPackage packageB = PackageUtility.CreatePackage("B", "1.0.0", content: new[] { @"net40\foo.txt" });
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
List <PackageReference> packageReferences = new List <PackageReference>();
packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=3.0"), isDevelopmentDependency: false));
packageReferences.Add(new PackageReference("B", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.5"), isDevelopmentDependency: false));
FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5");
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository);
// Assert
Assert.Equal(2, packagesToBeReinstalled.Count);
Assert.Equal(packagesToBeReinstalled[0].Id, "A");
Assert.Equal(packagesToBeReinstalled[1].Id, "B");
}
public static void GetPackagesToBeReinstalledReturnsPackageTargetingSingleFrameworkBasedOnTools()
{
// Create a packageA which has as content only in net40. Create a package reference corresponding to this package with the project target framework as 'net40'
// Now, Try and check if the created packagereference on a project with targetframework of net35 will require reinstallation. IT SHOULD REQUIRE REINSTALLATION
// Arrange
IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, null, tools: new[] { @"net40\init.ps1" });
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
List <PackageReference> packageReferences = new List <PackageReference>();
packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false));
FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5");
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository);
// Assert
Assert.Equal(1, packagesToBeReinstalled.Count);
Assert.Equal(packagesToBeReinstalled[0].Id, "A");
}
public static void GetPackagesToBeReinstalledReturnsMultiplePackagesToBeReinstalled()
{
// Create packageA, packageB and packageC such that only packageB and packageC will need to be reinstalled for changing
// targetframework for project from net40 to net35. And, validate that GetPackagesToBeReinstalled returns the correct list
// Arrange
IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, assemblyReferences: new[] { @"lib\net20\foo.dll" });
IPackage packageB = PackageUtility.CreatePackage("B", "1.0.0", content: new[] { @"net40\foo.txt" });
IPackage packageC = PackageUtility.CreatePackage("C", "1.0.0", null, null, tools: new[] { @"net40\bar.ps1" });
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
localRepository.AddPackage(packageC);
List <PackageReference> packageReferences = new List <PackageReference>();
packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false));
packageReferences.Add(new PackageReference("B", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false));
packageReferences.Add(new PackageReference("C", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false));
FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5");
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository);
// Assert
Assert.Equal(2, packagesToBeReinstalled.Count);
Assert.Equal(packagesToBeReinstalled[0].Id, "B");
Assert.Equal(packagesToBeReinstalled[1].Id, "C");
}
public static void GetPackagesToBeReinstalledReturnsEmptyListWhenNuGetIsNotInUseInAProject()
{
// Arrange
Mock <Project> mockProject = new Mock <Project>();
mockProject.SetupGet(p => p.FullName).Returns(@"c:\a\b\c.csproj");
MockPackageRepository localRepository = new MockPackageRepository();
// Setup project kind to a supported value. This makes sure that the check for existence of packages.config happens
mockProject.Setup(p => p.Kind).Returns(CsharpProjectTypeGuid);
var mockServices = new Dictionary <Type, object>();
Mock <IVsSolution> mockSolution = new Mock <IVsSolution>();
mockServices.Add(typeof(IVsSolution), mockSolution.Object);
Mock <IVsHierarchy> mockHier = new Mock <IVsHierarchy>();
IVsHierarchy hier = mockHier.Object;
mockSolution.Setup(m => m.GetProjectOfUniqueName(It.IsAny <string>(), out hier)).Returns(0);
ServiceLocator.TestServiceCache = mockServices;
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
int IVsTrackBatchRetargetingEvents.OnBatchRetargetingEnd()
{
_errorListProvider.Tasks.Clear();
if (_platformRetargetingProject != null)
{
try
{
Project project = _dte.Solution.Item(_platformRetargetingProject);
if (project != null)
{
string frameworkName = project.GetTargetFramework();
if (NETCore451.Equals(frameworkName, StringComparison.OrdinalIgnoreCase) || Windows81.Equals(frameworkName, StringComparison.OrdinalIgnoreCase))
{
IList <IPackage> packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(project);
if (packagesToBeReinstalled.Count > 0)
{
// By asserting that NuGet is in use, we are also asserting that NuGet.VisualStudio.dll is already loaded
// Hence, it is okay to call project.ToVsHierarchy()
Debug.Assert(project.IsNuGetInUse());
IVsHierarchy projectHierarchy = project.ToVsHierarchy();
ShowRetargetingErrorTask(packagesToBeReinstalled.Select(p => p.Id), projectHierarchy, TaskErrorCategory.Error, TaskPriority.High);
}
ProjectRetargetingUtility.MarkPackagesForReinstallation(project, packagesToBeReinstalled);
}
}
}
catch (ArgumentException)
{
// If the solution does not contain a project named '_platformRetargetingProject', it will throw ArgumentException
}
_platformRetargetingProject = null;
}
return(VSConstants.S_OK);
}
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);
}
public static void GetLocalRepositoryWhenSolutionDirectoryIsNotFound()
{
// Arrange
var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var mockSourceProvider = new Mock <IVsPackageSourceProvider>();
var mockAggregateRepository = new Mock <AggregateRepository>(Enumerable.Empty <IPackageRepository>());
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(s => s.SolutionDirectory).Returns(String.Empty);
var fileSystemProvider = new Mock <IFileSystemProvider>();
var repositorySettings = new RepositorySettings(solutionManager.Object, fileSystemProvider.Object, new Mock <IVsSourceControlTracker>().Object, null);
var packageManagerFactory = new VsPackageManagerFactory(
new Mock <ISolutionManager>().Object,
mockRepositoryFactory.Object,
mockSourceProvider.Object,
new Mock <IFileSystemProvider>().Object,
repositorySettings,
new Mock <VsPackageInstallerEvents>().Object,
mockAggregateRepository.Object,
frameworkMultiTargeting: null,
machineWideSettings: null);
// Act & Assert
// Get RepositoryPath throws InvalidOperationException and GetLocalRepository() handles it to return null
// To make a delegate out of property repositorySettings.RepositoryPath, calling String.IsNullOrEmpty
ExceptionAssert.Throws <InvalidOperationException>(() => String.IsNullOrEmpty(repositorySettings.RepositoryPath), "Unable to locate the solution directory. Please ensure that the solution has been saved.");
Assert.Null(ProjectRetargetingUtility.GetLocalRepository(packageManagerFactory));
}
public static void GetPackageReferencesMarkedForReinstallationWhenProjectKindIsNull()
{
// Arrange
Mock <Project> mockProject = new Mock <Project>();
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackageReferencesMarkedForReinstallation(mockProject.Object);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public static void GetPackageReferencesMarkedForReinstallationWhenProjectIsNotOfSupportedType()
{
// Arrange
Mock<Project> mockProject = new Mock<Project>();
mockProject.Setup(p => p.Kind).Returns(Guid.NewGuid().ToString());
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackageReferencesMarkedForReinstallation(mockProject.Object);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public static void GetLocalRepositoryWhenCreatePackageManagerReturnsNull()
{
// Arrange
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns((IVsPackageManager)null);
// Act
var localRepository = ProjectRetargetingUtility.GetLocalRepository(packageManagerFactory.Object);
// Assert
Assert.Null(localRepository);
}
public static void GetPackagesToBeReinstalledWhenProjectKindIsNull()
{
// Arrange
Mock<Project> mockProject = new Mock<Project>();
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(PackageUtility.CreatePackage("A"));
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public static void GetPackageReferencesMarkedForReinstallationReturnsEmptyListWhenNuGetIsNotInUseInAProject()
{
// Arrange
Mock <Project> mockProject = new Mock <Project>();
// Setup project kind to a supported value. This makes sure that the check for existence of packages.config happens
mockProject.Setup(p => p.Kind).Returns(VsConstants.CsharpProjectTypeGuid);
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackageReferencesMarkedForReinstallation(mockProject.Object);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public static void GetPackagesToBeReinstalledWhenLocalRepositoryIsNull()
{
// Arrange
Mock <Project> mockProject = new Mock <Project>();
// Setup project kind to a supported value. This makes sure that the check for existence of packages.config happens
mockProject.Setup(p => p.Kind).Returns(VsConstants.CsharpProjectTypeGuid);
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, null);
// Assert
Assert.Equal(0, packagesToBeReinstalled.Count);
}
public static void GetPackagesToBeReinstalledWhenProjectIsNotOfSupportedType()
{
// Arrange
Mock<Project> mockProject = new Mock<Project>();
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(PackageUtility.CreatePackage("A"));
mockProject.Setup(p => p.Kind).Returns(Guid.NewGuid().ToString());
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
private void ShowWarningsForPackageReinstallation(Solution solution)
{
Debug.Assert(solution != null);
foreach (Project project in solution.Projects)
{
IList <PackageReference> packageReferencesToBeReinstalled = ProjectRetargetingUtility.GetPackageReferencesMarkedForReinstallation(project);
if (packageReferencesToBeReinstalled.Count > 0)
{
Debug.Assert(project.IsNuGetInUse());
IVsHierarchy projectHierarchy = project.ToVsHierarchy();
ShowRetargetingErrorTask(packageReferencesToBeReinstalled.Select(p => p.Id), projectHierarchy, TaskErrorCategory.Warning, TaskPriority.Normal);
}
}
}
int IVsTrackProjectRetargetingEvents.OnRetargetingAfterChange(string projRef, IVsHierarchy pAfterChangeHier, string fromTargetFramework, string toTargetFramework)
{
_errorListProvider.Tasks.Clear();
Project retargetedProject = VsUtility.GetProjectFromHierarchy(pAfterChangeHier);
if (retargetedProject != null)
{
IList <IPackage> packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(retargetedProject);
if (!packagesToBeReinstalled.IsEmpty())
{
ShowRetargetingErrorTask(packagesToBeReinstalled.Select(p => p.Id), pAfterChangeHier, TaskErrorCategory.Error, TaskPriority.High);
}
ProjectRetargetingUtility.MarkPackagesForReinstallation(retargetedProject, packagesToBeReinstalled);
}
return(VSConstants.S_OK);
}
public static void GetPackagesToBeReinstalledReturnsEmptyListWhenNuGetIsNotInUseInAProject()
{
// Arrange
Mock <Project> mockProject = new Mock <Project>();
mockProject.SetupGet(p => p.FullName).Returns(@"c:\a\b\c.csproj");
MockPackageRepository localRepository = new MockPackageRepository();
// Setup project kind to a supported value. This makes sure that the check for existence of packages.config happens
mockProject.Setup(p => p.Kind).Returns(VsConstants.CsharpProjectTypeGuid);
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
int IVsSolutionEventsProjectUpgrade.OnAfterUpgradeProject(IVsHierarchy pHierarchy, uint fUpgradeFlag, string bstrCopyLocation, SYSTEMTIME stUpgradeTime, IVsUpgradeLogger pLogger)
{
Debug.Assert(pHierarchy != null);
Project upgradedProject = VsUtility.GetProjectFromHierarchy(pHierarchy);
if (upgradedProject != null)
{
IList <IPackage> packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(upgradedProject);
if (!packagesToBeReinstalled.IsEmpty())
{
pLogger.LogMessage((int)__VSUL_ERRORLEVEL.VSUL_ERROR, upgradedProject.Name, upgradedProject.Name,
String.Format(CultureInfo.CurrentCulture, Resources.ProjectUpgradeAndRetargetErrorMessage, String.Join(", ", packagesToBeReinstalled.Select(p => p.Id))));
}
}
return(VSConstants.S_OK);
}
public static void GetPackagesToBeReinstalledReturnsEmptyListForPackageTargetingMultipleFrameworks()
{
// Create a packageA which has as assembly reference in net 20 and net30. Create a package reference corresponding to this package with the project target framework as 'net40'
// Now, Try and check if the created packagereference on a project with targetframework of net35 will require reinstallation. IT SHOULD REQUIRE REINSTALLATION
// Arrange
IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, assemblyReferences: new[] { @"lib\net20\bar.dll", @"lib\net30\foo.dll" });
MockPackageRepository localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
List<PackageReference> packageReferences = new List<PackageReference>();
packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false));
FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5");
// Act
var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository);
// Assert
Assert.True(packagesToBeReinstalled.IsEmpty());
}
public static void GetLocalRepositoryWhenPackageManagerFactoryIsNull()
{
// Act & Assert
ExceptionAssert.ThrowsArgNull(() => ProjectRetargetingUtility.GetLocalRepository(null), "packageManagerFactory");
}
