OSOE-353: Add duplicate SQL query detector in Lombiq.UITestingToolbox

Lombiq.Tests.UI.Samples/Readme.md

@@ -30,6 +30,7 @@ For general details about and on using the Toolbox see the [root Readme](../Read
 - [Interactive mode](Tests/InteractiveModeTests.cs)
 - [Security scanning](Tests/SecurityScanningTests.cs)
 - [Testing remote apps](Tests/RemoteTests.cs)
+- [Duplicated SQL query detector](Tests/DuplicatedSqlQueryDetectorTests.cs)
 
 ## Adding new tutorials
 

Lombiq.Tests.UI.Samples/Tests/DuplicatedSqlQueryDetectorTests.cs

@@ -0,0 +1,115 @@
+using Lombiq.Tests.UI.Extensions;
+using Lombiq.Tests.UI.Services;
+using Lombiq.Tests.UI.Services.Counters.Configuration;
+using Shouldly;
+using System;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Lombiq.Tests.UI.Samples.Tests;
+
+// Some times you may want to detect duplicated SQL queries. This can be useful if you want to make sure that your code
+// does not execute the same query multiple times, wasting time and computing resources.
+public class DuplicatedSqlQueryDetectorTests : UITestBase
+{
+    public DuplicatedSqlQueryDetectorTests(ITestOutputHelper testOutputHelper)
+        : base(testOutputHelper)
+    {
+    }
+
+    // This test will fail because the app will read the same command result more times than the configured threshold
+    // during the Admin page rendering.
+    [Fact]
+    public Task PageWithTooManyReadsOnDbDataReaderShouldThrow() =>
+        Should.ThrowAsync<AggregateException>(() =>
+            ExecuteTestAfterSetupAsync(
+                context => context.SignInDirectlyAndGoToDashboardAsync(),
+                configuration => ConfigureAsync(
+                    configuration,
+                    commandExcludingParametersThreshold: 3,
+                    commandIncludingParametersThreshold: 2,
+                    readerReadThreshold: 0)));
+
+    // This test will fail because the app will execute the same SQL query having same parameter set more times than
+    // expected during the Admin page rendering.
+    [Fact]
+    public Task PageWithTooManySqlQueriesExecutedHavingTheSameParameterSetShouldThrow() =>
+        Should.ThrowAsync<AggregateException>(() =>
+            ExecuteTestAfterSetupAsync(
+                context => context.SignInDirectlyAndGoToDashboardAsync(),
+                configuration => ConfigureAsync(
+                    configuration,
+                    commandExcludingParametersThreshold: 3,
+                    commandIncludingParametersThreshold: 0,
+                    readerReadThreshold: 2)));
+
+    // This test will fail because the app will execute the same SQL query more times than expected during the Admin
+    // page rendering.
+    [Fact]
+    public Task PageWithTooManySqlQueriesExecutedShouldThrow() =>
+        Should.ThrowAsync<AggregateException>(() =>
+            ExecuteTestAfterSetupAsync(
+                context => context.SignInDirectlyAndGoToDashboardAsync(),
+                configuration => ConfigureAsync(
+                    configuration,
+                    commandExcludingParametersThreshold: 0,
+                    commandIncludingParametersThreshold: 2,
+                    readerReadThreshold: 2)));
+
+    // This test will pass because not any of the Admin page was loaded where the SQL queries are under monitoring.
+    [Fact]
+    public Task PageWithoutDuplicatedSqlQueriesShouldPass() =>
+        ExecuteTestAfterSetupAsync(
+            context => context.GoToHomePageAsync(onlyIfNotAlreadyThere: false),
+            configuration => ConfigureAsync(configuration));
+
+    // This test will pass because counter thresholds are exactly matching with the counter values captured during
+    // navigating to the Admin dashboard page.
+    [Fact]
+    public Task PageWithMatchingCounterThresholdsShouldPass() =>
+        ExecuteTestAfterSetupAsync(
+            context => context.SignInDirectlyAndGoToDashboardAsync(),
+            configuration => ConfigureAsync(
+                configuration,
+                commandExcludingParametersThreshold: 3,
+                commandIncludingParametersThreshold: 2,
+                readerReadThreshold: 2));
+
+    // We configure the test to throw an exception if a certain counter threshold is exceeded, but only in case of Admin
+    // pages.
+    private static Task ConfigureAsync(
+        OrchardCoreUITestExecutorConfiguration configuration,
+        int commandExcludingParametersThreshold = 0,
+        int commandIncludingParametersThreshold = 0,
+        int readerReadThreshold = 0)
+    {
+        // The test is guaranteed to fail so we don't want to retry it needlessly.
+        configuration.MaxRetryCount = 0;
+
+        var adminCounterConfiguration = new CounterConfiguration
+        {
+            ExcludeFilter = OrchardCoreUITestExecutorConfiguration.DefaultCounterExcludeFilter,
+            SessionThreshold =
+            {
+                // Let's enable and configure the counter thresholds for ORM sessions.
+                IsEnabled = true,
+                DbCommandExcludingParametersExecutionThreshold = commandExcludingParametersThreshold,
+                DbCommandIncludingParametersExecutionCountThreshold = commandIncludingParametersThreshold,
+                DbReaderReadThreshold = readerReadThreshold,
+            },
+        };
+
+        // Apply the configuration to the Admin pages only.
+        configuration.CounterConfiguration.AfterSetup.Add(
+            new RelativeUrlConfigurationKey(new Uri("/Admin", UriKind.Relative), exactMatch: false),
+            adminCounterConfiguration);
+
+        // Enable the counter subsystem.
+        configuration.CounterConfiguration.IsEnabled = true;
+
+        return Task.CompletedTask;
+    }
+}
+
+// END OF TRAINING SECTION: Duplicated SQL query detector.

Lombiq.Tests.UI.Samples/Tests/RemoteTests.cs

@@ -43,3 +43,4 @@ public Task ExampleDotComShouldWork() =>
 }
 
 // END OF TRAINING SECTION: Remote tests.
