improve test baseline (#3)

Author: pkamphuis

doc/Testing_Strategy.md

@@ -369,6 +369,33 @@ Examples:
 
 ---
 
+## Assertion Best Practices
+
+**MSTest Guidelines** (no third-party libraries):
+
+1. **Object comparison**: `Assert.AreEqual(expected, actual, message)`
+2. **JSON comparison**: Parse with `JsonDocument` for structure validation
+3. **Collection comparison**: `CollectionAssert.AreEqual(expected, actual)`
+4. **String checks** (MSTEST0037):
+   - ✅ Use `Assert.Contains(substring, actualString)` 
+   - ✅ Use `Assert.DoesNotContain(substring, actualString)`
+   - ❌ Avoid `Assert.IsTrue(str.Contains(...))` or `Assert.IsFalse(str.Contains(...))`
+5. **Null checks**: `Assert.IsNull()` / `Assert.IsNotNull()`
+6. **Boolean checks**: `Assert.IsTrue()` / `Assert.IsFalse()` (but prefer specific assertions when available)
+
+**Example**:
+```csharp
+// Good
+Assert.Contains("\"type\":\"line\"", json);
+Assert.DoesNotContain("\"series\"", json);
+
+// Avoid (triggers MSTEST0037 warning)
+Assert.IsTrue(json.Contains("\"type\":\"line\""));
+Assert.IsFalse(json.Contains("\"series\""));
+```
+
+---
+
 ## Test Data Isolation & Reusability
 
 ### Principles

src/Vizor.ECharts.Tests/.editorconfig

@@ -0,0 +1,7 @@
+[*.cs]
+
+# MSTest analyzer rules
+dotnet_diagnostic.MSTEST0037.severity = warning
+
+# Use Assert.Contains/DoesNotContain for string checks
+# instead of Assert.IsTrue/IsFalse with .Contains()

src/Vizor.ECharts.Tests/TestFixtures/ChartOptionsBuilder.cs

@@ -45,4 +45,134 @@ public static ChartOptions BarChartMultipleSeries()
             }
         };
     }
+
+    public static ChartOptions ScatterChartWithVisualMap()
+    {
+        return new ChartOptions
+        {
+            Title = new() { Text = "Scatter with Visual Map" },
+            XAxis = new() { Type = AxisType.Value },
+            YAxis = new() { Type = AxisType.Value },
+            VisualMap = new ContinuousVisualMap
+            {
+                Min = 0,
+                Max = 100,
+                Dimension = 2,
+                InRange = new()
+                {
+                    Color = new Color[] { "#50a3ba", "#eac736", "#d94e5d" }
+                }
+            },
+            Series = new List<ISeries>
+            {
+                new ScatterSeries
+                {
+                    Data = new List<SeriesData<double, double, double>>
+                    {
+                        new(10.0, 20.0, 30.0),
+                        new(15.0, 25.0, 50.0),
+                        new(20.0, 30.0, 80.0)
+                    },
+                    SymbolSize = 20
+                }
+            }
+        };
+    }
+
+    public static ChartOptions PieChartWithLabel()
+    {
+        return new ChartOptions
+        {
+            Title = new() { Text = "Pie Chart", Left = "center" },
+            Tooltip = new() { Trigger = TooltipTrigger.Item },
+            Legend = new() { Orient = Orient.Vertical, Left = "left" },
+            Series = new List<ISeries>
+            {
+                new PieSeries
+                {
+                    Radius = new CircleRadius("50%"),
+                    Data = new List<object>
+                    {
+                        new { value = 335, name = "Direct" },
+                        new { value = 234, name = "Email" },
+                        new { value = 1548, name = "Search" }
+                    },
+                    Emphasis = new()
+                    {
+                        ItemStyle = new()
+                        {
+                            ShadowBlur = 10,
+                            ShadowOffsetX = 0,
+                            ShadowColor = "rgba(0, 0, 0, 0.5)"
+                        }
+                    }
+                }
+            }
+        };
+    }
+
+    public static ChartOptions GaugeChart()
+    {
+        return new ChartOptions
+        {
+            Series = new List<ISeries>
+            {
+                new GaugeSeries
+                {
+                    Min = 0,
+                    Max = 100,
+                    Data = new List<object> { new { value = 75, name = "Score" } }
+                }
+            }
+        };
+    }
+
+    public static ChartOptions RadarChart()
+    {
+        return new ChartOptions
+        {
+            Radar = new()
+            {
+                Indicator = new List<RadarIndicator>
+                {
+                    new() { Name = "Sales", Max = 100 },
+                    new() { Name = "Quality", Max = 100 },
+                    new() { Name = "Support", Max = 100 }
+                }
+            },
+            Series = new List<ISeries>
+            {
+                new RadarSeries
+                {
+                    Data = new List<object>
+                    {
+                        new { value = new[] { 90, 80, 85 }, name = "Q1" }
+                    }
+                }
+            }
+        };
+    }
+
+    public static ChartOptions CandlestickChart()
+    {
+        return new ChartOptions
+        {
+            Title = new() { Text = "Candlestick Chart" },
+            XAxis = new() { Type = AxisType.Category, Data = new List<string> { "2024-01-01", "2024-01-02", "2024-01-03" } },
+            YAxis = new() { Type = AxisType.Value },
+            Series = new List<ISeries>
+            {
+                new CandlestickSeries
+                {
+                    Name = "Stock",
+                    Data = new List<object>
+                    {
+                        new[] { 20, 34, 10, 38 },  // [open, close, lowest, highest]
+                        new[] { 40, 35, 30, 50 },
+                        new[] { 31, 38, 33, 44 }
+                    }
+                }
+            }
+        };
+    }
 }

