{EnumerableAnalyzer} - more assertions

Meir017 · Meir017 · commit 0c8789201657 · 2017-10-13T12:35:43.000+03:00
diff --git a/src/FluentAssertions.BestPractices.Tests/Tips/CollectionTests.cs b/src/FluentAssertions.BestPractices.Tests/Tips/CollectionTests.cs
@@ -1,6 +1,5 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Reflection;
 
 namespace FluentAssertions.BestPractices.Tests
 {
@@ -257,7 +256,7 @@ public class CollectionTests
             newAssertion: "actual.Should().ContainSingle(x => x.BooleanProperty{0});")]
         [Implemented]
         public void CollectionShouldContainSingleProperty_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldContainSinglePropertyCodeFix, CollectionShouldContainSinglePropertyAnalyzer>(oldAssertion, newAssertion);
-        
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Should().NotBeNull().And.NotBeEmpty({0});")]
         [NotImplemented]
@@ -301,7 +300,7 @@ public class CollectionTests
             newAssertion: "actual.Should().HaveElementAt(6, expectedItem{0});")]
         [Implemented]
         public void CollectionShouldHaveElementAt_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldHaveElementAtCodeFix, CollectionShouldHaveElementAtAnalyzer>(oldAssertion, newAssertion);
-        
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.OrderBy(x => x.BooleanProperty).Should().Equal(actual{0});")]
         [Implemented]
@@ -340,57 +339,62 @@ public class CollectionTests
 
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Intersect(expected).Should().BeEmpty({0});")]
-        [NotImplemented]
+        [Implemented]
         public void CollectionShouldNotIntersectWith_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldNotIntersectWithAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
         oldAssertion: "actual.Intersect(expected).Should().BeEmpty({0});",
         newAssertion: "actual.Should().NotIntersectWith(expected{0});")]
-        [NotImplemented]
+        [Implemented]
         public void CollectionShouldNotIntersectWith_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldNotIntersectWithCodeFix, CollectionShouldNotIntersectWithAnalyzer>(oldAssertion, newAssertion);
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Intersect(expected).Should().NotBeEmpty({0});")]
-        [NotImplemented]
+        [Implemented]
         public void CollectionShouldIntersectWith_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldIntersectWithAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-        oldAssertion: "actual.Intersect(expected).Should().NotBeEmpty({0});",
-        newAssertion: "actual.Should().IntersectWith(expected{0});")]
-        [NotImplemented]
+            oldAssertion: "actual.Intersect(expected).Should().NotBeEmpty({0});",
+            newAssertion: "actual.Should().IntersectWith(expected{0});")]
+        [Implemented]
         public void CollectionShouldIntersectWith_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldIntersectWithCodeFix, CollectionShouldIntersectWithAnalyzer>(oldAssertion, newAssertion);
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Select(x => x.BooleanProperty).Should().NotContainNulls({0});")]
-        [NotImplemented]
+        [Implemented]
         public void CollectionShouldNotContainNulls_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldNotContainNullsAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-        oldAssertion: "actual.Select(x => x.BooleanProperty).Should().NotContainNulls({0});",
-        newAssertion: "actual.Should().NotContainNulls(e => e.OtherProperty{0});")]
-        [NotImplemented]
+            oldAssertion: "actual.Select(x => x.BooleanProperty).Should().NotContainNulls({0});",
+            newAssertion: "actual.Should().NotContainNulls(x => x.BooleanProperty{0});")]
+        [Implemented]
+        [Ignore("Will be available in Fluent Assertions 5.0")]
         public void CollectionShouldNotContainNulls_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldNotContainNullsCodeFix, CollectionShouldNotContainNullsAnalyzer>(oldAssertion, newAssertion);
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Should().HaveSameCount(actual.Distinct(){0});")]
         [NotImplemented]
         public void CollectionShouldOnlyHaveUniqueItems_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldOnlyHaveUniqueItemsAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-        oldAssertion: "actual.Should().HaveSameCount(actual.Distinct(){0});",
