public void AllRules_SonarWayTagPresenceMatchesIsEnabledByDefault()
{
var allAnalyzers = new RuleFinder().AllAnalyzerTypes
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
.SelectMany(analyzer => analyzer.SupportedDiagnostics)
.ToList();
var parameterizedAnalyzers = new RuleFinder().AllAnalyzerTypes
.Where(RuleFinder.IsParameterized)
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
.SelectMany(analyzer => analyzer.SupportedDiagnostics)
.ToHashSet();
foreach (var analyzer in allAnalyzers)
{
var isInSonarWay = analyzer.CustomTags.Contains(DiagnosticDescriptorBuilder.SonarWayTag);
if (parameterizedAnalyzers.Contains(analyzer))
{
analyzer.IsEnabledByDefault.Should().BeFalse();
}
else if (isInSonarWay)
{
analyzer.IsEnabledByDefault.Should().BeTrue();
}
else
{
analyzer.IsEnabledByDefault.Should().BeFalse();
}
}
}
public void RulesDoNotThrow_VB()
{
var analyzers = RuleFinder.GetAnalyzers(AnalyzerLanguage.VisualBasic).ToList();
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\InvalidSyntax.vb", analyzers, CompilationErrorBehavior.Ignore);
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\SpecialCases.vb", analyzers, CompilationErrorBehavior.Ignore);
}
public void CheckNumberOfBHIAnalyzers()
{
var ruleFinder = new RuleFinder();
var analyzers = ruleFinder.GetAllAnalyzerTypes();
var bhiAnalyzers = analyzers.Where( c => c.Assembly.FullName.Contains("BHI"));
Assert.AreEqual(12, bhiAnalyzers.Count(), "Should have number of analyzers");
}
private void AddMissingEntries(AnalysisOutput output, AnalyzerLanguage language)
{
var foundKeys = output.Issues.Select(i => i.RuleId).ToList();
var notFoundKeys = RuleFinder.GetAnalyzerTypes(language)
.Select(t =>
new
{
Type = t,
RuleAttribute = t.GetCustomAttribute <RuleAttribute>()
})
.Select(rule =>
RuleFinder.IsRuleTemplate(rule.Type)
? string.Format(TemplateRuleIdPattern, rule.RuleAttribute.Key)
: rule.RuleAttribute.Key)
.Where(s => !foundKeys.Contains(s));
foreach (var notFoundKey in notFoundKeys)
{
output.Issues.Add(new Issue
{
RuleId = notFoundKey
});
}
}
public static IEnumerable <DiagnosticAnalyzer> GetNonTemplateAnalyzers(AnalyzerLanguage language)
{
return
(new RuleFinder().GetAnalyzerTypes(language)
.Where(type => !RuleFinder.IsRuleTemplate(type))
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type)));
}
public void GetAllAnalyzerTypes()
{
var finder = new RuleFinder();
var countParameterless = finder.GetParameterlessAnalyzerTypes().Count();
finder.GetAllAnalyzerTypes().Count().Should().BeGreaterThan(countParameterless);
}
public void Rules_DoNot_Throw()
{
var analyzers = RuleFinder.GetAnalyzers().ToList();
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\InvalidSyntax.cs", analyzers, CompilationErrorBehavior.Ignore);
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\SpecialCases.cs", analyzers, CompilationErrorBehavior.Ignore);
}
public void SqaleSubCharacteristicAttribute()
{
var analyzers = new RuleFinder().GetAllAnalyzerTypes();
foreach (var analyzer in analyzers)
{
var noSqaleCount = analyzer.GetCustomAttributes <NoSqaleRemediationAttribute>().Count();
var subCharacteristicCount = analyzer.GetCustomAttributes <SqaleSubCharacteristicAttribute>().Count();
if (noSqaleCount > 0)
{
if (subCharacteristicCount > 0)
{
Assert.Fail(
"SqaleSubCharacteristicAttribute can only be assigned to DiagnosticAnalyzers that have a SQALE " +
"remediation function, '{0}' has NoSqaleRemediationAttribute",
analyzer.Name);
}
}
else
{
if (subCharacteristicCount != 1)
{
Assert.Fail(
"Only one SqaleSubCharacteristicAttribute can be assigned to DiagnosticAnalyzers, '{0}' has {1}",
analyzer.Name, subCharacteristicCount);
}
}
}
}
public void Rules_DoNot_Throw()
{
var analyzers = new RuleFinder().GetAnalyzerTypes(AnalyzerLanguage.CSharp)
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
.ToList();
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\InvalidSyntax.cs", analyzers);
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\SpecialCases.cs", analyzers);
}
public void VisualStudio_NoRuleTemplates()
{
var analyzers = GetDiagnosticAnalyzerTypes(new[] { RuleFinder.GetPackagedRuleAssembly() });
foreach (var analyzer in analyzers.Where(RuleFinder.IsRuleTemplate))
{
Assert.Fail("Visual Studio rules cannot be templates, remove DiagnosticAnalyzer '{0}'.", analyzer.Name);
}
}
public void DiagnosticAnalyzerHasRuleAttribute()
{
var analyzers = new RuleFinder().GetAllAnalyzerTypes();
foreach (var analyzer in analyzers)
{
var ruleDescriptors = analyzer.GetCustomAttributes <RuleAttribute>();
ruleDescriptors.Should().NotBeEmpty("RuleAttribute is missing from DiagnosticAnalyzer '{0}'", analyzer.Name);
}
}
private void CheckIntegrationTestCount(AnalyzerLanguage language)
{
ValidateLanguageInput(language);
CreateMissingExpectedDirectory(language);
Assert.AreEqual(
RuleFinder.GetAnalyzerTypes(language).Count(),
ExpectedDirectory
.GetDirectories(language.GetDirectoryName()).First()
.GetFiles("S*.json").Count());
}
public void GetAllAnalyzerTypes()
{
var finder = new RuleFinder();
var countParameterless = finder.GetParameterlessAnalyzerTypes(AnalyzerLanguage.CSharp).Count();
finder.AllAnalyzerTypes.Should().HaveCountGreaterThan(countParameterless);
countParameterless = finder.GetParameterlessAnalyzerTypes(AnalyzerLanguage.VisualBasic).Count();
finder.AllAnalyzerTypes.Should().HaveCountGreaterThan(countParameterless);
}
public void CheckBHIAnalyzers()
{
var ruleFinder = new RuleFinder();
var analyzers = ruleFinder.GetAllAnalyzerTypes();
var bhiAnalyzers = analyzers.Where(c => c.Assembly.FullName.Contains("BHI"));
foreach(var analyzer in bhiAnalyzers)
{
MemberInfo[] info = analyzer.GetMember("Rule", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.IsNotNull(info, "getting analyzer " + analyzer.Name);
}
}
public void Setup()
{
ItSourcesRootDirectory = GetItSourcesFolder();
CodeFiles = ItSourcesRootDirectory
.EnumerateFiles("*.*", SearchOption.AllDirectories)
.Where(file =>
SupportedExtensions.Contains(file.Extension, StringComparer.OrdinalIgnoreCase));
RuleFinder = new RuleFinder();
XmlInputPattern = GenerateAnalysisInputFilePattern();
ExpectedDirectory = new DirectoryInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Expected"));
CreateOrClearMissingActualDirectory();
}
protected virtual async Task ApplyEntityRuleAsync(IEntity entity)
{
Type entityType = ProxyHelper.GetUnProxiedType(entity);
// 加载规则列表
var groups = await RuleFinder.GetRuleGroupsAsync(entityType);
if (groups.Any())
{
// 应用规则
await EntityRuleContributor.ApplyAsync(new EntityRuleContext(groups, entity));
}
}
public void Setup()
{
ItSourcesRootDirectory = GetItSourcesFolder();
CodeFiles = ItSourcesRootDirectory
.EnumerateFiles("*.*", SearchOption.AllDirectories)
.Where(file =>
SupportedExtensions.Contains(file.Extension, StringComparer.OrdinalIgnoreCase));
RuleFinder = new RuleFinder();
XmlInputPattern = GenerateAnalysisInputFilePattern();
ExpectedDirectory = new DirectoryInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Expected"));
CreateOrClearMissingActualDirectory();
}
public void GetAllAnalyzerTypes()
{
var finder = new RuleFinder();
{
var countParameterless = finder.GetParameterlessAnalyzerTypes(AnalyzerLanguage.CSharp).Count();
finder.GetAllAnalyzerTypes().Count().Should().BeGreaterThan(countParameterless);
}
{
var countParameterless = finder.GetParameterlessAnalyzerTypes(AnalyzerLanguage.VisualBasic).Count();
finder.GetAllAnalyzerTypes().Count().Should().BeGreaterThan(countParameterless);
}
}
public void DiagnosticAnalyzerHasRuleAttribute()
{
var analyzers = GetDiagnosticAnalyzerTypes(RuleFinder.GetRuleAssemblies());
foreach (var analyzer in analyzers)
{
var ruleDescriptor = analyzer.GetCustomAttributes <RuleAttribute>().SingleOrDefault();
if (ruleDescriptor == null)
{
throw new Exception(string.Format("RuleAttribute is missing from DiagnosticAnalyzer '{0}'", analyzer.Name));
}
}
}
public void DiagnosticAnalyzerHasRuleAttribute()
{
var analyzers = new RuleFinder().GetAllAnalyzerTypes();
foreach (var analyzer in analyzers)
{
var ruleDescriptor = analyzer.GetCustomAttributes<RuleAttribute>().SingleOrDefault();
if (ruleDescriptor == null)
{
Assert.Fail("RuleAttribute is missing from DiagnosticAnalyzer '{0}'", analyzer.Name);
}
}
}
public void VisualStudio_OnlyParameterlessRules()
{
var analyzers = GetDiagnosticAnalyzerTypes(new[] { RuleFinder.GetPackagedRuleAssembly() });
foreach (var analyzer in analyzers)
{
var hasParameter = analyzer.GetProperties().Any(p => p.GetCustomAttributes <RuleParameterAttribute>().Any());
if (hasParameter)
{
Assert.Fail("Visual Studio rules cannot have parameters, remove DiagnosticAnalyzer '{0}'.", analyzer.Name);
}
}
}
public void DiagnosticAnalyzerHasRuleAttribute()
{
var analyzers = new RuleFinder().GetAllAnalyzerTypes();
foreach (var analyzer in analyzers)
{
var ruleDescriptor = analyzer.GetCustomAttributes <RuleAttribute>().SingleOrDefault();
if (ruleDescriptor == null)
{
Assert.Fail("RuleAttribute is missing from DiagnosticAnalyzer '{0}'", analyzer.Name);
}
}
}
public void SingleSqaleRemediationAttribute()
{
var analyzers = new RuleFinder().GetAllAnalyzerTypes();
foreach (var analyzer in analyzers)
{
var count = analyzer.GetCustomAttributes <SqaleRemediationAttribute>().Count();
if (count != 1)
{
Assert.Fail("Only one SqaleRemediationAttribute can be assigned to DiagnosticAnalyzers, '{0}' has {1}",
analyzer.Name, count);
}
}
}
public void VisualStudio_AllParameterlessRulesNotRuleTemplate()
{
var analyzers = GetDiagnosticAnalyzerTypes(new[] { RuleFinder.GetExtraRuleAssembly() });
foreach (var analyzer in analyzers.Where(type => !RuleFinder.IsRuleTemplate(type)))
{
var hasParameter = analyzer.GetProperties().Any(p => p.GetCustomAttributes <RuleParameterAttribute>().Any());
if (!hasParameter)
{
Assert.Fail(
"DiagnosticAnalyzer '{0}' should be moved to the assembly that implements Visual Studio rules.",
analyzer.Name);
}
}
}
public void AllRulesEnabledByDefault_ContainSonarWayCustomTag()
{
var descriptors = new RuleFinder().AllAnalyzerTypes.SelectMany(SupportedDiagnostics)
// Security hotspots are enabled by default, but they will report issues only
// when their ID is contained in SonarLint.xml
.Where(descriptor => !IsSecurityHotspot(descriptor));
foreach (var descriptor in descriptors)
{
if (descriptor.IsEnabledByDefault)
{
descriptor.CustomTags.Should().Contain(DiagnosticDescriptorBuilder.SonarWayTag, $"{descriptor.Id} should be in SonarWay");
}
}
}
public void AllRulesEnabledByDefault_ContainSonarWayCustomTag()
{
var analyzers = new RuleFinder().AllAnalyzerTypes
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
.SelectMany(analyzer => analyzer.SupportedDiagnostics)
.ToList();
foreach (var analyzer in analyzers)
{
if (analyzer.IsEnabledByDefault)
{
analyzer.CustomTags.Should().Contain(DiagnosticDescriptorBuilder.SonarWayTag);
}
}
}
public void TemplateRule_With_Direct_Parameters()
{
var analyzers = new RuleFinder().GetAllAnalyzerTypes();
foreach (var analyzer in analyzers.Where(RuleFinder.IsRuleTemplate))
{
var hasParameter = analyzer.GetProperties().Any(p => p.GetCustomAttributes<RuleParameterAttribute>().Any());
if (hasParameter)
{
Assert.Fail(
"DiagnosticAnalyzer '{0}' has parameters that are defined outside of IRuleTemplateInstance.",
analyzer.Name);
}
}
}
public void CodeFixProviders_Named_Properly()
{
var codeFixProviders = GetCodeFixProviderTypes(RuleFinder.GetPackagedRuleAssemblies());
foreach (var codeFixProvider in codeFixProviders)
{
var analyzerName = codeFixProvider.FullName.Replace(RuleDetailBuilder.CodeFixProviderSuffix, "");
if (codeFixProvider.Assembly.GetType(analyzerName) == null)
{
Assert.Fail(
"CodeFixProvider '{0}' has no matching DiagnosticAnalyzer.",
codeFixProvider.Name);
}
}
}
public void TemplateRule_With_Direct_Parameters()
{
var analyzers = new RuleFinder().GetAllAnalyzerTypes();
foreach (var analyzer in analyzers.Where(RuleFinder.IsRuleTemplate))
{
var hasParameter = analyzer.GetProperties().Any(p => p.GetCustomAttributes <RuleParameterAttribute>().Any());
if (hasParameter)
{
Assert.Fail(
"DiagnosticAnalyzer '{0}' has parameters that are defined outside of IRuleTemplateInstance.",
analyzer.Name);
}
}
}
public void CodeFixProviders_Have_Title()
{
var codeFixProviders = GetCodeFixProviderTypes(RuleFinder.GetPackagedRuleAssemblies());
foreach (var codeFixProvider in codeFixProviders)
{
var titles = RuleDetailBuilder.GetCodeFixTitles(codeFixProvider);
if (!titles.Any())
{
Assert.Fail(
"CodeFixProvider '{0}' has no title field.",
codeFixProvider.Name);
}
}
}
public void SecurityHotspots_Rules_Not_Configurable()
{
var hotspotDiagnosticDescriptors = new RuleFinder()
.GetAnalyzerTypes(AnalyzerLanguage.CSharp)
.Select(t => (SonarDiagnosticAnalyzer)Activator.CreateInstance(t))
.SelectMany(diagnosticAnalyzer => diagnosticAnalyzer.SupportedDiagnostics)
.Where(IsSecurityHotspot)
.ToList();
foreach (var descriptor in hotspotDiagnosticDescriptors)
{
descriptor.CustomTags.Should().Contain(
WellKnownDiagnosticTags.NotConfigurable,
because: $"{descriptor.Id} is hotspot and should not be configurable");
}
}
public ImmutableArray <DiagnosticAnalyzer> GetUtilityAnalyzers()
{
var builder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>();
var utilityAnalyzerTypes = RuleFinder.GetUtilityAnalyzerTypes(language)
.Where(t => !t.IsAbstract)
.ToList();
foreach (var analyzer in utilityAnalyzerTypes
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type)))
{
builder.Add(analyzer);
}
return(builder.ToImmutable());
}
public void AbstractDiagnosticAnalyzer_Should_Have_No_RuleAttribute()
{
var analyzers = RuleFinder.GetPackagedRuleAssemblies()
.SelectMany(assembly => assembly.GetTypes())
.Where(t =>
t.IsSubclassOf(typeof(DiagnosticAnalyzer)) &&
t.IsAbstract)
.ToList();
foreach (var analyzer in analyzers)
{
var ruleDescriptor = analyzer.GetCustomAttributes <RuleAttribute>().SingleOrDefault();
if (ruleDescriptor != null)
{
Assert.Fail("RuleAttribute is added to abstract DiagnosticAnalyzer '{0}'", analyzer.Name);
}
}
}
public ImmutableArray <DiagnosticAnalyzer> GetAnalyzers()
{
var builder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>();
foreach (var analyzer in nonTemplateAnalyzers
.Where(analyzer => AnalyzerIds.Contains(analyzer.SupportedDiagnostics.Single().Id)))
{
if (RuleFinder.IsParametered(analyzer.GetType()))
{
SetParameterValues(analyzer);
}
builder.Add(analyzer);
}
if (language == AnalyzerLanguage.CSharp)
{
AddAnalyzerCommentRegularExpression(builder);
}
return(builder.ToImmutable());
}
public void RuleHasResourceHtml()
{
var assemblies = RuleFinder.GetRuleAssemblies();
var analyzers = GetDiagnosticAnalyzerTypes(assemblies);
var resources = new Dictionary <Assembly, string[]>();
foreach (var assembly in assemblies)
{
resources[assembly] = assembly.GetManifestResourceNames();
}
var missingDescriptors = new List <string>();
foreach (var analyzer in analyzers)
{
var ruleDescriptor = analyzer.GetCustomAttributes <RuleAttribute>().First();
var resource = resources[analyzer.Assembly].SingleOrDefault(r => r.EndsWith(
string.Format(CultureInfo.InvariantCulture, RuleFinder.RuleDescriptionPathPattern,
ruleDescriptor.Key), StringComparison.OrdinalIgnoreCase));
if (resource != null)
{
using (var stream = analyzer.Assembly.GetManifestResourceStream(resource))
using (var reader = new StreamReader(stream))
{
var content = reader.ReadToEnd();
}
}
else
{
missingDescriptors.Add(string.Format("'{0}' ({1})", analyzer.Name, ruleDescriptor.Key));
}
}
if (missingDescriptors.Any())
{
throw new Exception(string.Format("Missing HTML description for rule {0}", string.Join(",", missingDescriptors)));
}
}
public void AllRules_SonarWayTagPresenceMatchesIsEnabledByDefault()
{
var allAnalyzers = new RuleFinder().AllAnalyzerTypes
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
.SelectMany(analyzer => analyzer.SupportedDiagnostics)
.ToList();
var parameterizedAnalyzers = new RuleFinder().AllAnalyzerTypes
.Where(RuleFinder.IsParameterized)
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
.SelectMany(analyzer => analyzer.SupportedDiagnostics)
.ToHashSet();
foreach (var analyzer in allAnalyzers)
{
var isInSonarWay = analyzer.CustomTags.Contains(DiagnosticDescriptorBuilder.SonarWayTag);
if (IsSecurityHotspot(analyzer))
{
// Security hotspots are enabled by default, but they will report issues only
// when their ID is contained in SonarLint.xml
analyzer.IsEnabledByDefault.Should().BeTrue($"{analyzer.Id} should be enabled by default");
}
else if (parameterizedAnalyzers.Contains(analyzer))
{
// Even if a a parametrized rule is in Sonar way profile, it is still disabled by default.
// See https://github.com/SonarSource/sonar-dotnet/issues/1274
analyzer.IsEnabledByDefault.Should().BeFalse($"{analyzer.Id} has parameters and should be disabled by default");
}
else if (isInSonarWay)
{
analyzer.IsEnabledByDefault.Should().BeTrue($"{analyzer.Id} is in SonarWay");
}
else
{
analyzer.IsEnabledByDefault.Should().BeFalse($"{analyzer.Id} is not in SonarWay");
}
}
}
public void CheckNumberOfParameterAnalyzers()
{
var ruleFinder = new RuleFinder();
var count=ruleFinder.GetParameterlessAnalyzerTypes().Count();
Assert.AreEqual(98, count, "Should have number of analyzers");
}
public void GetAnalyzerTypes()
{
var analyzers = new RuleFinder().GetAnalyzerTypes(AnalyzerLanguage.CSharp);
analyzers.Should().Contain(typeof(EmptyStatement));
}
public void GetAllAnalyzerTypes()
{
var finder = new RuleFinder();
var countParameterless = finder.GetParameterlessAnalyzerTypes().Count();
finder.GetAllAnalyzerTypes().Count().Should().BeGreaterThan(countParameterless);
}
public void CheckNumberOfAnalyzers()
{
var ruleFinder = new RuleFinder();
var count = ruleFinder.GetAllAnalyzerTypes().Count();
Assert.AreEqual(111, count, "Should have number of analyzers");
}
public void Rules_DoNot_Throw()
{
var analyzers = new RuleFinder().GetAnalyzerTypes(AnalyzerLanguage.CSharp)
.Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
.ToList();
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\InvalidSyntax.cs", analyzers);
Verifier.VerifyNoExceptionThrown(@"TestCasesForRuleFailure\SpecialCases.cs", analyzers);
}
