✅ refactor test data sources to use strongly-typed TheoryData and EndToEndTestCase

Author: techouse

QsNet.Tests/DecodeTests.cs

@@ -8,6 +8,7 @@
 using QsNet.Enums;
 using QsNet.Internal;
 using QsNet.Models;
+using QsNet.Tests.Fixtures.Data;
 using Xunit;
 
 namespace QsNet.Tests;
@@ -2210,26 +2211,17 @@ public void Decode_DoesNotInterpretUXXXXSyntaxInIso88591Mode()
     }
 
     [Theory]
-    [MemberData(nameof(EmptyTestCases))]
-    public void Decode_ParsesEmptyKeys_SkipsEmptyStringKey(
-        string input,
-        Dictionary<string, object?> noEmptyKeys
-    )
+    [MemberData(nameof(GetEmptyTestCases))]
+    public void Decode_ParsesEmptyKeys_SkipsEmptyStringKey(Dictionary<string, object?> testCase)
     {
-        Qs.Decode(input).Should().BeEquivalentTo(noEmptyKeys);
+        Qs.Decode(testCase["input"]).Should().BeEquivalentTo(testCase["noEmptyKeys"]);
     }
 
-    public static IEnumerable<object[]> EmptyTestCases()
+    public static TheoryData<Dictionary<string, object?>> GetEmptyTestCases()
     {
-        // You'll need to define the actual test cases here based on your EmptyTestCases data
-        // This is just an example structure
-        yield return new object[] { "=value", new Dictionary<string, object?>() };
-        yield return new object[]
-        {
-            "key=",
-            new Dictionary<string, object?> { ["key"] = "" }
-        };
-        // Add more test cases as needed
+        var data = new TheoryData<Dictionary<string, object?>>();
+        foreach (var testCase in EmptyTestCases.Cases) data.Add(testCase);
+        return data;
     }
 
     [Fact]

QsNet.Tests/EncodeTests.cs

@@ -3004,9 +3004,11 @@ public void Encode_MapWithEmptyStringKey(Dictionary<string, object?> testCase)
             .Be((string)stringifyOutput["repeat"]!);
     }
 
-    public static IEnumerable<object[]> GetEmptyTestCases()
+    public static TheoryData<Dictionary<string, object?>> GetEmptyTestCases()
     {
-        return EmptyTestCases.Cases.Select(testCase => new object[] { testCase });
+        var data = new TheoryData<Dictionary<string, object?>>();
+        foreach (var testCase in EmptyTestCases.Cases) data.Add(testCase);
+        return data;
     }
 
     [Fact]

QsNet.Tests/EndToEndTests.cs

@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-using System.Linq;
 using FluentAssertions;
 using JetBrains.Annotations;
 using QsNet.Models;
@@ -13,19 +11,19 @@ public class EndToEndTests
 {
     [Theory]
     [MemberData(nameof(GetEndToEndTestCases))]
-    public void EndToEndTest_EncodeDecodeRoundTrip(object data, string encoded)
+    public void EndToEndTest_EncodeDecodeRoundTrip(EndToEndTestCase testCase)
     {
         // Encode the data and verify it matches the expected encoded string
-        Qs.Encode(data, new EncodeOptions { Encode = false }).Should().Be(encoded);
+        Qs.Encode(testCase.Data, new EncodeOptions { Encode = false }).Should().Be(testCase.Encoded);
 
         // Decode the encoded string and verify it matches the original data
-        Qs.Decode(encoded).Should().BeEquivalentTo(data);
+        Qs.Decode(testCase.Encoded).Should().BeEquivalentTo(testCase.Data);
     }
 
-    public static IEnumerable<object[]> GetEndToEndTestCases()
+    public static TheoryData<EndToEndTestCase> GetEndToEndTestCases()
     {
-        return EndToEndTestCases.Cases.Select(testCase =>
-            new object[] { testCase.Data, testCase.Encoded }
-        );
+        var data = new TheoryData<EndToEndTestCase>();
+        foreach (var testCase in EndToEndTestCases.Cases) data.Add(testCase);
+        return data;
     }
 }

QsNet.Tests/ExtensionTests.cs

@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-using System.Linq;
 using FluentAssertions;
 using JetBrains.Annotations;
 using QsNet.Models;
@@ -13,33 +11,27 @@ public class ExtensionTests
 {
     [Theory]
     [MemberData(nameof(GetEndToEndTestCases))]
-    public void ToQueryString_ShouldEncodeEndToEndTestCases(
-        Dictionary<string, object?> data,
-        string expectedEncoded
-    )
+    public void ToQueryString_ShouldEncodeEndToEndTestCases(EndToEndTestCase testCase)
     {
-        data.ToQueryString(new EncodeOptions { Encode = false })
+        testCase.Data.ToQueryString(new EncodeOptions { Encode = false })
             .Should()
-            .Be(expectedEncoded, $"Failed for test case: {data}");
+            .Be(testCase.Encoded, $"Failed for test case: {testCase.Data}");
     }
 
     [Theory]
     [MemberData(nameof(GetEndToEndTestCases))]
-    public void ToQueryMap_ShouldDecodeEndToEndTestCases(
-        Dictionary<string, object?> expectedData,
-        string encoded
-    )
+    public void ToQueryMap_ShouldDecodeEndToEndTestCases(EndToEndTestCase testCase)
     {
-        encoded
+        testCase.Encoded
             .ToQueryMap()
             .Should()
-            .BeEquivalentTo(expectedData, $"Failed for test case: {encoded}");
+            .BeEquivalentTo(testCase.Data, $"Failed for test case: {testCase.Encoded}");
     }
 
-    public static IEnumerable<object[]> GetEndToEndTestCases()
+    public static TheoryData<EndToEndTestCase> GetEndToEndTestCases()
     {
-        return EndToEndTestCases.Cases.Select(testCase =>
-            (object[])[testCase.Data, testCase.Encoded]
-        );
+        var data = new TheoryData<EndToEndTestCase>();
+        foreach (var testCase in EndToEndTestCases.Cases) data.Add(testCase);
+        return data;
     }
 }

QsNet.Tests/Fixtures/Data/EndToEndTestCases.cs

@@ -2,7 +2,7 @@
 
 namespace QsNet.Tests.Fixtures.Data;
 
-internal record EndToEndTestCase(Dictionary<string, object?> Data, string Encoded);
+public record EndToEndTestCase(Dictionary<string, object?> Data, string Encoded);
 
 internal static class EndToEndTestCases
 {