-        newAssertion: "actual.Should().OnlyHaveUniqueItems({0});")]
+            oldAssertion: "actual.Should().HaveSameCount(actual.Distinct(){0});",
+            newAssertion: "actual.Should().OnlyHaveUniqueItems({0});")]
         [NotImplemented]
         public void CollectionShouldOnlyHaveUniqueItems_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldOnlyHaveUniqueItemsCodeFix, CollectionShouldOnlyHaveUniqueItemsAnalyzer>(oldAssertion, newAssertion);
+
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Select(x => x.BooleanProperty).Should().OnlyHaveUniqueItems({0});")]
         [NotImplemented]
         public void CollectionShouldOnlyHaveUniqueItemsByComparer_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<CollectionShouldOnlyHaveUniqueItemsByComparerAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-        oldAssertion: "actual.Select(x => x.BooleanProperty).Should().OnlyHaveUniqueItems({0});",
-        newAssertion: "actual.Should().OnlyHaveUniqueItems(x => x.BooleanProperty{0});")]
+            oldAssertion: "actual.Select(x => x.BooleanProperty).Should().OnlyHaveUniqueItems({0});",
+            newAssertion: "actual.Should().OnlyHaveUniqueItems(x => x.BooleanProperty{0});")]
         [NotImplemented]
         public void CollectionShouldOnlyHaveUniqueItemsByComparer_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldOnlyHaveUniqueItemsByComparerCodeFix, CollectionShouldOnlyHaveUniqueItemsByComparerAnalyzer>(oldAssertion, newAssertion);
         [AssertionDataTestMethod]
@@ -400,8 +404,8 @@ public class CollectionTests
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-        oldAssertion: "actual.FirstOrDefault().Should().BeNull({0});",
-        newAssertion: "actual.Should().HaveElementAt(0, null{0});")]
+            oldAssertion: "actual.FirstOrDefault().Should().BeNull({0});",
+            newAssertion: "actual.Should().HaveElementAt(0, null{0});")]
         [NotImplemented]
         public void CollectionShouldHaveElementAt0Null_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<CollectionShouldHaveElementAt0NullCodeFix, CollectionShouldHaveElementAt0NullAnalyzer>(oldAssertion, newAssertion);
 
diff --git a/src/FluentAssertions.BestPractices/FluentAssertions.BestPractices.nuspec b/src/FluentAssertions.BestPractices/FluentAssertions.BestPractices.nuspec
@@ -3,7 +3,7 @@
   <metadata>
     <id>FluentAssertions.BestPractices</id>
     <title>Fluent Assertions Best Practice</title>
-    <version>0.2.0</version>
+    <version>0.2.1</version>
     <owners>Meir Blachman</owners>
     <authors>Meir Blachman</authors>
     <summary>
@@ -16,12 +16,12 @@
     <licenseUrl>https://github.com/Meir017/fluentassertions.bestpractices/blob/master/LICENSE</licenseUrl>
     <iconUrl>https://raw.githubusercontent.com/fluentassertions/fluentassertions/release-5.0/Src/FluentAssertions.png</iconUrl>
     <projectUrl>http://www.fluentassertions.com</projectUrl>
-	<requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <tags>FluentAssertions Analyzers</tags>
-	<frameworkAssemblies>
+    <frameworkAssemblies>
       <frameworkAssembly assemblyName="System" targetFramework="" />
     </frameworkAssemblies>