src/Vizor.ECharts.Tests/TestFixtures/SnapshotHelper.cs

@@ -16,10 +16,11 @@ public static void AssertJsonSnapshot(
         string testClassName,
         string testMethodName,
         JsonSerializerOptions serializerOptions,
+        bool skipNormalization = false,
         [CallerFilePath] string filePath = "")
     {
         string actualJson = JsonSerializer.Serialize(actual, serializerOptions);
-        string normalizedActual = NormalizeJson(actualJson);
+        string normalizedActual = skipNormalization ? actualJson : NormalizeJson(actualJson);
 
         string snapshotDir = Path.Combine(
             Path.GetDirectoryName(filePath)!,

src/Vizor.ECharts.Tests/Unit/Serialization/ChartTypesSnapshotTests.cs

@@ -0,0 +1,64 @@
+using Vizor.ECharts.Tests.TestFixtures;
+
+namespace Vizor.ECharts.Tests.Unit.Serialization;
+
+[TestClass]
+public class ChartTypesSnapshotTests
+{
+    private static JsonSerializerOptions CreateOptions() => new TestChart().GetSerializerOptions();
+
+    [TestMethod]
+    public void SerializesScatterChartWithVisualMap()
+    {
+        var options = ChartOptionsBuilder.ScatterChartWithVisualMap();
+        SnapshotHelper.AssertJsonSnapshot(
+            options,
+            nameof(ChartTypesSnapshotTests),
+            nameof(SerializesScatterChartWithVisualMap),
+            CreateOptions());
+    }
+
+    [TestMethod]
+    public void SerializesPieChartWithLabel()
+    {
+        var options = ChartOptionsBuilder.PieChartWithLabel();
+        SnapshotHelper.AssertJsonSnapshot(
+            options,
+            nameof(ChartTypesSnapshotTests),
+            nameof(SerializesPieChartWithLabel),
+            CreateOptions());
+    }
+
+    [TestMethod]
+    public void SerializesGaugeChart()
+    {
+        var options = ChartOptionsBuilder.GaugeChart();
+        SnapshotHelper.AssertJsonSnapshot(
+            options,
+            nameof(ChartTypesSnapshotTests),
+            nameof(SerializesGaugeChart),
+            CreateOptions());
+    }
+
+    [TestMethod]
+    public void SerializesRadarChart()
+    {
+        var options = ChartOptionsBuilder.RadarChart();
+        SnapshotHelper.AssertJsonSnapshot(
+            options,
+            nameof(ChartTypesSnapshotTests),
+            nameof(SerializesRadarChart),
+            CreateOptions());
+    }
+
+    [TestMethod]
+    public void SerializesCandlestickChart()
+    {
+        var options = ChartOptionsBuilder.CandlestickChart();
+        SnapshotHelper.AssertJsonSnapshot(
+            options,
+            nameof(ChartTypesSnapshotTests),
+            nameof(SerializesCandlestickChart),
+            CreateOptions());
+    }
+}

src/Vizor.ECharts.Tests/Unit/Serialization/ComplexFeaturesTests.cs

@@ -0,0 +1,44 @@
+using Vizor.ECharts.Tests.TestFixtures;
+
+namespace Vizor.ECharts.Tests.Unit.Serialization;
+
+[TestClass]
+public class ComplexFeaturesTests
+{
+    private static JsonSerializerOptions CreateOptions() => new TestChart().GetSerializerOptions();
+
+    [TestMethod]
+    public void SerializesChartWithDataZoomAndFormatter()
+    {
+        var options = new ChartOptions
+        {
+            Title = new() { Text = "DataZoom Example" },
+            XAxis = new() { Type = AxisType.Category, Data = new List<string> { "A", "B", "C" } },
+            YAxis = new() { Type = AxisType.Value },
+            DataZoom = new List<IDataZoom>
+            {
+                new InsideDataZoom { XAxisIndex = new NumberOrNumberArray(0) },
+                new SliderDataZoom { XAxisIndex = new NumberOrNumberArray(0), Start = 10, End = 90 }
+            },
+            Tooltip = new()
+            {
+                Trigger = TooltipTrigger.Axis,
+                Formatter = new JavascriptFunction("function(params) { return params[0].name + ': ' + params[0].value; }")
+            },
+            Series = new List<ISeries>
+            {
+                new LineSeries
+                {
+                    Data = new List<int> { 10, 20, 30 }
+                }
+            }
+        };
+
+        SnapshotHelper.AssertJsonSnapshot(
+            options,
+            nameof(ComplexFeaturesTests),
+            nameof(SerializesChartWithDataZoomAndFormatter),
+            CreateOptions(),
+            skipNormalization: true);
+    }
+}

src/Vizor.ECharts.Tests/Unit/Serialization/EdgeCasesTests.cs

@@ -0,0 +1,75 @@
+using Vizor.ECharts.Tests.TestFixtures;
+
+namespace Vizor.ECharts.Tests.Unit.Serialization;
+
+[TestClass]
+public class EdgeCasesTests
+{
+    private static JsonSerializerOptions CreateOptions() => new TestChart().GetSerializerOptions();
+
+    [TestMethod]
+    public void SerializesEmptyChartOptions()
+    {
+        var options = new ChartOptions();
+        string json = JsonSerializer.Serialize(options, CreateOptions());
+
+        using var doc = JsonDocument.Parse(json);
+        Assert.AreEqual(JsonValueKind.Object, doc.RootElement.ValueKind);
+    }
+
+    [TestMethod]
+    public void SerializesChartWithNullSeries()
+    {
+        var options = new ChartOptions
+        {
+            Title = new() { Text = "Null Series" },
+            Series = null
+        };
+
+        string json = JsonSerializer.Serialize(options, CreateOptions());
+        Assert.DoesNotContain("\"series\"", json, "Null series should not appear in JSON");
+    }
+
+    [TestMethod]
+    public void SerializesMultipleAxesAndGrids()
+    {
+        var options = new ChartOptions
+        {
+            Grid = new Grid { Top = "10%", Bottom = "50%" },
+            XAxis = new() { Type = AxisType.Category, GridIndex = 0 },
+            YAxis = new() { Type = AxisType.Value, GridIndex = 0 }
+        };
+
+        string json = JsonSerializer.Serialize(options, CreateOptions());
+
+        using var doc = JsonDocument.Parse(json);
+        Assert.IsTrue(doc.RootElement.TryGetProperty("grid", out _));
+        Assert.IsTrue(doc.RootElement.TryGetProperty("xAxis", out _));
+        Assert.IsTrue(doc.RootElement.TryGetProperty("yAxis", out _));
+    }
+
+    [TestMethod]
+    public void SerializesSeriesWithNullData()
+    {
+        var options = new ChartOptions
+        {
+            XAxis = new() { Type = AxisType.Category },
+            YAxis = new() { Type = AxisType.Value },
+            Series = new List<ISeries>
+            {
+                new LineSeries
+                {
+                    Name = "Test",
+                    Data = null
+                }
+            }
+        };
+
+        string json = JsonSerializer.Serialize(options, CreateOptions());
+        
+        using var doc = JsonDocument.Parse(json);
+        Assert.IsTrue(doc.RootElement.TryGetProperty("series", out var series));
+        Assert.AreEqual(1, series.GetArrayLength());
+        Assert.AreEqual("line", series[0].GetProperty("type").GetString());
+    }
+}