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

Lombiq.Tests.UI/Exceptions/CounterThresholdException.cs

@@ -0,0 +1,50 @@
+using Lombiq.Tests.UI.Services.Counters;
+using System;
+using System.Text;
+
+namespace Lombiq.Tests.UI.Exceptions;
+
+// We need constructors with required informations.
+#pragma warning disable CA1032 // Implement standard exception constructors
+public class CounterThresholdException : Exception
+#pragma warning restore CA1032 // Implement standard exception constructors
+{
+    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) =>
+        new StringBuilder()
+            .AppendLine(probe.DumpHeadline())
+            .AppendLine(counter.Dump())
+            .AppendLine(value.Dump())
+            .AppendLine(message ?? string.Empty)
+            .ToString();
+}

Lombiq.Tests.UI/Extensions/CounterDataCollectorExtensions.cs

@@ -0,0 +1,60 @@
+using Lombiq.Tests.UI.Services.Counters;
+using Lombiq.Tests.UI.Services.Counters.Data;
+using System.Data;
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Lombiq.Tests.UI.Extensions;
+
+public static class CounterDataCollectorExtensions
+{
+    public static int DbCommandExecuteNonQuery(this ICounterDataCollector collector, DbCommand dbCommand)
+    {
+        collector.Increment(DbExecuteCounterKey.CreateFrom(dbCommand));
+        return dbCommand.ExecuteNonQuery();
+    }
+
+    public static Task<int> DbCommandExecuteNonQueryAsync(
+        this ICounterDataCollector collector,
+        DbCommand dbCommand,
+        CancellationToken cancellationToken)
+    {
+        collector.Increment(DbExecuteCounterKey.CreateFrom(dbCommand));
+        return dbCommand.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    public static object DbCommandExecuteScalar(this ICounterDataCollector collector, DbCommand dbCommand)
+    {
+        collector.Increment(DbExecuteCounterKey.CreateFrom(dbCommand));
+        return dbCommand.ExecuteScalar();
+    }
+
+    public static Task<object> DbCommandExecuteScalarAsync(
+        this ICounterDataCollector collector,
+        DbCommand dbCommand,
+        CancellationToken cancellationToken)
+    {
+        collector.Increment(DbExecuteCounterKey.CreateFrom(dbCommand));
+        return dbCommand.ExecuteScalarAsync(cancellationToken);
+    }
+
+    public static DbDataReader DbCommandExecuteDbDatareader(
+        this ICounterDataCollector collector,
+        DbCommand dbCommand,
+        CommandBehavior behavior)
+    {
+        collector.Increment(DbExecuteCounterKey.CreateFrom(dbCommand));
+        return dbCommand.ExecuteReader(behavior);
+    }
+
+    public static Task<DbDataReader> DbCommandExecuteDbDatareaderAsync(
+        this ICounterDataCollector collector,
+        DbCommand dbCommand,
+        CommandBehavior behavior,
+        CancellationToken cancellationToken)
+    {
+        collector.Increment(DbExecuteCounterKey.CreateFrom(dbCommand));
+        return dbCommand.ExecuteReaderAsync(behavior, cancellationToken);
+    }
+}

Lombiq.Tests.UI/Extensions/NavigationUITestContextExtensions.cs

@@ -2,6 +2,7 @@
 using Lombiq.Tests.UI.Constants;
 using Lombiq.Tests.UI.Pages;
 using Lombiq.Tests.UI.Services;
+using Lombiq.Tests.UI.Services.Counters;
 using OpenQA.Selenium;
 using OpenQA.Selenium.Support.UI;
 using System;
@@ -39,7 +40,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/Services/CounterConfiguration.cs

@@ -0,0 +1,62 @@
+using Lombiq.Tests.UI.Exceptions;
+using Lombiq.Tests.UI.Services.Counters;
+using Lombiq.Tests.UI.Services.Counters.Data;
+using Lombiq.Tests.UI.Services.Counters.Value;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Lombiq.Tests.UI.Services;
+
+public class CounterConfiguration
+{
+    /// <summary>
+    /// Gets the counter configuration used in the setup phase.
+    /// </summary>
+    public PhaseCounterConfiguration Setup { get; } = new();
+
+    /// <summary>
+    /// Gets the counter configuration used in the running phase.
+    /// </summary>
+    public PhaseCounterConfiguration Running { get; } = new();
+
+    public static Action<ICounterProbe> DefaultAssertCounterData(PhaseCounterConfiguration configuration) =>
+        probe =>
+        {
+            if (probe is NavigationProbe or CounterDataCollector)
+            {
+                var executeThreshold = probe is NavigationProbe
+                    ? configuration.DbCommandExecutionRepetitionPerNavigationThreshold
+                    : configuration.DbCommandExecutionRepetitionThreshold;
+                var executeThresholdName = probe is NavigationProbe
+                    ? nameof(configuration.DbCommandExecutionRepetitionPerNavigationThreshold)
+                    : nameof(configuration.DbCommandExecutionRepetitionThreshold);
+                var readThreshold = probe is NavigationProbe
+                    ? configuration.DbReaderReadPerNavigationThreshold
+                    : configuration.DbReaderReadThreshold;
+                var readThresholdName = probe is NavigationProbe
+                    ? nameof(configuration.DbReaderReadPerNavigationThreshold)
+                    : nameof(configuration.DbReaderReadThreshold);
+
+                AssertIntegerCounterValue<DbExecuteCounterKey>(probe, executeThresholdName, executeThreshold);
+                AssertIntegerCounterValue<DbReadCounterKey>(probe, readThresholdName, readThreshold);
+            }
+        };
+
+    public static void AssertIntegerCounterValue<TKey>(ICounterProbe probe, string thresholdName, int threshold)
+        where TKey : ICounterKey =>
+        probe.Counters.Keys
+            .OfType<TKey>()
+            .ForEach(key =>
+            {
+                if (probe.Counters[key] is IntegerCounterValue counterValue
+                    && counterValue.Value > threshold)
+                {
+                    throw new CounterThresholdException(
+                        probe,
+                        key,
+                        counterValue,
+                        $"Counter value is greater then {thresholdName}, threshold: {threshold.ToTechnicalString()}");
+                }
+            });
+}

Lombiq.Tests.UI/Services/CounterDataCollector.cs

@@ -0,0 +1,34 @@
+using Lombiq.Tests.UI.Services.Counters;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace Lombiq.Tests.UI.Services;
+
+public sealed class CounterDataCollector : CounterProbeBase, ICounterDataCollector
+{
+    private readonly ConcurrentBag<ICounterProbe> _probes = new();
+    public override bool IsRunning => true;
+    public Action<ICounterProbe> AssertCounterData { get; set; }
+
+    public void AttachProbe(ICounterProbe probe) => _probes.Add(probe);
+
+    public void Reset()
+    {
+        _probes.Clear();
+        Clear();
+    }
+
+    public override void Increment(ICounterKey counter)
+    {
+        _probes.SelectWhere(probe => probe, probe => probe.IsRunning)
+            .ForEach(probe => probe.Increment(counter));
+
+        base.Increment(counter);
+    }
+
+    public override string DumpHeadline() => nameof(CounterDataCollector);
+    public override string Dump() => DumpHeadline();
+    public void AssertCounter(ICounterProbe probe) => AssertCounterData?.Invoke(probe);
+    public void AssertCounter() => AssertCounter(this);
+}

Lombiq.Tests.UI/Services/Counters/CounterKey.cs

@@ -0,0 +1,13 @@
+namespace Lombiq.Tests.UI.Services.Counters;
+
+// The Equals must be implemented in consumer classes.
+#pragma warning disable S4035 // Classes implementing "IEquatable<T>" should be sealed
+public abstract class CounterKey : ICounterKey
+#pragma warning restore S4035 // Classes implementing "IEquatable<T>" should be sealed
+{
+    public abstract bool Equals(ICounterKey other);
+    protected abstract int HashCode();
+    public override bool Equals(object obj) => Equals(obj as ICounterKey);
+    public override int GetHashCode() => HashCode();
+    public abstract string Dump();
+}

Lombiq.Tests.UI/Services/Counters/CounterProbe.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Text;
+
+namespace Lombiq.Tests.UI.Services.Counters;
+
+public abstract class CounterProbe : CounterProbeBase, IDisposable
+{
+    private bool _disposed;
+
+    public override bool IsRunning => !_disposed;
+    public ICounterDataCollector CounterDataCollector { get; init; }
+
+    public override string Dump()
+    {
+        var builder = new StringBuilder();
+
+        builder.AppendLine(DumpHeadline());
+
+        foreach (var entry in Counters)
+        {
+            builder.AppendLine(entry.Key.Dump())
+                .AppendLine(entry.Value.Dump());
+        }
+
+        return builder.ToString();
+    }
+
+    protected CounterProbe(ICounterDataCollector counterDataCollector)
+    {
+        CounterDataCollector = counterDataCollector;
+        CounterDataCollector.AttachProbe(this);
+    }
+
+    protected virtual void OnAssertData() =>
+        CounterDataCollector.AssertCounter(this);
+
+    protected virtual void OnDispose()
+    {
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!_disposed)
+        {
+            try { OnAssertData(); }
+            catch { throw; }
+            finally
+            {
+                if (disposing)
+                {
+                    OnDispose();
+                }
+
+                _disposed = true;
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+}

Lombiq.Tests.UI/Services/Counters/CounterProbeBase.cs

@@ -0,0 +1,39 @@
+using Lombiq.Tests.UI.Services.Counters.Value;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace Lombiq.Tests.UI.Services.Counters;
+
+public abstract class CounterProbeBase : ICounterProbe
+{
+    private readonly ConcurrentDictionary<ICounterKey, ICounterValue> _counters = new();
+
+    public abstract bool IsRunning { get; }
+    public IDictionary<ICounterKey, ICounterValue> Counters => _counters;
+
+    protected void Clear() => _counters.Clear();
+
+    public virtual void Increment(ICounterKey counter) =>
+        _counters.AddOrUpdate(
+            counter,
+            new IntegerCounterValue { Value = 1 },
+            (_, current) => TryConvertAndUpdate<IntegerCounterValue>(current, current => current.Value++));
+
+    public abstract string DumpHeadline();
+
+    public abstract string Dump();
+
+    private static TCounter TryConvertAndUpdate<TCounter>(ICounterValue counter, Action<TCounter> update)
+    {
+        if (counter is not TCounter value)
+        {
+            throw new ArgumentException(
+                $"The type of ${nameof(counter)} is not compatible with ${typeof(TCounter).Name}");
+        }
+
+        update.Invoke(value);
+
+        return value;
+    }
+}

Lombiq.Tests.UI/Services/Counters/Data/DbCommandCounterKey.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+
+namespace Lombiq.Tests.UI.Services.Counters.Data;
+
+public abstract class DbCommandCounterKey : CounterKey
+{
+    private readonly List<KeyValuePair<string, object>> _parameters = new();
+    public string CommandText { get; private set; }
+    public IEnumerable<KeyValuePair<string, object>> Parameters => _parameters;
+
+    protected DbCommandCounterKey(string commandText, IEnumerable<KeyValuePair<string, object>> parameters)
+    {
+        _parameters.AddRange(parameters);
+        CommandText = commandText;
+    }
+
+    public override bool Equals(ICounterKey other)
+    {
+        if (ReferenceEquals(this, other)) return true;
+
+        return other is DbExecuteCounterKey otherKey
+            && GetType() == otherKey.GetType()
+            && CommandText == otherKey.CommandText
+            && Parameters
+                .Select(param => (param.Key, param.Value))
+                .SequenceEqual(otherKey.Parameters.Select(param => (param.Key, param.Value)));
+    }
+
+    public override string Dump()
+    {
+        var builder = new StringBuilder();
+
+        builder.AppendLine(GetType().Name)
+            .AppendLine(CultureInfo.InvariantCulture, $"\t{CommandText}");
+        var commandParams = Parameters.Select((parameter, index) =>
+            FormattableString.Invariant(
+                $"[{index.ToTechnicalString()}]{parameter.Key ?? string.Empty} = {parameter.Value?.ToString() ?? "(null)"}"))
+            .Join(", ");
+        builder.AppendLine(CultureInfo.InvariantCulture, $"\t\t{commandParams}");
+
+        return builder.ToString();
+    }
+
+    protected override int HashCode() => StringComparer.Ordinal.GetHashCode(CommandText);
+    public override string ToString() => $"[{GetType().Name}] {CommandText}";
+}