{EnumerableAnalyzer} - 2 more

Meir017 · Meir017 · commit 90021b52d03c · 2017-10-11T02:42:48.000+03:00
diff --git a/src/FluentAssertions.BestPractices.Tests/Tips/CollectionTests.cs b/src/FluentAssertions.BestPractices.Tests/Tips/CollectionTests.cs
@@ -103,26 +103,35 @@ public class CollectionTests
 
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Count().Should().Be(k{0});")]
-        [NotImplemented]
+        [AssertionDiagnostic("actual.Count().Should().Be(6{0});")]
+        [Implemented]
         public void CollectionShouldHaveCount_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldHaveCountAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
             oldAssertion: "actual.Count().Should().Be(k{0});",
             newAssertion: "actual.Should().HaveCount(k{0});")]
-        [NotImplemented]
+        [AssertionCodeFix(
+            oldAssertion: "actual.Count().Should().Be(6{0});",
+            newAssertion: "actual.Should().HaveCount(6{0});")]
+        [Implemented]
         public void CollectionShouldHaveCount_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldHaveCountCodeFix, CollectionShouldHaveCountAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Count().Should().BeGreaterThan(k{0});")]
-        [NotImplemented]
+        [AssertionDiagnostic("actual.Count().Should().BeGreaterThan(6{0});")]
+        [Implemented]
         public void CollectionShouldHaveCountGreaterThan_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldHaveCountGreaterThanAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
             oldAssertion: "actual.Count().Should().BeGreaterThan(k{0});",
             newAssertion: "actual.Should().HaveCountGreaterThan(k{0});")]
-        [NotImplemented]
+        [AssertionCodeFix(
+            oldAssertion: "actual.Count().Should().BeGreaterThan(6{0});",
+            newAssertion: "actual.Should().HaveCountGreaterThan(6{0});")]
+        [Implemented]
+        [Ignore("Waiting for official FluentAssertions 5.0")]
         public void CollectionShouldHaveCountGreaterThan_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldHaveCountGreaterThanCodeFix, CollectionShouldHaveCountGreaterThanAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
@@ -135,6 +144,7 @@ public class CollectionTests
             oldAssertion: "actual.Count().Should().BeGreaterOrEqualTo(k{0});",
             newAssertion: "actual.Should().HaveCountGreaterOrEqualTo(k{0});")]
         [NotImplemented]
+        [Ignore("Waiting for official FluentAssertions 5.0")]
         public void CollectionShouldHaveCountGreaterOrEqualTo_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldHaveCountGreaterOrEqualToCodeFix, CollectionShouldHaveCountGreaterOrEqualToAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
@@ -147,6 +157,7 @@ public class CollectionTests
             oldAssertion: "actual.Count().Should().BeLessThan(k{0});",
             newAssertion: "actual.Should().HaveCountLessThan(k{0});")]
         [NotImplemented]
+        [Ignore("Waiting for official FluentAssertions 5.0")]
         public void CollectionShouldHaveCountLessThan_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldHaveCountLessThanCodeFix, CollectionShouldHaveCountLessThanAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
@@ -207,7 +218,7 @@ public class CollectionTests
             newAssertion: "actual.Should().NotHaveSameCount(unexpected{0});")]
         [NotImplemented]
         public void CollectionShouldNotHaveSameCount_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldNotHaveSameCountCodeFix, CollectionShouldNotHaveSameCountAnalyzer>(oldAssertion, newAssertion);
-        
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Where(x => x.BooleanProperty).Should().BeEmpty({0});")]
         [NotImplemented]
diff --git a/src/FluentAssertions.BestPractices/Constants.cs b/src/FluentAssertions.BestPractices/Constants.cs
@@ -10,6 +10,7 @@ public static class DiagnosticProperties
             public const string ExpectedItemString = nameof(ExpectedItemString);
             public const string UnexpectedItemString = nameof(UnexpectedItemString);
             public const string BecauseArgumentsString = nameof(BecauseArgumentsString);
+            public const string CountArgument = nameof(CountArgument);
         }
 
         public static class Tips
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldBeEmpty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldBeEmpty.cs
@@ -48,10 +48,10 @@ public ShouldHaveCount0SyntaxVisitor() : base("Should", "HaveCount")
             public override void VisitArgumentList(ArgumentListSyntax node)
             {
                 if (!node.Arguments.Any()) return;
+                if (CurrentMethod != "HaveCount") return;
 
-                _haveCountMethodHas0Argument = !_haveCountMethodHas0Argument
-                    && CurrentMethod == "HaveCount"
-                    && node.Arguments[0].Expression is LiteralExpressionSyntax literal
+                _haveCountMethodHas0Argument =
+                    node.Arguments[0].Expression is LiteralExpressionSyntax literal
                     && literal.Token.Value is int argument
                     && argument == 0;
             }
