Add some debounce tests (from MudBlazor)

Author: DrastamatSargsyan

docs/CodeBeam.MudBlazor.Extensions.Docs.Wasm/wwwroot/CodeBeam.MudBlazor.Extensions.xml

@@ -14,7 +14,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="Microsoft.AspNetCore.Components.Web" Version="10.0.*" />
-		<PackageReference Include="MudBlazor" Version="9.0.0" />
+		<PackageReference Include="MudBlazor" Version="9.3.0" />
 	</ItemGroup>
 
 	<ItemGroup>

docs/CodeBeam.MudBlazor.Extensions.Docs/CodeBeam.MudBlazor.Extensions.Docs.csproj

@@ -94,7 +94,17 @@ protected MudBaseInputExtended()
         /// </summary>
         [Parameter]
         [Category(CategoryTypes.FormComponent.Behavior)]
-        public bool DisablePaste { get; set; }
+        public bool DisablePaste { get; set; } = false;
+
+        /// <summary>
+        /// Override to read Value from ParameterState instead of backing field.
+        /// </summary>
+        protected internal new T? ReadValue => base.ReadValue;
+
+        /// <summary>
+        /// Override to write Value to ParameterState instead of backing field.
+        /// </summary>
+        protected internal new string? ReadText => base.ReadText;
 
         /// <summary>
         /// Invokes logic to be executed before input is processed, including raising the BeforeInput event if a

src/CodeBeam.MudBlazor.Extensions/Base/MudBaseInputExtended.cs

@@ -41,7 +41,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="MudBlazor" Version="9.0.0" />
+		<PackageReference Include="MudBlazor" Version="9.3.0" />
 	</ItemGroup>
 
 	<Target Name="MinifyMudExtensionsJs" AfterTargets="Build" Condition="'$(CI)' != 'true'&#xD;&#xA; AND '$(TargetFramework)' == 'net10.0'&#xD;&#xA;               AND Exists('TScripts/MudExtensions.js')">

src/CodeBeam.MudBlazor.Extensions/CodeBeam.MudBlazor.Extensions.csproj

@@ -0,0 +1,21 @@
+@namespace MudExtensions.UnitTests.TestComponents
+
+<MudTextField T="string"
+              @bind-Value="_value"
+              DebounceInterval="500"
+              Label="Debounced" />
+
+<MudTextField T="string"
+              @bind-Value="_value"
+              Label="Immediate" />
+
+@code {
+    private string? _value = "i";
+
+    protected override async Task OnInitializedAsync()
+    {
+        await Task.Yield();
+        _value = "init value";
+        await InvokeAsync(StateHasChanged);
+    }
+}

tests/CodeBeam.MudBlazor.Extensions.UnitTests.Viewer/TestComponents/TextFieldExtended/DebouncedTextFieldAsyncInitializationSyncTest.razor

@@ -0,0 +1,106 @@
+using AwesomeAssertions;
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using MudExtensions.UnitTests.Extensions;
+using MudExtensions.UnitTests.TestComponents;
+
+namespace MudExtensions.UnitTests.Components;
+
+[TestFixture]
+public class DebouncedInputExtendedTests : BunitTest
+{
+    /// <summary>
+    /// If Debounce Interval is null or 0, Value should change immediately
+    /// </summary>
+    [Test]
+    public async Task WithNoDebounceIntervalValueShouldChangeImmediately()
+    {
+        //no interval passed, so, by default is 0
+        // We pass the Immediate parameter set to true, in order to bind to oninput
+        var comp = Context.Render<MudTextFieldExtended<string>>(parameters => parameters.Add(p => p.Immediate, true));
+        var textField = comp.Instance;
+        var input = comp.Find("input");
+
+        //Act
+        await input.InputAsync(new ChangeEventArgs() { Value = "Some Value" });
+
+        //Assert
+        //input value has changed, DebounceInterval is 0, so Value should change in TextField immediately
+        textField.ReadValue.Should().Be("Some Value");
+    }
+
+    /// <summary>
+    /// Value should not change immediately. Should respect the Debounce Interval
+    /// </summary>
+    [Test]
+    public async Task ShouldRespectDebounceIntervalPropertyInTextField()
+    {
+        var comp = Context.Render<MudTextFieldExtended<string>>(parameters => parameters.Add(p => p.DebounceInterval, 200d));
+        var textField = comp.Instance;
+        var input = comp.Find("input");
+
+        //Act
+        await input.InputAsync(new ChangeEventArgs() { Value = "Some Value" });
+
+        //Assert
+        //if DebounceInterval is set, Immediate should be true by default
+        textField.Immediate.Should().BeTrue();
+
+        //input value has changed, but elapsed time is 0, so Value should not change in TextField
+        textField.ReadValue.Should().BeNull();
+
+        //DebounceInterval is 200 ms, so at 100 ms Value should not change in TextField
+        await Task.Delay(100);
+        textField.ReadValue.Should().BeNull();
+
+        //More than 200 ms had elapsed, so Value should be updated
+        await comp.WaitForAssertionAsync(() => textField.ReadValue.Should().Be("Some Value"));
+    }
+
+    /// <summary>
+    /// DebounceInterval updates with epsilon-equivalent values should not break debouncing
+    /// </summary>
+    [Test]
+    public async Task DebounceInterval_EpsilonEquivalentValues_PreservesDebounce()
+    {
+        // Arrange
+        var comp = Context.Render<MudTextFieldExtended<string>>(parameters => parameters.Add(p => p.DebounceInterval, 200.0));
+        var textField = comp.Instance;
+        var input = comp.Find("input");
+
+        // Act - Input a value
+        await input.InputAsync(new ChangeEventArgs() { Value = "Test Value" });
+
+        // Change DebounceInterval to an epsilon-equivalent value (should not reset debouncer)
+        await comp.SetParametersAndRenderAsync(parameters => parameters.Add(p => p.DebounceInterval, 200.0000001));
+
+        // Assert - Value should still be null (debounce still pending)
+        textField.ReadValue.Should().BeNull();
+
+        // Wait for the debounce to complete
+        await comp.WaitForAssertionAsync(() => textField.ReadValue.Should().Be("Test Value"));
+    }
+
+    [Test]
+    public async Task DebouncedTextField_ShouldStayInSyncWithBoundValueAfterAsyncInitialization()
+    {
+        var comp = Context.Render<DebouncedTextFieldAsyncInitializationSyncTest>();
+
+        await comp.WaitForAssertionAsync(() =>
+        {
+            var inputs = comp.FindAll("input");
+            inputs[0].GetAttribute("value").Should().Be("init value");
+            inputs[1].GetAttribute("value").Should().Be("init value");
+        });
+
+        var immediateInput = comp.FindAll("input")[1];
+        await immediateInput.ChangeAsync(new ChangeEventArgs { Value = "changed value" });
+
+        await comp.WaitForAssertionAsync(() =>
+        {
+            var inputs = comp.FindAll("input");
+            inputs[0].GetAttribute("value").Should().Be("changed value");
+            inputs[1].GetAttribute("value").Should().Be("changed value");
+        }, TimeSpan.FromSeconds(1));
+    }
+}