Skip to content

Commit d2f9954

Browse files
Meir017Meir017
authored
feat: add nunit collection Assert.That OnlyHaveUniqueItems & NotContainNulls (#364)
1 parent 4781fd6 commit d2f9954

File tree

6 files changed

+132
-4
lines changed

6 files changed

+132
-4
lines changed

‎docs/Nunit3Analyzer.md‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -807,6 +807,8 @@ var collection = new object[] { 1, "test", true };
807807

808808
// old assertion:
809809
CollectionAssert.AllItemsAreNotNull(collection);
810+
Assert.That(collection, Has.None.Null);
811+
Assert.That(collection, Is.All.Not.Null);
810812

811813
// new assertion:
812814
collection.Should().NotContainNulls();
@@ -822,6 +824,14 @@ CollectionAssert.AllItemsAreNotNull(collection); /* fail message: Expected: al
822824
But was: < 1, null, True >
823825
First non-matching item at index [1]: null
824826
*/
827+
Assert.That(collection, Has.None.Null); /* fail message: Expected: no item null
828+
But was: < 1, null, True >
829+
First non-matching item at index [1]: null
830+
*/
831+
Assert.That(collection, Is.All.Not.Null); /* fail message: Expected: all items not null
832+
But was: < 1, null, True >
833+
First non-matching item at index [1]: null
834+
*/
825835

826836
// new assertion:
827837
collection.Should().NotContainNulls(); /* fail message: Expected collection not to contain <null>s, but found one at index 1. */
@@ -835,6 +845,7 @@ var collection = new[] { 1, 2, 3 };
835845

836846
// old assertion:
837847
CollectionAssert.AllItemsAreUnique(collection);
848+
Assert.That(collection, Is.Unique);
838849

839850
// new assertion:
840851
collection.Should().OnlyHaveUniqueItems();
@@ -850,6 +861,10 @@ CollectionAssert.AllItemsAreUnique(collection); /* fail message: Expected: all
850861
But was: < 1, 2, 1 >
851862
Not unique items: < 1 >
852863
*/
864+
Assert.That(collection, Is.Unique); /* fail message: Expected: all items unique
865+
But was: < 1, 2, 1 >
866+
Not unique items: < 1 >
867+
*/
853868

854869
// new assertion:
855870
collection.Should().OnlyHaveUniqueItems(); /* fail message: Expected collection to only have unique items, but item 1 is not unique. */

‎docs/Nunit4Analyzer.md‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -892,6 +892,8 @@ var collection = new object[] { 1, "test", true };
892892

893893
// old assertion:
894894
CollectionAssert.AllItemsAreNotNull(collection);
895+
Assert.That(collection, Has.None.Null);
896+
Assert.That(collection, Is.All.Not.Null);
895897

896898
// new assertion:
897899
collection.Should().NotContainNulls();
@@ -908,6 +910,16 @@ CollectionAssert.AllItemsAreNotNull(collection); /* fail message: Assert.That(
908910
But was: < 1, null, True >
909911
First non-matching item at index [1]: null
910912
*/
913+
Assert.That(collection, Has.None.Null); /* fail message: Assert.That(collection, Has.None.Null)
914+
Expected: no item null
915+
But was: < 1, null, True >
916+
First non-matching item at index [1]: null
917+
*/
918+
Assert.That(collection, Is.All.Not.Null); /* fail message: Assert.That(collection, Is.All.Not.Null)
919+
Expected: all items not null
920+
But was: < 1, null, True >
921+
First non-matching item at index [1]: null
922+
*/
911923

912924
// new assertion:
913925
collection.Should().NotContainNulls(); /* fail message: Expected collection not to contain <null>s, but found one at index 1. */
@@ -921,6 +933,7 @@ var collection = new[] { 1, 2, 3 };
921933

922934
// old assertion:
923935
CollectionAssert.AllItemsAreUnique(collection);
936+
Assert.That(collection, Is.Unique);
924937

925938
// new assertion:
926939
collection.Should().OnlyHaveUniqueItems();
@@ -937,6 +950,11 @@ CollectionAssert.AllItemsAreUnique(collection); /* fail message: Assert.That(c
937950
But was: < 1, 2, 1 >
938951
Not unique items: < 1 >
939952
*/
953+
Assert.That(collection, Is.Unique); /* fail message: Assert.That(collection, Is.Unique)
954+
Expected: all items unique
955+
But was: < 1, 2, 1 >
956+
Not unique items: < 1 >
957+
*/
940958

941959
// new assertion:
942960
collection.Should().OnlyHaveUniqueItems(); /* fail message: Expected collection to only have unique items, but item 1 is not unique. */

‎src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs.Nunit3/Nunit3AnalyzerTests.cs‎

Lines changed: 35 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1224,20 +1224,42 @@ public void CollectionAssertAllItemsAreNotNull()
12241224

12251225
// old assertion:
12261226
CollectionAssert.AllItemsAreNotNull(collection);
1227+
Assert.That(collection, Has.None.Null);
1228+
Assert.That(collection, Is.All.Not.Null);
12271229

12281230
// new assertion:
12291231
collection.Should().NotContainNulls();
12301232
}
12311233

