Analyzer implementation to enhance assertions

[AtolagbeMuiz]

This Pull request fixes #6360

This implementation involves changes to the Analyzer to suggest a much cleaner approach to write Assertions that involves the use of Predicate functions. for example

Assert.IsTrue(_enumerable.Where(x => x == 1).Any());
Assert.IsTrue(_enumerable.Any(x => x == 1));
Assert.IsTrue(_enumerable.Count(x => x == 1) > 0);

Analyzer will suggest (Expected Behaviour)
Assert.Contains(x => x == 1, _enumerable);

Example 2:

Assert.IsFalse(_enumerable.Where(x => x == 1).Any());
Assert.IsFalse(_enumerable.Any(x => x == 1));
Assert.IsFalse(_enumerable.Count(x => x == 1) > 0);

Analyzer will suggest (Expected Behaviour)
Assert.DoesNotContain(x => x == 1, _enumerable);

[AtolagbeMuiz]

@Youssef1313 @Evangelink Pls I need this pull request to be reviewed.. I don't really know how to request a review directly to a maintainer If they are not already part of the pull request reviewers

[Copilot]

Pull request overview

This PR enhances the MSTest analyzer to suggest cleaner assertion patterns when testing collection contents with predicates. The analyzer now detects patterns like Assert.IsTrue(collection.Any(predicate)) and suggests the more expressive Assert.Contains(predicate, collection).

Key Changes

• Added detection for LINQ predicate patterns (Any, Count, Single, SingleOrDefault, Where combinations)
• Introduced Assert.Contains and Assert.DoesNotContain suggestions with predicate support
• Introduced Assert.ContainsSingle suggestions for single-element checks
• Added comprehensive test coverage for new patterns

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 4 comments.

File	Description
src/Analyzers/MSTest.Analyzers/UseProperAssertMethodsAnalyzer.cs	Added LinqPredicateCheckStatus enum, RecognizeLinqPredicateCheck method, and logic to detect and suggest predicate-based assertions for IsNull/IsNotNull, IsTrue/IsFalse, and AreEqual patterns
test/UnitTests/MSTest.Analyzers.UnitTests/UseProperAssertMethodsAnalyzerTests.cs	Added 14 new test methods covering various LINQ predicate patterns with Any, Where, Count, Single, and SingleOrDefault combinations
test/IntegrationTests/MSTest.IntegrationTests/OutputTests.cs	Updated assertion to demonstrate new Assert.DoesNotContain usage (contains a bug - see comments)

[Copilot]

The analyzer implementation has significant code duplication in the RecognizeLinqPredicateCheck method. The patterns for checking Where().Single(), Where().SingleOrDefault(), Where().Any(), and Where().Count() follow nearly identical logic with only method names differing. Consider extracting this repetitive logic into a helper method to improve maintainability.

Example refactoring approach:

private static bool TryMatchWherePattern(
    IInvocationOperation invocation,
    string methodName,
    out SyntaxNode? collectionExpression,
    out SyntaxNode? predicateExpression)
{
    if (invocation.TargetMethod.Name == methodName &&
        invocation.TargetMethod.ContainingType?.ToDisplayString() == "System.Linq.Enumerable" &&
        invocation.Arguments.Length == 1 &&
        invocation.Arguments[0].Value is IInvocationOperation whereInvocation &&
        whereInvocation.TargetMethod.Name == "Where" &&
        whereInvocation.TargetMethod.ContainingType?.ToDisplayString() == "System.Linq.Enumerable" &&
        whereInvocation.Arguments.Length == 2)
    {
        collectionExpression = whereInvocation.Arguments[0].Value.Syntax;
        predicateExpression = whereInvocation.Arguments[1].Value.Syntax;
        return true;
    }
    
    collectionExpression = null;
    predicateExpression = null;
    return false;
}

[Copilot]

Operator precedence issue: The condition on line 308 is missing parentheses around the && operation, making the intent ambiguous. The current condition evaluates as:

(linqStatus is ... or ... or ... or ...) && (linqCollectionExpr != null)

However, based on the logic, it appears the intent is:

linqStatus is (...WhereSingle or WhereSingleOrDefault) && linqCollectionExpr != null

Add parentheses to clarify the intended precedence:

if ((linqStatus is LinqPredicateCheckStatus.Single or
                   LinqPredicateCheckStatus.SingleOrDefault or
                   LinqPredicateCheckStatus.WhereSingle or
                   LinqPredicateCheckStatus.WhereSingleOrDefault) &&
    linqCollectionExpr != null)

Suggested change

	if (linqStatus is LinqPredicateCheckStatus.Single or
	LinqPredicateCheckStatus.SingleOrDefault or
	LinqPredicateCheckStatus.WhereSingle or
	LinqPredicateCheckStatus.WhereSingleOrDefault &&
	if ((linqStatus is LinqPredicateCheckStatus.Single or
	LinqPredicateCheckStatus.SingleOrDefault or
	LinqPredicateCheckStatus.WhereSingle or
	LinqPredicateCheckStatus.WhereSingleOrDefault) &&

[Copilot]

This change appears incorrect. The original code Assert.IsFalse(shouldNotContain.Any(message.Text.Contains)) is checking that none of the strings in shouldNotContain are contained in message.Text.

The new code Assert.DoesNotContain(message.Text.Contains, shouldNotContain) reverses the logic: it's checking whether the method message.Text.Contains (as a delegate) exists in the shouldNotContain collection, which is a string array. This will always pass (or fail to compile) since it's comparing a method delegate to string values.

The correct assertion should remain as the original, or if you want to use Assert.DoesNotContain, it should be written as:

foreach (string item in shouldNotContain)
{
    Assert.DoesNotContain(item, message.Text);
}

Suggested change

	Assert.DoesNotContain(message.Text.Contains, shouldNotContain);
	foreach (string item in shouldNotContain)
	{
	Assert.DoesNotContain(item, message.Text);
	}

[Copilot]

The Count pattern checking (lines 860-906) doesn't validate that the Count method is actually from LINQ (System.Linq.Enumerable) or has a predicate. This could lead to false positives with other Count methods (e.g., string.Count from LINQ, or custom Count methods on collections).

The check should verify:

1. That it's the LINQ Count extension method with a predicate
2. That it's from System.Linq.Enumerable

Example:

if (countInvocation.TargetMethod.Name == "Count" &&
    countInvocation.TargetMethod.ContainingType?.ToDisplayString() == "System.Linq.Enumerable")

This is especially important since RecognizeLinqPredicateCheck already properly checks for this, so this code should either reuse that method or apply similar validation.