+// NEXT STATION: Head over to DuplicatedSqlQueryDetectorTests.cs.

Lombiq.Tests.UI/Exceptions/CounterThresholdException.cs

@@ -0,0 +1,68 @@
+using Lombiq.Tests.UI.Services.Counters;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Lombiq.Tests.UI.Exceptions;
+
+public class CounterThresholdException : Exception
+{
+    public CounterThresholdException()
+    {
+    }
+
+    public CounterThresholdException(string message)
+        : this(probe: null, counter: null, value: null, message)
+    {
+    }
+
+    public CounterThresholdException(string message, Exception innerException)
+        : this(probe: null, counter: null, value: null, message, innerException)
+    {
+    }
+
+    public CounterThresholdException(
+        ICounterProbe probe,
+        ICounterKey counter,
+        ICounterValue value)
+        : this(probe, counter, value, message: null, innerException: null)
+    {
+    }
+
+    public CounterThresholdException(
+        ICounterProbe probe,
+        ICounterKey counter,
+        ICounterValue value,
+        string message)
+        : this(probe, counter, value, message, innerException: null)
+    {
+    }
+
+    public CounterThresholdException(
+        ICounterProbe probe,
+        ICounterKey counter,
+        ICounterValue value,
+        string message,
+        Exception innerException)
+        : base(FormatMessage(probe, counter, value, message), innerException)
+    {
+    }
+
+    private static string FormatMessage(
+        ICounterProbe probe,
+        ICounterKey counter,
+        ICounterValue value,
+        string message)
+    {
+        var builder = new StringBuilder()
+            .AppendLine()
+            .AppendLine("A counter value has crossed the configured threshold level. Details:");
+
+        if (probe is not null) builder.AppendLine(probe.DumpHeadline());
+        counter?.Dump().ForEach(line => builder.AppendLine(line));
+        value?.Dump().ForEach(line => builder.AppendLine(line));
+        if (!string.IsNullOrEmpty(message)) builder.AppendLine(message);
+
+        return builder.ToString();
+    }
+}