12321234
[Test, ExpectedAssertionException]
1233-
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion()
1235+
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion_0()
12341236
{
12351237
// arrange
12361238
var collection = new object[] { 1, null, true };
12371239

12381240
// old assertion:
12391241
CollectionAssert.AllItemsAreNotNull(collection);
12401242
}
1243+
1244+
[Test, ExpectedAssertionException]
1245+
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion_1()
1246+
{
1247+
// arrange
1248+
var collection = new object[] { 1, null, true };
1249+
1250+
// old assertion:
1251+
Assert.That(collection, Has.None.Null);
1252+
}
1253+
1254+
[Test, ExpectedAssertionException]
1255+
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion_2()
1256+
{
1257+
// arrange
1258+
var collection = new object[] { 1, null, true };
1259+
1260+
// old assertion:
1261+
Assert.That(collection, Is.All.Not.Null);
1262+
}
12411263

12421264
[Test, ExpectedAssertionException]
12431265
public void CollectionAssertAllItemsAreNotNull_Failure_NewAssertion()
@@ -1257,13 +1279,14 @@ public void CollectionAssertAllItemsAreUnique()
12571279

12581280
// old assertion:
12591281
CollectionAssert.AllItemsAreUnique(collection);
1282+
Assert.That(collection, Is.Unique);
12601283

12611284
// new assertion:
12621285
collection.Should().OnlyHaveUniqueItems();
12631286
}
12641287

12651288
[Test, ExpectedAssertionException]
1266-
public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion()
1289+
public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion_0()
12671290
{
12681291
// arrange
12691292
var collection = new[] { 1, 2, 1 };
@@ -1272,6 +1295,16 @@ public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion()
12721295
CollectionAssert.AllItemsAreUnique(collection);
12731296
}
12741297

1298+
[Test, ExpectedAssertionException]
1299+
public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion_1()
1300+
{
1301+
// arrange
1302+
var collection = new[] { 1, 2, 1 };
1303+
1304+
// old assertion:
1305+
Assert.That(collection, Is.Unique);
1306+
}
1307+
12751308
[Test, ExpectedAssertionException]
12761309
public void CollectionAssertAllItemsAreUnique_Failure_NewAssertion()
12771310
{

‎src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs.Nunit4/Nunit4AnalyzerTests.cs‎

Lines changed: 35 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1245,20 +1245,42 @@ public void CollectionAssertAllItemsAreNotNull()
12451245

12461246
// old assertion:
12471247
CollectionAssert.AllItemsAreNotNull(collection);
1248+
Assert.That(collection, Has.None.Null);
1249+
Assert.That(collection, Is.All.Not.Null);
12481250

12491251
// new assertion:
12501252
collection.Should().NotContainNulls();
12511253
}
12521254