-    <copyright>Copyright Meir Blachman 2017-</copyright>
+    <copyright>Copyright Meir Blachman 2017</copyright>
     <releaseNotes>
       See https://github.com/Meir017/fluentassertions.bestpractices/releases/
     </releaseNotes>
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldIntersectWith.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldIntersectWith.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,23 @@ public class CollectionShouldIntersectWithAnalyzer : FluentAssertionsAnalyzer
         public const string DiagnosticId = Constants.Tips.Collections.CollectionShouldIntersectWith;
         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 .IntersectWith() 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
         {
-            return null;
-            var visitor = new CollectionShouldIntersectWithSyntaxVisitor();
-            statement.Accept(visitor);
-
-            if (visitor.IsValid)
+            get
             {
-                var properties = new Dictionary<string, string>
-                {
-                    [Constants.DiagnosticProperties.VariableName] = visitor.VariableName,
-                    [Constants.DiagnosticProperties.Title] = Title
-                }.ToImmutableDictionary();
-				throw new System.NotImplementedException();
+                yield return (new IntersectShouldNotBeEmptySyntaxVisitor(), new BecauseArgumentsSyntaxVisitor("NotBeEmpty", 0));
+            }
+        }
 
-                return Diagnostic.Create(
-                    descriptor: Rule,
-                    location: statement.Expression.GetLocation(),
-                    properties: properties,
-                    messageArgs: visitor.VariableName);
+        private class IntersectShouldNotBeEmptySyntaxVisitor : FluentAssertionsWithArgumentCSharpSyntaxVisitor
+        {
+            protected override string MethodContainingArgument => "Intersect";
+            public IntersectShouldNotBeEmptySyntaxVisitor() : base("Intersect", "Should", "NotBeEmpty")
+            {
             }
-            return null;
         }
     }
 
@@ -49,16 +41,6 @@ public class CollectionShouldIntersectWithCodeFix : FluentAssertionsCodeFixProvi
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldIntersectWithAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-        {
-			throw new System.NotImplementedException();
-		}
-    }
-
-    public class CollectionShouldIntersectWithSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
-    {
-        public CollectionShouldIntersectWithSyntaxVisitor() : base("###")
-        {
-			throw new System.NotImplementedException();
-        }
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().IntersectWith({properties.CombineWithBecauseArgumentsString(properties.ArgumentString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainNulls.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainNulls.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;
@@ -17,29 +18,20 @@ public class CollectionShouldNotContainNullsAnalyzer : FluentAssertionsAnalyzer
         public const string Message = "Use {0} .Should() followed by ### 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
         {
-            return null;
-            var visitor = new CollectionShouldNotContainNullsSyntaxVisitor();
-            statement.Accept(visitor);
-
-            if (visitor.IsValid)
+            get
             {
-                var properties = new Dictionary<string, string>
-                {
-                    [Constants.DiagnosticProperties.VariableName] = visitor.VariableName,
-                    [Constants.DiagnosticProperties.Title] = Title
-                }.ToImmutableDictionary();
-				throw new System.NotImplementedException();
+                yield return (new SelectShouldNotContainNullsSyntaxVisitor(), new BecauseArgumentsSyntaxVisitor("NotContainNulls", 0));
+            }
+        }
 
-                return Diagnostic.Create(
-                    descriptor: Rule,
-                    location: statement.Expression.GetLocation(),
-                    properties: properties,
-                    messageArgs: visitor.VariableName);
+        private class SelectShouldNotContainNullsSyntaxVisitor : FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor
+        {
+            protected override string MethodContainingLambda => "Select";
+            public SelectShouldNotContainNullsSyntaxVisitor() : base("Select", "Should", "NotContainNulls")
+            {
             }
-            return null;
         }
     }
 
@@ -49,16 +41,6 @@ public class CollectionShouldNotContainNullsCodeFix : FluentAssertionsCodeFixPro
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldNotContainNullsAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-        {
-			throw new System.NotImplementedException();
-		}
-    }
-
-    public class CollectionShouldNotContainNullsSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
-    {
-        public CollectionShouldNotContainNullsSyntaxVisitor() : base("###")
-        {
-			throw new System.NotImplementedException();
-        }
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().NotContainNulls({properties.CombineWithBecauseArgumentsString(properties.LambdaString)});");
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainProperty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainProperty.cs
@@ -16,7 +16,7 @@ public class CollectionShouldNotContainPropertyAnalyzer : FluentAssertionsAnalyz
         public const string Category = Constants.Tips.Category;
 
         public const string Message = "Use {0} .Should() followed by .NotContain() instead.";
-
+        
         protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);
         protected override IEnumerable<(FluentAssertionsCSharpSyntaxVisitor, BecauseArgumentsSyntaxVisitor)> Visitors
         {
@@ -42,7 +42,7 @@ public WhereShouldBeEmptySyntaxVisitor() : base("Where", "Should", "BeEmpty")
             {
             }
         }
-        // actual.Should().OnlyContain(e => !e.BooleanProperty{0});
+        
         private class ShouldOnlyContainNotSyntaxVisitor : FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor
         {
             protected override string MethodContainingLambda => "OnlyContain";
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotIntersectWith.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotIntersectWith.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,22 @@ public class CollectionShouldNotIntersectWithAnalyzer : FluentAssertionsAnalyzer
         public const string DiagnosticId = Constants.Tips.Collections.CollectionShouldNotIntersectWith;
         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 .NotIntersectWith() 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
         {
-            return null;
-            var visitor = new CollectionShouldNotIntersectWithSyntaxVisitor();
-            statement.Accept(visitor);
-
-            if (visitor.IsValid)
+            get
+            {
+                yield return (new IntersectShouldBeEmptySyntaxVisitor(), new BecauseArgumentsSyntaxVisitor("BeEmpty", 0));
+            }
+        }
+        private class IntersectShouldBeEmptySyntaxVisitor : FluentAssertionsWithArgumentCSharpSyntaxVisitor
+        {
+            protected override string MethodContainingArgument => "Intersect";
+            public IntersectShouldBeEmptySyntaxVisitor() : base("Intersect", "Should", "BeEmpty")
             {
-                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);
             }
-            return null;
         }
     }
 
@@ -49,16 +40,6 @@ public class CollectionShouldNotIntersectWithCodeFix : FluentAssertionsCodeFixPr
         public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CollectionShouldNotIntersectWithAnalyzer.DiagnosticId);
 
         protected override StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties)
