OSOE-838: Updating xUnit to latest and adapting to it

Lombiq.HelpfulLibraries.Tests/Lombiq.HelpfulLibraries.Tests.csproj

@@ -17,7 +17,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

Lombiq.HelpfulLibraries.Tests/UnitTests/Models/TypedRouteTests.cs

@@ -14,21 +14,23 @@ namespace Lombiq.HelpfulLibraries.Tests.UnitTests.Models;
 
 public class TypedRouteTests
 {
+    public static readonly TheoryData<TypedRouteShouldWorkCorrectlyInput> TypedRouteShouldWorkCorrectlyInputs =
+        new(GenerateTypedRouteShouldWorkCorrectlyInputs());
+
     [Theory]
-    [MemberData(nameof(TypedRouteShouldWorkCorrectlyData))]
-    public void TypedRouteShouldWorkCorrectly(
-        string expected,
-        Expression<Action<RouteTestController>> actionExpression,
-        (string Name, object Value)[] additional,
-        string tenantName)
+    // TypedRouteShouldWorkCorrectlyInput would need to implement IXunitSerializable but it works like this anyway.
+#pragma warning disable xUnit1045 // Avoid using TheoryData type arguments that might not be serializable
+    [MemberData(nameof(TypedRouteShouldWorkCorrectlyInputs))]
+#pragma warning restore xUnit1045 // Avoid using TheoryData type arguments that might not be serializable
+    public void TypedRouteShouldWorkCorrectly(TypedRouteShouldWorkCorrectlyInput input)
     {
         using var serviceProvider = CreateServiceProvider();
 
         var route = TypedRoute.CreateFromExpression(
-            actionExpression,
-            additional,
+            input.ActionExpression,
+            input.Additional,
             serviceProvider: serviceProvider);
-        route.ToString(tenantName).ShouldBe(expected);
+        route.ToString(input.TenantName).ShouldBe(input.Expected);
     }
 
     [Fact]
@@ -80,84 +82,64 @@ private static Expression<Action<RouteTestController>> AsExpression(
         Expression<Action<RouteTestController>> expression) =>
         expression;
 
-    public static IEnumerable<object[]> TypedRouteShouldWorkCorrectlyData()
+    public static IEnumerable<TypedRouteShouldWorkCorrectlyInput> GenerateTypedRouteShouldWorkCorrectlyInputs()
     {
         var noMoreArguments = Array.Empty<(string Name, object Value)>();
         var noTenant = string.Empty;
         var someTenant = "SomeTenant";
 
-        var tests = new List<object[]>
+        var tests = new List<TypedRouteShouldWorkCorrectlyInput>
         {
-            new object[]
-            {
+            new(
                 "/Lombiq.HelpfulLibraries.Tests/RouteTest/Foo",
                 AsExpression(controller => controller.Foo()),
                 noMoreArguments,
-                noTenant,
-            },
-            new object[]
-            {
+                noTenant),
+            new(
                 "/Lombiq.HelpfulLibraries.Tests/RouteTest/Bar",
                 AsExpression(controller => controller.Bar()),
                 noMoreArguments,
-                noTenant,
-            },
-            new object[]
-            {
+                noTenant),
+            new(
                 "/Admin/Lombiq.HelpfulLibraries.Tests/RouteTest/Baz",
                 AsExpression(controller => controller.Baz()),
                 noMoreArguments,
-                noTenant,
-            },
-            new object[]
-            {
+                noTenant),
+            new(
                 "/SomeTenant/Lombiq.HelpfulLibraries.Tests/RouteTest/Foo",
                 AsExpression(controller => controller.Foo()),
                 noMoreArguments,
-                someTenant,
-            },
-            new object[]
-            {
+                someTenant),
+            new(
                 "/SomeTenant/Lombiq.HelpfulLibraries.Tests/RouteTest/Bar",
                 AsExpression(controller => controller.Bar()),
                 noMoreArguments,
-                someTenant,
-            },
-            new object[]
-            {
+                someTenant),
+            new(
                 "/SomeTenant/Admin/Lombiq.HelpfulLibraries.Tests/RouteTest/Baz",
                 AsExpression(controller => controller.Baz()),
                 noMoreArguments,
-                someTenant,
-            },
-            new object[]
-            {
+                someTenant),
+            new(
                 "/I/Am/Routed",
                 AsExpression(controller => controller.Route()),
                 noMoreArguments,
-                noTenant,
-            },
-            new object[]
-            {
+                noTenant),
+            new(
                 "/I/Am/Routed/Admin",
                 AsExpression(controller => controller.AdminRoute()),
                 noMoreArguments,
-                noTenant,
-            },
-            new object[]
-            {
+                noTenant),
+            new(
                 "/I/Am/Routed?wat=is+this",
                 AsExpression(controller => controller.Route()),
-                new (string Name, object Value)[] { ("wat", "is this") },
-                noTenant,
-            },
-            new object[]
-            {
+                [("wat", "is this")],
+                noTenant),
+            new(
                 "/content/10",
                 AsExpression(controller => controller.RouteSubstitution(10)),
                 noMoreArguments,
-                noTenant,
-            },
+                noTenant),
         };
 
         // Here we test multiple arguments and also overlapping variable names to ensure it doesn't generate clashing
@@ -166,13 +148,11 @@ void AddArgumentsTest(int addDays, string expect)
         {
             var date = new DateTime(1997, 8, 29, 2, 14, 0, DateTimeKind.Utc).AddDays(addDays);
 
-            tests.Add(
-            [
+            tests.Add(new(
                 expect,
                 AsExpression(controller => controller.Arguments(9001, 2.71, date, "done")),
                 noMoreArguments,
-                noTenant,
-            ]);
+                noTenant));
         }
 
         AddArgumentsTest(
@@ -184,4 +164,16 @@ void AddArgumentsTest(int addDays, string expect)
 
         return tests;
     }
+
+    public class TypedRouteShouldWorkCorrectlyInput(
+        string expected,
+        Expression<Action<RouteTestController>> actionExpression,
+        IEnumerable<(string Key, object Value)> additional,
+        string tenantName)
+    {
+        public string Expected { get; set; } = expected;
+        public Expression<Action<RouteTestController>> ActionExpression { get; set; } = actionExpression;
+        public IEnumerable<(string Key, object Value)> Additional { get; set; } = additional;
+        public string TenantName { get; set; } = tenantName;
+    }
 }