12531255
[Test, ExpectedAssertionException]
1254-
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion()
1256+
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion_0()
12551257
{
12561258
// arrange
12571259
var collection = new object[] { 1, null, true };
12581260

12591261
// old assertion:
12601262
CollectionAssert.AllItemsAreNotNull(collection);
12611263
}
1264+
1265+
[Test, ExpectedAssertionException]
1266+
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion_1()
1267+
{
1268+
// arrange
1269+
var collection = new object[] { 1, null, true };
1270+
1271+
// old assertion:
1272+
Assert.That(collection, Has.None.Null);
1273+
}
1274+
1275+
[Test, ExpectedAssertionException]
1276+
public void CollectionAssertAllItemsAreNotNull_Failure_OldAssertion_2()
1277+
{
1278+
// arrange
1279+
var collection = new object[] { 1, null, true };
1280+
1281+
// old assertion:
1282+
Assert.That(collection, Is.All.Not.Null);
1283+
}
12621284

12631285
[Test, ExpectedAssertionException]
12641286
public void CollectionAssertAllItemsAreNotNull_Failure_NewAssertion()
@@ -1278,13 +1300,14 @@ public void CollectionAssertAllItemsAreUnique()
12781300

12791301
// old assertion:
12801302
CollectionAssert.AllItemsAreUnique(collection);
1303+
Assert.That(collection, Is.Unique);
12811304

12821305
// new assertion:
12831306
collection.Should().OnlyHaveUniqueItems();
12841307
}
12851308

12861309
[Test, ExpectedAssertionException]
1287-
public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion()
1310+
public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion_0()
12881311
{
12891312
// arrange
12901313
var collection = new[] { 1, 2, 1 };
@@ -1293,6 +1316,16 @@ public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion()
12931316
CollectionAssert.AllItemsAreUnique(collection);
12941317
}
12951318

