Improve NUnit tests (#603)

* Improve NUnit tests

- Add package reference to `NUnit.Analyzers`
- Use analyzer fixers to convert asserts to constraint models
- Remove the no longer necessary `GlobalUsings.cs`

* tweaks

.editorconfig

@@ -260,6 +260,9 @@ dotnet_diagnostic.SA1101.severity = none
 # SA1116: Split parameters should start on line after declaration
 dotnet_diagnostic.SA1116.severity = silent
 
+# SA1118: Parameter should not span multiple lines
+dotnet_diagnostic.SA1118.severity = suggestion
+
 # SA1122: Use string.Empty for empty strings
 dotnet_diagnostic.SA1122.severity = none
 

NGitLab.Mock.Tests/BranchesMockTests.cs

@@ -21,22 +21,22 @@ public void Test_search_branches()
 
             var branches = branchClient.Search("main").ToList();
             var expectedBranch = branches.Single();
-            Assert.AreEqual("main", expectedBranch.Name);
+            Assert.That(expectedBranch.Name, Is.EqualTo("main"));
 
             branches = branchClient.Search("^main$").ToList();
             expectedBranch = branches.Single();
-            Assert.AreEqual("main", expectedBranch.Name);
+            Assert.That(expectedBranch.Name, Is.EqualTo("main"));
 
             branches = branchClient.Search("^branch").ToList();
             expectedBranch = branches.Single();
-            Assert.AreEqual("branch_1", expectedBranch.Name);
+            Assert.That(expectedBranch.Name, Is.EqualTo("branch_1"));
 
             branches = branchClient.Search("1$").ToList();
             expectedBranch = branches.Single();
-            Assert.AreEqual("branch_1", expectedBranch.Name);
+            Assert.That(expectedBranch.Name, Is.EqualTo("branch_1"));
 
             branches = branchClient.Search("foobar").ToList();
-            Assert.IsEmpty(branches);
+            Assert.That(branches, Is.Empty);
         }
     }
 }

NGitLab.Mock.Tests/CommitsMockTests.cs

@@ -20,7 +20,7 @@ public void Test_commits_added_can_be_found()
             var client = server.CreateClient();
             var commit = client.GetCommits(1).GetCommit("branch-01");
 
-            Assert.AreEqual("Create branch", commit.Message.TrimEnd('\r', '\n'));
+            Assert.That(commit.Message.TrimEnd('\r', '\n'), Is.EqualTo("Create branch"));
         }
 
         [Test]
@@ -36,7 +36,7 @@ public void Test_commits_with_tags_can_be_found()
             var client = server.CreateClient();
             var commit = client.GetCommits(1).GetCommit("1.0.0");
 
-            Assert.AreEqual("Changes with tag", commit.Message.TrimEnd('\r', '\n'));
+            Assert.That(commit.Message.TrimEnd('\r', '\n'), Is.EqualTo("Changes with tag"));
         }
 
         [Test]
@@ -53,7 +53,7 @@ public void Test_tags_from_commit_can_be_found()
             var tags = client.GetRepository(1).Tags.All.ToArray();
 
             Assert.That(tags, Has.One.Items);
-            Assert.AreEqual("1.0.0", tags[0].Name);
+            Assert.That(tags[0].Name, Is.EqualTo("1.0.0"));
         }
 
         [Test]
@@ -72,11 +72,11 @@ public void Test_two_branches_can_be_created_from_same_commit()
             var commitFromBranch1 = repository.GetCommits("branch_1").FirstOrDefault();
             var commitFromBranch2 = repository.GetCommits("branch_2").FirstOrDefault();
 
-            Assert.NotNull(commitFromBranch1);
-            Assert.NotNull(commitFromBranch2);
-            Assert.IsNotEmpty(commitFromBranch1.Parents);
-            Assert.IsNotEmpty(commitFromBranch2.Parents);
-            Assert.AreEqual(commitFromBranch1.Parents[0], commitFromBranch2.Parents[0]);
+            Assert.That(commitFromBranch1, Is.Not.Null);
+            Assert.That(commitFromBranch2, Is.Not.Null);
+            Assert.That(commitFromBranch1.Parents, Is.Not.Empty);
+            Assert.That(commitFromBranch2.Parents, Is.Not.Empty);
+            Assert.That(commitFromBranch2.Parents[0], Is.EqualTo(commitFromBranch1.Parents[0]));
         }
 
         [Test]
@@ -98,11 +98,11 @@ public void Test_GetCommitsBetweenTwoRefs()
             var intermediateCommits = repository.GetCommits("main..branch_1");
 
             // Assert
