public async Task GetPackageSpecsAsync_WithPackageReference_Succeeds()
{
// Arrange
using (var randomTestFolder = TestDirectory.Create())
{
var framework = NuGetFramework.Parse("netstandard13");
var projectAdapter = CreateProjectAdapter(randomTestFolder);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
framework,
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var testDependencyGraphCacheContext = new DependencyGraphCacheContext();
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
//No top level dependencies
Assert.Equal(0, actualRestoreSpec.Dependencies.Count);
var actualDependency = actualRestoreSpec.TargetFrameworks.SingleOrDefault().Dependencies.Single();
Assert.NotNull(actualDependency);
Assert.Equal("packageA", actualDependency.LibraryRange.Name);
Assert.Equal(VersionRange.Parse("1.*"), actualDependency.LibraryRange.VersionRange);
// Verify
Mock.Get(projectServices.ReferencesReader)
.Verify(
x => x.GetPackageReferencesAsync(framework, CancellationToken.None),
Times.AtLeastOnce);
}
}
public async Task GetPackageSpecsAsync_ReadLockFileSettings(
string restorePackagesWithLockFile,
string lockFilePath,
bool restoreLockedMode)
{
// Arrange
using (var testDirectory = TestDirectory.Create())
{
var projectAdapter = CreateProjectAdapter(testDirectory);
Mock.Get(projectAdapter)
.Setup(x => x.GetRestorePackagesWithLockFileAsync())
.ReturnsAsync(restorePackagesWithLockFile);
Mock.Get(projectAdapter)
.Setup(x => x.GetNuGetLockFilePathAsync())
.ReturnsAsync(lockFilePath);
Mock.Get(projectAdapter)
.Setup(x => x.IsRestoreLockedAsync())
.ReturnsAsync(restoreLockedMode);
var projectServices = new TestProjectSystemServices();
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var settings = NullSettings.Instance;
var testDependencyGraphCacheContext = new DependencyGraphCacheContext(NullLogger.Instance, settings);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
// Assert restorePackagesWithLockFile
Assert.Equal(restorePackagesWithLockFile, actualRestoreSpec.RestoreMetadata.RestoreLockProperties.RestorePackagesWithLockFile);
// assert lockFilePath
Assert.Equal(lockFilePath, actualRestoreSpec.RestoreMetadata.RestoreLockProperties.NuGetLockFilePath);
// assert restoreLockedMode
Assert.Equal(restoreLockedMode, actualRestoreSpec.RestoreMetadata.RestoreLockProperties.RestoreLockedMode);
}
}
public async Task GetPackageSpecsAsync_WithPackageTargetFallback_Succeeds()
{
// Arrange
using (var testDirectory = TestDirectory.Create())
{
var projectAdapter = CreateProjectAdapter(testDirectory);
Mock.Get(projectAdapter)
.SetupGet(x => x.PackageTargetFallback)
.Returns("portable-net45+win8;dnxcore50");
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
new TestProjectSystemServices(),
_threadingService);
var testDependencyGraphCacheContext = new DependencyGraphCacheContext();
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
var actualTfi = actualRestoreSpec.TargetFrameworks.First();
Assert.NotNull(actualTfi);
Assert.Equal(
new NuGetFramework[]
{
NuGetFramework.Parse("portable-net45+win8"),
NuGetFramework.Parse("dnxcore50")
},
actualTfi.Imports);
Assert.IsType <FallbackFramework>(actualTfi.FrameworkName);
Assert.Equal(
new NuGetFramework[]
{
NuGetFramework.Parse("portable-net45+win8"),
NuGetFramework.Parse("dnxcore50")
},
((FallbackFramework)actualTfi.FrameworkName).Fallback);
// Verify
Mock.Get(projectAdapter)
.Verify(x => x.PackageTargetFallback, Times.AtLeastOnce);
}
}
public async Task GetPackageSpecsAsync_WithProjectReference_Succeeds()
{
// Arrange
using (var randomTestFolder = TestDirectory.Create())
{
var framework = NuGetFramework.Parse("netstandard13");
var projectAdapter = CreateProjectAdapter(randomTestFolder);
var projectServices = new TestProjectSystemServices();
projectServices.SetupProjectDependencies(
new ProjectRestoreReference
{
ProjectUniqueName = "TestProjectA",
ProjectPath = Path.Combine(randomTestFolder, "TestProjectA")
});
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var testDependencyGraphCacheContext = new DependencyGraphCacheContext();
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
var actualDependency = actualRestoreSpec.RestoreMetadata.TargetFrameworks.Single().ProjectReferences.Single();
Assert.NotNull(actualDependency);
Assert.Equal("TestProjectA", actualDependency.ProjectUniqueName);
// Verify
Mock.Get(projectServices.ReferencesReader)
.Verify(
x => x.GetProjectReferencesAsync(It.IsAny <Common.ILogger>(), CancellationToken.None),
Times.AtLeastOnce);
}
}
public async Task GetPackageSpecAsync_CentralPackageVersionsRemovedDuplicates()
{
// Arrange
var packageAv1 = (PackageId : "packageA", Version : "1.2.3");
var packageB = (PackageId : "packageB", Version : "3.4.5");
var packageAv5 = (PackageId : "packageA", Version : "5.0.0");
var projectNames = new ProjectNames(
fullName: "projectName",
uniqueName: "projectName",
shortName: "projectName",
customUniqueName: "projectName",
projectId: Guid.NewGuid().ToString());
var vsProjectAdapter = new TestVSProjectAdapter(
"projectPath",
projectNames,
"framework",
restorePackagesWithLockFile: null,
nuGetLockFilePath: null,
restoreLockedMode: false,
projectPackageVersions: new List <(string Id, string Version)>()
{
packageAv1, packageB, packageAv5
});
var legacyPRProject = new LegacyPackageReferenceProject(
vsProjectAdapter,
Guid.NewGuid().ToString(),
new TestProjectSystemServices(),
_threadingService);
var settings = NullSettings.Instance;
var context = new DependencyGraphCacheContext(NullLogger.Instance, settings);
var packageSpecs = await legacyPRProject.GetPackageSpecsAsync(context);
Assert.Equal(1, packageSpecs.Count);
Assert.True(packageSpecs.First().RestoreMetadata.CentralPackageVersionsEnabled);
var centralPackageVersions = packageSpecs.First().TargetFrameworks.First().CentralPackageVersions;
Assert.Equal(2, centralPackageVersions.Count);
Assert.Equal(VersionRange.Parse(packageAv1.Version), centralPackageVersions[packageAv1.PackageId].VersionRange);
Assert.Equal(VersionRange.Parse(packageB.Version), centralPackageVersions[packageB.PackageId].VersionRange);
}
public async Task GetPackageSpecsAsync_WithDefaultVersion_Succeeds()
{
// Arrange
using (var testDirectory = TestDirectory.Create())
{
var projectAdapter = CreateProjectAdapter(testDirectory);
var projectServices = new TestProjectSystemServices();
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var testDependencyGraphCacheContext = new DependencyGraphCacheContext();
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
Assert.Equal("1.0.0", actualRestoreSpec.Version.ToString());
// Verify
Mock.Get(projectAdapter)
.VerifyGet(x => x.Version, Times.AtLeastOnce);
Mock.Get(projectAdapter)
.VerifyGet(x => x.ProjectName, Times.AtLeastOnce);
Mock.Get(projectAdapter)
.Verify(x => x.GetRuntimeIdentifiersAsync(), Times.AtLeastOnce);
Mock.Get(projectAdapter)
.Verify(x => x.GetRuntimeSupportsAsync(), Times.AtLeastOnce);
Mock.Get(projectAdapter)
.VerifyGet(x => x.FullProjectPath, Times.AtLeastOnce);
Mock.Get(projectAdapter)
.Verify(x => x.GetTargetFrameworkAsync(), Times.AtLeastOnce);
}
}
public async Task GetPackageSpecsAsync_SkipContentFilesAlwaysTrue()
{
// Arrange
using (var randomTestFolder = TestDirectory.Create())
{
var framework = NuGetFramework.Parse("netstandard13");
var projectAdapter = CreateProjectAdapter(randomTestFolder);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
framework,
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var testDependencyGraphCacheContext = new DependencyGraphCacheContext();
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
Assert.True(actualRestoreSpec.RestoreMetadata.SkipContentFileWrite);
}
}
public async Task GetPackageSpecsAsync_WithNoFallbackFrameworks_Succeeds()
{
// Arrange
using (var randomTestFolder = TestDirectory.Create())
{
var framework = NuGetFramework.Parse("netcoreapp2.0");
var projectAdapter = CreateProjectAdapter(randomTestFolder);
Mock.Get(projectAdapter)
.SetupGet(x => x.PackageTargetFallback)
.Returns("");
Mock.Get(projectAdapter)
.SetupGet(x => x.AssetTargetFallback)
.Returns("");
var projectServices = new TestProjectSystemServices();
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var testDependencyGraphCacheContext = new DependencyGraphCacheContext();
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
actualRestoreSpec.TargetFrameworks[0].Imports.Should().BeEmpty();
actualRestoreSpec.TargetFrameworks[0].AssetTargetFallback.Should().BeEmpty();
}
}
public async Task GetPackageSpecsAsync_ReadSettingsWithFullPaths(string restorePackagesPath, string sources, string fallbackFolders)
{
// Arrange
using (var testDirectory = TestDirectory.Create())
{
var projectAdapter = CreateProjectAdapter(testDirectory);
Mock.Get(projectAdapter)
.SetupGet(x => x.RestorePackagesPath)
.Returns(restorePackagesPath);
Mock.Get(projectAdapter)
.SetupGet(x => x.RestoreSources)
.Returns(sources);
Mock.Get(projectAdapter)
.SetupGet(x => x.RestoreFallbackFolders)
.Returns(fallbackFolders);
var projectServices = new TestProjectSystemServices();
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var settings = NullSettings.Instance;
var testDependencyGraphCacheContext = new DependencyGraphCacheContext(NullLogger.Instance, settings);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
// Assert packagespath
Assert.Equal(restorePackagesPath != null ? restorePackagesPath : SettingsUtility.GetGlobalPackagesFolder(settings), actualRestoreSpec.RestoreMetadata.PackagesPath);
// assert sources
var specSources = actualRestoreSpec.RestoreMetadata.Sources.Select(e => e.Source);
var expectedSources = sources != null?MSBuildStringUtility.Split(sources) : SettingsUtility.GetEnabledSources(settings).Select(e => e.Source);
Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t)));
// assert fallbackfolders
var specFallback = actualRestoreSpec.RestoreMetadata.FallbackFolders;
var expectedFolders = fallbackFolders != null?MSBuildStringUtility.Split(fallbackFolders) : SettingsUtility.GetFallbackPackageFolders(settings);
Assert.True(Enumerable.SequenceEqual(expectedFolders.OrderBy(t => t), specFallback.OrderBy(t => t)));
// Verify
Mock.Get(projectAdapter)
.Verify(x => x.RestorePackagesPath, Times.Once);
Mock.Get(projectAdapter)
.Verify(x => x.RestoreSources, Times.Once);
Mock.Get(projectAdapter)
.Verify(x => x.RestoreFallbackFolders, Times.Once);
}
}