1319+
[Test, ExpectedAssertionException]
1320+
public void CollectionAssertAllItemsAreUnique_Failure_OldAssertion_1()
1321+
{
1322+
// arrange
1323+
var collection = new[] { 1, 2, 1 };
1324+
1325+
// old assertion:
1326+
Assert.That(collection, Is.Unique);
1327+
}
1328+
12961329
[Test, ExpectedAssertionException]
12971330
public void CollectionAssertAllItemsAreUnique_Failure_NewAssertion()
12981331
{

‎src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1807,49 +1807,73 @@ public void Nunit4_CollectionAssertDoesNotContain_WithCasting_TestCodeFix(string
18071807

18081808
[DataTestMethod]
18091809
[AssertionDiagnostic("CollectionAssert.AllItemsAreNotNull(actual{0});")]
1810+
[AssertionDiagnostic("Assert.That(actual, Is.All.Not.Null{0});")]
1811+
[AssertionDiagnostic("Assert.That(actual, Has.None.Null{0});")]
18101812
[Implemented]
18111813
public void Nunit3_CollectionAssertAllItemsAreNotNull_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("IEnumerable<string> actual", assertion);
18121814

18131815
[DataTestMethod]
18141816
[AssertionDiagnostic("CollectionAssert.AllItemsAreNotNull(actual{0});")]
1817+
[AssertionDiagnostic("Assert.That(actual, Is.All.Not.Null);")]
1818+
[AssertionDiagnostic("Assert.That(actual, Has.None.Null);")]
18151819
[Implemented]
18161820
public void Nunit4_CollectionAssertAllItemsAreNotNull_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("IEnumerable<string> actual", assertion);
18171821

18181822
[DataTestMethod]
18191823
[AssertionCodeFix(
18201824
oldAssertion: "CollectionAssert.AllItemsAreNotNull(actual{0});",
18211825
newAssertion: "actual.Should().NotContainNulls({0});")]
1826+
[AssertionCodeFix(
1827+
oldAssertion: "Assert.That(actual, Is.All.Not.Null{0});",
1828+
newAssertion: "actual.Should().NotContainNulls({0});")]
1829+
[AssertionCodeFix(
1830+
oldAssertion: "Assert.That(actual, Has.None.Null{0});",
1831+
newAssertion: "actual.Should().NotContainNulls({0});")]
18221832
[Implemented]
18231833
public void Nunit3_CollectionAssertAllItemsAreNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("IEnumerable<string> actual", oldAssertion, newAssertion);
18241834

18251835
[DataTestMethod]
18261836
[AssertionCodeFix(
18271837
oldAssertion: "CollectionAssert.AllItemsAreNotNull(actual{0});",
18281838
newAssertion: "actual.Should().NotContainNulls({0});")]
1839+
[AssertionCodeFix(
1840+
oldAssertion: "Assert.That(actual, Is.All.Not.Null);",
1841+
newAssertion: "actual.Should().NotContainNulls();")]
1842+
[AssertionCodeFix(
1843+
oldAssertion: "Assert.That(actual, Has.None.Null);",
1844+
newAssertion: "actual.Should().NotContainNulls();")]
18291845
[Implemented]
18301846
public void Nunit4_CollectionAssertAllItemsAreNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("IEnumerable<string> actual", oldAssertion, newAssertion);
18311847

18321848
[DataTestMethod]
18331849
[AssertionDiagnostic("CollectionAssert.AllItemsAreUnique(actual{0});")]
1850+
[AssertionDiagnostic("Assert.That(actual, Is.Unique{0});")]
18341851
[Implemented]
18351852
public void Nunit3_CollectionAssertAllItemsAreUnique_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("IEnumerable<string> actual", assertion);
18361853

18371854
[DataTestMethod]
18381855
[AssertionDiagnostic("CollectionAssert.AllItemsAreUnique(actual{0});")]
1856+
[AssertionDiagnostic("Assert.That(actual, Is.Unique);")]
18391857
[Implemented]
18401858
public void Nunit4_CollectionAssertAllItemsAreUnique_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("IEnumerable<string> actual", assertion);
18411859

18421860
[DataTestMethod]
18431861
[AssertionCodeFix(
18441862
oldAssertion: "CollectionAssert.AllItemsAreUnique(actual{0});",
18451863
newAssertion: "actual.Should().OnlyHaveUniqueItems({0});")]
1864+
[AssertionCodeFix(
1865+
oldAssertion: "Assert.That(actual, Is.Unique{0});",
1866+
newAssertion: "actual.Should().OnlyHaveUniqueItems({0});")]
18461867
[Implemented]
18471868
public void Nunit3_CollectionAssertAllItemsAreUnique_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("IEnumerable<string> actual", oldAssertion, newAssertion);
18481869

18491870
[DataTestMethod]
18501871
[AssertionCodeFix(
18511872
oldAssertion: "CollectionAssert.AllItemsAreUnique(actual{0});",
18521873
newAssertion: "actual.Should().OnlyHaveUniqueItems({0});")]
1874+
[AssertionCodeFix(
1875+
oldAssertion: "Assert.That(actual, Is.Unique);",
1876+
newAssertion: "actual.Should().OnlyHaveUniqueItems();")]
18531877
[Implemented]
18541878
public void Nunit4_CollectionAssertAllItemsAreUnique_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("IEnumerable<string> actual", oldAssertion, newAssertion);
18551879

‎src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -485,6 +485,11 @@ private CreateChangedDocument TryComputeFixForNunitThat(IInvocationOperation inv
485485
}
486486
return rewriter.Should("AllBeOfType", argument);
487487
}
488+
else if (matcher.Is("Unique"))
489+
return rewriter.Should("OnlyHaveUniqueItems");
490+
else if (matcher.Has("None", "Null")
491+
|| matcher.Is("All", "Not", "Null"))
492+
return rewriter.Should("NotContainNulls");
488493
}
489494
if (matcher.Is("Zero"))
490495
return rewriter.Should("Be", g => g.LiteralExpression(0));

0 commit comments

Comments
 (0)