private async Task LogWarningAsync(string id, FatalProtocolException e)
{
if (!_ignoreWarning)
{
await _logger.LogAsync(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1801, e.Message, id));
}
}
public void GetMessagesForProject_WithMultipleMessages_SelectedMessagesForCorrectProject()
{
// Arrange
var project1 = @"z:\src\solution\project1\project1.csproj";
var project2 = @"z:\src\solution\project2\project2.csproj";
var project1Error = RestoreLogMessage.CreateError(NuGetLogCode.NU1001, "project1 error");
project1Error.ProjectPath = project1;
var project2Error = RestoreLogMessage.CreateError(NuGetLogCode.NU1002, "project2 error");
project2Error.ProjectPath = project2;
var solutionMessages = new List <IAssetsLogMessage>()
{
AssetsLogMessage.Create(project1Error),
AssetsLogMessage.Create(project2Error)
};
// Act
IReadOnlyList <IAssetsLogMessage> actual = DependencyGraphSpecRequestProvider.GetMessagesForProject(solutionMessages, project1);
// Assert
var actualError = Assert.Single(actual);
Assert.Equal(NuGetLogCode.NU1001, actualError.Code);
}
public void WarningPropertiesCollection_MessageWithTargetGraphAndDependencyWithNoWarnForAllTfmAndNoProjectFrameworks_2()
{
// Arrange
var libraryId = "test_library";
var net45FrameworkString = "net45";
var net45TargetFramework = NuGetFramework.Parse(net45FrameworkString);
var noWarnSet = new HashSet <NuGetLogCode> {
};
var warnAsErrorSet = new HashSet <NuGetLogCode> {
};
var allWarningsAsErrors = false;
var packageSpecificWarningProperties = new PackageSpecificWarningProperties();
packageSpecificWarningProperties.Add(NuGetLogCode.NU1500, libraryId, net45TargetFramework);
var warningPropertiesCollection = new WarningPropertiesCollection()
{
ProjectWideWarningProperties = new WarningProperties(warnAsErrorSet, noWarnSet, allWarningsAsErrors),
PackageSpecificWarningProperties = packageSpecificWarningProperties
};
var suppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId, new string[] { net45FrameworkString });
// Act && Assert
Assert.True(warningPropertiesCollection.ApplyWarningProperties(suppressedMessage));
Assert.Equal(0, suppressedMessage.TargetGraphs.Count);
}
public void RestoreLogMessage_TestConstructorWithAllFields()
{
// Arrange & Act
var logMessage = new RestoreLogMessage(LogLevel.Warning, NuGetLogCode.NU1500, "test log message")
{
TargetGraphs = new List <string>()
{
"net46", "netcoreapp1.0", "netstandard1.6"
},
WarningLevel = WarningLevel.Severe,
FilePath = "kung\\fu\\fighting.targets",
StartLineNumber = 11,
EndLineNumber = 11,
StartColumnNumber = 2,
EndColumnNumber = 10
};
// Assert
Assert.NotNull(logMessage);
Assert.Equal(LogLevel.Warning, logMessage.Level);
Assert.Equal(WarningLevel.Severe, logMessage.WarningLevel);
Assert.Equal(NuGetLogCode.NU1500, logMessage.Code);
Assert.Equal("kung\\fu\\fighting.targets", logMessage.FilePath);
Assert.Equal(11, logMessage.StartLineNumber);
Assert.Equal(11, logMessage.EndLineNumber);
Assert.Equal(2, logMessage.StartColumnNumber);
Assert.Equal(10, logMessage.EndColumnNumber);
Assert.NotNull(logMessage.TargetGraphs);
Assert.Equal(3, logMessage.TargetGraphs.Count);
Assert.Equal("test log message", logMessage.Message);
}
/// <summary>
/// Get warning message for missing minimum dependencies.
/// </summary>
public static RestoreLogMessage GetMissingLowerBoundMessage(ResolvedDependencyKey dependency, params string[] targetGraphs)
{
NuGetLogCode code;
var message = string.Empty;
var parent = DiagnosticUtility.FormatIdentity(dependency.Parent);
var dependencyRange = DiagnosticUtility.FormatDependency(dependency.Child.Name, dependency.Range);
var missingChild = DiagnosticUtility.FormatExpectedIdentity(dependency.Child.Name, dependency.Range);
var resolvedChild = DiagnosticUtility.FormatIdentity(dependency.Child);
if (HasMissingLowerBound(dependency.Range))
{
// Range does not have a lower bound, the best match can only be approximate.
message = string.Format(CultureInfo.CurrentCulture, Strings.Warning_MinVersionNonInclusive,
parent,
dependencyRange,
resolvedChild);
code = NuGetLogCode.NU1602;
}
else
{
// The minimum version does not exist.
message = string.Format(CultureInfo.CurrentCulture, Strings.Warning_MinVersionDoesNotExist,
parent,
dependencyRange,
missingChild,
resolvedChild);
code = NuGetLogCode.NU1603;
}
return(RestoreLogMessage.CreateWarning(code, message, dependency.Child.Name, targetGraphs));
}
/// <summary>
/// Asynchronously discover all package versions from a feed.
/// </summary>
/// <param name="id">A package ID.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns an
/// <see cref="IEnumerable{NuGetVersion}" />.</returns>
public async Task <IEnumerable <NuGetVersion> > GetAllVersionsAsync(
string id,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
IEnumerable <NuGetVersion> packageVersions = null;
try
{
if (_throttle != null)
{
await _throttle.WaitAsync();
}
packageVersions = await _findPackagesByIdResource.GetAllVersionsAsync(
id,
cacheContext,
logger,
cancellationToken);
}
catch (FatalProtocolException e) when(_ignoreFailedSources)
{
if (!_ignoreWarning)
{
await _logger.LogAsync(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1801, e.Message, id));
}
return(null);
}
finally
{
_throttle?.Release();
}
return(packageVersions);
}
// Gets the runtime graph specified in the path.
// returns null if an error is hit. A valid runtime graph otherwise.
private RuntimeGraph GetRuntimeGraph(string runtimeGraphPath)
{
if (File.Exists(runtimeGraphPath))
{
try
{
using (var stream = File.OpenRead(runtimeGraphPath))
{
var runtimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(stream);
return(runtimeGraph);
}
}
catch (Exception e)
{
_logger.Log(
RestoreLogMessage.CreateError(
NuGetLogCode.NU1007,
string.Format(CultureInfo.CurrentCulture,
Strings.Error_ProjectRuntimeJsonIsUnreadable,
runtimeGraphPath,
e.Message)));
}
}
else
{
_logger.Log(
RestoreLogMessage.CreateError(
NuGetLogCode.NU1007,
string.Format(CultureInfo.CurrentCulture,
Strings.Error_ProjectRuntimeJsonNotFound,
runtimeGraphPath)));
}
return(null);
}
/// <summary>
/// Create restore requests but do not execute them.
/// </summary>
public static async Task <IReadOnlyList <RestoreSummaryRequest> > GetRequests(RestoreArgs restoreContext)
{
// Get requests
var requests = new List <RestoreSummaryRequest>();
var inputs = new List <string>(restoreContext.Inputs);
// If there are no inputs, use the current directory
if (restoreContext.PreLoadedRequestProviders.Count < 1 && !inputs.Any())
{
inputs.Add(Path.GetFullPath("."));
}
// Ignore casing on windows and mac
var comparer = (RuntimeEnvironmentHelper.IsWindows || RuntimeEnvironmentHelper.IsMacOSX) ?
StringComparer.OrdinalIgnoreCase
: StringComparer.Ordinal;
var uniqueRequest = new HashSet <string>(comparer);
// Create requests
// Pre-loaded requests
foreach (var request in await CreatePreLoadedRequests(restoreContext))
{
// De-dupe requests
if (request.Request.LockFilePath == null ||
uniqueRequest.Add(request.Request.LockFilePath))
{
requests.Add(request);
}
}
// Input based requests
foreach (var input in inputs)
{
var inputRequests = await CreateRequests(input, restoreContext);
if (inputRequests.Count == 0)
{
// No need to throw here - the situation is harmless, and we want to report all possible
// inputs that don't resolve to a project.
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.Error_UnableToLocateRestoreTarget,
Path.GetFullPath(input));
await restoreContext.Log.LogAsync(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1501, message));
}
foreach (var request in inputRequests)
{
// De-dupe requests
if (uniqueRequest.Add(request.Request.LockFilePath))
{
requests.Add(request);
}
}
}
return(requests);
}
public override void Log(ILogMessage message)
{
if (DisplayMessage(message.Level))
{
if (RuntimeEnvironmentHelper.IsMono)
{
LogForMono(message);
return;
}
else
{
var logMessage = message as IRestoreLogMessage;
if (logMessage == null)
{
logMessage = new RestoreLogMessage(message.Level, message.Message)
{
Code = message.Code,
FilePath = message.ProjectPath
};
}
LogForNonMono(logMessage);
}
}
}
public void WarningPropertiesCollection_PackagePropertiesWithFrameworkAndWarningWithFramework()
{
// Arrange
// Arrange
var libraryId = "test_library";
var frameworkString = "net45";
var targetFramework = NuGetFramework.Parse(frameworkString);
var packageSpecificWarningProperties = new PackageSpecificWarningProperties();
packageSpecificWarningProperties.Add(NuGetLogCode.NU1500, libraryId, targetFramework);
var warningPropertiesCollection = new WarningPropertiesCollection()
{
PackageSpecificWarningProperties = packageSpecificWarningProperties
};
var suppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId, frameworkString);
var nonSuppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1601, "Warning", libraryId, frameworkString);
// Act && Assert
Assert.True(warningPropertiesCollection.ApplyWarningProperties(suppressedMessage));
Assert.False(warningPropertiesCollection.ApplyWarningProperties(nonSuppressedMessage));
Assert.Equal(LogLevel.Warning, nonSuppressedMessage.Level);
}
public void WarningPropertiesCollection_MessageWithTargetGraphAndDependencyWithNoWarnForSomeTfmAndNoProjectFrameworks(string firstFrameworkString, string secondFrameworkString)
{
// Arrange
var libraryId = "test_library";
var firstTargetFramework = NuGetFramework.Parse(firstFrameworkString);
var secondTargetFramework = NuGetFramework.Parse(secondFrameworkString);
var noWarnSet = new HashSet <NuGetLogCode> {
};
var warnAsErrorSet = new HashSet <NuGetLogCode> {
};
var allWarningsAsErrors = false;
var packageSpecificWarningProperties = new PackageSpecificWarningProperties();
packageSpecificWarningProperties.Add(NuGetLogCode.NU1500, libraryId, firstTargetFramework);
var warningPropertiesCollection = new WarningPropertiesCollection(
new WarningProperties(warnAsErrorSet, noWarnSet, allWarningsAsErrors),
packageSpecificWarningProperties,
null);
var nonSuppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId, new string[] { firstFrameworkString, secondFrameworkString });
// Act && Assert
Assert.False(warningPropertiesCollection.ApplyWarningProperties(nonSuppressedMessage));
Assert.Equal(1, nonSuppressedMessage.TargetGraphs.Count);
}
public void WarningPropertiesCollection_PackagePropertiesWithNoWarnAndProjectPropertiesWithWarnAsErrorAndProjectWithoutTargetFramework(string frameworkString)
{
// Arrange
var libraryId = "test_library";
var targetFramework = NuGetFramework.Parse(frameworkString);
var noWarnSet = new HashSet <NuGetLogCode> {
};
var warnAsErrorSet = new HashSet <NuGetLogCode> {
NuGetLogCode.NU1500
};
var allWarningsAsErrors = false;
var packageSpecificWarningProperties = new PackageSpecificWarningProperties();
packageSpecificWarningProperties.Add(NuGetLogCode.NU1500, libraryId, targetFramework);
var warningPropertiesCollection = new WarningPropertiesCollection(
new WarningProperties(warnAsErrorSet, noWarnSet, allWarningsAsErrors),
packageSpecificWarningProperties,
new List <NuGetFramework> {
targetFramework
});
var suppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId, frameworkString);
var suppressedMessage2 = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId);
var unaffectedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1601, "Warning", libraryId);
// Act && Assert
Assert.True(warningPropertiesCollection.ApplyWarningProperties(suppressedMessage));
Assert.Equal(0, suppressedMessage.TargetGraphs.Count);
Assert.True(warningPropertiesCollection.ApplyWarningProperties(suppressedMessage2));
Assert.Equal(0, suppressedMessage2.TargetGraphs.Count);
Assert.False(warningPropertiesCollection.ApplyWarningProperties(unaffectedMessage));
Assert.Equal(0, unaffectedMessage.TargetGraphs.Count);
}
public void WarningPropertiesCollection_MessageWithNoTargetGraphAndDependencyWithNoWarnForAllTfm(string firstFrameworkString, string secondFrameworkString)
{
// Arrange
var libraryId = "test_library";
var firstTargetFramework = NuGetFramework.Parse(firstFrameworkString);
var secondTargetFramework = NuGetFramework.Parse(secondFrameworkString);
var noWarnSet = new HashSet <NuGetLogCode> {
};
var warnAsErrorSet = new HashSet <NuGetLogCode> {
};
var allWarningsAsErrors = false;
var packageSpecificWarningProperties = new PackageSpecificWarningProperties();
packageSpecificWarningProperties.Add(NuGetLogCode.NU1500, libraryId, firstTargetFramework);
packageSpecificWarningProperties.Add(NuGetLogCode.NU1500, libraryId, secondTargetFramework);
var warningPropertiesCollection = new WarningPropertiesCollection()
{
ProjectWideWarningProperties = new WarningProperties(warnAsErrorSet, noWarnSet, allWarningsAsErrors),
PackageSpecificWarningProperties = packageSpecificWarningProperties,
ProjectFrameworks = new List <NuGetFramework> {
firstTargetFramework, secondTargetFramework
}
};
var suppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId);
// Act && Assert
Assert.True(warningPropertiesCollection.ApplyWarningProperties(suppressedMessage));
Assert.Equal(0, suppressedMessage.TargetGraphs.Count);
}
public void WarningPropertiesCollection_PackagePropertiesAndProjectPropertiesWithNoWarn()
{
// Arrange
// Arrange
var libraryId = "test_library";
var frameworkString = "net45";
var targetFramework = NuGetFramework.Parse(frameworkString);
var noWarnSet = new HashSet <NuGetLogCode> {
NuGetLogCode.NU1500
};
var warnAsErrorSet = new HashSet <NuGetLogCode> {
};
var allWarningsAsErrors = false;
var packageSpecificWarningProperties = new PackageSpecificWarningProperties();
var warningPropertiesCollection = new WarningPropertiesCollection()
{
ProjectWideWarningProperties = new WarningProperties(warnAsErrorSet, noWarnSet, allWarningsAsErrors),
PackageSpecificWarningProperties = packageSpecificWarningProperties
};
var suppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId);
// Act && Assert
Assert.True(warningPropertiesCollection.ApplyWarningProperties(suppressedMessage));
}
public void GivenASingleMessageVerifySameReturned()
{
var messages = new List <RestoreLogMessage>();
messages.Add(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1000, "test", "a", "abc"));
DiagnosticUtility.MergeOnTargetGraph(messages).Should().BeEquivalentTo(messages);
}
/// <summary>
/// Asynchronously gets a package downloader.
/// </summary>
/// <param name="packageIdentity">A package identity.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns a <see cref="IPackageDownloader" />
/// instance.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" />
/// is either <c>null</c> or empty.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" />
/// is either <c>null</c> or empty.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" />
/// is either <c>null</c> or empty.</exception>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public async Task <IPackageDownloader> GetPackageDownloaderAsync(
PackageIdentity packageIdentity,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
cancellationToken.ThrowIfCancellationRequested();
await EnsureResource();
try
{
if (_throttle != null)
{
await _throttle.WaitAsync();
}
cancellationToken.ThrowIfCancellationRequested();
var packageDownloader = await _findPackagesByIdResource.GetPackageDownloaderAsync(
packageIdentity,
cacheContext,
logger,
cancellationToken);
packageDownloader.SetThrottle(_throttle);
return(packageDownloader);
}
catch (FatalProtocolException e) when(_ignoreFailedSources)
{
if (!_ignoreWarning)
{
await _logger.LogAsync(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1801, e.Message, packageIdentity.Id));
}
}
finally
{
_throttle?.Release();
}
return(null);
}
/// <summary>
/// Log upgrade warnings from the graphs.
/// </summary>
public static IEnumerable <RestoreLogMessage> GetDependenciesAboveUpperBounds(List <IndexedRestoreTargetGraph> graphs, ILogger logger)
{
var messages = new List <RestoreLogMessage>();
foreach (var indexedGraph in graphs)
{
var graph = indexedGraph.Graph;
foreach (var node in graph.Flattened)
{
var dependencies = node.Data?.Dependencies ?? Enumerable.Empty <LibraryDependency>();
foreach (var dependency in dependencies)
{
// Check if the dependency has an upper bound
var dependencyRange = dependency.LibraryRange.VersionRange;
var upperBound = dependencyRange?.MaxVersion;
if (upperBound != null)
{
var dependencyId = dependency.Name;
// If the version does not exist then it was not resolved or is a project and should be skipped.
var match = indexedGraph.GetItemById(dependencyId, LibraryType.Package);
if (match != null)
{
var actualVersion = match.Key.Version;
// If the upper bound is included then require that the version be higher than the upper bound to fail
// If the upper bound is not included, then an exact match on the upperbound is a failure
var compare = dependencyRange.IsMaxInclusive ? 1 : 0;
if (VersionComparer.VersionRelease.Compare(actualVersion, upperBound) >= compare)
{
// True if the package already has an NU1107 error, NU1608 would be redundant here.
if (!indexedGraph.HasErrors(dependencyId))
{
var parent = DiagnosticUtility.FormatIdentity(node.Key);
var child = DiagnosticUtility.FormatDependency(dependencyId, dependencyRange);
var actual = DiagnosticUtility.FormatIdentity(match.Key);
var message = string.Format(CultureInfo.CurrentCulture,
Strings.Warning_VersionAboveUpperBound,
parent,
child,
actual);
messages.Add(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1608, message, dependencyId, graph.TargetGraphName));
}
}
}
}
}
}
}
// Merge log messages
return(DiagnosticUtility.MergeOnTargetGraph(messages));
}
public static RestoreLogMessage GetInvalidFallbackCombinationMessage(string path)
{
var error = RestoreLogMessage.CreateError(NuGetLogCode.NU1003, Strings.Error_InvalidATF);
error.ProjectPath = path;
error.FilePath = path;
return(error);
}
/// <summary>
/// Log warning NU1503
/// </summary>
public static RestoreLogMessage GetWarningForUnsupportedProject(string path)
{
var text = string.Format(CultureInfo.CurrentCulture, Strings.UnsupportedProject, path);
var message = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1503, text);
message.FilePath = path;
return(message);
}
private async Task <LibraryDependencyInfo> GetDependenciesCoreAsync(
LibraryIdentity match,
NuGetFramework targetFramework,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
await EnsureResource();
FindPackageByIdDependencyInfo packageInfo = null;
try
{
if (_throttle != null)
{
await _throttle.WaitAsync();
}
// Read package info, this will download the package if needed.
packageInfo = await _findPackagesByIdResource.GetDependencyInfoAsync(
match.Name,
match.Version,
cacheContext,
logger,
cancellationToken);
}
catch (FatalProtocolException e) when(_ignoreFailedSources && !(e is InvalidCacheProtocolException))
{
if (!_ignoreWarning)
{
await _logger.LogAsync(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1801, e.Message, match.Name));
}
}
finally
{
_throttle?.Release();
}
if (packageInfo == null)
{
// Package was not found
return(LibraryDependencyInfo.CreateUnresolved(match, targetFramework));
}
else
{
// Package found
var originalIdentity = new LibraryIdentity(
packageInfo.PackageIdentity.Id,
packageInfo.PackageIdentity.Version,
match.Type);
var dependencies = GetDependencies(packageInfo, targetFramework);
return(LibraryDependencyInfo.Create(originalIdentity, targetFramework, dependencies));
}
}
private ITaskItem AssignNearestFrameworkForSingleReference(
ITaskItem project,
NuGetFramework projectNuGetFramework,
IList <NuGetFramework> fallbackNuGetFrameworks,
MSBuildLogger logger)
{
var itemWithProperties = new TaskItem(project);
var referencedProjectFrameworkString = project.GetMetadata(TARGET_FRAMEWORKS);
var referencedProjectFile = project.GetMetadata(MSBUILD_SOURCE_PROJECT_FILE);
if (string.IsNullOrEmpty(referencedProjectFrameworkString))
{
// No target frameworks set, nothing to do.
return(itemWithProperties);
}
var referencedProjectFrameworks = MSBuildStringUtility.Split(referencedProjectFrameworkString);
// try project framework
var nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(referencedProjectFrameworks, projectNuGetFramework, NuGetFramework.Parse);
if (nearestNuGetFramework != null)
{
itemWithProperties.SetMetadata(NEAREST_TARGET_FRAMEWORK, nearestNuGetFramework);
return(itemWithProperties);
}
// try project fallback frameworks
foreach (var currentProjectTargetFramework in fallbackNuGetFrameworks)
{
nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(referencedProjectFrameworks, currentProjectTargetFramework, NuGetFramework.Parse);
if (nearestNuGetFramework != null)
{
var message = string.Format(CultureInfo.CurrentCulture,
Strings.ImportsFallbackWarning,
referencedProjectFile,
currentProjectTargetFramework.DotNetFrameworkName,
projectNuGetFramework.DotNetFrameworkName);
var warning = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1702, message);
warning.LibraryId = referencedProjectFile;
warning.ProjectPath = CurrentProjectName;
// log NU1702 for ATF on project reference
logger.Log(warning);
itemWithProperties.SetMetadata(NEAREST_TARGET_FRAMEWORK, nearestNuGetFramework);
return(itemWithProperties);
}
}
// no match found
logger.LogError(string.Format(Strings.NoCompatibleTargetFramework, project.ItemSpec, CurrentProjectTargetFramework, referencedProjectFrameworkString));
return(itemWithProperties);
}
public void LogWarningEvent(BuildWarningEventArgs e)
{
var message = new RestoreLogMessage(LogLevel.Warning, e.Message)
{
FilePath = e.File,
ProjectPath = e.ProjectFile
};
TestLogger.Log(message);
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
var message = new RestoreLogMessage(LogLevel.Error, e.Message)
{
FilePath = e.File,
ProjectPath = e.ProjectFile
};
TestLogger.Log(message);
}
private static IRestoreLogMessage ToRestoreLogMessage(ILogMessage message)
{
var restoreLogMessage = message as IRestoreLogMessage;
if (restoreLogMessage == null)
{
restoreLogMessage = new RestoreLogMessage(message.Level, message.Code, message.Message);
}
return(restoreLogMessage);
}
/// <summary>
/// Warn for project dependencies that do not include a lower bound on the version range.
/// </summary>
public static IEnumerable <RestoreLogMessage> GetProjectDependenciesMissingLowerBounds(PackageSpec project)
{
return(project.GetAllPackageDependencies()
.Where(e => HasMissingLowerBound(e.LibraryRange.VersionRange))
.OrderBy(e => e.Name, StringComparer.OrdinalIgnoreCase)
.Select(e => RestoreLogMessage.CreateWarning(
code: NuGetLogCode.NU1604,
message: string.Format(CultureInfo.CurrentCulture, Strings.Warning_ProjectDependencyMissingLowerBound,
DiagnosticUtility.FormatDependency(e.Name, e.LibraryRange.VersionRange)),
libraryId: e.Name)));
}
public void GivenMessagesWithDifferentTextVerifyNoMerges()
{
var messages = new List <RestoreLogMessage>();
messages.Add(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1000, "a", "a", "abc"));
messages.Add(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1000, "b", "a", "abc"));
var outMessages = DiagnosticUtility.MergeOnTargetGraph(messages).ToList();
outMessages.Count.Should().Be(2);
}
public void GivenADuplicateMessagesVerifySingleMessageReturnedWithAllFramweworks()
{
var messages = new List <RestoreLogMessage>();
messages.Add(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1000, "test", "a", "abc"));
messages.Add(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1000, "test", "a", "xyz"));
var outMessages = DiagnosticUtility.MergeOnTargetGraph(messages).ToList();
outMessages.Count.Should().Be(1);
outMessages.Single().TargetGraphs.Should().BeEquivalentTo(new[] { "abc", "xyz" });
}
public void TryGetValue_StringContentNotAvailable_ReturnsNull(string key)
{
// Arrange
var logMessage = new RestoreLogMessage(LogLevel.Error, _testCode, _testMessage);
// Act
var entry = new ErrorListTableEntry(logMessage);
// Assert
entry.Should().NotBeNull();
entry.TryGetValue(key, out var result).Should().BeFalse();
result.Should().BeNull();
}
/// <summary>
/// Log downgrade warnings from the graphs.
/// </summary>
private static Task LogDowngradeWarningsAsync(IEnumerable <RestoreTargetGraph> graphs, ILogger logger)
{
var messages = new List <RestoreLogMessage>();
foreach (var graph in graphs)
{
if (graph.AnalyzeResult.Downgrades.Count > 0)
{
// Find all dependencies in the flattened graph that are not packages.
var ignoreIds = new HashSet <string>(
graph.Flattened.Where(e => e.Key.Type != LibraryType.Package)
.Select(e => e.Key.Name),
StringComparer.OrdinalIgnoreCase);
foreach (var downgrade in graph.AnalyzeResult.Downgrades)
{
var downgraded = downgrade.DowngradedFrom;
var downgradedBy = downgrade.DowngradedTo;
// Filter out non-package dependencies
if (!ignoreIds.Contains(downgraded.Key.Name))
{
// Not all dependencies have a min version, if one does not exist use 0.0.0
var fromVersion = downgraded.GetVersionRange().MinVersion
?? new NuGetVersion(0, 0, 0);
// Use the actual version resolved if it exists
var toVersion = downgradedBy.GetVersionOrDefault()
?? downgradedBy.GetVersionRange().MinVersion
?? new NuGetVersion(0, 0, 0);
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.Log_DowngradeWarning,
downgraded.Key.Name,
fromVersion,
toVersion)
+ $" {Environment.NewLine} {downgraded.GetPathWithLastRange()} {Environment.NewLine} {downgradedBy.GetPathWithLastRange()}";
messages.Add(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1605, message, downgraded.Key.Name, graph.TargetGraphName));
}
}
}
}
// Merge and log messages
var mergedMessages = DiagnosticUtility.MergeOnTargetGraph(messages);
return(logger.LogMessagesAsync(mergedMessages));
}
/// <summary>
/// Logs an error and returns false if any cycles exist.
/// </summary>
private static async Task<bool> ValidateCyclesAsync(IEnumerable<RestoreTargetGraph> graphs, ILogger logger)
{
foreach (var graph in graphs)
{
foreach (var cycle in graph.AnalyzeResult.Cycles)
{
var text = Strings.Log_CycleDetected + $" {Environment.NewLine} {cycle.GetPath()}.";
await logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1606, text, cycle.Key?.Name, graph.TargetGraphName));
return false;
}
}
return true;
}