-            CollectionAssert.AreEqual(new[]
+            Assert.That(intermediateCommits.Select(c => c.Title), Is.EqualTo(new[]
             {
                 "Yet another commit for branch_1",
                 "Commit for branch_1",
-            }, intermediateCommits.Select(c => c.Title));
+            }).AsCollection);
         }
 
         [Test]
@@ -118,14 +118,14 @@ public void Test_commits_can_be_cherry_pick()
             var client = server.CreateClient();
             var repository = client.GetRepository(1);
             var commitFromBranch1 = repository.GetCommits("branch_1").FirstOrDefault();
-            Assert.NotNull(commitFromBranch1);
+            Assert.That(commitFromBranch1, Is.Not.Null);
 
             var cherryPicked = client.GetCommits(1).CherryPick(new CommitCherryPick
             {
                 Sha = commitFromBranch1.Id,
                 Branch = "main",
             });
-            Assert.NotNull(cherryPicked);
+            Assert.That(cherryPicked, Is.Not.Null);
         }
     }
 }

NGitLab.Mock.Tests/ConfigTests.cs

@@ -40,33 +40,33 @@ public void Test_server_can_be_saved_in_config()
             project.Permissions.Add(new Permission(user, AccessLevel.Owner));
 
             var config = server.ToConfig();
-            Assert.IsNotNull(config);
+            Assert.That(config, Is.Not.Null);
 
             Assert.That(config.Users, Has.One.Items);
-            Assert.AreEqual("user1", config.Users[0].Username);
+            Assert.That(config.Users[0].Username, Is.EqualTo("user1"));
             Assert.That(config.Groups, Has.One.Items);
-            Assert.AreEqual("unit-tests", config.Groups[0].Name);
+            Assert.That(config.Groups[0].Name, Is.EqualTo("unit-tests"));
             Assert.That(config.Projects, Has.One.Items);
-            Assert.AreEqual("test-project", config.Projects[0].Name);
-            Assert.AreEqual("unit-tests", config.Projects[0].Namespace);
-            Assert.AreEqual("Test project", config.Projects[0].Description);
-            Assert.AreEqual("default", config.Projects[0].DefaultBranch);
-            Assert.AreEqual(VisibilityLevel.Public, config.Projects[0].Visibility);
+            Assert.That(config.Projects[0].Name, Is.EqualTo("test-project"));
+            Assert.That(config.Projects[0].Namespace, Is.EqualTo("unit-tests"));
+            Assert.That(config.Projects[0].Description, Is.EqualTo("Test project"));
+            Assert.That(config.Projects[0].DefaultBranch, Is.EqualTo("default"));
+            Assert.That(config.Projects[0].Visibility, Is.EqualTo(VisibilityLevel.Public));
             Assert.That(config.Projects[0].Labels, Has.One.Items);
-            Assert.AreEqual("label1", config.Projects[0].Labels[0].Name);
+            Assert.That(config.Projects[0].Labels[0].Name, Is.EqualTo("label1"));
             Assert.That(config.Projects[0].Issues, Has.One.Items);
-            Assert.AreEqual("Issue #1", config.Projects[0].Issues[0].Title);
-            Assert.AreEqual("My issue", config.Projects[0].Issues[0].Description);
-            Assert.AreEqual("user1", config.Projects[0].Issues[0].Author);
+            Assert.That(config.Projects[0].Issues[0].Title, Is.EqualTo("Issue #1"));
+            Assert.That(config.Projects[0].Issues[0].Description, Is.EqualTo("My issue"));
+            Assert.That(config.Projects[0].Issues[0].Author, Is.EqualTo("user1"));
             Assert.That(config.Projects[0].Issues[0].Labels, Has.One.Items);
-            Assert.AreEqual("label1", config.Projects[0].Issues[0].Labels[0]);
+            Assert.That(config.Projects[0].Issues[0].Labels[0], Is.EqualTo("label1"));
             Assert.That(config.Projects[0].MergeRequests, Has.One.Items);
-            Assert.AreEqual("Merge request #1", config.Projects[0].MergeRequests[0].Title);
-            Assert.AreEqual("My merge request", config.Projects[0].MergeRequests[0].Description);
-            Assert.AreEqual("user1", config.Projects[0].MergeRequests[0].Author);
+            Assert.That(config.Projects[0].MergeRequests[0].Title, Is.EqualTo("Merge request #1"));
+            Assert.That(config.Projects[0].MergeRequests[0].Description, Is.EqualTo("My merge request"));
+            Assert.That(config.Projects[0].MergeRequests[0].Author, Is.EqualTo("user1"));
             Assert.That(config.Projects[0].Permissions, Has.One.Items);
