Add robust CLI budget and JSON edge tests (wildcards, regex, invalid input, negative sampling, null meta) and verify aggregated violation messages

Author: KeelMatrix

tests/KeelMatrix.QueryWatch.Cli.IntegrationTests/PatternBudgetWildcardsAndRegexTests.cs

@@ -0,0 +1,77 @@
+using FluentAssertions;
+using Xunit;
+
+namespace KeelMatrix.QueryWatch.Cli.IntegrationTests {
+    public class PatternBudgetWildcardsAndRegexTests {
+        [Fact]
+        public void Wildcard_QuestionMark_Matches_Single_Character_And_Ignores_Case() {
+            var f = System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", "pattern.json");
+
+            // Lowercase pattern, '?' for one char in "Users", '*' for the rest of the line
+            var (ok, stdoutOk, stderrOk) = CliRunner.Run(new[] {
+                "--input", f,
+                "--budget", "select * from user?* = 2".Replace(" ", "") // avoid quoting/space headaches
+            });
+            ok.Should().Be(0, stdoutOk + Environment.NewLine + stderrOk);
+
+            // Overly strict budget should fail (2 matches > 1 allowed)
+            var (fail, stdoutFail, stderrFail) = CliRunner.Run(new[] {
+                "--input", f,
+                "--budget", "SELECT*FROM*User?*=1"
+            });
+            fail.Should().Be(4, stdoutFail + Environment.NewLine + stderrFail);
+        }
+
+        [Fact]
+        public void Regex_Budget_Is_Case_Insensitive_And_Anchored_From_Start() {
+            var f = System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", "pattern.json");
+
+            // Should match both SELECTs in pattern.json
+            var (ok, so1, se1) = CliRunner.Run(new[] {
+                "--input", f,
+                "--budget", @"regex:^select\s+\*\s+from\s+users\b.*=2"
+            });
+            ok.Should().Be(0, so1 + Environment.NewLine + se1);
+
+            // Only allow 1 -> should fail because there are 2 matches
+            var (bad, so2, se2) = CliRunner.Run(new[] {
+                "--input", f,
+                "--budget", @"regex:^SELECT\s+\*\s+FROM\s+Users\b.*=1"
+            });
+            bad.Should().Be(4, so2 + Environment.NewLine + se2);
+        }
+
+        [Fact]
+        public void Invalid_Regex_Budget_Returns_InvalidArguments() {
+            var f = System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", "pattern.json");
+
+            var spec = "regex:(unclosed=2";
+            var (code, stdout, stderr) = CliRunner.Run(new[] { "--input", f, "--budget", spec });
+            code.Should().Be(1, stdout + Environment.NewLine + stderr); // ExitCodes.InvalidArguments
+            stderr.Should().Contain($"Invalid --budget value '{spec}'").And.Contain("Invalid regex");
+        }
+
+        [Fact]
+        public void Zero_Allowed_Count_Fails_When_There_Are_Matches() {
+            var f = System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", "pattern.json");
+
+            var (code, stdout, stderr) = CliRunner.Run(new[] {
+                "--input", f,
+                "--budget", "SELECT * FROM Users*=0"
+            });
+            code.Should().Be(4, stdout + Environment.NewLine + stderr); // BudgetExceeded
+        }
+
+        [Fact]
+        public void Multiple_Budgets_One_Over_Still_Triggers_Failure() {
+            var f = System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", "pattern.json");
+
+            var (code, stdout, stderr) = CliRunner.Run(new[] {
+                "--input", f,
+                "--budget", "SELECT * FROM Users*=1",   // over (2 > 1)
+                "--budget", "INSERT INTO Users*=2"      // under (1 <= 2)
+            });
+            code.Should().Be(4, stdout + Environment.NewLine + stderr);
+        }
+    }
+}

tests/KeelMatrix.QueryWatch.Tests/QueryWatchJsonEdgeTests.cs

@@ -0,0 +1,50 @@
+using System.Text.Json;
+using FluentAssertions;
+using KeelMatrix.QueryWatch.Reporting;
+using Xunit;
+
+namespace KeelMatrix.QueryWatch.Tests {
+    public class QueryWatchJsonEdgeTests {
+        [Fact]
+        public void ToSummary_Clamps_Negative_SampleTop_To_Zero() {
+            using var session = KeelMatrix.QueryWatch.QueryWatcher.Start();
+            session.Record("a", TimeSpan.FromMilliseconds(1));
+            session.Record("b", TimeSpan.FromMilliseconds(2));
+            var report = session.Stop();
+
+            var summary = QueryWatchJson.ToSummary(report, sampleTop: -5);
+            summary.Should().NotBeNull();
+            summary.Events.Should().NotBeNull();
+            summary.Events.Count.Should().Be(0, "negative sampleTop should be treated as zero");
+            summary.Meta.Should().ContainKey("sampleTop").WhoseValue.Should().Be("0");
+        }
+
+        [Fact]
+        public void Export_Omits_Event_Meta_Property_When_Null() {
+            using var session = KeelMatrix.QueryWatch.QueryWatcher.Start();
+            session.Record("query", TimeSpan.FromMilliseconds(1), meta: null);
+            var report = session.Stop();
+
+            var tempRoot = Path.Combine(Path.GetTempPath(), "qwatch-json-edge-" + Guid.NewGuid().ToString("N"));
+            var path = Path.Combine(tempRoot, "out", "summary.json");
+
+            try {
+                QueryWatchJson.ExportToFile(report, path, sampleTop: 1);
+                File.Exists(path).Should().BeTrue();
+
+                using var doc = JsonDocument.Parse(File.ReadAllText(path));
+                var root = doc.RootElement;
+                var events = root.GetProperty("events");
+                events.GetArrayLength().Should().BeGreaterThanOrEqualTo(1);
+                var first = events.EnumerateArray().First();
+                // Contract: omit event-level "meta" when it's null to keep JSON compact
+                first.TryGetProperty("meta", out _).Should().BeFalse("null meta should be omitted to reduce JSON size");
+            }
+            finally {
+                if (Directory.Exists(tempRoot)) {
+                    try { Directory.Delete(tempRoot, recursive: true); } catch { /* ignore */ }
+                }
+            }
+        }
+    }
+}

tests/KeelMatrix.QueryWatch.Tests/QueryWatchReportMessageTests.cs

@@ -0,0 +1,28 @@
+using FluentAssertions;
+using Xunit;
+
+namespace KeelMatrix.QueryWatch.Tests {
+    public class QueryWatchReportMessageTests {
+        [Fact]
+        public void ThrowIfViolations_Aggregates_All_Problems_And_Prefixes_With_Summary_Header() {
+            var options = new KeelMatrix.QueryWatch.QueryWatchOptions {
+                MaxQueries = 1,
+                MaxAverageDuration = TimeSpan.FromMilliseconds(1),
+                MaxTotalDuration = TimeSpan.FromMilliseconds(1)
+            };
+            using var session = KeelMatrix.QueryWatch.QueryWatcher.Start(options);
+
+            // Two slow queries → violate all three
+            session.Record("SELECT 1", TimeSpan.FromMilliseconds(2));
+            session.Record("SELECT 2", TimeSpan.FromMilliseconds(2));
+            var report = session.Stop();
+
+            Action act = () => report.ThrowIfViolations();
+            act.Should().Throw<KeelMatrix.QueryWatch.QueryWatchViolationException>()
+               .Which.Message.Should().Contain("Summary:")
+                               .And.Contain("MaxQueries=")
+                               .And.Contain("MaxAverageDuration=")
+                               .And.Contain("MaxTotalDuration=");
+        }
+    }
+}