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; }