-            Assert.AreEqual("user1", config.Projects[0].Permissions[0].User);
-            Assert.AreEqual(AccessLevel.Owner, config.Projects[0].Permissions[0].Level);
+            Assert.That(config.Projects[0].Permissions[0].User, Is.EqualTo("user1"));
+            Assert.That(config.Projects[0].Permissions[0].Level, Is.EqualTo(AccessLevel.Owner));
         }
 
         [Test]
@@ -84,30 +84,30 @@ public void Test_config_can_be_serialized()
                 .WithProject("project-2");
 
             var content = config.Serialize();
-            Assert.IsNotEmpty(content);
+            Assert.That(content, Is.Not.Empty);
 
             var config2 = GitLabConfig.Deserialize(content);
-            Assert.IsNotNull(config2);
+            Assert.That(config2, Is.Not.Null);
 
             Assert.That(config2.Users, Has.One.Items);
-            Assert.AreEqual("user1", config2.Users[0].Username);
+            Assert.That(config2.Users[0].Username, Is.EqualTo("user1"));
             Assert.That(config2.Projects, Has.Exactly(2).Items);
-            Assert.AreEqual("project-1", config2.Projects[0].Name);
-            Assert.AreEqual("Project #1", config2.Projects[0].Description);
-            Assert.AreEqual(VisibilityLevel.Public, config2.Projects[0].Visibility);
+            Assert.That(config2.Projects[0].Name, Is.EqualTo("project-1"));
+            Assert.That(config2.Projects[0].Description, Is.EqualTo("Project #1"));
+            Assert.That(config2.Projects[0].Visibility, Is.EqualTo(VisibilityLevel.Public));
             Assert.That(config2.Projects[0].Commits, Has.Exactly(2).Items);
-            Assert.AreEqual("Initial commit", config2.Projects[0].Commits[0].Message);
-            Assert.AreEqual("Create branch", config2.Projects[0].Commits[1].Message);
+            Assert.That(config2.Projects[0].Commits[0].Message, Is.EqualTo("Initial commit"));
+            Assert.That(config2.Projects[0].Commits[1].Message, Is.EqualTo("Create branch"));
             Assert.That(config2.Projects[0].Issues, Has.One.Items);
-            Assert.AreEqual("Issue #1", config2.Projects[0].Issues[0].Title);
+            Assert.That(config2.Projects[0].Issues[0].Title, Is.EqualTo("Issue #1"));
             Assert.That(config2.Projects[0].MergeRequests, Has.One.Items);
-            Assert.AreEqual("Merge request #1", config2.Projects[0].MergeRequests[0].Title);
+            Assert.That(config2.Projects[0].MergeRequests[0].Title, Is.EqualTo("Merge request #1"));
             Assert.That(config2.Projects[0].Permissions, Has.One.Items);
-            Assert.AreEqual("user1", config2.Projects[0].Permissions[0].User);
-            Assert.AreEqual("project-2", config2.Projects[1].Name);
+            Assert.That(config2.Projects[0].Permissions[0].User, Is.EqualTo("user1"));
+            Assert.That(config2.Projects[1].Name, Is.EqualTo("project-2"));
 
             using var server = config2.BuildServer();
-            Assert.IsNotNull(server);
+            Assert.That(server, Is.Not.Null);
         }
 
         [Test]
@@ -125,15 +125,15 @@ public void Test_job_ids_are_unique()
                         .WithPipeline("C1", p => p.WithJob().WithJob()));
 
             using var server = config.BuildServer();
-            Assert.IsNotNull(server);
+            Assert.That(server, Is.Not.Null);
 
             var project1 = server.AllProjects.FirstOrDefault();
-            Assert.IsNotNull(project1);
+            Assert.That(project1, Is.Not.Null);
 
             project1.Jobs.Should().BeEquivalentTo(new[] { new { Id = 1 }, new { Id = 2 }, new { Id = 3 } });
 
             var project2 = server.AllProjects.LastOrDefault();
-            Assert.IsNotNull(project2);
+            Assert.That(project2, Is.Not.Null);
 
             project2.Jobs.Should().BeEquivalentTo(new[] { new { Id = 4 }, new { Id = 5 } });
         }

NGitLab.Mock.Tests/GroupsMockTests.cs

@@ -21,7 +21,7 @@ public async Task Test_group_get_by_id()
             var client = server.CreateClient("user1");
             var group = await client.Groups.GetByIdAsync(1);
 
-            Assert.AreEqual("G1", group.Name, "Subgroups found are invalid");
+            Assert.That(group.Name, Is.EqualTo("G1"), "Subgroups found are invalid");
         }
 
         [Test]