-        {
-			throw new System.NotImplementedException();
-		}
-    }
-
-    public class CollectionShouldNotIntersectWithSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
-    {
-        public CollectionShouldNotIntersectWithSyntaxVisitor() : base("###")
-        {
-			throw new System.NotImplementedException();
-        }
+            => SyntaxFactory.ParseStatement($"{properties.VariableName}.Should().NotIntersectWith({properties.CombineWithBecauseArgumentsString(properties.ArgumentString)});");
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class CollectionShouldNotContainPropertyAnalyzer : FluentAssertionsAnalyz`
`16`	`16`	`public const string Category = Constants.Tips.Category;`
`17`	`17`
`18`	`18`	`public const string Message = "Use {0} .Should() followed by .NotContain() instead.";`
`19`		`-`
	`19`	`+`
`20`	`20`	`protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);`
`21`	`21`	`protected override IEnumerable<(FluentAssertionsCSharpSyntaxVisitor, BecauseArgumentsSyntaxVisitor)> Visitors`
`22`	`22`	`{`
`@@ -42,7 +42,7 @@ public WhereShouldBeEmptySyntaxVisitor() : base("Where", "Should", "BeEmpty")`
`42`	`42`	`{`
`43`	`43`	`}`
`44`	`44`	`}`
`45`		`- // actual.Should().OnlyContain(e => !e.BooleanProperty{0});`
	`45`	`+`
`46`	`46`	`private class ShouldOnlyContainNotSyntaxVisitor : FluentAssertionsWithLambdaArgumentCSharpSyntaxVisitor`
`47`	`47`	`{`
`48`	`48`	`protected override string MethodContainingLambda => "OnlyContain";`