added dictionary analyzers

fluentassertions · Oct 21, 2017 · cdd9a01 · cdd9a01
1 parent 55ef45f
commit cdd9a01
Show file tree

Hide file tree

Showing 17 changed files with 280 additions and 100 deletions.
diff --git a/src/FluentAssertions.BestPractices.Tests/GenerateCode.cs b/src/FluentAssertions.BestPractices.Tests/GenerateCode.cs
@@ -42,7 +42,7 @@ public static class GenerateCode
             .AppendLine("{")
             .AppendLine("    public class TestClass")
             .AppendLine("    {")
-            .AppendLine($"        public void TestMethod(Dictionary<string, TestComplexClass> {ActualVariableName}, IDictionary<string, TestComplexClass> expected, IDictionary<string, TestComplexClass> unexpected, string expectedKey, TestComplexClass expectedValue, string unexpectedKey, TestComplexClass unexpectedValue)")
+            .AppendLine($"        public void TestMethod(Dictionary<string, TestComplexClass> {ActualVariableName}, IDictionary<string, TestComplexClass> expected, IDictionary<string, TestComplexClass> unexpected, string expectedKey, TestComplexClass expectedValue, string unexpectedKey, TestComplexClass unexpectedValue, KeyValuePair<string, TestComplexClass> pair)")
             .AppendLine("        {")
             .AppendLine($"            {assertion}")
             .AppendLine("        }")

diff --git a/src/FluentAssertions.BestPractices.Tests/Tips/DictionaryTests.cs b/src/FluentAssertions.BestPractices.Tests/Tips/DictionaryTests.cs
@@ -71,9 +71,15 @@ public class DictionaryTests
         public void DictionaryShouldNotContainValue_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<DictionaryShouldNotContainValueCodeFix, DictionaryShouldNotContainValueAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
-        [AssertionDiagnostic("actual.Should().ContainKey(expectedKey{0}).And.ContainValue(expectedValue{0});")]
-        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(expectedKey{0}).And.ContainValue(expectedValue{0}).And.ToString();")]
-        [NotImplemented]
+        [AssertionDiagnostic("actual.Should().ContainKey(expectedKey{0}).And.ContainValue(expectedValue);")]
+        [AssertionDiagnostic("actual.Should().ContainKey(expectedKey).And.ContainValue(expectedValue{0});")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(expectedKey{0}).And.ContainValue(expectedValue).And.ToString();")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(expectedKey).And.ContainValue(expectedValue{0}).And.ToString();")]
+        [AssertionDiagnostic("actual.Should().ContainValue(expectedValue{0}).And.ContainKey(expectedKey);")]
+        [AssertionDiagnostic("actual.Should().ContainValue(expectedValue).And.ContainKey(expectedKey{0});")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(expectedValue{0}).And.ContainKey(expectedKey).And.ToString();")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(expectedValue).And.ContainKey(expectedKey{0}).And.ToString();")]
+        [Implemented]
         public void DictionaryShouldContainKeyAndValue_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<DictionaryShouldContainKeyAndValueAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
