{EnumerableAnalyzer} - added orderBy assertions

Meir017 · Meir017 · commit b50a3a42aea1 · 2017-10-13T08:15:47.000+03:00
diff --git a/src/FluentAssertions.BestPractices.Tests/Tips/CollectionTests.cs b/src/FluentAssertions.BestPractices.Tests/Tips/CollectionTests.cs
@@ -316,26 +316,26 @@ public class CollectionTests
 
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.OrderBy(x => x.BooleanProperty).Should().Equal(actual{0});")]
-        [NotImplemented]
+        [Implemented]
         public void CollectionShouldBeInAscendingOrder_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldBeInAscendingOrderAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-        oldAssertion: "actual.OrderBy(x => x.BooleanProperty).Should().Equal(actual{0});",
-        newAssertion: "actual.Should().BeInAscendingOrder(x => x.BooleanProperty{0});")]
-        [NotImplemented]
+            oldAssertion: "actual.OrderBy(x => x.BooleanProperty).Should().Equal(actual{0});",
+            newAssertion: "actual.Should().BeInAscendingOrder(x => x.BooleanProperty{0});")]
+        [Implemented]
         public void CollectionShouldBeInAscendingOrder_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldBeInAscendingOrderCodeFix, CollectionShouldBeInAscendingOrderAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.OrderByDescending(x => x.BooleanProperty).Should().Equal(actual{0});")]
-        [NotImplemented]
+        [Implemented]
         public void CollectionShouldBeInDescendingOrder_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldBeInDescendingOrderAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-        oldAssertion: "actual.OrderByDescending(x => x.BooleanProperty).Should().Equal(actual{0});",
-        newAssertion: "actual.Should().BeInDescendingOrder(x => x.BooleanProperty{0});")]
-        [NotImplemented]
+            oldAssertion: "actual.OrderByDescending(x => x.BooleanProperty).Should().Equal(actual{0});",
+            newAssertion: "actual.Should().BeInDescendingOrder(x => x.BooleanProperty{0});")]
+        [Implemented]
         public void CollectionShouldBeInDescendingOrder_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldBeInDescendingOrderCodeFix, CollectionShouldBeInDescendingOrderAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
diff --git a/src/FluentAssertions.BestPractices/Constants.cs b/src/FluentAssertions.BestPractices/Constants.cs
@@ -6,7 +6,7 @@ public static class DiagnosticProperties
         {
             public const string Title = nameof(Title);
             public const string VariableName = nameof(VariableName);
-            public const string PredicateString = nameof(PredicateString);
+            public const string LambdaString = nameof(LambdaString);
             public const string ExpectedItemString = nameof(ExpectedItemString);
             public const string UnexpectedItemString = nameof(UnexpectedItemString);
             public const string BecauseArgumentsString = nameof(BecauseArgumentsString);
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldBeInAscendingOrder.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldBeInAscendingOrder.cs
@@ -1,5 +1,6 @@
 ﻿using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using System.Collections.Generic;
@@ -14,31 +15,39 @@ public class CollectionShouldBeInAscendingOrderAnalyzer : FluentAssertionsAnalyz
         public const string DiagnosticId = Constants.Tips.Collections.CollectionShouldBeInAscendingOrder;
         public const string Category = Constants.Tips.Category;
 
-        public const string Message = "Use {0} .Should() followed by ### instead.";
+        public const string Message = "Use {0} .Should() followed by .BeInAscendingOrder() instead.";
 
         protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);