@@ -62,8 +62,8 @@ public override void VisitArgumentList(ArgumentListSyntax node)
     public class CollectionShouldBeEmptyCodeFix : FluentAssertionsCodeFixProvider
     {
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldBeEmptyAnalyzer.DiagnosticId);
-        
+
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
             => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().BeEmpty({properties.BecauseArgumentsString});");
-    } 
+    }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCount.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCount.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,32 +15,37 @@ public class CollectionShouldHaveCountAnalyzer : FluentAssertionsAnalyzer
         public const string DiagnosticId = Constants.Tips.Collections.CollectionShouldHaveCount;
         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 .HaveCount() instead.";
 
         protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);
+        protected override IEnumerable<(FluentAssertionsCSharpSyntaxVisitor, BecauseArgumentsSyntaxVisitor)> Visitors
+        {
+            get
+            {
+                yield return (new CountShouldBeSyntaxVisitor(), new BecauseArgumentsSyntaxVisitor("Be", 1));
+            }
+        }
 
-        protected override Diagnostic AnalyzeExpressionStatement(ExpressionStatementSyntax statement)
+        private class CountShouldBeSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
         {
-            return null;
-            var visitor = new CollectionShouldHaveCountSyntaxVisitor();
-            statement.Accept(visitor);
+            public string CountArgument { get; private set; }
 
-            if (visitor.IsValid)
+            public override bool IsValid => base.IsValid && CountArgument != null;
+
+            public CountShouldBeSyntaxVisitor() : base("Count", "Should", "Be")
             {
-                var properties = new Dictionary<string, string>
-                {
-                    [Constants.DiagnosticProperties.VariableName] = visitor.VariableName,
-                    [Constants.DiagnosticProperties.Title] = Title
-                }.ToImmutableDictionary();
-				throw new System.NotImplementedException();
+            }
 
-                return Diagnostic.Create(
-                    descriptor: Rule,
-                    location: statement.Expression.GetLocation(),
-                    properties: properties,
-                    messageArgs: visitor.VariableName);
+            public override ImmutableDictionary<string, string> ToDiagnosticProperties()
+                => base.ToDiagnosticProperties().Add(Constants.DiagnosticProperties.CountArgument, CountArgument);
+
+            public override void VisitArgumentList(ArgumentListSyntax node)
+            {
+                if (!node.Arguments.Any()) return;
+                if (CurrentMethod != "Be") return;
+
+                CountArgument = node.Arguments[0].ToFullString();
             }
-            return null;
         }
     }
 
