private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
AnalyzersSettings settings = SettingsProvider.GetSettings(context);
IUnitTestParser unitTestParser = UnitTestParserFactory.Create(settings);
context.RegisterSyntaxNodeAction(c => AnalyzeNode(c, unitTestParser, settings), SyntaxKind.MethodDeclaration);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context, IUnitTestParser parser, AnalyzersSettings settings)
{
if (!parser.IsUnitTestMethod(context))
{
return;
}
MethodDeclarationSyntax methodDeclaration = (MethodDeclarationSyntax)context.Node;
Match match = settings.TestMethodNameFormatRegex.Match(methodDeclaration.Identifier.ToString());
string memberUnderTest = match?.Groups[AnalyzersSettings.MemberUnderTestRegexGroupName].Value;
if (string.IsNullOrWhiteSpace(memberUnderTest))
{
return;
}
IEnumerable <SyntaxNode> descendantNodes = methodDeclaration.Body.DescendantNodes();
if (!descendantNodes?.Any() ?? true)
{
return;
}
IEnumerable <MemberAccessExpressionSyntax> memberAccessExpressions = descendantNodes.OfType <MemberAccessExpressionSyntax>();
IEnumerable <ObjectCreationExpressionSyntax> ctorExpressions = descendantNodes.OfType <ObjectCreationExpressionSyntax>();
if (!memberAccessExpressions.Any() && !ctorExpressions.Any())
{
return;
}
if (memberAccessExpressions.Any(memberAccess => string.Equals(memberUnderTest, memberAccess.Name.Identifier.ToString(), StringComparison.Ordinal)))
{
return;
}
if (ctorExpressions.Any(ctorExpression => string.Equals(memberUnderTest, ctorExpression.Type.ToString(), StringComparison.Ordinal)))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.ToString(), memberUnderTest);
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context, IUnitTestParser parser)
{
if (!parser.IsUnitTestClass(context))
{
return;
}
ClassDeclarationSyntax classDeclaration = (ClassDeclarationSyntax)context.Node;
if (classDeclaration.Identifier.ToString().EndsWith("UnitTests"))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, classDeclaration.Identifier.GetLocation(), classDeclaration.Identifier.ToString());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context, IUnitTestParser parser, AnalyzersSettings settings)
{
if (!parser.IsUnitTestMethod(context))
{
return;
}
MethodDeclarationSyntax methodDeclaration = (MethodDeclarationSyntax)context.Node;
var identifier = methodDeclaration.Identifier;
var name = identifier.ToString();
if (settings.TestMethodNameFormatRegex.IsMatch(name))
{
return;
}
string testNameFormatExamples = settings.TestMethodNameFormatExamples.Any() ? string.Join(", ", settings.TestMethodNameFormatExamples) : AnalyzersSettings.NoTestMethodNameExamplesProvided;
var diagnostic = Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.ToString(), settings.TestMethodNameFormat, testNameFormatExamples);
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context, IUnitTestParser parser)
{
if (!parser.IsUnitTestMethod(context))
{
return;
}
MethodDeclarationSyntax methodDeclaration = (MethodDeclarationSyntax)context.Node;
IEnumerable <SyntaxNode> descendantNodes = methodDeclaration.Body.DescendantNodes();
if (!descendantNodes?.Any() ?? true)
{
return;
}
IEnumerable <MemberAccessExpressionSyntax> memberAccessExpressions = descendantNodes.OfType <MemberAccessExpressionSyntax>();
IEnumerable <ObjectCreationExpressionSyntax> ctorExpressions = descendantNodes.OfType <ObjectCreationExpressionSyntax>();
if (!memberAccessExpressions.Any() && !ctorExpressions.Any())
{
return;
}
IEnumerable <SyntaxTrivia> singleLineComments = methodDeclaration.Body.DescendantTrivia().Where(trivia => trivia.IsKind(SyntaxKind.SingleLineCommentTrivia));
IEnumerable <SyntaxTrivia> arrangeComments = singleLineComments.Where(comment => string.Equals("// Arrange.", comment.ToFullString()));
IEnumerable <SyntaxTrivia> actComments = singleLineComments.Where(comment => string.Equals("// Act.", comment.ToFullString()));
IEnumerable <SyntaxTrivia> assertComments = singleLineComments.Where(comment => string.Equals("// Assert.", comment.ToFullString()));
Diagnostic diagnostic = null;
LinePosition arrangeCommentLine = default(LinePosition);
if (arrangeComments.Any())
{
arrangeCommentLine = arrangeComments.First().GetLocation().GetLineSpan().StartLinePosition;
}
// Check to see whether each comment exists. Only a single instance of each comment should exist.
if (arrangeComments.Count() != 1 || actComments.Count() != 1 || assertComments.Count() != 1)
{
diagnostic = Diagnostic.Create(AAACommentsRule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.ToString());
}
else
{
// Check whether the comments appear with the expected order.
LinePosition actCommentLine = actComments.First().GetLocation().GetLineSpan().StartLinePosition;
LinePosition assertCommentLine = assertComments.First().GetLocation().GetLineSpan().StartLinePosition;
if (arrangeCommentLine > actCommentLine || actCommentLine > assertCommentLine)
{
diagnostic = Diagnostic.Create(AAACommentsRule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.ToString());
}
}
if (diagnostic != null)
{
context.ReportDiagnostic(diagnostic);
}
var methodOpenBrace = methodDeclaration.Body.ChildTokens().FirstOrDefault(token => token.IsKind(SyntaxKind.OpenBraceToken));
LinePosition openBraceLinePosition = methodOpenBrace.GetLocation().GetLineSpan().EndLinePosition;
if (arrangeCommentLine.Line != openBraceLinePosition.Line + 1)
{
diagnostic = Diagnostic.Create(FirstLineArrangeRule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.ToString());
context.ReportDiagnostic(diagnostic);
}
}
