private static async Task AddProjectReferencesAsync(
IDeferredProjectWorkspaceService deferredWorkspaceService,
ProjectRestoreMetadata metadata,
string projectPath)
{
var references = await deferredWorkspaceService.GetProjectReferencesAsync(projectPath);
foreach (var reference in references)
{
var restoreReference = new ProjectRestoreReference()
{
ProjectPath = reference,
ProjectUniqueName = reference
};
foreach (var frameworkInfo in metadata.TargetFrameworks)
{
frameworkInfo.ProjectReferences.Add(restoreReference);
}
}
}
public void HashCode_WithDifferentWarningProperties_ReturnsTrue()
{
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var leftSide = new ProjectRestoreMetadata
{
ProjectWideWarningProperties = new WarningProperties(allWarningsAsErrors: true, warningsAsErrors: warningsAsErrors, noWarn: noWarn)
};
var rightSide = new ProjectRestoreMetadata
{
ProjectWideWarningProperties = new WarningProperties(allWarningsAsErrors: false, warningsAsErrors: warningsAsErrors, noWarn: noWarn)
};
AssertHashCode(expected: false, leftSide, rightSide);
}
public void Equals_WithEquivalentWarningProperties_ReturnsTrue()
{
var allWarningsAsErrors = true;
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var leftSide = new ProjectRestoreMetadata
{
ProjectWideWarningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn)
};
var rightSide = new ProjectRestoreMetadata
{
ProjectWideWarningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn)
};
AssertEquality(leftSide, rightSide);
}
public override async Task <IReadOnlyList <PackageSpec> > GetPackageSpecsAsync(DependencyGraphCacheContext context)
{
PackageSpec packageSpec = null;
if (context == null || !context.PackageSpecCache.TryGetValue(MSBuildProjectPath, out packageSpec))
{
packageSpec = JsonPackageSpecReader.GetPackageSpec(ProjectName, JsonConfigPath);
if (packageSpec == null)
{
throw new InvalidOperationException(
string.Format(Strings.ProjectNotLoaded_RestoreFailed, ProjectName));
}
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.OutputPath = await GetBaseIntermediatePathAsync();
metadata.ProjectPath = MSBuildProjectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = MSBuildProjectPath;
// Reload the target framework from csproj and update the target framework in packageSpec for restore
await UpdateInternalTargetFrameworkAsync();
if (TryGetInternalFramework(out var internalTargetFramework))
{
// Ensure the project json has only one target framework
if (packageSpec.TargetFrameworks != null && packageSpec.TargetFrameworks.Count == 1)
{
var replaceTargetFramework = new TargetFrameworkInformation();
replaceTargetFramework.FrameworkName = internalTargetFramework as NuGetFramework;
packageSpec.TargetFrameworks[0] = replaceTargetFramework;
}
}
var references = (await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(context.Logger, CancellationToken.None))
.ToList();
if (references != null && references.Count > 0)
{
// Add msbuild reference groups for each TFM in the project
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
foreach (var reference in references)
{
// This reference applies to all frameworks
// Include/exclude flags may be applied later when merged with project.json
// Add the reference for all TFM groups, there are no conditional project
// references in UWP. There should also be just one TFM.
foreach (var frameworkInfo in metadata.TargetFrameworks)
{
frameworkInfo.ProjectReferences.Add(reference);
}
}
}
// Write restore settings to the package spec.
// For project.json these properties may not come from the project file.
var settings = context?.Settings ?? NullSettings.Instance;
packageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings);
packageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).AsList();
packageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).AsList();
packageSpec.RestoreMetadata.ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).AsList();
context?.PackageSpecCache.Add(MSBuildProjectPath, packageSpec);
}
return(new[] { packageSpec });
}
/// <summary>
/// Gets the restore metadata and target framework information for the specified project.
/// </summary>
/// <param name="project">An <see cref="IMSBuildProject" /> representing the project.</param>
/// <param name="projectsByTargetFramework">A <see cref="IReadOnlyDictionary{NuGetFramework,IMSBuildProject}" /> containing the inner nodes by target framework.</param>
/// <param name="settings">The <see cref="ISettings" /> of the specified project.</param>
/// <returns>A <see cref="Tuple" /> containing the <see cref="ProjectRestoreMetadata" /> and <see cref="List{TargetFrameworkInformation}" /> for the specified project.</returns>
private (ProjectRestoreMetadata RestoreMetadata, List <TargetFrameworkInformation> TargetFrameworkInfos) GetProjectRestoreMetadataAndTargetFrameworkInformation(IMSBuildProject project, IReadOnlyDictionary <NuGetFramework, IMSBuildProject> projectsByTargetFramework, ISettings settings)
{
var projectName = GetProjectName(project);
var outputPath = GetRestoreOutputPath(project);
var targetFrameworkInfos = GetTargetFrameworkInfos(projectsByTargetFramework);
var projectStyleResult = BuildTasksUtility.GetProjectRestoreStyle(
restoreProjectStyle: project.GetProperty("RestoreProjectStyle"),
hasPackageReferenceItems: targetFrameworkInfos.Any(i => i.Dependencies.Any()),
projectJsonPath: project.GetProperty("_CurrentProjectJsonPath"),
projectDirectory: project.Directory,
projectName: project.GetProperty("MSBuildProjectName"),
log: MSBuildLogger);
var projectStyle = projectStyleResult.ProjectStyle;
var innerNodes = projectsByTargetFramework.Values.ToList();
ProjectRestoreMetadata restoreMetadata;
if (projectStyle == ProjectStyle.PackagesConfig)
{
restoreMetadata = new PackagesConfigProjectRestoreMetadata
{
PackagesConfigPath = projectStyleResult.PackagesConfigFilePath,
RepositoryPath = GetRepositoryPath(project, settings)
};
}
else
{
restoreMetadata = new ProjectRestoreMetadata
{
CrossTargeting = (projectStyle == ProjectStyle.PackageReference || projectStyle == ProjectStyle.DotnetToolReference) && projectsByTargetFramework.Count > 1,
FallbackFolders = BuildTasksUtility.GetFallbackFolders(
project.Directory,
project.SplitPropertyValueOrNull("RestoreFallbackFolders"),
project.SplitPropertyValueOrNull("RestoreFallbackFoldersOverride"),
innerNodes.SelectMany(i => MSBuildStringUtility.Split(i.GetProperty("RestoreAdditionalProjectFallbackFolders"))),
innerNodes.SelectMany(i => MSBuildStringUtility.Split(i.GetProperty("RestoreAdditionalProjectFallbackFoldersExcludes"))),
settings),
SkipContentFileWrite = IsLegacyProject(project),
ValidateRuntimeAssets = project.IsPropertyTrue("ValidateRuntimeIdentifierCompatibility")
};
}
restoreMetadata.CacheFilePath = NoOpRestoreUtilities.GetProjectCacheFilePath(outputPath, project.FullPath);
restoreMetadata.ConfigFilePaths = settings.GetConfigFilePaths();
restoreMetadata.OutputPath = outputPath;
restoreMetadata.OriginalTargetFrameworks = GetOriginalTargetFrameworks(project, projectsByTargetFramework.Keys.ToList());
restoreMetadata.PackagesPath = GetPackagesPath(project, settings);
restoreMetadata.ProjectName = projectName;
restoreMetadata.ProjectPath = project.FullPath;
restoreMetadata.ProjectStyle = projectStyle;
restoreMetadata.ProjectUniqueName = project.FullPath;
restoreMetadata.ProjectWideWarningProperties = WarningProperties.GetWarningProperties(project.GetProperty("TreatWarningsAsErrors"), project.GetProperty("WarningsAsErrors"), project.GetProperty("NoWarn"));
restoreMetadata.RestoreLockProperties = new RestoreLockProperties(project.GetProperty("RestorePackagesWithLockFile"), project.GetProperty("NuGetLockFilePath"), project.IsPropertyTrue("RestoreLockedMode"));
restoreMetadata.Sources = GetSources(project, innerNodes, settings);
restoreMetadata.TargetFrameworks = GetProjectRestoreMetadataFrameworkInfos(projectsByTargetFramework);
return(restoreMetadata, targetFrameworkInfos);
}
public async Task <IReadOnlyList <PackageSpec> > GetPackageSpecsAsync(DependencyGraphCacheContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// Some projects like website project don't have project file.
// Return empty list for this case.
if (string.IsNullOrEmpty(ProjectSystem.ProjectFileFullPath))
{
return(new List <PackageSpec>());
}
PackageSpec packageSpec = null;
if (!context.PackageSpecCache.TryGetValue(ProjectSystem.ProjectFileFullPath, out packageSpec))
{
packageSpec = new PackageSpec(new List <TargetFrameworkInformation>
{
new TargetFrameworkInformation
{
FrameworkName = ProjectSystem.TargetFramework
}
});
packageSpec.Name = ProjectSystem.ProjectName;
packageSpec.FilePath = ProjectSystem.ProjectFileFullPath;
// A packages.config project does not follow the typical restore flow so there is no need to add package
// dependencides to the package spec. Packages.config package restoration is done elsewhere.
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.Unknown;
metadata.ProjectPath = ProjectSystem.ProjectFileFullPath;
metadata.ProjectName = ProjectSystem.ProjectName;
metadata.ProjectUniqueName = ProjectSystem.ProjectFileFullPath;
var references = (await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(context.Logger, CancellationToken.None))
.ToList();
if (references != null && references.Count > 0)
{
// Add framework group
var frameworkGroup = new ProjectRestoreMetadataFrameworkInfo(ProjectSystem.TargetFramework);
metadata.TargetFrameworks.Add(frameworkGroup);
foreach (var reference in references)
{
// This reference applies to all frameworks
// Include/exclude flags are not possible for this project type
frameworkGroup.ProjectReferences.Add(reference);
}
}
context.PackageSpecCache.Add(MSBuildProjectPath, packageSpec);
}
return(new[] { packageSpec });
}
private ProjectRestoreMetadata CreateProjectRestoreMetadata()
{
var projectReference = new ProjectRestoreReference();
projectReference.ProjectPath = "Path";
projectReference.ProjectUniqueName = "ProjectUniqueName";
projectReference.IncludeAssets = LibraryIncludeFlags.All;
projectReference.ExcludeAssets = LibraryIncludeFlags.Analyzers;
projectReference.PrivateAssets = LibraryIncludeFlags.Build;
var nugetFramework = NuGetFramework.Parse("net461");
var originalPRMFI = new ProjectRestoreMetadataFrameworkInfo(nugetFramework);
originalPRMFI.ProjectReferences = new List <ProjectRestoreReference>()
{
projectReference
};
var targetframeworks = new List <ProjectRestoreMetadataFrameworkInfo>()
{
originalPRMFI
};
var allWarningsAsErrors = true;
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var warningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn);
var originalProjectRestoreMetadata = new ProjectRestoreMetadata();
originalProjectRestoreMetadata.ProjectStyle = ProjectStyle.PackageReference;
originalProjectRestoreMetadata.ProjectPath = "ProjectPath";
originalProjectRestoreMetadata.ProjectJsonPath = "ProjectJsonPath";
originalProjectRestoreMetadata.OutputPath = "OutputPath";
originalProjectRestoreMetadata.ProjectName = "ProjectName";
originalProjectRestoreMetadata.ProjectUniqueName = "ProjectUniqueName";
originalProjectRestoreMetadata.PackagesPath = "PackagesPath";
originalProjectRestoreMetadata.CacheFilePath = "CacheFilePath";
originalProjectRestoreMetadata.CrossTargeting = true;
originalProjectRestoreMetadata.LegacyPackagesDirectory = true;
originalProjectRestoreMetadata.ValidateRuntimeAssets = true;
originalProjectRestoreMetadata.SkipContentFileWrite = true;
originalProjectRestoreMetadata.TargetFrameworks = targetframeworks;
originalProjectRestoreMetadata.Sources = new List <PackageSource>()
{
new PackageSource("http://api.nuget.org/v3/index.json")
};;
originalProjectRestoreMetadata.FallbackFolders = new List <string>()
{
"fallback1"
};
originalProjectRestoreMetadata.ConfigFilePaths = new List <string>()
{
"config1"
};
originalProjectRestoreMetadata.OriginalTargetFrameworks = new List <string>()
{
"net45"
};
originalProjectRestoreMetadata.Files = new List <ProjectRestoreMetadataFile>()
{
new ProjectRestoreMetadataFile("packagePath", "absolutePath")
};
originalProjectRestoreMetadata.ProjectWideWarningProperties = warningProperties;
return(originalProjectRestoreMetadata);
}
private static void AssertHashCode(bool expected, ProjectRestoreMetadata leftSide, ProjectRestoreMetadata rightSide)
{
if (expected)
{
leftSide.GetHashCode().Should().Be(rightSide.GetHashCode());
}
else
{
leftSide.GetHashCode().Should().NotBe(rightSide.GetHashCode());
}
}
private static void AssertHashCode(ProjectRestoreMetadata leftSide, ProjectRestoreMetadata rightSide)
{
AssertHashCode(true, leftSide, rightSide);
}
public async Task BuildIntegratedRestoreUtility_IsRestoreRequired_DeferredProjectLoad()
{
// Arrange
var projectName = "testproj";
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = Path.Combine(projectFolder.FullName, "project.json");
var projectPath = Path.Combine(projectFolder.FullName, $"{projectName}.csproj");
var packageSpec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", projectConfig);
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.ProjectPath = projectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = projectPath;
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
var solutionManager = new TestSolutionManager(false);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
restoreContext.DeferredPackageSpecs.Add(packageSpec);
var pathContext = NuGetPathContext.Create(NullSettings.Instance);
var oldHash = restoreContext.SolutionSpecHash;
// Act
var result = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync(
solutionManager,
forceRestore : false,
pathContext : pathContext,
cacheContext : restoreContext,
oldDependencyGraphSpecHash : oldHash);
// Assert
Assert.Equal(true, result);
Assert.Equal(0, testLogger.Errors);
Assert.Equal(0, testLogger.Warnings);
}
}
private static void AssertEquality(ProjectRestoreMetadata leftSide, ProjectRestoreMetadata rightSide)
{
AssertEquality(true, leftSide, rightSide);
}
private ProjectRestoreMetadata CreateProjectRestoreMetadata()
{
var projectReference = new ProjectRestoreReference
{
ProjectPath = "Path",
ProjectUniqueName = "ProjectUniqueName",
IncludeAssets = LibraryIncludeFlags.All,
ExcludeAssets = LibraryIncludeFlags.Analyzers,
PrivateAssets = LibraryIncludeFlags.Build
};
var nugetFramework = NuGetFramework.Parse("net461");
var originalPRMFI = new ProjectRestoreMetadataFrameworkInfo(nugetFramework)
{
ProjectReferences = new List <ProjectRestoreReference>()
{
projectReference
}
};
var targetframeworks = new List <ProjectRestoreMetadataFrameworkInfo>()
{
originalPRMFI
};
var allWarningsAsErrors = true;
var noWarn = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1000, NuGetLogCode.NU1500
};
var warningsAsErrors = new HashSet <NuGetLogCode>()
{
NuGetLogCode.NU1001, NuGetLogCode.NU1501
};
var warningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn);
var restoreLockProperties = new RestoreLockProperties(restorePackagesWithLockFile: "true", nuGetLockFilePath: null, restoreLockedMode: false);
var originalProjectRestoreMetadata = new ProjectRestoreMetadata
{
ProjectStyle = ProjectStyle.PackageReference,
ProjectPath = "ProjectPath",
ProjectJsonPath = "ProjectJsonPath",
OutputPath = "OutputPath",
ProjectName = "ProjectName",
ProjectUniqueName = "ProjectUniqueName",
PackagesPath = "PackagesPath",
CacheFilePath = "CacheFilePath",
CrossTargeting = true,
LegacyPackagesDirectory = true,
ValidateRuntimeAssets = true,
SkipContentFileWrite = true,
TargetFrameworks = targetframeworks,
Sources = new List <PackageSource>()
{
new PackageSource("http://api.nuget.org/v3/index.json")
},
FallbackFolders = new List <string>()
{
"fallback1"
},
ConfigFilePaths = new List <string>()
{
"config1"
},
OriginalTargetFrameworks = new List <string>()
{
"net45"
},
Files = new List <ProjectRestoreMetadataFile>()
{
new ProjectRestoreMetadataFile("packagePath", "absolutePath")
},
ProjectWideWarningProperties = warningProperties,
RestoreLockProperties = restoreLockProperties
};
return(originalProjectRestoreMetadata);
}
private PackageSpec ToPackageSpec(ProjectNames projectNames, IVsProjectRestoreInfo projectRestoreInfo)
{
var tfis = projectRestoreInfo
.TargetFrameworks
.Cast <IVsTargetFrameworkInfo>()
.Select(ToTargetFrameworkInformation)
.ToArray();
var projectFullPath = Path.GetFullPath(projectNames.FullName);
var projectDirectory = Path.GetDirectoryName(projectFullPath);
// TODO: Remove temporary integration code NuGet/Home#3810
// Initialize OTF and CT values when original value of OTF property is not provided.
var originalTargetFrameworks = tfis
.Select(tfi => tfi.FrameworkName.GetShortFolderName())
.ToArray();
var crossTargeting = originalTargetFrameworks.Length > 1;
// if "TargetFrameworks" property presents in the project file prefer the raw value.
if (!string.IsNullOrWhiteSpace(projectRestoreInfo.OriginalTargetFrameworks))
{
originalTargetFrameworks = MSBuildStringUtility.Split(
projectRestoreInfo.OriginalTargetFrameworks);
// cross-targeting is always ON even in case of a single tfm in the list.
crossTargeting = true;
}
var outputPath = Path.GetFullPath(
Path.Combine(
projectDirectory,
projectRestoreInfo.BaseIntermediatePath));
var projectName = GetPackageId(projectNames, projectRestoreInfo.TargetFrameworks);
var packageSpec = new PackageSpec(tfis)
{
Name = projectName,
Version = GetPackageVersion(projectRestoreInfo.TargetFrameworks),
FilePath = projectFullPath,
ProjectId = TryGetProjectIdFromCache(projectFullPath, _projectSystemCache, out var projectId) ? projectId : string.Empty,
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectName = projectName,
ProjectUniqueName = projectFullPath,
ProjectPath = projectFullPath,
OutputPath = outputPath,
ProjectStyle = ProjectStyle.PackageReference,
TargetFrameworks = projectRestoreInfo.TargetFrameworks
.Cast <IVsTargetFrameworkInfo>()
.Select(item => ToProjectRestoreMetadataFrameworkInfo(item, projectDirectory))
.ToList(),
OriginalTargetFrameworks = originalTargetFrameworks,
CrossTargeting = crossTargeting,
// Read project properties for settings. ISettings values will be applied later since
// this value is put in the nomination cache and ISettings could change.
PackagesPath = GetRestoreProjectPath(projectRestoreInfo.TargetFrameworks),
FallbackFolders = GetRestoreFallbackFolders(projectRestoreInfo.TargetFrameworks).AsList(),
Sources = GetRestoreSources(projectRestoreInfo.TargetFrameworks)
.Select(e => new PackageSource(e))
.ToList(),
ProjectWideWarningProperties = WarningProperties.GetWarningProperties(
treatWarningsAsErrors: GetSingleOrDefaultPropertyValue(projectRestoreInfo.TargetFrameworks, TreatWarningsAsErrors, e => e),
warningsAsErrors: GetSingleOrDefaultNuGetLogCodes(projectRestoreInfo.TargetFrameworks, WarningsAsErrors, e => MSBuildStringUtility.GetNuGetLogCodes(e)),
noWarn: GetSingleOrDefaultNuGetLogCodes(projectRestoreInfo.TargetFrameworks, NoWarn, e => MSBuildStringUtility.GetNuGetLogCodes(e))),
CacheFilePath = NoOpRestoreUtilities.GetProjectCacheFilePath(cacheRoot: outputPath, projectPath: projectFullPath)
},
RuntimeGraph = GetRuntimeGraph(projectRestoreInfo),
RestoreSettings = new ProjectRestoreSettings()
{
HideWarningsAndErrors = true
}
};
return(packageSpec);
}
public void DependencyGraphSpec_RoundTripMSBuildMetadata()
{
// Arrange
var frameworks = new List <TargetFrameworkInformation>();
frameworks.Add(new TargetFrameworkInformation()
{
FrameworkName = NuGetFramework.Parse("net45")
});
var spec = new PackageSpec(frameworks);
spec.Version = NuGetVersion.Parse("24.5.1.2-alpha.1.2+a.b.c");
var msbuildMetadata = new ProjectRestoreMetadata();
spec.RestoreMetadata = msbuildMetadata;
msbuildMetadata.ProjectUniqueName = "A55205E7-4D08-4672-8011-0925467CC45F";
msbuildMetadata.ProjectPath = "c:\\x\\x.csproj";
msbuildMetadata.ProjectName = PackageSpecName;
msbuildMetadata.ProjectJsonPath = "c:\\x\\project.json";
msbuildMetadata.ProjectStyle = ProjectStyle.PackageReference;
msbuildMetadata.PackagesPath = "c:\\packages";
msbuildMetadata.Sources = new[] { new PackageSource("https://api.nuget.org/v3/index.json") };
var tfmGroup = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"));
msbuildMetadata.TargetFrameworks.Add(tfmGroup);
tfmGroup.ProjectReferences.Add(new ProjectRestoreReference()
{
ProjectUniqueName = "44B29B8D-8413-42D2-8DF4-72225659619B",
ProjectPath = "c:\\a\\a.csproj"
});
tfmGroup.ProjectReferences.Add(new ProjectRestoreReference()
{
ProjectUniqueName = "78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F",
ProjectPath = "c:\\b\\b.csproj"
});
msbuildMetadata.FallbackFolders.Add("c:\\fallback1");
msbuildMetadata.FallbackFolders.Add("c:\\fallback2");
msbuildMetadata.ConfigFilePaths.Add("c:\\nuget.config");
msbuildMetadata.ConfigFilePaths.Add("d:\\nuget.config");
msbuildMetadata.CrossTargeting = true;
msbuildMetadata.LegacyPackagesDirectory = true;
// Act
PackageSpec readSpec = PackageSpecTestUtility.RoundTrip(spec, PackageSpecName, PackageSpecPath);
ProjectRestoreMetadata msbuildMetadata2 = readSpec.RestoreMetadata;
// Assert
Assert.NotNull(msbuildMetadata2);
Assert.Equal("A55205E7-4D08-4672-8011-0925467CC45F", msbuildMetadata2.ProjectUniqueName);
Assert.Equal("c:\\x\\x.csproj", msbuildMetadata2.ProjectPath);
Assert.Equal(PackageSpecName, msbuildMetadata2.ProjectName);
Assert.Equal("c:\\x\\project.json", msbuildMetadata2.ProjectJsonPath);
Assert.Equal(ProjectStyle.PackageReference, msbuildMetadata2.ProjectStyle);
Assert.Equal("c:\\packages", msbuildMetadata2.PackagesPath);
Assert.Equal("https://api.nuget.org/v3/index.json", string.Join("|", msbuildMetadata.Sources.Select(s => s.Source)));
Assert.Equal("c:\\fallback1|c:\\fallback2", string.Join("|", msbuildMetadata2.FallbackFolders));
Assert.Equal("c:\\nuget.config|d:\\nuget.config", string.Join("|", msbuildMetadata.ConfigFilePaths));
Assert.Equal("44B29B8D-8413-42D2-8DF4-72225659619B|c:\\a\\a.csproj|78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F|c:\\b\\b.csproj", string.Join("|", msbuildMetadata2.TargetFrameworks.Single().ProjectReferences.Select(e => $"{e.ProjectUniqueName}|{e.ProjectPath}")));
Assert.True(msbuildMetadata.CrossTargeting);
Assert.True(msbuildMetadata.LegacyPackagesDirectory);
// Verify build metadata is not lost.
Assert.Equal("24.5.1.2-alpha.1.2+a.b.c", readSpec.Version.ToFullString());
}
private static void AssertEquality(bool expected, ProjectRestoreMetadata leftSide, ProjectRestoreMetadata rightSide)
{
if (expected)
{
leftSide.Should().Be(rightSide);
}
else
{
leftSide.Should().NotBe(rightSide);
}
}
public void DependencyGraphSpec_RoundTripMSBuildMetadata_ProjectReferenceFlags()
{
// Arrange
var frameworks = new List <TargetFrameworkInformation>();
frameworks.Add(new TargetFrameworkInformation()
{
FrameworkName = NuGetFramework.Parse("net45")
});
var spec = new PackageSpec(frameworks);
var msbuildMetadata = new ProjectRestoreMetadata();
spec.RestoreMetadata = msbuildMetadata;
msbuildMetadata.ProjectUniqueName = "A55205E7-4D08-4672-8011-0925467CC45F";
msbuildMetadata.ProjectPath = "c:\\x\\x.csproj";
msbuildMetadata.ProjectName = PackageSpecName;
msbuildMetadata.ProjectStyle = ProjectStyle.PackageReference;
var tfmGroup = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"));
var tfmGroup2 = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("netstandard1.3"));
msbuildMetadata.TargetFrameworks.Add(tfmGroup);
msbuildMetadata.TargetFrameworks.Add(tfmGroup2);
var ref1 = new ProjectRestoreReference()
{
ProjectUniqueName = "44B29B8D-8413-42D2-8DF4-72225659619B",
ProjectPath = "c:\\a\\a.csproj",
IncludeAssets = LibraryIncludeFlags.Build,
ExcludeAssets = LibraryIncludeFlags.Compile,
PrivateAssets = LibraryIncludeFlags.Runtime
};
var ref2 = new ProjectRestoreReference()
{
ProjectUniqueName = "78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F",
ProjectPath = "c:\\b\\b.csproj"
};
tfmGroup.ProjectReferences.Add(ref1);
tfmGroup.ProjectReferences.Add(ref2);
tfmGroup2.ProjectReferences.Add(ref1);
tfmGroup2.ProjectReferences.Add(ref2);
// Act
PackageSpec readSpec = PackageSpecTestUtility.RoundTrip(spec, PackageSpecName, PackageSpecPath);
// Assert
Assert.Equal(2, readSpec.RestoreMetadata.TargetFrameworks.Count);
foreach (var framework in readSpec.RestoreMetadata.TargetFrameworks)
{
var references = framework.ProjectReferences.OrderBy(e => e.ProjectUniqueName).ToArray();
Assert.Equal("44B29B8D-8413-42D2-8DF4-72225659619B", references[0].ProjectUniqueName);
Assert.Equal(LibraryIncludeFlags.Build, references[0].IncludeAssets);
Assert.Equal(LibraryIncludeFlags.Compile, references[0].ExcludeAssets);
Assert.Equal(LibraryIncludeFlags.Runtime, references[0].PrivateAssets);
Assert.Equal("78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F", references[1].ProjectUniqueName);
Assert.Equal(LibraryIncludeFlags.All, references[1].IncludeAssets);
Assert.Equal(LibraryIncludeFlags.None, references[1].ExcludeAssets);
Assert.Equal(LibraryIncludeFlagUtils.DefaultSuppressParent, references[1].PrivateAssets);
}
}
public async Task BuildIntegratedRestoreUtility_RestoreDeferredProjectLoad()
{
// Arrange
var projectName = "testproj";
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
""dependencies"": {
""packageA"": ""1.0.0""
}
}
}
}";
using (var packageSource = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <PackageSource>()
{
new PackageSource(packageSource.Path)
});
var packageContext = new SimpleTestPackageContext("packageA");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = Path.Combine(projectFolder.FullName, "project.json");
var projectPath = Path.Combine(projectFolder.FullName, $"{projectName}.csproj");
var packageSpec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", projectConfig);
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.ProjectPath = projectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = projectPath;
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
var solutionManager = new TestSolutionManager(false);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
restoreContext.DeferredPackageSpecs.Add(packageSpec);
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
NullSettings.Instance,
testLogger,
CancellationToken.None);
// Assert
Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json")));
Assert.True(testLogger.Errors == 0);
}
}