Lombiq.Tests.UI/Extensions/NavigationUITestContextExtensions.cs

@@ -3,6 +3,7 @@
 using Lombiq.Tests.UI.Helpers;
 using Lombiq.Tests.UI.Pages;
 using Lombiq.Tests.UI.Services;
+using Lombiq.Tests.UI.Services.Counters;
 using Newtonsoft.Json;
 using OpenQA.Selenium;
 using OpenQA.Selenium.Interactions;
@@ -57,7 +58,10 @@ public static Task GoToAbsoluteUrlAsync(this UITestContext context, Uri absolute
                 await context.Configuration.Events.BeforeNavigation
                     .InvokeAsync<NavigationEventHandler>(eventHandler => eventHandler(context, absoluteUri));
 
-                context.Driver.Navigate().GoToUrl(absoluteUri);
+                using (new NavigationProbe(context.CounterDataCollector, absoluteUri))
+                {
+                    context.Driver.Navigate().GoToUrl(absoluteUri);
+                }
 
                 await context.Configuration.Events.AfterNavigation
                     .InvokeAsync<NavigationEventHandler>(eventHandler => eventHandler(context, absoluteUri));

Lombiq.Tests.UI/Models/UITestContextParameters.cs

@@ -0,0 +1,16 @@
+using Lombiq.Tests.UI.SecurityScanning;
+using Lombiq.Tests.UI.Services;
+
+namespace Lombiq.Tests.UI.Models;
+
+internal sealed record UITestContextParameters
+{
+    public string Id { get; init; }
+    public UITestManifest TestManifest { get; init; }
+    public OrchardCoreUITestExecutorConfiguration Configuration { get; init; }
+    public IWebApplicationInstance Application { get; init; }
+    public AtataScope Scope { get; init; }
+    public RunningContextContainer RunningContextContainer { get; init; }
+    public ZapManager ZapManager { get; init; }
+    public CounterDataCollector CounterDataCollector { get; init; }
+}

Lombiq.Tests.UI/OrchardCoreUITestBase.cs

@@ -334,8 +334,12 @@ protected virtual async Task ExecuteTestAsync(
         if (changeConfigurationAsync != null) await changeConfigurationAsync(configuration);
 
         await ExecuteOrchardCoreTestAsync(
-            (configuration, contextId) =>
-                new OrchardCoreInstance<TEntryPoint>(configuration.OrchardCoreConfiguration, contextId, configuration.TestOutputHelper),
+            (configuration, contextId, counterDataCollector) =>
+                new OrchardCoreInstance<TEntryPoint>(
+                    configuration.OrchardCoreConfiguration,
+                    contextId,
+                    configuration.TestOutputHelper,
+                    counterDataCollector),
             testManifest,
             configuration);
     }

Lombiq.Tests.UI/RemoteUITestBase.cs

@@ -71,6 +71,6 @@ async Task BaseUriVisitingTest(UITestContext context)
 
         if (changeConfigurationAsync != null) await changeConfigurationAsync(configuration);
 
-        await ExecuteOrchardCoreTestAsync((_, _) => new RemoteInstance(baseUri), testManifest, configuration);
+        await ExecuteOrchardCoreTestAsync((_, _, _) => new RemoteInstance(baseUri), testManifest, configuration);
     }
 }

Lombiq.Tests.UI/Services/CounterDataCollector.cs

