public void RestoreLogMessage_TestCreateWarning(NuGetLogCode code, string message, string libraryId, string[] targetGraphs)
{
// Arrange & Act
var logMessage = RestoreLogMessage.CreateWarning(code, message, libraryId, targetGraphs);
// Assert
Assert.Equal(LogLevel.Warning, logMessage.Level);
Assert.Equal(code, logMessage.Code);
Assert.Equal(message, logMessage.Message);
Assert.Equal(-1, logMessage.StartLineNumber);
Assert.Equal(-1, logMessage.EndLineNumber);
Assert.Equal(-1, logMessage.StartColumnNumber);
Assert.Equal(-1, logMessage.EndColumnNumber);
targetGraphs.SequenceEqual(logMessage.TargetGraphs);
}
public AssetsLogMessage(LogLevel logLevel, NuGetLogCode errorCode,
string errorString, string targetGraph)
{
Level = logLevel;
Code = errorCode;
Message = errorString;
if (!string.IsNullOrEmpty(targetGraph))
{
TargetGraphs = new List <string>
{
targetGraph
};
}
}
public RestoreLogMessage(LogLevel logLevel, NuGetLogCode errorCode,
string errorString, string targetGraph, bool logToInnerLogger)
{
Level = logLevel;
Code = errorCode;
Message = errorString;
Time = DateTimeOffset.UtcNow;
var graphList = new List <string>();
if (!string.IsNullOrEmpty(targetGraph))
{
graphList.Add(targetGraph);
}
TargetGraphs = graphList;
ShouldDisplay = logToInnerLogger;
}
private static void AssertValue(
uint expectedValue,
uint actualValue,
NuGetLogCode errorCode,
string errorMessagePrefix,
string errorMessageSuffix,
string fieldName)
{
if (!actualValue.Equals(expectedValue))
{
var failureCause = string.Format(
CultureInfo.CurrentCulture,
errorMessageSuffix,
fieldName,
actualValue);
throw new SignatureException(
errorCode,
string.Format(CultureInfo.CurrentCulture, errorMessagePrefix, failureCause));
}
}
/// <summary>
/// Adds a NuGetLogCode into the NoWarn Set for the specified library Id and target graph.
/// </summary>
/// <param name="code">NuGetLogCode for which no warning should be thrown.</param>
/// <param name="libraryId">Library for which no warning should be thrown.</param>
/// <param name="framework">Target graph for which no warning should be thrown.</param>
public void Add(NuGetLogCode code, string libraryId, NuGetFramework framework)
{
if (Properties == null)
{
Properties = new Dictionary <NuGetLogCode, IDictionary <string, ISet <NuGetFramework> > >();
}
if (!Properties.ContainsKey(code))
{
Properties.Add(code, new Dictionary <string, ISet <NuGetFramework> >(StringComparer.OrdinalIgnoreCase));
}
if (Properties[code].ContainsKey(libraryId))
{
Properties[code][libraryId].Add(framework);
}
else
{
Properties[code].Add(libraryId, new HashSet <NuGetFramework> {
framework
});
}
}
public void RestoreLogMessage_TestConstructorWithTargetGraph(LogLevel level, NuGetLogCode code, string message, string targetGraph)
{
// Arrange & Act
var logMessage = new RestoreLogMessage(level, code, message, targetGraph);
// Assert
Assert.Equal(level, logMessage.Level);
Assert.Equal(code, logMessage.Code);
Assert.Equal(message, logMessage.Message);
Assert.Equal(0, logMessage.StartLineNumber);
Assert.Equal(0, logMessage.EndLineNumber);
Assert.Equal(0, logMessage.StartColumnNumber);
Assert.Equal(0, logMessage.EndColumnNumber);
if (string.IsNullOrEmpty(targetGraph))
{
Assert.Equal(0, logMessage.TargetGraphs.Count);
}
else
{
Assert.NotNull(logMessage.TargetGraphs);
Assert.Equal(1, logMessage.TargetGraphs.Count);
Assert.Equal(targetGraph, logMessage.TargetGraphs.First());
}
}
public LogMessage(LogLevel level, string message, NuGetLogCode code)
: this(level, message)
{
Code = code;
}
public SignatureException(NuGetLogCode code, string message, PackageIdentity package)
: this(code, message)
{
PackageIdentity = package;
}
/// <summary>
/// Create an error log message.
/// </summary>
public static RestoreLogMessage CreateError(
NuGetLogCode code,
string message)
{
return(new RestoreLogMessage(LogLevel.Error, code, message));
}
public static void AssertOfflineRevocationOfflineMode(IEnumerable <SignatureLog> issues, LogLevel logLevel, NuGetLogCode code)
{
Assert.Contains(issues, issue =>
issue.Code == code &&
issue.Level == logLevel &&
issue.Message.Contains(NuGet.Packaging.Strings.VerifyCertTrustOfflineWhileRevocationModeOffline));
}
/// <summary>
/// Create an error message for the given issue.
/// </summary>
private static RestoreLogMessage GetErrorMessage(NuGetLogCode logCode, CompatibilityIssue issue, RestoreTargetGraph graph)
{
return(RestoreLogMessage.CreateError(logCode, issue.Format(), issue.Package.Id, graph.TargetGraphName));
}
/// <summary>
/// Tries to get the string from the NuGetLogCode enum.
/// </summary>
/// <param name="code">NuGetLogCode to be formatted into string.</param>
/// <param name="codeString">strings representation of the NuGetLogCode if the result is true else null.</param>
/// <returns>bool indcating if the GetName operation was successfull or not.</returns>
public static bool TryGetName(this NuGetLogCode code, out string codeString)
{
codeString = code.GetName();
return(codeString != null);
}
public static SignatureLog Error(NuGetLogCode code, string message)
{
return(new SignatureLog(LogLevel.Error, code, message));
}
/// <summary>
/// Create an error log message.
/// </summary>
/// <param name="code">The logging code</param>
/// <param name="message">The log message</param>
public static PackagingLogMessage CreateError(string message, NuGetLogCode code)
{
return(new PackagingLogMessage(LogLevel.Error, code, message));
}
public static PackagingLogMessage CreateWarning(string message, NuGetLogCode code)
{
return(new PackagingLogMessage(LogLevel.Warning, code, message));
}
public RestoreLogMessage(LogLevel logLevel, NuGetLogCode errorCode, string errorString)
: this(logLevel, errorCode, errorString, string.Empty, logToInnerLogger : false)
{
}
public RestoreLogMessage(LogLevel logLevel, NuGetLogCode errorCode,
string errorString, string targetGraph)
: this(logLevel, errorCode, errorString, targetGraph, logToInnerLogger : false)
{
}
public TimestampException(NuGetLogCode code, string message)
: base(code, message)
{
}
public static LogMessage CreateError(NuGetLogCode code, string message)
{
return(new LogMessage(LogLevel.Error, message, code));
}
public void RestoreLogMessage_TestConstructorWithoutTargetGraph(LogLevel level, NuGetLogCode code, string message)
{
// Arrange & Act
var logMessage = new RestoreLogMessage(level, code, message);
// Assert
Assert.Equal(level, logMessage.Level);
Assert.Equal(code, logMessage.Code);
Assert.Equal(message, logMessage.Message);
Assert.Equal(0, logMessage.StartLineNumber);
Assert.Equal(0, logMessage.EndLineNumber);
Assert.Equal(0, logMessage.StartColumnNumber);
Assert.Equal(0, logMessage.EndColumnNumber);
Assert.Equal(0, logMessage.TargetGraphs.Count);
}
public static LogMessage CreateWarning(NuGetLogCode code, string message)
{
return(new LogMessage(LogLevel.Warning, message, code));
}
/// <summary>
/// Adds a NuGetLogCode into the NoWarn Set for the specified library Id with unconditional reference.
/// </summary>
/// <param name="code">NuGetLogCode for which no warning should be thrown.</param>
/// <param name="libraryId">Library for which no warning should be thrown.</param>
public void Add(NuGetLogCode code, string libraryId)
{
Add(code, libraryId, _globalFramework);
}
/// <summary>
/// Formats a NuGetLogCode into a string representation.
/// </summary>
/// <param name="code">NuGetLogCode to be formatted into string.</param>
/// <returns>strings representation of the NuGetLogCode.</returns>
public static string GetName(this NuGetLogCode code)
{
return(Enum.GetName(typeof(NuGetLogCode), code));
}
/// <summary>
/// Checks if a NugetLogCode is part of the NoWarn list for the specified library Id with uncoditional reference.
/// </summary>
/// <param name="code">NugetLogCode to be checked.</param>
/// <param name="libraryId">library Id to be checked.</param>
/// <returns>True iff the NugetLogCode is part of the NoWarn list for the specified libraryId with uncoditional reference.</returns>
public bool Contains(NuGetLogCode code, string libraryId)
{
return(Contains(code, libraryId, _globalFramework));
}
public PackagingException(NuGetLogCode logCode, string message)
: base(message)
{
_logMessage = PackLogMessage.CreateError(logCode, message);
}
public SignatureException(NuGetLogCode code, string message)
: base(code, message)
{
Code = code;
}
public AssetsLogMessage(LogLevel logLevel, NuGetLogCode errorCode, string errorString)
: this(logLevel, errorCode, errorString, string.Empty)
{
}
public SignatureException(NuGetLogCode code, string message, Exception innerException)
: base(code, message, innerException)
{
Code = code;
}
public static void AssertRevocationStatusUnknown(IEnumerable <ILogMessage> issues, LogLevel logLevel, NuGetLogCode code)
{
string revocationStatusUnknown = X509ChainStatusFlags.RevocationStatusUnknown.ToString();
bool isRevocationStatusUnknown = issues.Any(issue =>
issue.Code == code &&
issue.Level == logLevel &&
issue.Message.Split(new[] { ' ', ':' }).Where(WORDEXTFLAGS => WORDEXTFLAGS == revocationStatusUnknown).Any());
Assert.True(isRevocationStatusUnknown);
}
public TimestampException(NuGetLogCode code, string message, Exception innerException)
: base(code, message, innerException)
{
}
