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/BasicOrchardFeaturesTests.cs

@@ -21,7 +21,19 @@ public BasicOrchardFeaturesTests(ITestOutputHelper testOutputHelper)
     // this test.
     [Fact]
     public Task BasicOrchardFeaturesShouldWork() =>
-        ExecuteTestAsync(context => context.TestBasicOrchardFeaturesAsync(RecipeIds.BasicOrchardFeaturesTests));
+        ExecuteTestAsync(
+            context => context.TestBasicOrchardFeaturesAsync(RecipeIds.BasicOrchardFeaturesTests),
+            configuration =>
+            {
+                // The UI Testing Toolbox includes a DbCommand execution counter to check for duplicated SQL queries..
+                // After the end of the test, it checks the number of executed commands with the same SQL command text
+                // and parameter set against the threshold value in its configuration. If the executed command count is
+                // greater than the threshold, it raises a CounterThresholdException. So here we set the minimum
+                // required value to avoid it.
+                configuration.CounterConfiguration.Running.PhaseThreshold.DbCommandIncludingParametersExecutionCountThreshold = 26;
+
+                return Task.CompletedTask;
+            });
 }
 
 // END OF TRAINING SECTION: Basic Orchard features tests.

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

@@ -0,0 +1,61 @@
+using Lombiq.Tests.UI.Attributes;
+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.
+    [Theory, Chrome]
+    public Task PageWithTooManyDuplicatedSqlQueriesShouldThrow(Browser browser) =>
+        Should.ThrowAsync<AggregateException>(() =>
+            ExecuteTestAfterSetupAsync(
+                context => context.SignInDirectlyAndGoToDashboardAsync(),
+                browser,
+                ConfigureAsync));
+
+    // This test will pass because not the Admin page was loaded.
+    [Theory, Chrome]
+    public Task PageWithoutDuplicatedSqlQueriesShouldPass(Browser browser) =>
+        Should.NotThrowAsync(() =>
+            ExecuteTestAfterSetupAsync(
+                async context => await context.GoToHomePageAsync(onlyIfNotAlreadyThere: false),
+                browser,
+                ConfigureAsync));
+
+    // 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)
+    {
+        // The test is guaranteed to fail so we don't want to retry it needlessly.
+        configuration.MaxRetryCount = 0;
+
+        var adminCounterConfiguration = new CounterConfiguration();
+        // Let's enable and configure the counter threshold for ORM sessions.
+        adminCounterConfiguration.SessionThreshold.Disable = false;
+        adminCounterConfiguration.SessionThreshold.DbReaderReadThreshold = 0;
+        // Apply the configuration to the Admin pages only.
+        configuration.CounterConfiguration.Running.Add(
+            new RelativeUrlConfigurationKey(new Uri("/Admin", UriKind.Relative), exactMatch: false),
+            adminCounterConfiguration);
+
+        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,65 @@
+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();
+        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.Support.UI;
@@ -45,7 +46,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,74 @@
+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 CounterDataCollector(ITestOutputHelper testOutputHelper) =>
+        _testOutputHelper = testOutputHelper;
+
+    public void AttachProbe(ICounterProbe probe)
+    {
+        probe.CaptureCompleted = ProbeCaptureCompleted;
+        _probes.Add(probe);
+    }
+
+    public void Reset()
+    {
+        _probes.Clear();
+        _postponedCounterExceptions.Clear();
+        Clear();
+    }
+
+    public override void Increment(ICounterKey counter)
+    {
+        _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 (!_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,86 @@
+using Lombiq.Tests.UI.Services.Counters.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Lombiq.Tests.UI.Services.Counters.Configuration;
+
+public class CounterConfiguration
+{
+    private const string WorkflowTypeStartActivitiesQuery =
+        "SELECT DISTINCT [Document].* FROM [Document] INNER JOIN [WorkflowTypeStartActivitiesIndex]"
+        + " AS [WorkflowTypeStartActivitiesIndex_a1]"
+        + " ON [WorkflowTypeStartActivitiesIndex_a1].[DocumentId] = [Document].[Id]"
+        + " WHERE (([WorkflowTypeStartActivitiesIndex_a1].[StartActivityName] = @p0)"
+        + " and ([WorkflowTypeStartActivitiesIndex_a1].[IsEnabled] = @p1))";
+
+    /// <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; } = DefaultExcludeFilter;
+
+    /// <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 CounterThresholdConfiguration
+    {
+        DbCommandIncludingParametersExecutionCountThreshold = 11,
+        DbCommandExcludingParametersExecutionThreshold = 22,
+        DbReaderReadThreshold = 11,
+    };
+
+    /// <summary>
+    /// Gets or sets threshold configuration used per <see cref="YesSql.ISession"/> lifetime. See:
+    /// <see cref="SessionProbe"/>.
+    /// </summary>
+    public CounterThresholdConfiguration SessionThreshold { get; set; } = new CounterThresholdConfiguration
+    {
+        DbCommandIncludingParametersExecutionCountThreshold = 22,
+        DbCommandExcludingParametersExecutionThreshold = 44,
+        DbReaderReadThreshold = 11,
+    };
+
+    /// <summary>
+    /// Gets or sets threshold configuration used per page load. See: <see cref="PageLoadProbe"/>.
+    /// </summary>
+    public CounterThresholdConfiguration PageLoadThreshold { get; set; } = new CounterThresholdConfiguration
+    {
+        DbCommandIncludingParametersExecutionCountThreshold = 22,
+        DbCommandExcludingParametersExecutionThreshold = 44,
+        DbReaderReadThreshold = 11,
+    };
+
+    public static IEnumerable<ICounterKey> DefaultExcludeList { get; } = new List<ICounterKey>
+    {
+        new DbCommandExecuteCounterKey(
+            WorkflowTypeStartActivitiesQuery,
+            new List<KeyValuePair<string, object>>
+            {
+                new("p0", "ContentCreatedEvent"),
+                new("p1", value: true),
+            }),
+        new DbCommandExecuteCounterKey(
+            WorkflowTypeStartActivitiesQuery,
+            new List<KeyValuePair<string, object>>
+            {
+                new("p0", "ContentPublishedEvent"),
+                new("p1", value: true),
+            }),
+        new DbCommandExecuteCounterKey(
+            WorkflowTypeStartActivitiesQuery,
+            new List<KeyValuePair<string, object>>
+            {
+                new("p0", "ContentUpdatedEvent"),
+                new("p1", value: true),
+            }),
+    };
+
+    public static bool DefaultExcludeFilter(ICounterKey key) => DefaultExcludeList.Contains(key);
+}