-
-        protected override Diagnostic AnalyzeExpressionStatement(ExpressionStatementSyntax statement)
+        protected override IEnumerable<(FluentAssertionsCSharpSyntaxVisitor, BecauseArgumentsSyntaxVisitor)> Visitors
+        {
+            get
+            {
+                yield return (new OrderByShouldEqualSyntaxVisitor(), new BecauseArgumentsSyntaxVisitor("Equal", 1));
+            }
+        }
+        private class OrderByShouldEqualSyntaxVisitor : FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor
         {
-            return null;
-            var visitor = new CollectionShouldBeInAscendingOrderSyntaxVisitor();
-            statement.Accept(visitor);
+            private bool _argumentIsSelf;
+            protected override string MathodContainingLambda => "OrderBy";
+
+            public override bool IsValid => base.IsValid && _argumentIsSelf;
+
+            public OrderByShouldEqualSyntaxVisitor() : base("OrderBy", "Should", "Equal")
+            {
+            }
 
-            if (visitor.IsValid)
+            public override void VisitArgumentList(ArgumentListSyntax node)
             {
-                var properties = new Dictionary<string, string>
+                if (!node.Arguments.Any()) return;
+                if (CurrentMethod != "Equal")
                 {
-                    [Constants.DiagnosticProperties.VariableName] = visitor.VariableName,
-                    [Constants.DiagnosticProperties.Title] = Title
-                }.ToImmutableDictionary();
-
-                return Diagnostic.Create(
-                    descriptor: Rule,
-                    location: statement.Expression.GetLocation(),
-                    properties: properties,
-                    messageArgs: visitor.VariableName);
+                    base.VisitArgumentList(node);
+                    return;
+                }
+
+                _argumentIsSelf = node.Arguments[0].Expression is IdentifierNameSyntax identifier
+                    && identifier.Identifier.Text == VariableName;
             }
-            return null;
         }
     }
 
@@ -48,16 +57,6 @@ public class CollectionShouldBeInAscendingOrderCodeFix : FluentAssertionsCodeFix
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldBeInAscendingOrderAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-        {
-			throw new System.NotImplementedException();
-		}
-    }
-
-    public class CollectionShouldBeInAscendingOrderSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
-    {
-        public CollectionShouldBeInAscendingOrderSyntaxVisitor() : base("###")
-        {
-			throw new System.NotImplementedException();
-        }
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().BeInAscendingOrder({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldBeInDescendingOrder.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldBeInDescendingOrder.cs
@@ -1,5 +1,6 @@
 ﻿using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using System.Collections.Generic;
@@ -14,31 +15,39 @@ public class CollectionShouldBeInDescendingOrderAnalyzer : FluentAssertionsAnaly
         public const string DiagnosticId = Constants.Tips.Collections.CollectionShouldBeInDescendingOrder;
         public const string Category = Constants.Tips.Category;
 
-        public const string Message = "Use {0} .Should() followed by ### instead.";
+        public const string Message = "Use {0} .Should() followed by .BeInDescendingOrder instead.";
 
         protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);
-
-        protected override Diagnostic AnalyzeExpressionStatement(ExpressionStatementSyntax statement)
+        protected override IEnumerable<(FluentAssertionsCSharpSyntaxVisitor, BecauseArgumentsSyntaxVisitor)> Visitors
+        {
+            get
+            {
+                yield return (new OrderByDescendingShouldEqualSyntaxVisitor(), new BecauseArgumentsSyntaxVisitor("Equal", 1));
+            }
+        }
+        private class OrderByDescendingShouldEqualSyntaxVisitor : FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor
         {
-            return null;
-            var visitor = new CollectionShouldBeInDescendingOrderSyntaxVisitor();
-            statement.Accept(visitor);
+            private bool _argumentIsSelf;
+            protected override string MathodContainingLambda => "OrderByDescending";
+
+            public override bool IsValid => base.IsValid && _argumentIsSelf;
+
+            public OrderByDescendingShouldEqualSyntaxVisitor() : base("OrderByDescending", "Should", "Equal")
+            {
+            }
 
-            if (visitor.IsValid)
+            public override void VisitArgumentList(ArgumentListSyntax node)
             {
-                var properties = new Dictionary<string, string>
+                if (!node.Arguments.Any()) return;
+                if (CurrentMethod != "Equal")
                 {
-                    [Constants.DiagnosticProperties.VariableName] = visitor.VariableName,
-                    [Constants.DiagnosticProperties.Title] = Title
-                }.ToImmutableDictionary();
-
-                return Diagnostic.Create(
-                    descriptor: Rule,
-                    location: statement.Expression.GetLocation(),
-                    properties: properties,
-                    messageArgs: visitor.VariableName);
+                    base.VisitArgumentList(node);
+                    return;
+                }
+
+                _argumentIsSelf = node.Arguments[0].Expression is IdentifierNameSyntax identifier
+                    && identifier.Identifier.Text == VariableName;
             }
-            return null;
         }
     }
 