@@ -38,7 +38,7 @@ public async Task Test_group_get_by_fullpath()
             var client = server.CreateClient("user1");
             var group = await client.Groups.GetByFullPathAsync("name3");
 
-            Assert.AreEqual("name3", group.FullPath, "Subgroups found are invalid");
+            Assert.That(group.FullPath, Is.EqualTo("name3"), "Subgroups found are invalid");
         }
 
         [Test]
@@ -57,7 +57,7 @@ public void Test_get_subgroups_by_id()
             var client = server.CreateClient("user1");
             var group = client.Groups.GetSubgroupsByIdAsync(12, new Models.SubgroupQuery { });
 
-            Assert.AreEqual(2, group.Count(), "Subgroups found are invalid");
+            Assert.That(group.Count(), Is.EqualTo(2), "Subgroups found are invalid");
         }
 
         [Test]
@@ -76,7 +76,7 @@ public void Test_get_subgroups_by_fullpath()
             var client = server.CreateClient("user1");
             var group = client.Groups.GetSubgroupsByFullPathAsync("parentgroup1", new Models.SubgroupQuery { });
 
-            Assert.AreEqual(2, group.Count(), "Subgroups found are invalid");
+            Assert.That(group.Count(), Is.EqualTo(2), "Subgroups found are invalid");
         }
     }
 }

NGitLab.Mock.Tests/IssuesMockTests.cs

@@ -21,8 +21,8 @@ public void Test_issues_created_by_me_can_be_listed()
             var client = server.CreateClient("user1");
             var issues = client.Issues.Get(new IssueQuery { Scope = "created_by_me" }).ToArray();
 
-            Assert.AreEqual(1, issues.Length, "Issues count is invalid");
-            Assert.AreEqual("Issue 1", issues[0].Title, "Issue found is invalid");
+            Assert.That(issues, Has.Length.EqualTo(1), "Issues count is invalid");
+            Assert.That(issues[0].Title, Is.EqualTo("Issue 1"), "Issue found is invalid");
         }
 
         [Test]
@@ -39,8 +39,8 @@ public void Test_issues_assigned_to_me_can_be_listed()
             var client = server.CreateClient("user1");
             var issues = client.Issues.Get(new IssueQuery { Scope = "assigned_to_me" }).ToArray();
 
-            Assert.AreEqual(1, issues.Length, "Issues count is invalid");
-            Assert.AreEqual("Issue 2", issues[0].Title, "Issue found is invalid");
+            Assert.That(issues, Has.Length.EqualTo(1), "Issues count is invalid");
+            Assert.That(issues[0].Title, Is.EqualTo("Issue 2"), "Issue found is invalid");
         }
 
         [Test]
@@ -68,8 +68,8 @@ public void Test_issue_by_id_can_be_found()
             var client = server.CreateClient();
 
             var issue = client.Issues.GetById(10001);
-            Assert.AreEqual(5, issue.IssueId);
-            Assert.AreEqual("Issue title", issue.Title);
+            Assert.That(issue.IssueId, Is.EqualTo(5));
+            Assert.That(issue.Title, Is.EqualTo("Issue title"));
         }
 
         [Test]
@@ -102,16 +102,16 @@ public void Test_issue_resource_milestone_events_can_be_found()
             });
 
             var resourceMilestoneEvents = issuesClient.ResourceMilestoneEvents(projectId: 1, issueIid: 5).ToList();
-            Assert.AreEqual(3, resourceMilestoneEvents.Count);
+            Assert.That(resourceMilestoneEvents, Has.Count.EqualTo(3));
 
             var removeMilestoneEvents = resourceMilestoneEvents.Where(e => e.Action == ResourceMilestoneEventAction.Remove).ToArray();
-            Assert.AreEqual(1, removeMilestoneEvents.Length);
-            Assert.AreEqual(1, removeMilestoneEvents[0].Milestone.Id);
+            Assert.That(removeMilestoneEvents, Has.Length.EqualTo(1));
+            Assert.That(removeMilestoneEvents[0].Milestone.Id, Is.EqualTo(1));
 
             var addMilestoneEvents = resourceMilestoneEvents.Where(e => e.Action == ResourceMilestoneEventAction.Add).ToArray();
-            Assert.AreEqual(2, addMilestoneEvents.Length);
-            Assert.AreEqual(1, addMilestoneEvents[0].Milestone.Id);
-            Assert.AreEqual(2, addMilestoneEvents[1].Milestone.Id);
+            Assert.That(addMilestoneEvents, Has.Length.EqualTo(2));
+            Assert.That(addMilestoneEvents[0].Milestone.Id, Is.EqualTo(1));
+            Assert.That(addMilestoneEvents[1].Milestone.Id, Is.EqualTo(2));
         }
     }
 }