@@ -49,16 +55,6 @@ public class CollectionShouldHaveCountCodeFix : FluentAssertionsCodeFixProvider
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldHaveCountAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-        {
-			throw new System.NotImplementedException();
-		}
-    }
-
-    public class CollectionShouldHaveCountSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
-    {
-        public CollectionShouldHaveCountSyntaxVisitor() : base("###")
-        {
-			throw new System.NotImplementedException();
-        }
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().HaveCount({properties.CombineWithBecauseArgumentsString(properties.CountArgument)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountGreaterThan.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountGreaterThan.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,32 +15,37 @@ public class CollectionShouldHaveCountGreaterThanAnalyzer : FluentAssertionsAnal
         public const string DiagnosticId = Constants.Tips.Collections.CollectionShouldHaveCountGreaterThan;
         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 .BeGreaterThan() instead.";
 
         protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);
+        protected override IEnumerable<(FluentAssertionsCSharpSyntaxVisitor, BecauseArgumentsSyntaxVisitor)> Visitors
+        {
+            get
+            {
+                yield return (new CountShouldBeGreaterThanSyntaxVisitor(), new BecauseArgumentsSyntaxVisitor("BeGreaterThan", 1));
+            }
+        }
 
-        protected override Diagnostic AnalyzeExpressionStatement(ExpressionStatementSyntax statement)
+        private class CountShouldBeGreaterThanSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
         {
-            return null;
-            var visitor = new CollectionShouldHaveCountGreaterThanSyntaxVisitor();
-            statement.Accept(visitor);
+            public string CountArgument { get; private set; }
 
-            if (visitor.IsValid)
+            public override bool IsValid => base.IsValid && CountArgument != null;
+
+            public CountShouldBeGreaterThanSyntaxVisitor() : base("Count", "Should", "BeGreaterThan")
             {
-                var properties = new Dictionary<string, string>
-                {
-                    [Constants.DiagnosticProperties.VariableName] = visitor.VariableName,
-                    [Constants.DiagnosticProperties.Title] = Title
-                }.ToImmutableDictionary();
-				throw new System.NotImplementedException();
+            }
 
-                return Diagnostic.Create(
-                    descriptor: Rule,
-                    location: statement.Expression.GetLocation(),
-                    properties: properties,
-                    messageArgs: visitor.VariableName);
+            public override ImmutableDictionary<string, string> ToDiagnosticProperties()
+                => base.ToDiagnosticProperties().Add(Constants.DiagnosticProperties.CountArgument, CountArgument);
+
+            public override void VisitArgumentList(ArgumentListSyntax node)
+            {
+                if (!node.Arguments.Any()) return;
+                if (CurrentMethod != "BeGreaterThan") return;
+
+                CountArgument = node.Arguments[0].ToFullString();
             }
-            return null;
         }
     }
 
@@ -49,16 +55,6 @@ public class CollectionShouldHaveCountGreaterThanCodeFix : FluentAssertionsCodeF
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldHaveCountGreaterThanAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-        {
-			throw new System.NotImplementedException();
-		}
-    }
-
-    public class CollectionShouldHaveCountGreaterThanSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
-    {
-        public CollectionShouldHaveCountGreaterThanSyntaxVisitor() : base("###")
-        {
-			throw new System.NotImplementedException();
-        }
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().HaveCountGreaterThan({properties.CombineWithBecauseArgumentsString(properties.CountArgument)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Utilities/FluentAssertionsDiagnosticProperties.cs b/src/FluentAssertions.BestPractices/Utilities/FluentAssertionsDiagnosticProperties.cs
@@ -18,6 +18,7 @@ public FluentAssertionsDiagnosticProperties(ImmutableDictionary<string, string>
         public string PredicateString => Properties[Constants.DiagnosticProperties.PredicateString];
         public string ExpectedItemString => Properties[Constants.DiagnosticProperties.ExpectedItemString];
         public string UnexpectedItemString => Properties[Constants.DiagnosticProperties.UnexpectedItemString];
+        public string CountArgument => Properties[Constants.DiagnosticProperties.CountArgument];
 
         public string CombineWithBecauseArgumentsString(string validArgument)
         {

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ public static class DiagnosticProperties`
`10`	`10`	`public const string ExpectedItemString = nameof(ExpectedItemString);`
`11`	`11`	`public const string UnexpectedItemString = nameof(UnexpectedItemString);`
`12`	`12`	`public const string BecauseArgumentsString = nameof(BecauseArgumentsString);`
	`13`	`+ public const string CountArgument = nameof(CountArgument);`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`public static class Tips`
Original file line number	Diff line number	Diff line change
`@@ -48,10 +48,10 @@ public ShouldHaveCount0SyntaxVisitor() : base("Should", "HaveCount")`
`48`	`48`	`public override void VisitArgumentList(ArgumentListSyntax node)`
`49`	`49`	`{`
`50`	`50`	`if (!node.Arguments.Any()) return;`
	`51`	`+ if (CurrentMethod != "HaveCount") return;`
`51`	`52`
`52`		`- _haveCountMethodHas0Argument = !_haveCountMethodHas0Argument`
`53`		`- && CurrentMethod == "HaveCount"`
`54`		`- && node.Arguments[0].Expression is LiteralExpressionSyntax literal`
	`53`	`+ _haveCountMethodHas0Argument =`
	`54`	`+ node.Arguments[0].Expression is LiteralExpressionSyntax literal`
`55`	`55`	`&& literal.Token.Value is int argument`
`56`	`56`	`&& argument == 0;`
`57`	`57`	`}`
`@@ -62,8 +62,8 @@ public override void VisitArgumentList(ArgumentListSyntax node)`
`62`	`62`	`public class CollectionShouldBeEmptyCodeFix : FluentAssertionsCodeFixProvider`
`63`	`63`	`{`
`64`	`64`	`public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldBeEmptyAnalyzer.DiagnosticId);`
`65`		`-`
	`65`	`+`
`66`	`66`	`protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)`
`67`	`67`	`=> SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().BeEmpty({properties.BecauseArgumentsString});");`
`68`		`- }`
	`68`	`+ }`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ public FluentAssertionsDiagnosticProperties(ImmutableDictionary<string, string>`
`18`	`18`	`public string PredicateString => Properties[Constants.DiagnosticProperties.PredicateString];`
`19`	`19`	`public string ExpectedItemString => Properties[Constants.DiagnosticProperties.ExpectedItemString];`
`20`	`20`	`public string UnexpectedItemString => Properties[Constants.DiagnosticProperties.UnexpectedItemString];`
	`21`	`+ public string CountArgument => Properties[Constants.DiagnosticProperties.CountArgument];`
`21`	`22`
`22`	`23`	`public string CombineWithBecauseArgumentsString(string validArgument)`
`23`	`24`	`{`