@@ -89,29 +95,59 @@ public class DictionaryTests
         [AssertionCodeFix(
             oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(expectedKey).And.ContainValue(expectedValue{0}).And.ToString();",
             newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(expectedKey, expectedValue{0}).And.ToString();")]
-        [NotImplemented]
+        [AssertionCodeFix(
+            oldAssertion: "actual.Should().ContainValue(expectedValue{0}).And.ContainKey(expectedKey);",
+            newAssertion: "actual.Should().Contain(expectedKey, expectedValue{0});")]
+        [AssertionCodeFix(
+            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(expectedValue).And.ContainKey(expectedKey{0}).And.ToString();",
+            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(expectedKey, expectedValue{0}).And.ToString();")]
+        [AssertionCodeFix(
+            oldAssertion: "actual.Should().ContainValue(expectedValue).And.ContainKey(expectedKey{0});",
+            newAssertion: "actual.Should().Contain(expectedKey, expectedValue{0});")]
+        [AssertionCodeFix(
+            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(expectedValue{0}).And.ContainKey(expectedKey).And.ToString();",
+            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(expectedKey, expectedValue{0}).And.ToString();")]
+        [Implemented]
         public void DictionaryShouldContainKeyAndValue_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<DictionaryShouldContainKeyAndValueCodeFix, DictionaryShouldContainKeyAndValueAnalyzer>(oldAssertion, newAssertion);
 
         [AssertionDataTestMethod]
-        [AssertionDiagnostic("actual.Should().ContainKey(expected.Key{0}).And.ContainValue(expected.Value);")]
-        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(expected.Key{0}).And.ContainValue(expected.Value).And.ToString();")]
-        [NotImplemented]
+        [AssertionDiagnostic("actual.Should().ContainKey(pair.Key{0}).And.ContainValue(pair.Value);")]
+        [AssertionDiagnostic("actual.Should().ContainKey(pair.Key).And.ContainValue(pair.Value{0});")]
+        [AssertionDiagnostic("actual.Should().ContainValue(pair.Value{0}).And.ContainKey(pair.Key);")]
+        [AssertionDiagnostic("actual.Should().ContainValue(pair.Value).And.ContainKey(pair.Key{0});")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(pair.Key{0}).And.ContainValue(pair.Value).And.ToString();")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(pair.Key).And.ContainValue(pair.Value{0}).And.ToString();")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(pair.Value{0}).And.ContainKey(pair.Key).And.ToString();")]
+        [AssertionDiagnostic("actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(pair.Value).And.ContainKey(pair.Key{0}).And.ToString();")]
+        [Implemented]
         public void DictionaryShouldContainPair_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic<DictionaryShouldContainPairAnalyzer>(assertion);
 
         [AssertionDataTestMethod]
         [AssertionCodeFix(
-            oldAssertion: "actual.Should().ContainKey(expected.Key{0}).And.ContainValue(expected.Value);",
-            newAssertion: "actual.Should().Contain(expected{0});")]
+            oldAssertion: "actual.Should().ContainKey(pair.Key{0}).And.ContainValue(pair.Value);",
+            newAssertion: "actual.Should().Contain(pair{0});")]
+        [AssertionCodeFix(
+            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(pair.Key{0}).And.ContainValue(pair.Value).And.ToString();",
+            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(pair{0}).And.ToString();")]
         [AssertionCodeFix(
-            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(expected.Key{0}).And.ContainValue(expected.Value).And.ToString();",
-            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(expected{0}).And.ToString();")]
+            oldAssertion: "actual.Should().ContainKey(pair.Key).And.ContainValue(pair.Value{0});",
+            newAssertion: "actual.Should().Contain(pair{0});")]
         [AssertionCodeFix(
-            oldAssertion: "actual.Should().ContainKey(expected.Key).And.ContainValue(expected.Value{0});",
-            newAssertion: "actual.Should().Contain(expected{0});")]
+            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(pair.Key).And.ContainValue(pair.Value{0}).And.ToString();",
+            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(pair{0}).And.ToString();")]
         [AssertionCodeFix(
-            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainKey(expected.Key).And.ContainValue(expected.Value{0}).And.ToString();",
-            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(expected{0}).And.ToString();")]
-        [NotImplemented]
+            oldAssertion: "actual.Should().ContainValue(pair.Value{0}).And.ContainKey(pair.Key);",
+            newAssertion: "actual.Should().Contain(pair{0});")]
+        [AssertionCodeFix(
+            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(pair.Value{0}).And.ContainKey(pair.Key).And.ToString();",
+            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(pair{0}).And.ToString();")]
+        [AssertionCodeFix(
+            oldAssertion: "actual.Should().ContainValue(pair.Value).And.ContainKey(pair.Key{0});",
+            newAssertion: "actual.Should().Contain(pair{0});")]
+        [AssertionCodeFix(
+            oldAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().ContainValue(pair.Value).And.ContainKey(pair.Key{0}).And.ToString();",
+            newAssertion: "actual.ToDictionary(p => p.Key, p=> p.Value).Should().Contain(pair{0}).And.ToString();")]
+        [Implemented]
         public void DictionaryShouldContainPair_TestCodeFix(string oldAssertion, string newAssertion) => VerifyCSharpFix<DictionaryShouldContainPairCodeFix, DictionaryShouldContainPairAnalyzer>(oldAssertion, newAssertion);
 
         private void VerifyCSharpDiagnostic<TDiagnosticAnalyzer>(string sourceAssersion) where TDiagnosticAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer, new()

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.4.0</version>
+    <version>0.5.0</version>
     <owners>Meir Blachman</owners>
     <authors>Meir Blachman</authors>
     <summary>

diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCount.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCount.cs
@@ -55,7 +55,7 @@ public class CollectionShouldHaveCountCodeFix : FluentAssertionsCodeFixProvider
 
         protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties)
         {
-            return GetNewStatement(statement, new NodeReplacement.RemoveNodeReplacement("Count"), new NodeReplacement.RenameNodeReplacement("Be", "HaveCount"));
+            return GetNewStatement(statement, NodeReplacement.Remove("Count"), NodeReplacement.Rename("Be", "HaveCount"));
         }
     }
 }
diff --git a/...entAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountGreaterOrEqualTo.cs b/...entAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountGreaterOrEqualTo.cs
@@ -41,7 +41,7 @@ public class CollectionShouldHaveCountGreaterOrEqualToCodeFix : FluentAssertions
 
         protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties)
         {
-            return GetNewStatement(statement, new NodeReplacement.RemoveNodeReplacement("Count"), new NodeReplacement.RenameNodeReplacement("BeGreaterOrEqualTo", "HaveCountGreaterOrEqualTo"));
+            return GetNewStatement(statement, NodeReplacement.Remove("Count"), NodeReplacement.Rename("BeGreaterOrEqualTo", "HaveCountGreaterOrEqualTo"));
         }
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountGreaterThan.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountGreaterThan.cs
@@ -42,7 +42,7 @@ public class CollectionShouldHaveCountGreaterThanCodeFix : FluentAssertionsCodeF
 
         protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties)
         {
-            return GetNewStatement(statement, new NodeReplacement.RemoveNodeReplacement("Count"), new NodeReplacement.RenameNodeReplacement("BeGreaterThan", "HaveCountGreaterThan"));
+            return GetNewStatement(statement, NodeReplacement.Remove("Count"), NodeReplacement.Rename("BeGreaterThan", "HaveCountGreaterThan"));
         }
     }
 }
diff --git a/...FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountLessOrEqualTo.cs b/...FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountLessOrEqualTo.cs
@@ -41,7 +41,7 @@ public class CollectionShouldHaveCountLessOrEqualToCodeFix : FluentAssertionsCod
 
         protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties)
         {
-            return GetNewStatement(statement, new NodeReplacement.RemoveNodeReplacement("Count"), new NodeReplacement.RenameNodeReplacement("BeLessOrEqualTo", "HaveCountLessOrEqualTo"));
+            return GetNewStatement(statement, NodeReplacement.Remove("Count"), NodeReplacement.Rename("BeLessOrEqualTo", "HaveCountLessOrEqualTo"));
         }
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountLessThan.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldHaveCountLessThan.cs
@@ -41,7 +41,7 @@ public class CollectionShouldHaveCountLessThanCodeFix : FluentAssertionsCodeFixP
 
         protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties)
         {
-            return GetNewStatement(statement, new NodeReplacement.RemoveNodeReplacement("Count"), new NodeReplacement.RenameNodeReplacement("BeLessThan", "HaveCountLessThan"));
+            return GetNewStatement(statement, NodeReplacement.Remove("Count"), NodeReplacement.Rename("BeLessThan", "HaveCountLessThan"));
         }
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotBeEmpty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotBeEmpty.cs
@@ -46,8 +46,8 @@ protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax sta
         {
             NodeReplacement[] replacements =
             {
-                new NodeReplacement.RemoveNodeReplacement("Any"),
-                new NodeReplacement.RenameNodeReplacement("BeTrue", "NotBeEmpty")
+                NodeReplacement.Remove("Any"),
+                NodeReplacement.Rename("BeTrue", "NotBeEmpty")
             };
 
             return GetNewStatement(statement, replacements);

diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainProperty.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotContainProperty.cs
@@ -77,18 +77,18 @@ protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax sta
                 var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Any");
                 var newStatement = GetNewStatement(statement, remove);
 
-                return GetNewStatement(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeFalse", "NotContain", remove.Arguments));
+                return GetNewStatement(newStatement, NodeReplacement.RenameAndPrependArguments("BeFalse", "NotContain", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.WhereShouldBeEmptySyntaxVisitor))
             {
                 var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Where");
                 var newStatement = GetNewStatement(statement, remove);
 
-                return GetNewStatement(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeEmpty", "NotContain", remove.Arguments));
+                return GetNewStatement(newStatement, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotContain", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.ShouldOnlyContainNotSyntaxVisitor))
             {
-                return GetNewStatement(statement, new NodeReplacement.RenameAndNegateLambdaNodeReplacement("OnlyContain", "NotContain"));
+                return GetNewStatement(statement, NodeReplacement.RenameAndNegateLambda("OnlyContain", "NotContain"));
             }
             throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");
         }

diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotHaveCount.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotHaveCount.cs
@@ -48,7 +48,7 @@ public class CollectionShouldNotHaveCountCodeFix : FluentAssertionsCodeFixProvid
 
         protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties)
         {
-            return GetNewStatement(statement, new NodeReplacement.RemoveNodeReplacement("Count"), new NodeReplacement.RenameNodeReplacement("NotBe", "NotHaveCount"));
+            return GetNewStatement(statement, NodeReplacement.Remove("Count"), NodeReplacement.Rename("NotBe", "NotHaveCount"));
         }
     }
 }
diff --git a/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotHaveSameCount.cs b/src/FluentAssertions.BestPractices/Tips/Collections/CollectionShouldNotHaveSameCount.cs
@@ -49,7 +49,7 @@ public class CollectionShouldNotHaveSameCountCodeFix : FluentAssertionsCodeFixPr
 
         protected override StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties)
         {
-            return GetNewStatement(statement, new NodeReplacement.RemoveNodeReplacement("Count"), new NodeReplacement.RenameAndRemoveInvocationOfMethodOnFirstArgumentNodeReplacement("NotBe", "NotHaveSameCount"));
+            return GetNewStatement(statement, NodeReplacement.Remove("Count"), new NodeReplacement.RenameAndRemoveInvocationOfMethodOnFirstArgumentNodeReplacement("NotBe", "NotHaveSameCount"));
         }
     }
 }