@@ -0,0 +1,90 @@
+using Lombiq.Tests.UI.Services.Counters;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit.Abstractions;
+
+namespace Lombiq.Tests.UI.Services;
+
+public sealed class CounterDataCollector : CounterProbeBase, ICounterDataCollector
+{
+    private readonly ITestOutputHelper _testOutputHelper;
+    private readonly ConcurrentBag<ICounterProbe> _probes = [];
+    private readonly ConcurrentBag<Exception> _postponedCounterExceptions = [];
+    public override bool IsAttached => true;
+    public Action<ICounterDataCollector, ICounterProbe> AssertCounterData { get; set; }
+    public string Phase { get; set; }
+    public bool IsEnabled { get; set; }
+
+    public CounterDataCollector(ITestOutputHelper testOutputHelper) =>
+        _testOutputHelper = testOutputHelper;
+
+    public void AttachProbe(ICounterProbe probe)
+    {
+        if (!IsEnabled)
+        {
+            return;
+        }
+
+        probe.CaptureCompleted = ProbeCaptureCompleted;
+        _probes.Add(probe);
+    }
+
+    public void Reset()
+    {
+        _probes.Clear();
+        _postponedCounterExceptions.Clear();
+        Clear();
+    }
+
+    public override void Increment(ICounterKey counter)
+    {
+        if (!IsEnabled)
+        {
+            return;
+        }
+
+        _probes.Where(probe => probe.IsAttached)
+            .ForEach(probe => probe.Increment(counter));
+        base.Increment(counter);
+    }
+
+    public override string DumpHeadline() => $"{nameof(CounterDataCollector)}, Phase = {Phase}";
+
+    public override IEnumerable<string> Dump()
+    {
+        var lines = new List<string>
+        {
+            DumpHeadline(),
+        };
+
+        lines.AddRange(DumpSummary().Select(line => $"\t{line}"));
+
+        return lines;
+    }
+
+    public void AssertCounter(ICounterProbe probe) => AssertCounterData?.Invoke(this, probe);
+
+    public void AssertCounter()
+    {
+        if (!IsEnabled)
+        {
+            return;
+        }
+
+        if (!_postponedCounterExceptions.IsEmpty)
+        {
+            throw new AggregateException(
+                "There were exceptions out of the test execution context.",
+                _postponedCounterExceptions);
+        }
+
+        AssertCounter(this);
+    }
+
+    public void PostponeCounterException(Exception exception) => _postponedCounterExceptions.Add(exception);
+
+    private void ProbeCaptureCompleted(ICounterProbe probe) =>
+        probe.Dump().ForEach(_testOutputHelper.WriteLine);
+}

Lombiq.Tests.UI/Services/Counters/Configuration/CounterConfiguration.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Lombiq.Tests.UI.Services.Counters.Configuration;
+
+public class CounterConfiguration
+{
+    /// <summary>
+    /// Gets or sets the counter assertion method.
+    /// </summary>
+    public Action<ICounterDataCollector, ICounterProbe> AssertCounterData { get; set; }
+
+    /// <summary>
+    /// Gets or sets the exclude filter. Can be used to exclude counted values before assertion.
+    /// </summary>
+    public Func<ICounterKey, bool> ExcludeFilter { get; set; }
+
+    /// <summary>
+    /// Gets or sets threshold configuration used under navigation requests. See:
+    /// <see cref="UI.Extensions.NavigationUITestContextExtensions.GoToAbsoluteUrlAsync(UITestContext, Uri, bool)"/>.
+    /// See: <see cref="NavigationProbe"/>.
+    /// </summary>
+    public CounterThresholdConfiguration NavigationThreshold { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets threshold configuration used per <see cref="YesSql.ISession"/> lifetime. See:
+    /// <see cref="SessionProbe"/>.
+    /// </summary>
+    public CounterThresholdConfiguration SessionThreshold { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets threshold configuration used per page load. See: <see cref="RequestProbe"/>.
+    /// </summary>
+    public CounterThresholdConfiguration PageLoadThreshold { get; set; } = new();
+}