public SonarQubeRule(string key, string repositoryKey, bool isActive, SonarQubeIssueSeverity severity, IDictionary <string, string> parameters)
{
Key = key;
RepositoryKey = repositoryKey;
IsActive = isActive;
Severity = severity;
if (parameters == null || parameters.Count == 0)
{
Parameters = Empty;
}
else
{
Parameters = new ReadOnlyDictionary <string, string>(parameters);
}
}
public SonarQubeIssue(string issueKey, string filePath, string hash, string message, string moduleKey, string ruleId, bool isResolved,
SonarQubeIssueSeverity severity, DateTimeOffset creationTimestamp, DateTimeOffset lastUpdateTimestamp,
IssueTextRange textRange, List <IssueFlow> flows)
{
IssueKey = issueKey;
FilePath = filePath;
Hash = hash;
Message = message;
ModuleKey = moduleKey;
RuleId = ruleId;
IsResolved = isResolved;
Severity = severity;
CreationTimestamp = creationTimestamp;
LastUpdateTimestamp = lastUpdateTimestamp;
TextRange = textRange;
Flows = flows ?? EmptyFlows;
}
internal /* for testing */ RuleAction GetVsSeverity(SonarQubeIssueSeverity sqSeverity)
{
switch (sqSeverity)
{
case SonarQubeIssueSeverity.Info:
case SonarQubeIssueSeverity.Minor:
return(RuleAction.Info);
case SonarQubeIssueSeverity.Major:
case SonarQubeIssueSeverity.Critical:
return(RuleAction.Warning);
case SonarQubeIssueSeverity.Blocker:
return(environmentSettings.TreatBlockerSeverityAsError() ? RuleAction.Error : RuleAction.Warning);
default:
throw new NotSupportedException($"Unsupported SonarQube issue severity: {sqSeverity}");
}
}
internal /* for testing */ static IssueSeverity?Convert(SonarQubeIssueSeverity sonarQubeIssueSeverity)
{
switch (sonarQubeIssueSeverity)
{
case SonarQubeIssueSeverity.Blocker:
return(IssueSeverity.Blocker);
case SonarQubeIssueSeverity.Critical:
return(IssueSeverity.Critical);
case SonarQubeIssueSeverity.Info:
return(IssueSeverity.Info);
case SonarQubeIssueSeverity.Major:
return(IssueSeverity.Major);
case SonarQubeIssueSeverity.Minor:
return(IssueSeverity.Minor);
default:
return(null);
}
}
/// <summary>
/// Converts from the sonarqube issue severity enum to the standard AnalysisIssueSeverity
/// </summary>
internal /* for testing */ static AnalysisIssueSeverity Convert(SonarQubeIssueSeverity issueSeverity)
{
switch (issueSeverity)
{
case SonarQubeIssueSeverity.Blocker:
return(AnalysisIssueSeverity.Blocker);
case SonarQubeIssueSeverity.Critical:
return(AnalysisIssueSeverity.Critical);
case SonarQubeIssueSeverity.Info:
return(AnalysisIssueSeverity.Info);
case SonarQubeIssueSeverity.Major:
return(AnalysisIssueSeverity.Major);
case SonarQubeIssueSeverity.Minor:
return(AnalysisIssueSeverity.Minor);
default:
throw new ArgumentOutOfRangeException(nameof(issueSeverity));
}
}
public void SeverityEnumConversion_NotUnknown(SonarQubeIssueSeverity sqSeverity, IssueSeverity?expected)
{
CFamilyBindingConfigProvider.Convert(sqSeverity).Should().Be(expected);
}
private static SonarQubeRule CreateRule(string ruleKey, string repoKey, bool isActive,
SonarQubeIssueSeverity severity, IDictionary <string, string> parameters = null) =>
new SonarQubeRule(ruleKey, repoKey, isActive, severity, parameters, SonarQubeIssueType.Unknown);
private static SonarQubeRule CreateRule(string repoKey, string ruleKey, bool isActive = true, SonarQubeIssueSeverity sqSeverity = SonarQubeIssueSeverity.Info) => new SonarQubeRule(ruleKey, repoKey, isActive, sqSeverity, new Dictionary <string, string>(), SonarQubeIssueType.Unknown);
private static SonarQubeRule CreateSonarCSharpRule(string ruleKey, bool isActive = true, SonarQubeIssueSeverity sqSeverity = SonarQubeIssueSeverity.Info) =>
CreateRule("csharpsquid", ruleKey, isActive, sqSeverity);
public void GetVSSeverity_Invalid_Throws(SonarQubeIssueSeverity sqSeverity)
{
Action act = () => new RuleSetGenerator().GetVsSeverity(sqSeverity);
act.Should().Throw <NotSupportedException>();
}
public void GetVSSeverity_NotBlocker_CorrectlyMapped(SonarQubeIssueSeverity sqSeverity, RuleAction expectedVsSeverity)
{
var testSubject = new RuleSetGenerator();
testSubject.GetVsSeverity(sqSeverity).Should().Be(expectedVsSeverity);
}
public void SeverityConversion(string inputData, SonarQubeIssueSeverity expectedResult)
{
SonarQubeIssueSeverityConverter.Convert(inputData).Should().Be(expectedResult);
}
private SonarQubeIssue CreateServerIssue(string issueKey = "issue key", string filePath = "test.cpp", string hash = "hash", string message = "message", string rule = "rule",
SonarQubeIssueSeverity severity = SonarQubeIssueSeverity.Info, IssueTextRange textRange = null,
DateTimeOffset created = default, DateTimeOffset lastUpdate = default, params IssueFlow[] flows) =>
new SonarQubeIssue(issueKey, filePath, hash, message, null, rule, true, severity, created, lastUpdate, textRange, flows.ToList());
public void Convert_UnknownSeverity_ArgumentOutOfRangeException(SonarQubeIssueSeverity sqSeverity)
{
Action act = () => TaintIssueToIssueVisualizationConverter.Convert(sqSeverity);
act.Should().Throw <ArgumentOutOfRangeException>().And.ParamName.Should().Be("issueSeverity");
}
public void Convert_Severity(SonarQubeIssueSeverity sqSeverity, AnalysisIssueSeverity expectedSeverity)
{
var result = TaintIssueToIssueVisualizationConverter.Convert(sqSeverity);
result.Should().Be(expectedSeverity);
}