@@ -48,16 +57,6 @@ public class CollectionShouldBeInDescendingOrderCodeFix : FluentAssertionsCodeFi
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldBeInDescendingOrderAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-        {
-			throw new System.NotImplementedException();
-		}
-    }
-
-    public class CollectionShouldBeInDescendingOrderSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
-    {
-        public CollectionShouldBeInDescendingOrderSyntaxVisitor() : base("###")
-        {
-			throw new System.NotImplementedException();
-        }
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().BeInDescendingOrder({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldContainProperty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldContainProperty.cs
@@ -49,6 +49,6 @@ public class CollectionShouldContainPropertyCodeFix : FluentAssertionsCodeFixPro
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldContainPropertyAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().Contain({properties.CombineWithBecauseArgumentsString(properties.PredicateString)});");
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().Contain({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldContainSingleProperty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldContainSingleProperty.cs
@@ -39,7 +39,11 @@ public WhereShouldHaveCount1SyntaxVisitor() : base("Where", "Should", "HaveCount
             public override void VisitArgumentList(ArgumentListSyntax node)
             {
                 if (!node.Arguments.Any()) return;
-                if (CurrentMethod != "HaveCount") base.VisitArgumentList(node); ;
+                if (CurrentMethod != "HaveCount")
+                {
+                    base.VisitArgumentList(node);
+                    return;
+                }
 
                 _haveCountMethodHas1Argument =
                     node.Arguments[0].Expression is LiteralExpressionSyntax literal
@@ -55,6 +59,6 @@ public class CollectionShouldContainSinglePropertyCodeFix : FluentAssertionsCode
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldContainSinglePropertyAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().ContainSingle({properties.CombineWithBecauseArgumentsString(properties.PredicateString)});");
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().ContainSingle({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainProperty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainProperty.cs
@@ -49,6 +49,6 @@ public class CollectionShouldNotContainPropertyCodeFix : FluentAssertionsCodeFix
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldNotContainPropertyAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().NotContain({properties.CombineWithBecauseArgumentsString(properties.PredicateString)});");
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().NotContain({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldOnlyContainProperty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldOnlyContainProperty.cs
@@ -42,6 +42,6 @@ public class CollectionShouldOnlyContainPropertyCodeFix : FluentAssertionsCodeFi
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldOnlyContainPropertyAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().OnlyContain({properties.CombineWithBecauseArgumentsString(properties.PredicateString)});");
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().OnlyContain({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Utilities/FluentAssertionsDiagnosticProperties.cs b/src/FluentAssertions.BestPractices/Utilities/FluentAssertionsDiagnosticProperties.cs
@@ -15,7 +15,7 @@ public FluentAssertionsDiagnosticProperties(ImmutableDictionary<string, string>
         public string Title => Properties[Constants.DiagnosticProperties.Title];
         public string VariableName => Properties[Constants.DiagnosticProperties.VariableName];
         public string BecauseArgumentsString => Properties[Constants.DiagnosticProperties.BecauseArgumentsString];
-        public string PredicateString => Properties[Constants.DiagnosticProperties.PredicateString];
+        public string LambdaString => Properties[Constants.DiagnosticProperties.LambdaString];
         public string ExpectedItemString => Properties[Constants.DiagnosticProperties.ExpectedItemString];
         public string UnexpectedItemString => Properties[Constants.DiagnosticProperties.UnexpectedItemString];
         public string ArgumentString => Properties[Constants.DiagnosticProperties.ArgumentString];
diff --git a/src/FluentAssertions.BestPractices/Utilities/FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor.cs b/src/FluentAssertions.BestPractices/Utilities/FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor.cs
@@ -17,7 +17,7 @@ protected FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor(params string[]
         }
 
         public override ImmutableDictionary<string, string> ToDiagnosticProperties()
-            => base.ToDiagnosticProperties().Add(Constants.DiagnosticProperties.PredicateString, PredicateString);
+            => base.ToDiagnosticProperties().Add(Constants.DiagnosticProperties.LambdaString, PredicateString);
 
         public override void VisitArgumentList(ArgumentListSyntax node)
         {

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ public static class DiagnosticProperties`
`6`	`6`	`{`
`7`	`7`	`public const string Title = nameof(Title);`
`8`	`8`	`public const string VariableName = nameof(VariableName);`
`9`		`- public const string PredicateString = nameof(PredicateString);`
	`9`	`+ public const string LambdaString = nameof(LambdaString);`
`10`	`10`	`public const string ExpectedItemString = nameof(ExpectedItemString);`
`11`	`11`	`public const string UnexpectedItemString = nameof(UnexpectedItemString);`
`12`	`12`	`public const string BecauseArgumentsString = nameof(BecauseArgumentsString);`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,6 @@ public class CollectionShouldContainPropertyCodeFix : FluentAssertionsCodeFixPro`
`49`	`49`	`public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldContainPropertyAnalyzer.DiagnosticId);`
`50`	`50`
`51`	`51`	`protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)`
`52`		`- => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().Contain({properties.CombineWithBecauseArgumentsString(properties.PredicateString)});");`
	`52`	`+ => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().Contain({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,11 @@ public WhereShouldHaveCount1SyntaxVisitor() : base("Where", "Should", "HaveCount`
`39`	`39`	`public override void VisitArgumentList(ArgumentListSyntax node)`
`40`	`40`	`{`
`41`	`41`	`if (!node.Arguments.Any()) return;`
`42`		`- if (CurrentMethod != "HaveCount") base.VisitArgumentList(node); ;`
	`42`	`+ if (CurrentMethod != "HaveCount")`
	`43`	`+ {`
	`44`	`+ base.VisitArgumentList(node);`
	`45`	`+ return;`
	`46`	`+ }`
`43`	`47`
`44`	`48`	`_haveCountMethodHas1Argument =`
`45`	`49`	`node.Arguments[0].Expression is LiteralExpressionSyntax literal`
`@@ -55,6 +59,6 @@ public class CollectionShouldContainSinglePropertyCodeFix : FluentAssertionsCode`
`55`	`59`	`public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldContainSinglePropertyAnalyzer.DiagnosticId);`
`56`	`60`
`57`	`61`	`protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)`
`58`		`- => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().ContainSingle({properties.CombineWithBecauseArgumentsString(properties.PredicateString)});");`
	`62`	`+ => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().ContainSingle({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");`
`59`	`63`	`}`
`60`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,6 @@ public class CollectionShouldOnlyContainPropertyCodeFix : FluentAssertionsCodeFi`
`42`	`42`	`public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldOnlyContainPropertyAnalyzer.DiagnosticId);`
`43`	`43`
`44`	`44`	`protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)`
`45`		`- => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().OnlyContain({properties.CombineWithBecauseArgumentsString(properties.PredicateString)});");`
	`45`	`+ => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().OnlyContain({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ protected FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor(params string[]`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`public override ImmutableDictionary<string, string> ToDiagnosticProperties()`
`20`		`- => base.ToDiagnosticProperties().Add(Constants.DiagnosticProperties.PredicateString, PredicateString);`
	`20`	`+ => base.ToDiagnosticProperties().Add(Constants.DiagnosticProperties.LambdaString, PredicateString);`
`21`	`21`
`22`	`22`	`public override void VisitArgumentList(ArgumentListSyntax node)`
`23`	`23`	`{`