+
@Row.Default
@@ -37,7 +37,7 @@
@if (!Row.Default.Equals(Row.Dark))
{
-
+
@Row.Dark
@@ -351,4 +351,4 @@
public string CSSVariable { get; set; }
public bool IsHeader { get; set; }
}
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.Docs/Pages/Customization/Globals/Examples/ButtonGlobalsExample.razor b/src/MudBlazor.Docs/Pages/Customization/Globals/Examples/ButtonGlobalsExample.razor
deleted file mode 100644
index 3bdd94bcd4c6..000000000000
--- a/src/MudBlazor.Docs/Pages/Customization/Globals/Examples/ButtonGlobalsExample.razor
+++ /dev/null
@@ -1,3 +0,0 @@
-๏ปฟ@namespace MudBlazor.Docs.Examples
-
- Button with new defaults
diff --git a/src/MudBlazor.Docs/Pages/Customization/Globals/Examples/ButtonGlobalsStartupExample.razor b/src/MudBlazor.Docs/Pages/Customization/Globals/Examples/ButtonGlobalsStartupExample.razor
deleted file mode 100644
index 88ffbfcea811..000000000000
--- a/src/MudBlazor.Docs/Pages/Customization/Globals/Examples/ButtonGlobalsStartupExample.razor
+++ /dev/null
@@ -1,9 +0,0 @@
-๏ปฟ@namespace MudBlazor.Docs.Examples
-
-// Add MudBlazor services
-Services.AddMudServices();
-
-// Change the default appearance of all MudButton components
-MudGlobal.ButtonDefaults.Color = Color.Secondary;
-MudGlobal.ButtonDefaults.Size = Size.Large;
-MudGlobal.ButtonDefaults.Variant = Variant.Filled;
diff --git a/src/MudBlazor.Docs/Pages/Customization/Globals/Globals.razor b/src/MudBlazor.Docs/Pages/Customization/Globals/Globals.razor
index 303428b369e9..db251c8e3faa 100644
--- a/src/MudBlazor.Docs/Pages/Customization/Globals/Globals.razor
+++ b/src/MudBlazor.Docs/Pages/Customization/Globals/Globals.razor
@@ -1,15 +1,14 @@
๏ปฟ@page "/customization/globals"
-
+
-
- Warning: This feature is currently under development.
-
-
- Breaking changes to the API may occur between releases.
- Please only use MudGlobal if you are prepared to adapt your code and provide feedback or contribute code .
+
+ EXPERIMENTAL:
+ This feature is under development and may not be ready for general use.
+ Breaking changes will occur between releases.
+ Use only if you are prepared to adapt your code and provide feedback or contribute to its development.
@@ -18,29 +17,26 @@
- The static class contains default settings which can override the default settings for MudBlazor components.
-
-
- The following example changes all components to use a large size, secondary color, and filled variant as their defaults.
-
-
- Note: Defaults should be set when your application initializes, such as when adding MudBlazor services.
+ You can find default setting overrides of some MudBlazor features in the static class.
+ These defaults should be set when your application initializes, such as when adding MudBlazor services.
+ If they are set after the app has started, they may not take effect until the next page load, or may not take effect at all.
+
+
+ Our theming system is recommended for changing the looks and style of your application.
+ To find more ways to customize your app, refer to our other documentation in the sidebar.
+
-
-
-
- A global exception handler is available via the MudGlobal.UnhandledExceptionHandler property.
+ You can handle MudBlazor component exceptions using MudGlobal.UnhandledExceptionHandler.
-
diff --git a/src/MudBlazor.Docs/Shared/Appbar.razor b/src/MudBlazor.Docs/Shared/Appbar.razor
index cb4462e9f895..a0638b45cbd8 100644
--- a/src/MudBlazor.Docs/Shared/Appbar.razor
+++ b/src/MudBlazor.Docs/Shared/Appbar.razor
@@ -92,7 +92,8 @@
+ ValueChanged="OnSearchResult" OpenChanged="o => _searchDialogAutocompleteOpen = o" ReturnedItemsCountChanged="c => _searchDialogReturnedItemsCount = c"
+ Modal="false">
@result.Title @result.SubTitle
diff --git a/src/MudBlazor.UnitTests.Docs/Generated/ApiDocsTests.cs b/src/MudBlazor.UnitTests.Docs/Generated/ApiDocsTests.cs
index 5ba1f3c0e353..ab78863413a4 100644
--- a/src/MudBlazor.UnitTests.Docs/Generated/ApiDocsTests.cs
+++ b/src/MudBlazor.UnitTests.Docs/Generated/ApiDocsTests.cs
@@ -38,6 +38,7 @@ public void Setup()
ctx.Services.AddSingleton();
ctx.Services.AddTransient();
ctx.Services.AddScoped();
+ ctx.Services.AddScoped();
ctx.Services.AddTransient();
ctx.Services.AddTransient();
ctx.Services.AddTransient();
diff --git a/src/MudBlazor.UnitTests.Docs/Generated/ExampleDocsTests.cs b/src/MudBlazor.UnitTests.Docs/Generated/ExampleDocsTests.cs
index 81a85deb4698..b5fafbb7c3c9 100644
--- a/src/MudBlazor.UnitTests.Docs/Generated/ExampleDocsTests.cs
+++ b/src/MudBlazor.UnitTests.Docs/Generated/ExampleDocsTests.cs
@@ -35,6 +35,7 @@ public void Setup()
ctx.Services.AddTransient();
ctx.Services.AddSingleton();
ctx.Services.AddScoped();
+ ctx.Services.AddScoped();
ctx.Services.AddTransient();
ctx.Services.AddTransient();
ctx.Services.AddTransient();
diff --git a/src/MudBlazor.UnitTests.Shared/Mocks/MockPointerEventsNoneService.cs b/src/MudBlazor.UnitTests.Shared/Mocks/MockPointerEventsNoneService.cs
new file mode 100644
index 000000000000..ffff14be9ee9
--- /dev/null
+++ b/src/MudBlazor.UnitTests.Shared/Mocks/MockPointerEventsNoneService.cs
@@ -0,0 +1,20 @@
+๏ปฟ// Copyright (c) MudBlazor 2021
+// MudBlazor licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace MudBlazor.UnitTests.Shared.Mocks;
+
+#nullable enable
+
+public class MockPointerEventsNoneService : IPointerEventsNoneService
+{
+ public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+
+ public Task SubscribeAsync(IPointerEventsNoneObserver observer, PointerEventsNoneOptions options) => Task.CompletedTask;
+
+ public Task SubscribeAsync(string elementId, PointerEventsNoneOptions options, IPointerDownObserver? pointerDown = null, IPointerUpObserver? pointerUp = null) => Task.CompletedTask;
+
+ public Task UnsubscribeAsync(IPointerEventsNoneObserver observer) => Task.CompletedTask;
+
+ public Task UnsubscribeAsync(string elementId) => Task.CompletedTask;
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridColumnGroupingTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridColumnGroupingTest.razor
index 4a36fae30175..4e6ba3996f66 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridColumnGroupingTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridColumnGroupingTest.razor
@@ -1,7 +1,7 @@
๏ปฟ
-
+
@@ -17,6 +17,8 @@
? "(None)" // Customize group name for null values otherwise would be empty group name
: x.Profession;
+ public bool IsNameGrouped { get; private set; } = true;
+
public bool IsGenderGrouped { get; private set; }
public bool IsAgeGrouped { get; private set; }
@@ -31,11 +33,29 @@
new("Alice", 32, "Female", "Cook")
];
- private void GroupByGender(MouseEventArgs args) => IsGenderGrouped = true;
-
- private void GroupByAge(MouseEventArgs args) => IsAgeGrouped = true;
-
- private void GroupByProfession(MouseEventArgs args) => IsProfessionGrouped = true;
+ private void GroupByGender(MouseEventArgs args)
+ {
+ IsNameGrouped = false;
+ IsProfessionGrouped = false;
+ IsAgeGrouped = false;
+ IsGenderGrouped = true;
+ }
+
+ private void GroupByAge(MouseEventArgs args)
+ {
+ IsNameGrouped = false;
+ IsProfessionGrouped = false;
+ IsAgeGrouped = true;
+ IsGenderGrouped = false;
+ }
+
+ private void GroupByProfession(MouseEventArgs args)
+ {
+ IsNameGrouped = false;
+ IsProfessionGrouped = true;
+ IsAgeGrouped = false;
+ IsGenderGrouped = false;
+ }
public record Model(string Name, int Age, string Gender, string? Profession);
}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupCollapseAllTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupCollapseAllTest.razor
index 41ec96f0b0a5..21110d147005 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupCollapseAllTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupCollapseAllTest.razor
@@ -1,4 +1,4 @@
- new TestObject(x.Name, x.Category)).ToList();
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
public record TestObject(string Name, string Category);
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandAllCollapseAllTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandAllCollapseAllTest.razor
index ef9f81346164..d91faf9d49d3 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandAllCollapseAllTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandAllCollapseAllTest.razor
@@ -1,4 +1,4 @@
- new Element(x.Group, x.Position, x.Name)).ToList();
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
public class Element(string group, int position, string name)
@@ -139,4 +139,4 @@
public string Group { get; set; } = group;
}
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedAsyncTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedAsyncTest.razor
index 375a8c413972..90644b3ce048 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedAsyncTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedAsyncTest.razor
@@ -1,4 +1,4 @@
-
Fruits
@@ -39,15 +39,15 @@
_fruits.Add(new Fruit("Banana", 5, "Musa"));
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
public record Fruit(string Name, int Count, string Category);
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseAsyncTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseAsyncTest.razor
index 8aab110089a7..f0d16995aaac 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseAsyncTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseAsyncTest.razor
@@ -40,15 +40,15 @@
_fruits.Add(new Fruit("Banana", 5, "Musa"));
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
public record Fruit(string Name, int Count, string Category);
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseServerDataTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseServerDataTest.razor
index 196ca80fc9d6..aa7e4e2bd9e2 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseServerDataTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseServerDataTest.razor
@@ -46,15 +46,15 @@
_fruits.Add(new Fruit("Banana", 5, "Musa"));
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
public record Fruit(string Name, int Count, string Category);
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseTest.razor
index cd7ed6c7d192..0e6e447c0638 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedFalseTest.razor
@@ -37,15 +37,15 @@
_fruits.Add(new Fruit("Banana", 5, "Musa"));
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
public record Fruit(string Name, int Count, string Category);
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedServerDataTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedServerDataTest.razor
index 0a251fea0714..a55530f6412e 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedServerDataTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedServerDataTest.razor
@@ -1,4 +1,4 @@
-
Fruits
@@ -48,15 +48,15 @@
_fruits.Add(new Fruit("Banana", 5, "Musa"));
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
public record Fruit(string Name, int Count, string Category);
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedTest.razor
index 24a404458fbb..e96e1dfbd56b 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupExpandedTest.razor
@@ -1,4 +1,4 @@
-
Fruits
@@ -38,14 +38,14 @@ GroupExpanded="true" RowContextMenuClick="@OnRowContextMenuClick">
_fruits.Add(new Fruit("Banana", 5, "Musa"));
}
- public void ExpandAllGroups()
+ public Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- public void CollapseAllGroups()
+ public Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
private void OnRowContextMenuClick(DataGridRowClickEventArgs args)
@@ -61,4 +61,4 @@ GroupExpanded="true" RowContextMenuClick="@OnRowContextMenuClick">
public string Category { get; set; } = category;
}
-}
\ No newline at end of file
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupingMultiLevelTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupingMultiLevelTest.razor
new file mode 100644
index 000000000000..eb88375c9738
--- /dev/null
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridGroupingMultiLevelTest.razor
@@ -0,0 +1,392 @@
+๏ปฟ@using MudBlazor.Utilities
+
+
+
+ US States Information2025
+
+
+
+
+
+
+
+
+
+ @if (_customizeGroupTemplate)
+ {
+ var color = context.Grouping.Key?.ToString() switch
+ {
+ "Healthcare" => Color.Primary,
+ "Tech" => Color.Secondary,
+ "Tourism" => Color.Info,
+ _ => Color.Dark
+ };
+
+
+ @context.Grouping.Key
+
+ @context.Grouping.Count() states
+
+
+ }
+ else
+ {
+ @context.Title: @(context.Grouping.Key)
+ }
+
+
+
+
+ @if (_customizeGroupTemplate)
+ {
+ var (icon, color) = context.Grouping.Key?.ToString() switch
+ {
+ "Northeast" or "Southeast" => (Icons.Material.Filled.East, Color.Warning),
+ "West" or "Pacific" => (Icons.Material.Filled.West, Color.Success),
+ "Midwest" => (Icons.Material.Filled.LocationOn, Color.Info),
+ "Southwest" => (Icons.Material.Filled.South, Color.Error),
+ _ => (Icons.Material.Filled.Public, Color.Default)
+ };
+
+
+ @context.Grouping.Key
+
+ @context.Grouping.Count() states
+
+
+ }
+ else
+ {
+ @context.Title: @(context.Grouping.Key)
+ }
+
+
+
+
+ @if (_customizeGroupTemplate)
+ {
+ var (icon, color) = context.Grouping.Key?.ToString() switch
+ {
+ "Continental" => (Icons.Material.Filled.AcUnit, Color.Primary),
+ "Humid Subtropical" => (Icons.Material.Filled.WbSunny, Color.Warning),
+ "Mediterranean" or "Tropical" => (Icons.Material.Filled.WaterDrop, Color.Info),
+ "Desert" or "Semi-arid" or "Arid" => (Icons.Material.Filled.Landscape, Color.Error),
+ _ => (Icons.Material.Filled.Cloud, Color.Default)
+ };
+
+
+ @context.Grouping.Key
+
+ @context.Grouping.Count() states
+
+
+ }
+ else
+ {
+ @context.Title: @(context.Grouping.Key)
+ }
+
+
+
+
+ @if (_customizeGroupTemplate)
+ {
+ Year Inducted: @context.Grouping.Key total @context.Grouping.Count()
+ }
+ else
+ {
+ @context.Title: @(context.Grouping.Key)
+ }
+
+
+
+
+
+
+ Customize Group Template
+ Customize Group By Industry
+ Customize Group Style
+ Expand All
+ Collapse All
+
+
+@code {
+#nullable enable
+ public static string __description__ = "Multi Level Grouping within DataGrid";
+ // For the Grid
+ private MudDataGrid _dataGrid = null!;
+ private string? _searchString = string.Empty;
+ // Bound Properties @bind-
+ private bool _customizeGroupTemplate;
+ private bool _customizeGroupBy;
+ private bool _customizeGroupStyle;
+ private bool _primaryIndustryGrouping = true;
+ private bool _regionGrouping;
+ private bool _climateGrouping = true;
+ private int _primaryIndustryOrder;
+ private int _climateOrder = 1;
+ private int _regionOrder = 2;
+ // Display Options
+ private bool _primaryIndustryExpanded = true;
+ private bool _regionExpanded = true;
+ private bool _climateExpanded = true;
+
+ // Primary grouping by industry type
+ private Func? _groupBy1;
+
+ protected override void OnInitialized()
+ {
+ _groupBy1 = x =>
+ {
+ if (_customizeGroupBy)
+ {
+ return x.PrimaryIndustry switch
+ {
+ "Healthcare" => "Health",
+ "Technology" => "Tech",
+ "Tourism" => "Vacay",
+ _ => "Other"
+ };
+ }
+
+ return x.PrimaryIndustry;
+ };
+ }
+
+ protected override void OnAfterRender(bool firstRender)
+ {
+ base.OnAfterRender(firstRender);
+
+ if (firstRender)
+ {
+ // Check if the dataGrid is grouped and update the state accordingly (for IsGrouped)
+ if (_dataGrid.IsGrouped == true)
+ {
+ StateHasChanged();
+ }
+ }
+ }
+
+ private async Task> ServerReload(GridState state)
+ {
+ // call API
+ var data = GetAllStates(_searchString, state.SortDefinitions);
+ // simulate some wait time
+ await Task.Delay(150);
+
+ var totalItems = data.Count;
+ var pagedData = data.Skip(state.Page * state.PageSize).Take(state.PageSize).ToArray();
+ return new()
+ {
+ TotalItems = totalItems,
+ Items = pagedData
+ };
+ }
+
+ private static string GroupClassFunc(GroupDefinition item)
+ {
+ var key = item.Grouping.Key?.ToString();
+
+ return item.Title switch
+ {
+ "Primary Industry" => key switch
+ {
+ "Healthcare" => "mud-theme-primary",
+ "Tech" => "mud-theme-secondary",
+ "Tourism" => "mud-theme-info",
+ _ => "mud-theme-dark"
+ },
+ "Region" => key switch
+ {
+ "Northeast" or "Southeast" => "mud-theme-warning",
+ "West" or "Pacific" => "mud-theme-success",
+ "Midwest" => "mud-theme-info",
+ "Southwest" => "mud-theme-error",
+ _ => string.Empty
+ },
+ _ => key switch
+ {
+ "Continental" => "mud-theme-primary",
+ "Humid Subtropical" => "mud-theme-warning",
+ "Mediterranean" or "Tropical" => "mud-theme-info",
+ "Desert" or "Semi-arid" or "Arid" => "mud-theme-error",
+ _ => string.Empty
+ }
+ };
+ }
+
+ private static string GroupStyleFunc(GroupDefinition item)
+ {
+ var indent = item.Level * 16; // 16px per level
+ var borderWidth = Math.Max(1, 4 - item.Level); // Decrease border width with depth
+
+ var style = new StyleBuilder()
+ .AddStyle("padding-left", $"{indent}px")
+ .AddStyle("border-left", $"{borderWidth}px solid")
+ .AddStyle("border-color", GetBorderColor(item))
+ .AddStyle("opacity", $"{1 - (item.Level - 1) * 0.2}") // Fade out deeper levels slightly
+ .Build();
+
+ return style;
+ }
+
+ private static string GetBorderColor(GroupDefinition item)
+ {
+ var key = item.Grouping.Key?.ToString();
+
+ return item.Title switch
+ {
+ // Primary level (Industry)
+ "Primary Industry" => key switch
+ {
+ "Healthcare" => "var(--mud-palette-primary)",
+ "Tech" => "var(--mud-palette-secondary)",
+ "Tourism" => "var(--mud-palette-info)",
+ _ => "var(--mud-palette-dark)"
+ },
+ "Region" => key switch
+ {
+ "Northeast" or "Southeast" => "var(--mud-palette-warning)",
+ "West" or "Pacific" => "var(--mud-palette-success)",
+ "Midwest" => "var(--mud-palette-info)",
+ "Southwest" => "var(--mud-palette-error)",
+ _ => "var(--mud-palette-dark)"
+ },
+ "Climate" => key switch
+ {
+ "Continental" => "var(--mud-palette-primary)",
+ "Humid Subtropical" => "var(--mud-palette-warning)",
+ "Mediterranean" or "Tropical" => "var(--mud-palette-info)",
+ "Desert" or "Semi-arid" or "Arid" => "var(--mud-palette-error)",
+ _ => "var(--mud-palette-dark)"
+ },
+ _ => "var(--mud-palette-dark)"
+ };
+ }
+
+ private Task ExpandAllGroupsAsync()
+ {
+ return _dataGrid.ExpandAllGroupsAsync();
+ }
+
+ private Task CollapseAllGroupsAsync()
+ {
+ return _dataGrid.CollapseAllGroupsAsync();
+ }
+
+ private void CustomizeByGroupChanged(bool isChecked)
+ {
+ _customizeGroupBy = isChecked;
+ _dataGrid.GroupItems();
+ }
+
+ private static List GetAllStates(string? searchString, ICollection>? sortDefinitions)
+ {
+ List data =
+ [
+ new USState(Id: 1, State: "Alabama", Counties: 67, Population: 5024279, PrimaryIndustry: "Manufacturing", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1819),
+ new USState(Id: 2, State: "Alaska", Counties: 30, Population: 733406, PrimaryIndustry: "Oil and Gas", Region: "Pacific", Climate: "Subarctic", YearInducted: 1959),
+ new USState(Id: 3, State: "Arizona", Counties: 15, Population: 7151502, PrimaryIndustry: "Healthcare", Region: "Southwest", Climate: "Desert", YearInducted: 1912),
+ new USState(Id: 4, State: "Arkansas", Counties: 75, Population: 3011524, PrimaryIndustry: "Agriculture", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1836),
+ new USState(Id: 5, State: "California", Counties: 58, Population: 39538223, PrimaryIndustry: "Technology", Region: "West", Climate: "Mediterranean", YearInducted: 1850),
+ new USState(Id: 6, State: "Colorado", Counties: 64, Population: 5773714, PrimaryIndustry: "Tourism", Region: "West", Climate: "Semi-arid", YearInducted: 1876),
+ new USState(Id: 7, State: "Connecticut", Counties: 8, Population: 3605944, PrimaryIndustry: "Finance and Insurance", Region: "Northeast", Climate: "Continental", YearInducted: 1788),
+ new USState(Id: 8, State: "Delaware", Counties: 3, Population: 989948, PrimaryIndustry: "Finance and Insurance", Region: "Northeast", Climate: "Continental", YearInducted: 1787),
+ new USState(Id: 9, State: "Florida", Counties: 67, Population: 21538187, PrimaryIndustry: "Tourism", Region: "Southeast", Climate: "Tropical", YearInducted: 1845),
+ new USState(Id: 10, State: "Georgia", Counties: 159, Population: 10711908, PrimaryIndustry: "Agriculture", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1788),
+ new USState(Id: 11, State: "Hawaii", Counties: 5, Population: 1455271, PrimaryIndustry: "Tourism", Region: "Pacific", Climate: "Tropical", YearInducted: 1959),
+ new USState(Id: 12, State: "Idaho", Counties: 44, Population: 1839106, PrimaryIndustry: "Agriculture", Region: "West", Climate: "Continental", YearInducted: 1890),
+ new USState(Id: 13, State: "Illinois", Counties: 102, Population: 12812508, PrimaryIndustry: "Manufacturing", Region: "Midwest", Climate: "Continental", YearInducted: 1818),
+ new USState(Id: 14, State: "Indiana", Counties: 92, Population: 6785528, PrimaryIndustry: "Manufacturing", Region: "Midwest", Climate: "Continental", YearInducted: 1816),
+ new USState(Id: 15, State: "Iowa", Counties: 99, Population: 3190369, PrimaryIndustry: "Agriculture", Region: "Midwest", Climate: "Continental", YearInducted: 1846),
+ new USState(Id: 16, State: "Kansas", Counties: 105, Population: 2937880, PrimaryIndustry: "Agriculture", Region: "Midwest", Climate: "Continental", YearInducted: 1861),
+ new USState(Id: 17, State: "Kentucky", Counties: 120, Population: 4505836, PrimaryIndustry: "Manufacturing", Region: "Southeast", Climate: "Humid Continental", YearInducted: 1792),
+ new USState(Id: 18, State: "Louisiana", Counties: 64, Population: 4657757, PrimaryIndustry: "Oil and Gas", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1812),
+ new USState(Id: 19, State: "Maine", Counties: 16, Population: 1362359, PrimaryIndustry: "Healthcare", Region: "Northeast", Climate: "Continental", YearInducted: 1820),
+ new USState(Id: 20, State: "Maryland", Counties: 24, Population: 6177224, PrimaryIndustry: "Healthcare", Region: "Northeast", Climate: "Continental", YearInducted: 1788),
+ new USState(Id: 21, State: "Massachusetts", Counties: 14, Population: 7029917, PrimaryIndustry: "Healthcare", Region: "Northeast", Climate: "Continental", YearInducted: 1788),
+ new USState(Id: 22, State: "Michigan", Counties: 83, Population: 10077331, PrimaryIndustry: "Manufacturing", Region: "Midwest", Climate: "Continental", YearInducted: 1837),
+ new USState(Id: 23, State: "Minnesota", Counties: 87, Population: 5706494, PrimaryIndustry: "Healthcare", Region: "Midwest", Climate: "Continental", YearInducted: 1858),
+ new USState(Id: 24, State: "Mississippi", Counties: 82, Population: 2961279, PrimaryIndustry: "Agriculture", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1817),
+ new USState(Id: 25, State: "Missouri", Counties: 115, Population: 6154913, PrimaryIndustry: "Healthcare", Region: "Midwest", Climate: "Continental", YearInducted: 1821),
+ new USState(Id: 26, State: "Montana", Counties: 56, Population: 1084225, PrimaryIndustry: "Agriculture", Region: "West", Climate: "Continental", YearInducted: 1889),
+ new USState(Id: 27, State: "Nebraska", Counties: 93, Population: 1961504, PrimaryIndustry: "Agriculture", Region: "Midwest", Climate: "Continental", YearInducted: 1867),
+ new USState(Id: 28, State: "Nevada", Counties: 17, Population: 3104614, PrimaryIndustry: "Tourism", Region: "West", Climate: "Desert", YearInducted: 1864),
+ new USState(Id: 29, State: "New Hampshire", Counties: 10, Population: 1377529, PrimaryIndustry: "Healthcare", Region: "Northeast", Climate: "Continental", YearInducted: 1788),
+ new USState(Id: 30, State: "New Jersey", Counties: 21, Population: 9288994, PrimaryIndustry: "Finance and Insurance", Region: "Northeast", Climate: "Continental", YearInducted: 1787),
+ new USState(Id: 31, State: "New Mexico", Counties: 33, Population: 2117522, PrimaryIndustry: "Oil and Gas", Region: "Southwest", Climate: "Arid", YearInducted: 1912),
+ new USState(Id: 32, State: "New York", Counties: 62, Population: 20201249, PrimaryIndustry: "Finance and Insurance", Region: "Northeast", Climate: "Continental", YearInducted: 1788),
+ new USState(Id: 33, State: "North Carolina", Counties: 100, Population: 10439388, PrimaryIndustry: "Manufacturing", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1789),
+ new USState(Id: 34, State: "North Dakota", Counties: 53, Population: 779094, PrimaryIndustry: "Agriculture", Region: "Midwest", Climate: "Continental", YearInducted: 1889),
+ new USState(Id: 35, State: "Ohio", Counties: 88, Population: 11799448, PrimaryIndustry: "Manufacturing", Region: "Midwest", Climate: "Continental", YearInducted: 1803),
+ new USState(Id: 36, State: "Oklahoma", Counties: 77, Population: 3959353, PrimaryIndustry: "Oil and Gas", Region: "Southwest", Climate: "Continental", YearInducted: 1907),
+ new USState(Id: 37, State: "Oregon", Counties: 36, Population: 4237256, PrimaryIndustry: "Technology", Region: "West", Climate: "Mediterranean", YearInducted: 1859),
+ new USState(Id: 38, State: "Pennsylvania", Counties: 67, Population: 13002700, PrimaryIndustry: "Healthcare", Region: "Northeast", Climate: "Continental", YearInducted: 1787),
+ new USState(Id: 39, State: "Rhode Island", Counties: 5, Population: 1097379, PrimaryIndustry: "Healthcare", Region: "Northeast", Climate: "Continental", YearInducted: 1790),
+ new USState(Id: 40, State: "South Carolina", Counties: 46, Population: 5118425, PrimaryIndustry: "Manufacturing", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1788),
+ new USState(Id: 41, State: "South Dakota", Counties: 66, Population: 886667, PrimaryIndustry: "Agriculture", Region: "Midwest", Climate: "Continental", YearInducted: 1889),
+ new USState(Id: 42, State: "Tennessee", Counties: 95, Population: 6910840, PrimaryIndustry: "Healthcare", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1796),
+ new USState(Id: 43, State: "Texas", Counties: 254, Population: 29145505, PrimaryIndustry: "Oil and Gas", Region: "Southwest", Climate: "Subtropical", YearInducted: 1845),
+ new USState(Id: 44, State: "Utah", Counties: 29, Population: 3271616, PrimaryIndustry: "Healthcare", Region: "West", Climate: "Semi-arid", YearInducted: 1896),
+ new USState(Id: 45, State: "Vermont", Counties: 14, Population: 643077, PrimaryIndustry: "Tourism", Region: "Northeast", Climate: "Continental", YearInducted: 1791),
+ new USState(Id: 46, State: "Virginia", Counties: 133, Population: 8631393, PrimaryIndustry: "Technology", Region: "Southeast", Climate: "Humid Subtropical", YearInducted: 1788),
+ new USState(Id: 47, State: "Washington", Counties: 39, Population: 7705281, PrimaryIndustry: "Technology", Region: "West", Climate: "Oceanic", YearInducted: 1889),
+ new USState(Id: 48, State: "West Virginia", Counties: 55, Population: 1793716, PrimaryIndustry: "Healthcare", Region: "Southeast", Climate: "Continental", YearInducted: 1863),
+ new USState(Id: 49, State: "Wisconsin", Counties: 72, Population: 5893718, PrimaryIndustry: "Manufacturing", Region: "Midwest", Climate: "Continental", YearInducted: 1848),
+ new USState(Id: 50, State: "Wyoming", Counties: 23, Population: 576851, PrimaryIndustry: "Mining", Region: "West", Climate: "Semi-arid", YearInducted: 1890)
+ ];
+
+ if (sortDefinitions != null && sortDefinitions.Any())
+ {
+ // on server or actual API would be IQueryable likely
+ IOrderedEnumerable? orderedQuery = null;
+ foreach (var sort in sortDefinitions)
+ {
+ orderedQuery = data.OrderByDirection(sort.Descending ? SortDirection.Descending : SortDirection.Ascending,
+ obj => GetPropertyValue(obj, sort.SortBy));
+ }
+ data = orderedQuery!.ToList();
+ }
+
+ return data.Where(x => MatchesSearch(x, searchString)).ToList();
+ }
+
+ private static bool MatchesSearch(USState obj, string? searchString)
+ {
+ if (string.IsNullOrEmpty(searchString))
+ {
+ return true;
+ }
+
+ return obj.State.Contains(searchString, StringComparison.OrdinalIgnoreCase) ||
+ obj.PrimaryIndustry.Contains(searchString, StringComparison.OrdinalIgnoreCase) ||
+ obj.YearInducted.ToString().Contains(searchString) ||
+ obj.Climate.Contains(searchString, StringComparison.OrdinalIgnoreCase) ||
+ obj.Region.Contains(searchString, StringComparison.OrdinalIgnoreCase);
+ }
+
+ private static object? GetPropertyValue(TT obj, string propertyName)
+ {
+ return typeof(TT).GetProperty(propertyName)?.GetValue(obj);
+ }
+
+ public record USState(int Id, string State, int Counties, int Population, string PrimaryIndustry, string Region, string Climate, int YearInducted);
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridHierarchyColumnTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridHierarchyColumnTest.razor
index c9a0ac2cd696..1e4146ce1b9b 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridHierarchyColumnTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridHierarchyColumnTest.razor
@@ -1,21 +1,34 @@
-๏ปฟ
+๏ปฟ
+
+
+
+
+
+
+
+
+
+ | @($"uid = {context.Item.Name}|{context.Item.Age}|{context.Item.Status}|{Guid.NewGuid()}") |
+
+
+
+
+Expand All
+Collapse All
+
+
+@code {
+ [Parameter]
+ public bool RightToLeft { get; set; }
-
-
-
-
-
-
-
-
-
- | @($"uid = {context.Item.Name}|{context.Item.Age}|{context.Item.Status}|{Guid.NewGuid()}") |
-
-
-
+ [Parameter]
+ public bool EnableHeaderToggle { get; set;}
-@code {
- private IEnumerable _items = new List()
+ [Parameter]
+ public bool ExpandSingleRow { get; set; }
+
+ private MudDataGrid _dataGrid = null!;
+ private readonly IEnumerable _items = new List
{
new Model("Sam", 56, Severity.Normal),
new Model("Alicia", 54, Severity.Info),
@@ -24,5 +37,15 @@
new Model("Anders", 24, Severity.Error)
};
+ private Task ExpandAll()
+ {
+ return _dataGrid.ExpandAllHierarchy();
+ }
+
+ private Task CollapseAll()
+ {
+ return _dataGrid.CollapseAllHierarchy();
+ }
+
public record Model (string Name, int Age, Severity Status);
}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridServerDataColumnGroupingTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridServerDataColumnGroupingTest.razor
index de1562e608bb..3514cc7e54c4 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridServerDataColumnGroupingTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridServerDataColumnGroupingTest.razor
@@ -70,14 +70,14 @@
_elements = await _periodicTableService.GetElements();
}
- private void ExpandAllGroups()
+ private Task ExpandAllGroups()
{
- _dataGrid.ExpandAllGroups();
+ return _dataGrid.ExpandAllGroupsAsync();
}
- private void CollapseAllGroups()
+ private Task CollapseAllGroups()
{
- _dataGrid.CollapseAllGroups();
+ return _dataGrid.CollapseAllGroupsAsync();
}
private void CustomizeByGroupChanged(bool isChecked)
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridUniqueRowKeyTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridUniqueRowKeyTest.razor
index bb8a8b680ff4..dd80cf08b7f0 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridUniqueRowKeyTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridUniqueRowKeyTest.razor
@@ -1,16 +1,17 @@
๏ปฟ
@* The input element will be tested to see if it gets recreated when row order changes. *@
-
+
-
+
-
+
@code {
+
[Parameter]
public bool Group { get; set; }
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Input/InputHeapLockedTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Input/InputHeapLockedTest.razor
new file mode 100644
index 000000000000..fffb51b5e5be
--- /dev/null
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Input/InputHeapLockedTest.razor
@@ -0,0 +1,45 @@
+๏ปฟ
+
+
+@code {
+ private bool _isLoading = false;
+
+ private readonly Dictionary _userAttributes = new Dictionary
+ {
+ { "autocomplete", "off" },
+ { "data-textfieldref", "ChatbotMessageTextField" }
+ };
+
+ private Task SendMessage(KeyboardEventArgs e) => Task.CompletedTask;
+
+ private void HandleKeyDown(KeyboardEventArgs e)
+ {
+ switch (e.Key)
+ {
+ case "Enter":
+ _isLoading = true;
+ break;
+ default:
+ if (e.Key.Length == 1) // Single character
+ {
+ StateHasChanged();
+ }
+ break;
+ }
+ }
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Menu/MenuEdgeCasesTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Menu/MenuEdgeCasesTest.razor
new file mode 100644
index 000000000000..174ec0d05568
--- /dev/null
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Menu/MenuEdgeCasesTest.razor
@@ -0,0 +1,179 @@
+๏ปฟ
+
+ Test Application
+
+
+ @{
+ var priority = "1";
+ switch (priority)
+ {
+ case "1":
+ Priority 1
+ break;
+ case "2":
+ Priority 2
+ break;
+ case "3":
+ Priority 3
+ break;
+ case "4":
+ Priority 4
+ break;
+ case "5":
+ Priority 5
+ break;
+ case null:
+ None
+ break;
+ }
+ }
+
+
+
+ Priority 1
+ Priority 2
+ Priority 3
+ Priority 4
+ Priority 5
+ None
+
+
+
+
+
+ @{
+ var priority = "1";
+ switch (priority)
+ {
+ case "1":
+ Priority 1
+ break;
+ case "2":
+ Priority 2
+ break;
+ case "3":
+ Priority 3
+ break;
+ case "4":
+ Priority 4
+ break;
+ case "5":
+ Priority 5
+ break;
+ case null:
+ None
+ break;
+ }
+ }
+
+
+
+ Priority 1
+ Priority 2
+ Priority 3
+ Priority 4
+ Priority 5
+ None
+
+
+
+
+
+ @* On initial load these don't respect the mouseover leave event only activating and not deactivating *@
+
+ @foreach (var menu in _menuList)
+ {
+
+
+ @($"Menu {menu}")
+
+
+
+
+
+
+
+
+
+ }
+
+
+
+ Click
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @{
+ var priority = "1";
+ switch (priority)
+ {
+ case "1":
+ Priority 1
+ break;
+ case "2":
+ Priority 2
+ break;
+ case "3":
+ Priority 3
+ break;
+ case "4":
+ Priority 4
+ break;
+ case "5":
+ Priority 5
+ break;
+ case null:
+ None
+ break;
+ }
+ }
+
+
+
+ Priority 1
+ Priority 2
+ Priority 3
+ Priority 4
+ Priority 5
+ None
+
+
+
+
+
+
+@code {
+ public static string __description__ = "4 menu edge cases for visual testing, initial load, in appbar, nested, and in dialog.";
+ private readonly string[] _menuList = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];
+ private bool _visible;
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Popover/PopoverFlipDirectionTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Popover/PopoverFlipDirectionTest.razor
new file mode 100644
index 000000000000..d4efc91780ba
--- /dev/null
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Popover/PopoverFlipDirectionTest.razor
@@ -0,0 +1,115 @@
+๏ปฟ
+
+ @(_expanded ? "Collapse" : "Expand")
+ @(_expanded ? "Collapse" : "Expand") for 5 s
+ Expand list in 5 s
+
+
+
+
+
+
+ Top Left
+ Top Center
+ Top Right
+ Bottom Left
+ Bottom Center
+ Bottom Right
+ Center Left
+ Center Center
+ Center Right
+
+
+ Top Left
+ Top Center
+ Top Right
+ Bottom Left
+ Bottom Center
+ Bottom Right
+ Center Left
+ Center Center
+ Center Right
+
+
+
+
+
+
+
+
+
+
+
+
+ @if (_expandList)
+ {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+
+ @if (!_hideBottom)
+ {
+ @(_expanded ? "Collapse" : "Expand")
+ @(_expanded ? "Collapse" : "Expand") for 5 s
+
+
+
+
+
+
+ }
+
+@code {
+ public static string __description__ = "Popover should take the best available space";
+
+ private bool _hideBottom;
+ private bool _expandList;
+ private bool _expanded = true;
+ private int _height = 600;
+ private int _heightBottom = 400;
+ private Origin _anchor = Origin.BottomLeft;
+ private Origin _transform = Origin.TopLeft;
+
+ private readonly DropdownSettings _dropdownSettings = new()
+ {
+ OverflowBehavior = OverflowBehavior.FlipAlways
+ };
+
+ private void OnExpandCollapseClick() => _expanded = !_expanded;
+
+ private async Task OnExpandCollapseFor5sClickAsync()
+ {
+ var expanded = _expanded;
+ _expanded = !expanded;
+ await Task.Delay(5000);
+ _expanded = expanded;
+ }
+
+ private async Task OnExpandListIn5sAsync()
+ {
+ _expandList = false;
+ await Task.Delay(5000);
+ _expandList = true;
+ }
+}
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Tooltip/TooltipNotRemovedTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Tooltip/TooltipNotRemovedTest.razor
new file mode 100644
index 000000000000..a675c8aaf52a
--- /dev/null
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Tooltip/TooltipNotRemovedTest.razor
@@ -0,0 +1,35 @@
+๏ปฟ
+ @for (var i = 0; i < 200; i++)
+ {
+
+ @{
+ var current = i;
+ }
+
+ BTN @current
+
+
+ }
+
+
+@code
+{
+ private Guid _key;
+
+ protected override Task OnInitializedAsync()
+ {
+ var cts = new CancellationTokenSource();
+ RunThingAsync(cts.Token).CatchAndLog();
+ return base.OnInitializedAsync();
+ }
+
+ private async Task RunThingAsync(CancellationToken cancellationToken)
+ {
+ while (!cancellationToken.IsCancellationRequested)
+ {
+ _key = Guid.NewGuid();
+ InvokeAsync(StateHasChanged).CatchAndLog();
+ await Task.Delay(100, cancellationToken);
+ }
+ }
+}
diff --git a/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs b/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs
index f55ad21931b6..eca2b66399b0 100644
--- a/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs
+++ b/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs
@@ -1853,6 +1853,75 @@ public void RequiredAndAriaRequiredAutocompleteAttributes_Should_BeDynamic()
comp.Find("input").GetAttribute("aria-required").Should().Be("true");
}
+ ///
+ /// Ensure selecting an option does not reopen the list.
+ ///
+ [Test]
+ public void Autocomplete_SelectingOption_ShouldNot_ReopenList()
+ {
+ var comp = Context.RenderComponent();
+ var autocompleteComponent = comp.FindComponent>();
+ var autocomplete = autocompleteComponent.Instance;
+
+ // Open the menu
+ autocompleteComponent.Find("div.mud-input-control").Focus();
+ comp.WaitForAssertion(() => comp.Find("div.mud-popover").ClassList.Should().Contain("mud-popover-open"));
+
+ // Select an option
+ comp.Find("div.mud-list-item").Click();
+
+ // Assert: Menu should remain closed
+ comp.WaitForAssertion(() => comp.Find("div.mud-popover").ClassList.Should().NotContain("mud-popover-open"));
+ }
+
+ ///
+ /// Ensure the menu does not open in read-only mode.
+ ///
+ [Test]
+ public void Autocomplete_User_ShouldNot_OpenMenu_InReadOnlyMode()
+ {
+ var comp = Context.RenderComponent>(parameters => parameters
+ .Add(p => p.ReadOnly, true)
+ .Add(p => p.OpenOnFocus, true));
+ var autocomplete = comp.Instance;
+
+ // Attempt to open the menu via focus
+ comp.Find("div.mud-input-control").Focus();
+
+ // Assert: Menu should not open
+ comp.WaitForAssertion(() => autocomplete.Open.Should().BeFalse());
+
+ // Attempt to open the menu via click
+ comp.Find("div.mud-input-control").MouseDown();
+
+ // Assert: Menu should not open
+ comp.WaitForAssertion(() => autocomplete.Open.Should().BeFalse());
+ }
+
+ ///
+ /// Ensure the menu does not open in disabled mode.
+ ///
+ [Test]
+ public void Autocomplete_User_ShouldNot_OpenMenu_InDisabledMode()
+ {
+ var comp = Context.RenderComponent>(parameters => parameters
+ .Add(p => p.Disabled, true)
+ .Add(p => p.OpenOnFocus, true));
+ var autocomplete = comp.Instance;
+
+ // Attempt to open the menu via focus
+ comp.Find("div.mud-input-control").Focus();
+
+ // Assert: Menu should not open
+ comp.WaitForAssertion(() => autocomplete.Open.Should().BeFalse());
+
+ // Attempt to open the menu via click
+ comp.Find("div.mud-input-control").MouseDown();
+
+ // Assert: Menu should not open
+ comp.WaitForAssertion(() => autocomplete.Open.Should().BeFalse());
+ }
+
///
/// Ensure that the ItemDisabledTemplate and ItemSelectedTemplate both can display when ItemTemplate isn't provided (null)
///
diff --git a/src/MudBlazor.UnitTests/Components/ChartTests.cs b/src/MudBlazor.UnitTests/Components/ChartTests.cs
index f83331f8ac57..4b9b1411367a 100644
--- a/src/MudBlazor.UnitTests/Components/ChartTests.cs
+++ b/src/MudBlazor.UnitTests/Components/ChartTests.cs
@@ -63,9 +63,18 @@ public void BarChartSelectionTest()
var comp = Context.RenderComponent();
// print the generated html
comp.Find("h6").InnerHtml.Trim().Should().Be("Selected portion of the chart: -1");
+
+ //check tooltip
+ comp.FindAll("path.mud-chart-bar")[0].MouseOver();
+ comp.Find("tspan").InnerHtml.Trim().Should().Be("40");
+
// now click something and see that the selected index changes:
comp.FindAll("path.mud-chart-bar")[0].Click();
comp.Find("h6").InnerHtml.Trim().Should().Be("Selected portion of the chart: 0");
+
+ comp.FindAll("path.mud-chart-bar")[10].MouseOver();
+ comp.Find("tspan").InnerHtml.Trim().Should().Be("24");
+
comp.FindAll("path.mud-chart-bar")[10].Click();
comp.Find("h6").InnerHtml.Trim().Should().Be("Selected portion of the chart: 1");
}
diff --git a/src/MudBlazor.UnitTests/Components/DataGridGroupingTests.cs b/src/MudBlazor.UnitTests/Components/DataGridGroupingTests.cs
new file mode 100644
index 000000000000..d9613c4de469
--- /dev/null
+++ b/src/MudBlazor.UnitTests/Components/DataGridGroupingTests.cs
@@ -0,0 +1,544 @@
+๏ปฟ// Copyright (c) MudBlazor 2021
+// MudBlazor licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using AngleSharp.Dom;
+using Bunit;
+using FluentAssertions;
+using MudBlazor.UnitTests.TestComponents.DataGrid;
+using NUnit.Framework;
+
+#nullable enable
+namespace MudBlazor.UnitTests.Components
+{
+ public class DataGridGroupingTests : BunitTest
+ {
+ [Test]
+ public async Task DataGridGroupExpandedTrueTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+ // until a change happens this bool tracks whether GroupExpanded is applied.
+ dataGrid.Instance._groupInitialExpanded = true;
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(7);
+ await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroupsAsync());
+ // collapsing group rows counts
+ dataGrid.Instance._groupInitialExpanded = false;
+ dataGrid.Render();
+ // after all groups are collapsed
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
+ await comp.InvokeAsync(() =>
+ comp.Instance.AddFruit());
+ // datagrid should not be expanded with the new category since CollapseAll collapsed it (Even if it was empty)
+ dataGrid.Render();
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(3);
+ }
+
+ [Test]
+ public async Task DataGridGroupExpandedTrueAsyncTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
+ await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroupsAsync());
+ dataGrid.Render();
+ // after all groups are collapsed
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
+ await comp.InvokeAsync(() =>
+ comp.Instance.AddFruit());
+ // datagrid should not be expanded with the new category since CollapseAll collapsed it (Even if it was empty)
+ dataGrid.Render();
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(3));
+ }
+
+ [Test]
+ public async Task DataGridGroupExpandedTrueServerDataTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
+ await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroupsAsync());
+ dataGrid.Render();
+ // after all groups are collapsed
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
+ await comp.InvokeAsync(() => comp.Instance.AddFruit());
+ // datagrid should not be expanded with the new category since CollapseAll collapsed it (Even if it was empty)
+ dataGrid.Render();
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(3));
+ }
+
+ [Test]
+ public async Task DataGridGroupExpandedFalseTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
+ dataGrid.Render();
+ // after all groups are expanded
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(7);
+ await comp.InvokeAsync(() =>
+ comp.Instance.AddFruit());
+ // datagrid should not be collapsed with the new category since ExpandAll expanded it (Even if it was empty)
+ dataGrid.Render();
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(10);
+ }
+
+ [Test]
+ public async Task DataGridGroupExpandedFalseAsyncTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
+ dataGrid.Render();
+ // after all groups are expanded
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
+ await comp.InvokeAsync(() =>
+ comp.Instance.AddFruit());
+ // datagrid should not be collapsed with the new category since ExpandAll expanded it (Even if it was empty)
+ dataGrid.Render();
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(10));
+ }
+
+ [Test]
+ public async Task DataGridGroupExpandedFalseServerDataTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
+ dataGrid.Render();
+ // after all groups are expanded
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
+ await comp.InvokeAsync(() => comp.Instance.AddFruit());
+ // datagrid should not be collapsed with the new category since ExpandAll expanded it (Even if it was empty)
+ dataGrid.Render();
+ comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(10));
+ }
+
+ [Test]
+ public async Task DataGridGroupCollapseAllTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(3);
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
+ comp.Render();
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(15);
+ await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroupsAsync());
+ comp.Render();
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(3);
+ comp.Instance.RefreshList();
+ comp.Render();
+ // after all groups are expanded
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(3);
+ }
+
+ [Test]
+ public async Task DataGridGroupExpandAllCollapseAllTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
+ comp.Render();
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(14);
+ await dataGrid.InvokeAsync(() => dataGrid.Instance.NavigateTo(Page.First));
+ await dataGrid.InvokeAsync(() => dataGrid.Instance.NavigateTo(Page.Next));
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(18);
+ await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroupsAsync());
+ await dataGrid.InvokeAsync(() => dataGrid.Instance.NavigateTo(Page.First));
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
+ comp.Instance.RefreshList();
+ comp.Render();
+ comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
+ }
+
+
+ [Test]
+ public void ShouldSetIsGenderGroupedToTrueWhenGroupingIsApplied()
+ {
+ // Render the DataGridGroupingTest component for testing.
+ var comp = Context.RenderComponent();
+
+ // Attempt to find the MudPopoverProvider component within the rendered component.
+ // MudPopoverProvider is used to manage popovers in the component, including the grouping popover.
+ var popoverProvider = comp.FindComponent();
+
+ // Assert that initially, before any user interaction, IsGenderGrouped should be false.
+ comp.Instance.IsGenderGrouped.Should().Be(false);
+
+ // Find the button within the 'th' element with class 'gender' that triggers the popover for grouping.
+ var genderHeaderOption = comp.Find("th.gender .mud-menu button");
+
+ // Simulate a click on the gender header group button to open the popover with grouping options.
+ genderHeaderOption.Click();
+
+ // Find all MudListItem components within the popoverProvider.
+ // These list items represent the individual options within the grouping popover.
+ var listItems = popoverProvider.FindComponents();
+
+ // Assert that there are exactly 2 list items (options) available in the popover.
+ listItems.Count.Should().Be(2);
+
+ // From the list items found, select the second one which is expected to be the clickable option for grouping.
+ var clickablePopover = listItems[1].Find(".mud-menu-item");
+
+ // click on the grouping option to apply grouping to the data grid.
+ clickablePopover.Click();
+
+ // After clicking the grouping option, assert that IsGenderGrouped is now true, indicating that
+ // the action of applying grouping has successfully updated the component's state.
+ comp.Instance.IsGenderGrouped.Should().Be(true);
+ }
+
+ [Test]
+ [SetCulture("en-US")]
+ public void DataGridServerGroupUngroupingTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+ var popoverProvider = comp.FindComponent();
+
+ //ungroup Category
+ var headerCategory = comp.Find("th.group .mud-menu button");
+ headerCategory.Click();
+ var catListItems = popoverProvider.FindComponents();
+ catListItems.Count.Should().Be(4);
+ var clickableCategoryUngroup = catListItems[3].Find(".mud-menu-item");
+ clickableCategoryUngroup.Click();
+
+ //click name grouping in grid
+ var headerOption = comp.Find("th.name .mud-menu button");
+ headerOption.Click();
+ var listItems = popoverProvider.FindComponents();
+ listItems.Count.Should().Be(4);
+ var clickablePopover = listItems[3].Find(".mud-menu-item");
+ clickablePopover.Click();
+ var cells = dataGrid.FindAll("td");
+
+ //checking cell content is the most reliable way to verify grouping
+ cells[0].TextContent.Should().Be("Name: Hydrogen");
+ cells[1].TextContent.Should().Be("Name: Helium");
+ cells[2].TextContent.Should().Be("Name: Lithium");
+ cells[3].TextContent.Should().Be("Name: Beryllium");
+ cells[4].TextContent.Should().Be("Name: Boron");
+ cells[5].TextContent.Should().Be("Name: Carbon");
+ cells[6].TextContent.Should().Be("Name: Nitrogen");
+ cells[7].TextContent.Should().Be("Name: Oxygen");
+ cells[8].TextContent.Should().Be("Name: Fluorine");
+ cells[9].TextContent.Should().Be("Name: Neon");
+ dataGrid.Instance.IsGrouped.Should().BeTrue();
+
+ //click name ungrouping in grid
+ headerOption = comp.Find("th.name .mud-menu button");
+ headerOption.Click();
+ listItems = popoverProvider.FindComponents();
+ listItems.Count.Should().Be(4);
+ clickablePopover = listItems[3].Find(".mud-menu-item");
+ clickablePopover.Click();
+ cells = dataGrid.FindAll("td");
+ // We do not need check all 10 rows as it's clear that it's ungrouped if first row pass
+ cells[0].TextContent.Should().Be("1");
+ cells[1].TextContent.Should().Be("H");
+ cells[2].TextContent.Should().Be("Hydrogen");
+ cells[3].TextContent.Should().Be("0");
+ cells[4].TextContent.Should().Be("1.00794");
+ cells[5].TextContent.Should().Be("Other");
+ dataGrid.Instance.IsGrouped.Should().BeFalse();
+ }
+
+ [Test]
+ public void DataGridGroupingTestBoundAndUnboundScenarios()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+ var popoverProvider = comp.FindComponent();
+
+ IRefreshableElementCollection Rows() => dataGrid.FindAll("tr");
+ IRefreshableElementCollection Cells() => dataGrid.FindAll("td");
+
+ // Assert that initially, before any user interaction, IsGenderGrouped and IsAgeGrouped should be false
+ // The default grouping is by name
+ comp.Instance.IsGenderGrouped.Should().Be(false);
+ comp.Instance.IsAgeGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(false);
+
+ var nameCells = Cells();
+ nameCells.Count.Should().Be(4, because: "4 data rows");
+ nameCells[0].TextContent.Should().Be("Name: John");
+ nameCells[1].TextContent.Should().Be("Name: Johanna");
+ nameCells[2].TextContent.Should().Be("Name: Steve");
+ nameCells[3].TextContent.Should().Be("Name: Alice");
+ Rows().Count.Should().Be(6, because: "1 header row + 4 data rows + 1 footer row");
+
+ var ageGrouping = comp.Find(".GroupByAge");
+ ageGrouping.Click();
+ comp.Instance.IsAgeGrouped.Should().Be(true);
+ comp.Instance.IsGenderGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(false);
+ var ageCells = Cells();
+ ageCells.Count.Should().Be(3, because: "3 data rows");
+ ageCells[0].TextContent.Should().Be("Age: 45");
+ ageCells[1].TextContent.Should().Be("Age: 23");
+ ageCells[2].TextContent.Should().Be("Age: 32");
+ Rows().Count.Should().Be(5, because: "1 header row + 3 data rows + 1 footer row");
+
+ var genderGrouping = comp.Find(".GroupByGender");
+ genderGrouping.Click();
+ comp.Instance.IsGenderGrouped.Should().Be(true);
+ comp.Instance.IsAgeGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(false);
+ var genderCells = Cells();
+ genderCells.Count.Should().Be(2, because: "2 data rows");
+ genderCells[0].TextContent.Should().Be("Gender: Male");
+ genderCells[1].TextContent.Should().Be("Gender: Female");
+ Rows().Count.Should().Be(4, because: "1 header row + 2 data rows + 1 footer row");
+
+ var professionGrouping = comp.Find(".GroupByProfession");
+ professionGrouping.Click();
+ comp.Instance.IsGenderGrouped.Should().Be(false);
+ comp.Instance.IsAgeGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(true);
+ var professionCells = Cells();
+ professionCells.Count.Should().Be(2, because: "2 data rows");
+ professionCells[0].TextContent.Should().Be("Profession: Cook");
+ professionCells[1].TextContent.Should().Be("Profession: (None)");
+ Rows().Count.Should().Be(4, because: "1 header row + 2 data rows + 1 footer row");
+
+ //click age grouping in grid
+ var headerOption = comp.Find("th.age .mud-menu button");
+ headerOption.Click();
+ var listItems = popoverProvider.FindComponents();
+ listItems.Count.Should().Be(2);
+ var clickablePopover = listItems[1].Find(".mud-menu-item");
+ clickablePopover.Click();
+ comp.Instance.IsAgeGrouped.Should().Be(false);
+ comp.Instance.IsGenderGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(true);
+ Rows().Count.Should().Be(5, because: "1 header row + 3 data rows + 1 footer row");
+
+ //click gender grouping in grid
+ headerOption = comp.Find("th.gender .mud-menu button");
+ headerOption.Click();
+ listItems = popoverProvider.FindComponents();
+ listItems.Count.Should().Be(2);
+ clickablePopover = listItems[1].Find(".mud-menu-item");
+ clickablePopover.Click();
+ comp.Instance.IsGenderGrouped.Should().Be(true);
+ comp.Instance.IsAgeGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(true);
+ Rows().Count.Should().Be(5, because: "1 header row + 3 data rows + 1 footer row");
+
+ //click Name grouping in grid
+ headerOption = comp.Find("th.name .mud-menu button");
+ headerOption.Click();
+ listItems = popoverProvider.FindComponents();
+ listItems.Count.Should().Be(2);
+ clickablePopover = listItems[1].Find(".mud-menu-item");
+ clickablePopover.Click();
+ comp.Instance.IsGenderGrouped.Should().Be(true);
+ comp.Instance.IsAgeGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(true);
+ Rows().Count.Should().Be(6, because: "1 header row + 4 data rows + 1 footer row");
+
+ //click profession grouping in grid
+ headerOption = comp.Find("th.profession .mud-menu button");
+ headerOption.Click();
+ listItems = popoverProvider.FindComponents();
+ listItems.Count.Should().Be(2);
+ clickablePopover = listItems[1].Find(".mud-menu-item");
+ clickablePopover.Click();
+ comp.Instance.IsGenderGrouped.Should().Be(true);
+ comp.Instance.IsAgeGrouped.Should().Be(false);
+ comp.Instance.IsProfessionGrouped.Should().Be(false);
+ Rows().Count.Should().Be(6, because: "1 header row + 4 data rows + 1 footer row");
+ }
+
+
+ [Test]
+ public async Task DataGridGroupedWithServerDataPaginationTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+ var rows = dataGrid.FindAll("tr");
+ rows.Count.Should().Be(12, because: "1 header row + 10 data rows + 1 footer row");
+ var cells = dataGrid.FindAll("td");
+ cells.Count.Should().Be(10, because: "We have 10 data rows with one group collapsed");
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
+ rows = dataGrid.FindAll("tr");
+ rows.Count.Should().Be(32, because: "1 header row + 10 data rows + 1 footer row + 10 group rows + 10 footer group rows");
+ cells = dataGrid.FindAll("td");
+ cells.Count.Should().Be(30, because: "We have 10 data rows with one group + 10*2 cells inside groups");
+ //check cells
+ cells[0].TextContent.Should().Be("Number: 1");
+ cells[1].TextContent.Should().Be("Hydrogen"); cells[2].TextContent.Should().Be("1");
+ cells[3].TextContent.Should().Be("Number: 2");
+ cells[4].TextContent.Should().Be("Helium"); cells[5].TextContent.Should().Be("2");
+ cells[6].TextContent.Should().Be("Number: 3");
+ cells[7].TextContent.Should().Be("Lithium"); cells[8].TextContent.Should().Be("3");
+ cells[9].TextContent.Should().Be("Number: 4");
+ cells[10].TextContent.Should().Be("Beryllium"); cells[11].TextContent.Should().Be("4");
+ cells[12].TextContent.Should().Be("Number: 5");
+ cells[13].TextContent.Should().Be("Boron"); cells[14].TextContent.Should().Be("5");
+ cells[15].TextContent.Should().Be("Number: 6");
+ cells[16].TextContent.Should().Be("Carbon"); cells[17].TextContent.Should().Be("6");
+ cells[18].TextContent.Should().Be("Number: 7");
+ cells[19].TextContent.Should().Be("Nitrogen"); cells[20].TextContent.Should().Be("7");
+ cells[21].TextContent.Should().Be("Number: 8");
+ cells[22].TextContent.Should().Be("Oxygen"); cells[23].TextContent.Should().Be("8");
+ cells[24].TextContent.Should().Be("Number: 9");
+ cells[25].TextContent.Should().Be("Fluorine"); cells[26].TextContent.Should().Be("9");
+ cells[27].TextContent.Should().Be("Number: 10");
+ cells[28].TextContent.Should().Be("Neon"); cells[29].TextContent.Should().Be("10");
+ //get next page
+ await comp.InvokeAsync(() => dataGrid.Instance.NavigateTo(Page.Next));
+ comp.Render();
+ await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroupsAsync());
+ cells = dataGrid.FindAll("td");
+ cells.Count.Should().Be(10, because: "We have 10 data rows with one group collapsed from next page");
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
+ cells = dataGrid.FindAll("td");
+ cells.Count.Should().Be(30, because: "We have next 10 data rows with one group + 10*2 cells inside groups");
+ //cells should have data from next page
+ cells[0].TextContent.Should().Be("Number: 11");
+ cells[1].TextContent.Should().Be("Sodium"); cells[2].TextContent.Should().Be("11");
+ cells[3].TextContent.Should().Be("Number: 12");
+ cells[4].TextContent.Should().Be("Magnesium"); cells[5].TextContent.Should().Be("12");
+ cells[6].TextContent.Should().Be("Number: 13");
+ cells[7].TextContent.Should().Be("Aluminium"); cells[8].TextContent.Should().Be("13");
+ cells[9].TextContent.Should().Be("Number: 14");
+ cells[10].TextContent.Should().Be("Silicon"); cells[11].TextContent.Should().Be("14");
+ cells[12].TextContent.Should().Be("Number: 15");
+ cells[13].TextContent.Should().Be("Phosphorus"); cells[14].TextContent.Should().Be("15");
+ cells[15].TextContent.Should().Be("Number: 16");
+ cells[16].TextContent.Should().Be("Sulfur"); cells[17].TextContent.Should().Be("16");
+ cells[18].TextContent.Should().Be("Number: 17");
+ cells[19].TextContent.Should().Be("Chlorine"); cells[20].TextContent.Should().Be("17");
+ cells[21].TextContent.Should().Be("Number: 18");
+ cells[22].TextContent.Should().Be("Argon"); cells[23].TextContent.Should().Be("18");
+ cells[24].TextContent.Should().Be("Number: 19");
+ cells[25].TextContent.Should().Be("Potassium"); cells[26].TextContent.Should().Be("19");
+ cells[27].TextContent.Should().Be("Number: 20");
+ cells[28].TextContent.Should().Be("Calcium"); cells[29].TextContent.Should().Be("20");
+ }
+
+ [Test]
+ [TestCase(true, true)]
+ [TestCase(true, false)]
+ [TestCase(false, true)]
+ [TestCase(false, false)]
+ public void TestRtlGroupIconMethod(bool isRightToLeft, bool isExpanded)
+ {
+ var test = new MudDataGrid();
+ if (isExpanded)
+ {
+ test.GetGroupIcon(isExpanded, isRightToLeft).Should().Be(Icons.Material.Filled.ExpandMore);
+ }
+ else
+ {
+ test.GetGroupIcon(isExpanded, isRightToLeft).Should().Be(isRightToLeft ? Icons.Material.Filled.ChevronLeft : Icons.Material.Filled.ChevronRight);
+ }
+ }
+
+ [Test]
+ public async Task GroupExpandClick_ShouldToggleExpandedState()
+ {
+ // Arrange
+ var component = Context.RenderComponent();
+
+ var dataGrid = component.FindComponent>();
+ await component.InvokeAsync(() => dataGrid.Instance.ReloadServerData());
+
+ var rows = component.FindComponents>();
+ rows.Count.Should().Be(15);
+ var row = rows[0];
+ // Test the method
+ // Act
+ void GetCount(bool currExpanded)
+ {
+ var defaultExpanded = row.Instance.GroupDefinition.Expanded;
+ // Whatever the expanded state is if it differs from the default it should be in the dictionary
+ dataGrid.Instance._groupExpansionsDict.Count.Should().Be(currExpanded != defaultExpanded ? 1 : 0);
+ }
+
+ // Test the UI
+ var expandButton = () => row.Find(".mud-datagrid-group-button");
+ expandButton.Should().NotBeNull();
+ expandButton().Click();
+
+ row.WaitForAssertion(() => row.Instance._expanded.Should().BeFalse());
+ row.WaitForAssertion(() => GetCount(false));
+ expandButton().Click();
+
+ row.WaitForAssertion(() => row.Instance._expanded.Should().BeTrue());
+ row.WaitForAssertion(() => GetCount(true));
+ }
+
+ [Test]
+ public async Task DataGrid_Grouping_TestGroupableSets()
+ {
+ var component = Context.RenderComponent();
+
+ var dataGrid = component.FindComponent>();
+ // by default has a groupdefinition
+ dataGrid.WaitForAssertion(() => dataGrid.Instance._groupDefinition.Should().NotBeNull());
+ // turn off grouping for the whole grid
+ dataGrid.SetParam(x => x.Groupable, false);
+ dataGrid.Render();
+ await component.InvokeAsync(() => dataGrid.Instance.ReloadServerData());
+
+ // grouping shouldn't exist
+ dataGrid.Instance._groupDefinition.Should().BeNull();
+ foreach (var column in dataGrid.Instance.RenderedColumns)
+ {
+ column.GroupingState.Value.Should().Be(false);
+ }
+
+ // no grouping rows
+ var rows = component.FindComponents>();
+ rows.Count.Should().Be(0);
+ }
+
+ [Test]
+ public async Task DataGrid_Grouping_GroupDefinition()
+ {
+ var component = Context.RenderComponent();
+
+ var dataGrid = component.FindComponent>();
+ await component.InvokeAsync(() => dataGrid.Instance.ReloadServerData());
+ // grouping is already setup make sure group definition is not null and it's first inner definition is not null
+ dataGrid.WaitForAssertion(() => dataGrid.Instance._groupDefinition.Should().NotBeNull());
+ dataGrid.Instance._groupDefinition.InnerGroup.Should().NotBeNull();
+ dataGrid.Instance._groupDefinition.Grouping.Should().BeNullOrEmpty();
+ // _groupDefinition is the definition for all the groups but isn't combined into the items until display so we need to
+ // check the final definitions from within the DataGridGroupRow
+
+ var rows = component.FindComponents>();
+ rows.Count.Should().Be(15);
+ var row = rows[0];
+
+ // Only One Manufacturing Primary Industry
+ row.Instance.GroupDefinition.Title.Should().Be("Primary Industry");
+ row.Instance.GroupDefinition.Grouping.Key.Should().Be("Manufacturing");
+ row.Instance.Items.Should().NotBeNull();
+ row.Instance.Items.Count().Should().Be(1);
+ // Agriculture should have 2 items
+ row = rows[6];
+ row.Instance.Items.Should().NotBeNull();
+ row.Instance.Items.Count().Should().Be(2);
+ // the next row is a sub group of Agriculture and should also have 2 items
+ row = rows[7];
+ row.Instance.Items.Should().NotBeNull();
+ row.Instance.Items.Count().Should().Be(2);
+ }
+ }
+}
diff --git a/src/MudBlazor.UnitTests/Components/DataGridTests.cs b/src/MudBlazor.UnitTests/Components/DataGridTests.cs
index 3e07b0a7750d..02f5082b1da5 100644
--- a/src/MudBlazor.UnitTests/Components/DataGridTests.cs
+++ b/src/MudBlazor.UnitTests/Components/DataGridTests.cs
@@ -2939,6 +2939,44 @@ public void DataGridRowDetailClosedTest()
dataGrid.FindAll("td").SingleOrDefault(x => x.TextContent.Trim().StartsWith("uid = Sam|56|Normal|")).Should().BeNull();
}
+ [Test]
+ public async Task DataGrid_RowDetail_ExpandCollapseAllTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ dataGrid.WaitForAssertion(() => dataGrid.Instance._openHierarchies.Count.Should().Be(2));
+ await dataGrid.InvokeAsync(() => dataGrid.Instance.CollapseAllHierarchy());
+ dataGrid.WaitForAssertion(() => dataGrid.Instance._openHierarchies.Count.Should().Be(0));
+ await dataGrid.InvokeAsync(() => dataGrid.Instance.ExpandAllHierarchy());
+ dataGrid.WaitForAssertion(() => dataGrid.Instance._openHierarchies.Count.Should().Be(5));
+ }
+
+ [Test]
+ [TestCase(true)]
+ [TestCase(false)]
+ public void DataGrid_RowDetail_RTL_GroupIcon(bool rightToLeft)
+ {
+ var comp = Context.RenderComponent(param => param
+ .Add(p => p.RightToLeft, rightToLeft)
+ );
+ var dataGrid = comp.FindComponent>();
+ var svg = dataGrid.Find(".mud-table-body .mud-table-row .mud-table-cell .mud-icon-root");
+
+ if (!rightToLeft)
+ {
+ // ChevronRight by Default
+ svg.InnerHtml.Should().Contain("();
- var dataGrid = comp.FindComponent>();
-
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(7);
- await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroups());
- dataGrid.Render();
- // after all groups are collapsed
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
- await comp.InvokeAsync(() =>
- comp.Instance.AddFruit());
- // datagrid should be expanded with the new category
- dataGrid.Render();
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(5);
- }
-
- [Test]
- public async Task DataGridGroupExpandedTrueAsyncTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
-
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
- await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroups());
- dataGrid.Render();
- // after all groups are collapsed
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
- await comp.InvokeAsync(() =>
- comp.Instance.AddFruit());
- // datagrid should be expanded with the new category
- dataGrid.Render();
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(5));
- }
-
- [Test]
- public async Task DataGridGroupExpandedTrueServerDataTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
-
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
- await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroups());
- dataGrid.Render();
- // after all groups are collapsed
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
- await comp.InvokeAsync(() => comp.Instance.AddFruit());
- // datagrid should be expanded with the new category
- dataGrid.Render();
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(5));
- }
-
- [Test]
- public async Task DataGridGroupExpandedFalseTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
-
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
- dataGrid.Render();
- // after all groups are expanded
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(7);
- await comp.InvokeAsync(() =>
- comp.Instance.AddFruit());
- // datagrid should be collapsed with the new category
- dataGrid.Render();
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(8);
- }
-
- [Test]
- public async Task DataGridGroupExpandedFalseAsyncTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
-
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
- dataGrid.Render();
- // after all groups are expanded
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
- await comp.InvokeAsync(() =>
- comp.Instance.AddFruit());
- // datagrid should be collapsed with the new category
- dataGrid.Render();
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(8));
- }
-
- [Test]
- public async Task DataGridGroupExpandedFalseServerDataTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
-
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(2));
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
- dataGrid.Render();
- // after all groups are expanded
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(7));
- await comp.InvokeAsync(() => comp.Instance.AddFruit());
- // datagrid should be collapsed with the new category
- dataGrid.Render();
- comp.WaitForAssertion(() => comp.FindAll("tbody .mud-table-row").Count.Should().Be(8));
- }
-
- [Test]
- public async Task DataGridGroupCollapseAllTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
-
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(3);
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
- comp.Render();
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(15);
- await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroups());
- comp.Render();
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(3);
- comp.Instance.RefreshList();
- comp.Render();
- // after all groups are expanded
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(3);
- }
-
- [Test]
- public async Task DataGridGroupExpandAllCollapseAllTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
-
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
- comp.Render();
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(14);
- await dataGrid.InvokeAsync(() => dataGrid.Instance.NavigateTo(Page.First));
- await dataGrid.InvokeAsync(() => dataGrid.Instance.NavigateTo(Page.Next));
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(18);
- await comp.InvokeAsync(() => dataGrid.Instance.CollapseAllGroups());
- await dataGrid.InvokeAsync(() => dataGrid.Instance.NavigateTo(Page.First));
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
- comp.Instance.RefreshList();
- comp.Render();
- comp.FindAll("tbody .mud-table-row").Count.Should().Be(2);
- }
-
[Test]
public async Task DataGridPropertyColumnFormatTest()
{
@@ -4491,43 +4383,6 @@ public void DataGridRedundantMenuTest()
columnOptionsSpan.TextContent.Trim().Should().BeEmpty();
}
- [Test]
- public void ShouldSetIsGenderGroupedToTrueWhenGroupingIsApplied()
- {
- // Render the DataGridGroupingTest component for testing.
- var comp = Context.RenderComponent();
-
- // Attempt to find the MudPopoverProvider component within the rendered component.
- // MudPopoverProvider is used to manage popovers in the component, including the grouping popover.
- var popoverProvider = comp.FindComponent();
-
- // Assert that initially, before any user interaction, IsGenderGrouped should be false.
- comp.Instance.IsGenderGrouped.Should().Be(false);
-
- // Find the button within the 'th' element with class 'gender' that triggers the popover for grouping.
- var genderHeaderOption = comp.Find("th.gender .mud-menu button");
-
- // Simulate a click on the gender header group button to open the popover with grouping options.
- genderHeaderOption.Click();
-
- // Find all MudListItem components within the popoverProvider.
- // These list items represent the individual options within the grouping popover.
- var listItems = popoverProvider.FindComponents();
-
- // Assert that there are exactly 2 list items (options) available in the popover.
- listItems.Count.Should().Be(2);
-
- // From the list items found, select the second one which is expected to be the clickable option for grouping.
- var clickablePopover = listItems[1].Find(".mud-menu-item");
-
- // click on the grouping option to apply grouping to the data grid.
- clickablePopover.Click();
-
- // After clicking the grouping option, assert that IsGenderGrouped is now true, indicating that
- // the action of applying grouping has successfully updated the component's state.
- comp.Instance.IsGenderGrouped.Should().Be(true);
- }
-
[Test]
public void DataGridDynamicColumnsTest()
{
@@ -4580,161 +4435,6 @@ public void DataGridSelectColumnTest()
selectAllCheckboxes[1].Instance.Value.Should().BeFalse();
}
- [Test]
- [SetCulture("en-US")]
- public void DataGridServerGroupUngroupingTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
- var popoverProvider = comp.FindComponent();
-
- //click name grouping in grid
- var headerOption = comp.Find("th.name .mud-menu button");
- headerOption.Click();
- var listItems = popoverProvider.FindComponents();
- listItems.Count.Should().Be(4);
- var clickablePopover = listItems[3].Find(".mud-menu-item");
- clickablePopover.Click();
- var cells = dataGrid.FindAll("td");
-
- //checking cell content is the most reliable way to verify grouping
- cells[0].TextContent.Should().Be("Name: Hydrogen");
- cells[1].TextContent.Should().Be("Name: Helium");
- cells[2].TextContent.Should().Be("Name: Lithium");
- cells[3].TextContent.Should().Be("Name: Beryllium");
- cells[4].TextContent.Should().Be("Name: Boron");
- cells[5].TextContent.Should().Be("Name: Carbon");
- cells[6].TextContent.Should().Be("Name: Nitrogen");
- cells[7].TextContent.Should().Be("Name: Oxygen");
- cells[8].TextContent.Should().Be("Name: Fluorine");
- cells[9].TextContent.Should().Be("Name: Neon");
- dataGrid.Instance.GroupedColumn.Should().NotBeNull();
-
- //click name ungrouping in grid
- headerOption = comp.Find("th.name .mud-menu button");
- headerOption.Click();
- listItems = popoverProvider.FindComponents();
- listItems.Count.Should().Be(4);
- clickablePopover = listItems[3].Find(".mud-menu-item");
- clickablePopover.Click();
- cells = dataGrid.FindAll("td");
- // We do not need check all 10 rows as it's clear that it's ungrouped if first row pass
- cells[0].TextContent.Should().Be("1");
- cells[1].TextContent.Should().Be("H");
- cells[2].TextContent.Should().Be("Hydrogen");
- cells[3].TextContent.Should().Be("0");
- cells[4].TextContent.Should().Be("1.00794");
- cells[5].TextContent.Should().Be("Other");
- dataGrid.Instance.GroupedColumn.Should().BeNull();
- }
-
- [Test]
- public void DataGridGroupingTestBoundAndUnboundScenarios()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
- var popoverProvider = comp.FindComponent();
-
- IRefreshableElementCollection Rows() => dataGrid.FindAll("tr");
- IRefreshableElementCollection Cells() => dataGrid.FindAll("td");
-
- // Assert that initially, before any user interaction, IsGenderGrouped and IsAgeGrouped should be false
- // The default grouping is by name
- comp.Instance.IsGenderGrouped.Should().Be(false);
- comp.Instance.IsAgeGrouped.Should().Be(false);
- comp.Instance.IsProfessionGrouped.Should().Be(false);
-
- var nameCells = Cells();
- nameCells.Count.Should().Be(4, because: "4 data rows");
- nameCells[0].TextContent.Should().Be("Name: John");
- nameCells[1].TextContent.Should().Be("Name: Johanna");
- nameCells[2].TextContent.Should().Be("Name: Steve");
- nameCells[3].TextContent.Should().Be("Name: Alice");
- Rows().Count.Should().Be(6, because: "1 header row + 4 data rows + 1 footer row");
-
- var ageGrouping = comp.Find(".GroupByAge");
- ageGrouping.Click();
- comp.Instance.IsAgeGrouped.Should().Be(true);
- comp.Instance.IsGenderGrouped.Should().Be(false);
- comp.Instance.IsProfessionGrouped.Should().Be(false);
- var ageCells = Cells();
- ageCells.Count.Should().Be(3, because: "3 data rows");
- ageCells[0].TextContent.Should().Be("Age: 45");
- ageCells[1].TextContent.Should().Be("Age: 23");
- ageCells[2].TextContent.Should().Be("Age: 32");
- Rows().Count.Should().Be(5, because: "1 header row + 3 data rows + 1 footer row");
-
- var genderGrouping = comp.Find(".GroupByGender");
- genderGrouping.Click();
- comp.Instance.IsGenderGrouped.Should().Be(true);
- comp.Instance.IsAgeGrouped.Should().Be(true, because: "Age is not bound");
- comp.Instance.IsProfessionGrouped.Should().Be(false);
- var genderCells = Cells();
- genderCells.Count.Should().Be(2, because: "2 data rows");
- genderCells[0].TextContent.Should().Be("Gender: Male");
- genderCells[1].TextContent.Should().Be("Gender: Female");
- Rows().Count.Should().Be(4, because: "1 header row + 2 data rows + 1 footer row");
-
- var professionGrouping = comp.Find(".GroupByProfession");
- professionGrouping.Click();
- comp.Instance.IsGenderGrouped.Should().Be(false);
- comp.Instance.IsAgeGrouped.Should().Be(true, because: "Age is not bound");
- comp.Instance.IsProfessionGrouped.Should().Be(true);
- var professionCells = Cells();
- professionCells.Count.Should().Be(2, because: "2 data rows");
- professionCells[0].TextContent.Should().Be("Profession: Cook");
- professionCells[1].TextContent.Should().Be("Profession: (None)");
- Rows().Count.Should().Be(4, because: "1 header row + 2 data rows + 1 footer row");
-
- //click age grouping in grid
- var headerOption = comp.Find("th.age .mud-menu button");
- headerOption.Click();
- var listItems = popoverProvider.FindComponents();
- listItems.Count.Should().Be(2);
- var clickablePopover = listItems[1].Find(".mud-menu-item");
- clickablePopover.Click();
- comp.Instance.IsAgeGrouped.Should().Be(true);
- comp.Instance.IsGenderGrouped.Should().Be(false);
- comp.Instance.IsProfessionGrouped.Should().Be(false);
- Rows().Count.Should().Be(5, because: "1 header row + 3 data rows + 1 footer row");
-
- //click gender grouping in grid
- headerOption = comp.Find("th.gender .mud-menu button");
- headerOption.Click();
- listItems = popoverProvider.FindComponents();
- listItems.Count.Should().Be(2);
- clickablePopover = listItems[1].Find(".mud-menu-item");
- clickablePopover.Click();
- comp.Instance.IsGenderGrouped.Should().Be(true);
- comp.Instance.IsAgeGrouped.Should().Be(true, because: "Age is not bound");
- comp.Instance.IsProfessionGrouped.Should().Be(false);
- Rows().Count.Should().Be(4, because: "1 header row + 2 data rows + 1 footer row");
-
- //click Name grouping in grid
- headerOption = comp.Find("th.name .mud-menu button");
- headerOption.Click();
- listItems = popoverProvider.FindComponents();
- listItems.Count.Should().Be(2);
- clickablePopover = listItems[1].Find(".mud-menu-item");
- clickablePopover.Click();
- comp.Instance.IsGenderGrouped.Should().Be(false);
- comp.Instance.IsAgeGrouped.Should().Be(true, because: "Age is not bound");
- comp.Instance.IsProfessionGrouped.Should().Be(false);
- Rows().Count.Should().Be(6, because: "1 header row + 4 data rows + 1 footer row");
-
- //click profession grouping in grid
- headerOption = comp.Find("th.profession .mud-menu button");
- headerOption.Click();
- listItems = popoverProvider.FindComponents();
- listItems.Count.Should().Be(2);
- clickablePopover = listItems[1].Find(".mud-menu-item");
- clickablePopover.Click();
- comp.Instance.IsGenderGrouped.Should().Be(false);
- comp.Instance.IsAgeGrouped.Should().Be(true, because: "Age is not bound");
- comp.Instance.IsProfessionGrouped.Should().Be(true);
- Rows().Count.Should().Be(4, because: "1 header row + 2 data rows + 1 footer row");
- }
-
[Test]
public async Task FilterDefinitionTestHasFilterProperty()
{
@@ -4760,72 +4460,6 @@ await comp.InvokeAsync(() => dataGrid.Instance.AddFilterAsync(new FilterDefiniti
statusHeaderCell.Instance.hasFilter.Should().BeFalse();
}
- [Test]
- public async Task DataGridGroupedWithServerDataPaginationTest()
- {
- var comp = Context.RenderComponent();
- var dataGrid = comp.FindComponent>();
- var rows = dataGrid.FindAll("tr");
- rows.Count.Should().Be(12, because: "1 header row + 10 data rows + 1 footer row");
- var cells = dataGrid.FindAll("td");
- cells.Count.Should().Be(10, because: "We have 10 data rows with one group collapsed");
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
- rows = dataGrid.FindAll("tr");
- rows.Count.Should().Be(32, because: "1 header row + 10 data rows + 1 footer row + 10 group rows + 10 footer group rows");
- cells = dataGrid.FindAll("td");
- cells.Count.Should().Be(30, because: "We have 10 data rows with one group + 10*2 cells inside groups");
- //check cells
- cells[0].TextContent.Should().Be("Number: 1");
- cells[1].TextContent.Should().Be("Hydrogen"); cells[2].TextContent.Should().Be("1");
- cells[3].TextContent.Should().Be("Number: 2");
- cells[4].TextContent.Should().Be("Helium"); cells[5].TextContent.Should().Be("2");
- cells[6].TextContent.Should().Be("Number: 3");
- cells[7].TextContent.Should().Be("Lithium"); cells[8].TextContent.Should().Be("3");
- cells[9].TextContent.Should().Be("Number: 4");
- cells[10].TextContent.Should().Be("Beryllium"); cells[11].TextContent.Should().Be("4");
- cells[12].TextContent.Should().Be("Number: 5");
- cells[13].TextContent.Should().Be("Boron"); cells[14].TextContent.Should().Be("5");
- cells[15].TextContent.Should().Be("Number: 6");
- cells[16].TextContent.Should().Be("Carbon"); cells[17].TextContent.Should().Be("6");
- cells[18].TextContent.Should().Be("Number: 7");
- cells[19].TextContent.Should().Be("Nitrogen"); cells[20].TextContent.Should().Be("7");
- cells[21].TextContent.Should().Be("Number: 8");
- cells[22].TextContent.Should().Be("Oxygen"); cells[23].TextContent.Should().Be("8");
- cells[24].TextContent.Should().Be("Number: 9");
- cells[25].TextContent.Should().Be("Fluorine"); cells[26].TextContent.Should().Be("9");
- cells[27].TextContent.Should().Be("Number: 10");
- cells[28].TextContent.Should().Be("Neon"); cells[29].TextContent.Should().Be("10");
- //get next page
- dataGrid.Instance.CurrentPage = 1;
- await comp.InvokeAsync(async () => await dataGrid.Instance.ReloadServerData());
- cells = dataGrid.FindAll("td");
- cells.Count.Should().Be(10, because: "We have 10 data rows with one group collapsed from next page");
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
- cells = dataGrid.FindAll("td");
- cells.Count.Should().Be(30, because: "We have next 10 data rows with one group + 10*2 cells inside groups");
- //cells should have data from next page
- cells[0].TextContent.Should().Be("Number: 11");
- cells[1].TextContent.Should().Be("Sodium"); cells[2].TextContent.Should().Be("11");
- cells[3].TextContent.Should().Be("Number: 12");
- cells[4].TextContent.Should().Be("Magnesium"); cells[5].TextContent.Should().Be("12");
- cells[6].TextContent.Should().Be("Number: 13");
- cells[7].TextContent.Should().Be("Aluminium"); cells[8].TextContent.Should().Be("13");
- cells[9].TextContent.Should().Be("Number: 14");
- cells[10].TextContent.Should().Be("Silicon"); cells[11].TextContent.Should().Be("14");
- cells[12].TextContent.Should().Be("Number: 15");
- cells[13].TextContent.Should().Be("Phosphorus"); cells[14].TextContent.Should().Be("15");
- cells[15].TextContent.Should().Be("Number: 16");
- cells[16].TextContent.Should().Be("Sulfur"); cells[17].TextContent.Should().Be("16");
- cells[18].TextContent.Should().Be("Number: 17");
- cells[19].TextContent.Should().Be("Chlorine"); cells[20].TextContent.Should().Be("17");
- cells[21].TextContent.Should().Be("Number: 18");
- cells[22].TextContent.Should().Be("Argon"); cells[23].TextContent.Should().Be("18");
- cells[24].TextContent.Should().Be("Number: 19");
- cells[25].TextContent.Should().Be("Potassium"); cells[26].TextContent.Should().Be("19");
- cells[27].TextContent.Should().Be("Number: 20");
- cells[28].TextContent.Should().Be("Calcium"); cells[29].TextContent.Should().Be("20");
- }
-
///
/// Reproduce the bug from https://github.com/MudBlazor/MudBlazor/issues/9585
/// When a column is hidden by the menu and the precedent column is resized, then the app crash
@@ -5016,24 +4650,6 @@ public async Task TestCurrentPageParameterTwoWayBinding()
comp.WaitForAssertion(() => comp.Find(".mud-table-body .mud-table-row .mud-table-cell").TextContent.Should().Be("3"));
}
- [Test]
- [TestCase(true, true)]
- [TestCase(true, false)]
- [TestCase(false, true)]
- [TestCase(false, false)]
- public void TestRtlGroupIconMethod(bool isRightToLeft, bool isExpanded)
- {
- var test = new MudDataGrid();
- if (isExpanded)
- {
- test.GetGroupIcon(isExpanded, isRightToLeft).Should().Be(Icons.Material.Filled.ExpandMore);
- }
- else
- {
- test.GetGroupIcon(isExpanded, isRightToLeft).Should().Be(isRightToLeft ? Icons.Material.Filled.ChevronLeft : Icons.Material.Filled.ChevronRight);
- }
- }
-
///
/// Verifies data grid does not reuse row child components for different items (the @key for the row is set to the user supplied item).
///
@@ -5053,10 +4669,9 @@ public async Task DataGridUniqueRowKey()
before.Should().NotBeSameAs(after, because: "If the @key is correctly set to the row item, child components will be recreated on row reordering.");
-
//Test the expanded group case
comp.SetParametersAndRender(parameters => parameters.Add(p => p.Group, true));
- await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroups());
+ await comp.InvokeAsync(() => dataGrid.Instance.ExpandAllGroupsAsync());
await comp.InvokeAsync(() => dataGrid.Instance.SetSortAsync(sortByColumnName, SortDirection.Ascending, x => x));
before = dataGrid.FindComponent>();
@@ -5176,5 +4791,150 @@ public async Task DataGridSelectedItemEventsTest()
comp.Instance.SelectedItemChanged = false;
comp.Instance.SelectedItemsChanged = false;
}
+
+ [Test]
+ public void DataGridHeaderToggleHierarchyTest()
+ {
+ // Render with EnableHeaderToggle = true to enable header toggle functionality
+ var comp = Context.RenderComponent(parameters =>
+ parameters.Add(p => p.EnableHeaderToggle, true));
+ var dataGrid = comp.FindComponent>();
+
+ // Find the header cell that should include hierarchy toggle
+ var headerCell = dataGrid.FindComponents>().First();
+
+ var headerElement = comp.Find("th.mud-header-togglehierarchy");
+ headerElement.Should().NotBeNull("Header should have mud-header-togglehierarchy class when EnableHeaderToggle is true");
+ headerCell.Instance.IncludeHierarchyToggle.Should().BeTrue();
+
+ // Check that the HierarchyToggle button exists in the header
+ var toggleButton = headerElement.QuerySelector(".mud-hierarchy-toggle-button");
+ toggleButton.Should().NotBeNull("HierarchyToggle button should be rendered in header");
+
+ // The initial state should be expanded (Anders and Ira items are initially expanded)
+ dataGrid.Instance._openHierarchies.Count.Should().Be(2);
+
+ // Click the toggle button to collapse all hierarchies
+ toggleButton.Click();
+ comp.WaitForAssertion(() => dataGrid.Instance._openHierarchies.Count.Should().Be(0));
+
+ // Click again to expand all
+ toggleButton = headerElement.QuerySelector(".mud-hierarchy-toggle-button");
+ toggleButton.Click();
+ comp.WaitForAssertion(() => dataGrid.Instance._openHierarchies.Count.Should().Be(5));
+ }
+
+ [Test]
+ [TestCase(true)]
+ [TestCase(false)]
+ public void DataGridHeaderToggleIconTest(bool rightToLeft)
+ {
+ // Render with EnableHeaderToggle = true and set RTL mode
+ var comp = Context.RenderComponent(parameters =>
+ {
+ parameters.Add(p => p.EnableHeaderToggle, true);
+ parameters.Add(p => p.RightToLeft, rightToLeft);
+ });
+ var dataGrid = comp.FindComponent>();
+
+ // Find the header with toggle
+ var headerElement = comp.Find("th.mud-header-togglehierarchy");
+
+ // Find the toggle button in header
+ var toggleButton = headerElement.QuerySelector(".mud-hierarchy-toggle-button");
+ var icon = toggleButton.QuerySelector(".mud-icon-root");
+
+ // Initial state should show expanded icon (ExpandMore)
+ var iconPath = icon.InnerHtml;
+ iconPath.Should().Contain("M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z",
+ "Icon should be ExpandMore when hierarchies are expanded");
+
+ // Click to collapse all
+ toggleButton.Click();
+
+ // Now the icon should change based on RTL mode
+ icon = headerElement.QuerySelector(".mud-hierarchy-toggle-button .mud-icon-root");
+ iconPath = icon.InnerHtml;
+
+ if (rightToLeft)
+ {
+ iconPath.Should().Contain("M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z",
+ "Icon should be ChevronLeft in RTL mode when hierarchies are collapsed");
+ }
+ else
+ {
+ iconPath.Should().Contain("M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z",
+ "Icon should be ChevronRight in LTR mode when hierarchies are collapsed");
+ }
+ }
+
+ [Test]
+ public async Task DataGridToggleHierarchyMethodTest()
+ {
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ var headerCell = dataGrid.FindComponents>().First();
+
+ // Initially, there should be 2 expanded items
+ dataGrid.Instance._openHierarchies.Count.Should().Be(2);
+ var accessor = headerCell.Instance;
+ await accessor.ToggleHierarchyAsync();
+
+ // After calling ToggleHierarchy when some hierarchies are open, all should be collapsed
+ dataGrid.Instance._openHierarchies.Count.Should().Be(0);
+
+ // Call ToggleHierarchy again
+ await accessor.ToggleHierarchyAsync();
+
+ // Now all hierarchies should be expanded
+ dataGrid.Instance._openHierarchies.Count.Should().Be(5);
+ }
+
+ [Test]
+ public async Task DataGridGetHierarchyGroupIconTest()
+ {
+ // Create a test component
+ var comp = Context.RenderComponent();
+ var dataGrid = comp.FindComponent>();
+
+ // Get a reference to a HeaderCell to test GetGroupIcon method
+ var headerCell = dataGrid.FindComponents>().First();
+
+ // Create a PrivateAccessor to invoke the GetGroupIcon method
+ var accessor = headerCell.Instance;
+
+ // When expanded (RTL doesn't matter in this case)
+ var expandedIcon = accessor.GetGroupIcon();
+ expandedIcon.Should().Be(Icons.Material.Filled.ExpandMore);
+
+ await accessor.ToggleHierarchyAsync(); // collapse all
+
+ // When collapsed + LTR
+ var collapsedIcon = accessor.GetGroupIcon();
+ comp.WaitForAssertion(() => collapsedIcon.Should().Be(Icons.Material.Filled.ChevronRight));
+
+ comp.SetParametersAndRender(parameters => parameters.Add(p => p.RightToLeft, true));
+ // When collapsed + RTL
+ comp.WaitForAssertion(() => accessor.GetGroupIcon().Should().Be(Icons.Material.Filled.ChevronLeft));
+ }
+
+ [Test]
+ public void DataGrid_HierarchyExpandSingleRowTest()
+ {
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(p => p.ExpandSingleRow, false));
+ var dataGrid = comp.FindComponent>();
+
+ dataGrid.Instance._openHierarchies.Count.Should().Be(2);
+ var item = dataGrid.Instance._openHierarchies.First();
+ item.Should().NotBeNull();
+
+ comp.SetParametersAndRender(p => p.Add(p => p.ExpandSingleRow, true));
+
+ dataGrid.Instance._openHierarchies.Count.Should().Be(1);
+
+ dataGrid.Instance._openHierarchies.First().Should().Be(item);
+ }
}
}
diff --git a/src/MudBlazor.UnitTests/Components/DateRangePickerTests.cs b/src/MudBlazor.UnitTests/Components/DateRangePickerTests.cs
index 1baeadf8075f..fd4eef1567fb 100644
--- a/src/MudBlazor.UnitTests/Components/DateRangePickerTests.cs
+++ b/src/MudBlazor.UnitTests/Components/DateRangePickerTests.cs
@@ -255,10 +255,8 @@ public void Open_SelectEndDateLowerThanStart_CheckClosed()
{
var comp = OpenPicker();
// clicking a day buttons to select a range and close
- comp.FindAll("button.mud-picker-calendar-day")
- .Where(x => x.TrimmedText().Equals("10")).First().Click();
- comp.FindAll("button.mud-picker-calendar-day")
- .Where(x => x.TrimmedText().Equals("8")).First().Click();
+ comp.SelectDate("10");
+ comp.SelectDate("8");
comp.FindAll("div.mud-picker-open").Count.Should().Be(1);
comp.WaitForAssertion(() => comp.FindAll("div.mud-picker-open").Count.Should().Be(0), TimeSpan.FromSeconds(5));
comp.Instance.DateRange.Should().NotBeNull();
@@ -1203,5 +1201,55 @@ await comp.FindAll("button.mud-picker-calendar-day")
comp.Instance.DateRange.Start.Should().Be(comp.Instance.DateRange.End);
}
+
+ [Test]
+ public async Task DateRangePicker_BlurAsync()
+ {
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(picker => picker.ReadOnly, false)
+ .Add(picker => picker.Editable, true));
+
+ var input = comp.Find("input");
+
+ await comp.Instance.FocusStartAsync();
+
+ // the input is actually never focused because the test is run in a headless browser
+ //comp.Find("input").IsFocused.Should().BeTrue();
+
+ await comp.Instance.BlurAsync();
+
+ comp.Find("input").IsFocused.Should().BeFalse();
+ }
+ }
+
+ public static class DatePickerRenderedFragmentExtensions
+ {
+ public static void SelectDate(this IRenderedFragment comp, string day, bool firstOccurrence = true)
+ {
+ comp.ValidateSelection(day, firstOccurrence).Click();
+ }
+
+ public static async Task SelectDateAsync(this IRenderedFragment comp, string day, bool firstOccurrence = true)
+ {
+ await comp.ValidateSelection(day, firstOccurrence).ClickAsync(new MouseEventArgs());
+ }
+
+ private static IElement ValidateSelection(this IRenderedFragment comp, string day, bool firstOccurrence)
+ {
+ var matchingDays = comp.FindAll("button.mud-picker-calendar-day")
+ .Where(x => !x.ClassList.Contains("mud-hidden") && x.TrimmedText().Equals(day))
+ .ToList();
+
+ Assert.That(matchingDays.Count != 0, $"Invalid day ({day}) selected");
+
+ if (!firstOccurrence)
+ Assert.That(matchingDays.Count == 2, $"Only one instance of date ({day}) found");
+
+ var selectedDate = matchingDays[firstOccurrence ? 0 : 1];
+
+ Assert.That(!selectedDate.IsDisabled(), $"Selected date ({day}) is disabled");
+
+ return selectedDate;
+ }
}
}
diff --git a/src/MudBlazor.UnitTests/Components/DynamicTabsTests.cs b/src/MudBlazor.UnitTests/Components/DynamicTabsTests.cs
index a4f5b55d9c64..6069573b0287 100644
--- a/src/MudBlazor.UnitTests/Components/DynamicTabsTests.cs
+++ b/src/MudBlazor.UnitTests/Components/DynamicTabsTests.cs
@@ -104,12 +104,11 @@ public async Task BasicParameters_WithToolTips()
actual.Should().BeEquivalentTo(expected);
var parent = (IHtmlElement)item.Parent;
- parent.Children.Should().HaveCount(1, because: "the button and no empty popover hint since it's not active");
+ parent.Children.Should().HaveCount(2, because: "the button and the empty popover hint since it's not active");
await item.ParentElement.TriggerEventAsync("onpointerenter", new PointerEventArgs());
- var popover = comp.Find("div.mud-popover");
- var popoverId = popover.Id.Substring(15);
+ var popoverId = parent.Children[1].Id.Substring(8);
var toolTip = comp.Find($"#popovercontent-{popoverId}");
@@ -134,12 +133,11 @@ public async Task BasicParameters_WithToolTips()
actual.Should().BeEquivalentTo(expected);
var parent = (IHtmlElement)item.Parent;
- parent.Children.Should().HaveCount(1, because: "the button and no popover hint"); ;
+ parent.Children.Should().HaveCount(2, because: "the button and the empty popover hint"); ;
await item.ParentElement.TriggerEventAsync("onpointerenter", new PointerEventArgs());
- var popover = comp.Find("div.mud-popover");
- var popoverId = popover.Id.Substring(15);
+ var popoverId = parent.Children[1].Id.Substring(8);
var toolTip = comp.Find($"#popovercontent-{popoverId}");
diff --git a/src/MudBlazor.UnitTests/Components/MenuTests.cs b/src/MudBlazor.UnitTests/Components/MenuTests.cs
index 5d55a744abe6..6b98f3fb4e5f 100644
--- a/src/MudBlazor.UnitTests/Components/MenuTests.cs
+++ b/src/MudBlazor.UnitTests/Components/MenuTests.cs
@@ -688,11 +688,11 @@ public async Task Menu_PointerEvents_ShowHide_WithDebounce()
// Immediately after leave, submenu should still be visible (hide debounce in effect)
comp.FindAll("div.mud-popover-open").Count.Should().Be(2, "Submenu should remain open immediately after pointer leave");
- // Wait less than the hide delay (which is 2x show delay)
- await Task.Delay(hoverDelay + 50);
+ // Wait less than the delay
+ await Task.Delay(hoverDelay / 2);
comp.FindAll("div.mud-popover-open").Count.Should().Be(2, "Submenu should still be open before hide delay completes");
- // After the full hide delay (2x hover delay), submenu should close
+ // After the full delay, submenu should close
await Task.Delay(hoverDelay + 50);
comp.FindAll("div.mud-popover-open").Count.Should().Be(1, "Submenu should close after full hide delay (2x hover delay)");
}
@@ -735,11 +735,11 @@ public async Task Menu_PointerEvents_Cancellation()
// Start leave sequence, but re-enter before hide completes
menu.PointerLeaveAsync(new PointerEventArgs()).CatchAndLog();
- await Task.Delay(hoverDelay);
+ await Task.Delay(hoverDelay / 2);
menu._hideDebouncer.Cancel();
// Wait for what would have been the full hide delay
- await Task.Delay((hoverDelay * 2) + 100);
+ await Task.Delay(hoverDelay + 100);
comp.FindAll("div.mud-popover-open").Count.Should().Be(2,
"Submenu should still be open because hide debounce was cancelled by re-entering");
}
diff --git a/src/MudBlazor.UnitTests/Components/OverlayTests.cs b/src/MudBlazor.UnitTests/Components/OverlayTests.cs
index b04d97ebc61f..f94dfa7ff483 100644
--- a/src/MudBlazor.UnitTests/Components/OverlayTests.cs
+++ b/src/MudBlazor.UnitTests/Components/OverlayTests.cs
@@ -1,6 +1,8 @@
๏ปฟusing AngleSharp.Dom;
using Bunit;
using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
using MudBlazor.UnitTests.TestComponents.Overlay;
using NUnit.Framework;
@@ -150,6 +152,37 @@ public void ShouldApplyAbsoluteClass(bool absolute)
}
}
+ [Test]
+ [TestCase(true)]
+ [TestCase(false)]
+ public void ShouldApplyCorrectPointerEvents(bool modal)
+ {
+ var providerComp = Context.RenderComponent();
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(p => p.Visible, true)
+ .Add(p => p.Modal, modal)
+ );
+
+ if (modal)
+ {
+ providerComp.Find("div.mud-overlay").Attributes["style"].Value.Should().NotContain("pointer-events:none");
+ }
+ else
+ {
+ providerComp.Find("div.mud-overlay").Attributes["style"].Value.Should().Contain("pointer-events:none");
+ }
+ }
+
+ [Test]
+ public void ShouldHaveId()
+ {
+ var providerComp = Context.RenderComponent();
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(p => p.Visible, true)
+ );
+ providerComp.Find("div.mud-overlay").Attributes["id"].Value.Should().NotBeNullOrEmpty();
+ }
+
[Test]
[TestCase(true, "", false, 0)] // Absolute is true
[TestCase(false, "mud-skip-overlay-section", false, 1)] // Dialog
@@ -222,4 +255,138 @@ public void ShouldRenderChildContent()
comp.Find("div.child-content").TextContent.Should().Be("Hello World");
}
+
+ [Test]
+ [TestCase(true, true, false, true)]
+ [TestCase(true, false, false, false)]
+ [TestCase(true, false, true, false)]
+ [TestCase(true, true, true, false)]
+ [TestCase(false, true, false, false)]
+ [TestCase(false, false, false, false)]
+ [TestCase(false, false, true, false)]
+ [TestCase(false, true, true, false)]
+ public void CallsSubscribeAsyncOnPointerEventsNoneServiceWhenExpected(bool visible, bool autoClose, bool modal, bool callsStart)
+ {
+ Context.Services.Remove(ServiceDescriptor.Scoped());
+ var serviceMock = new Mock();
+ serviceMock
+ .Setup(s => s.SubscribeAsync(It.IsAny(), It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+ Context.Services.AddScoped(_ => serviceMock.Object);
+
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(p => p.Visible, visible)
+ .Add(p => p.AutoClose, autoClose)
+ .Add(p => p.Modal, modal)
+ );
+
+ serviceMock.Verify(s => s.SubscribeAsync(It.IsAny(), It.IsAny()), callsStart ? Times.Once() : Times.Never());
+ }
+
+ [Test]
+ public void Overlay_ShouldHaveElementId_AndMatchRenderedDivId()
+ {
+ // Arrange
+ var providerComp = Context.RenderComponent();
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(p => p.Visible, true)
+ );
+
+ // Act
+ var elementId = ((IPointerEventsNoneObserver)comp.Instance).ElementId;
+ var overlayDiv = providerComp.Find("div.mud-overlay");
+
+ // Assert
+ elementId.Should().NotBeNullOrWhiteSpace();
+ overlayDiv.Id.Should().Be(elementId);
+ }
+
+ [Test]
+ [TestCase(true, true)]
+ [TestCase(true, false)]
+ [TestCase(false, true)]
+ [TestCase(false, false)]
+ public async Task Overlay_HandleLockScrollChanges(bool absolute, bool lockscroll)
+ {
+ var scrollManagerMock = new Mock();
+ Context.Services.AddSingleton(scrollManagerMock.Object);
+ var providerComp = Context.RenderComponent();
+
+ var visible = true;
+
+ // === Initial: Visible = true, should lock scroll if conditions match ===
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(p => p.Absolute, absolute)
+ .Bind(p => p.Visible, visible, p => visible = p)
+ .Add(p => p.LockScroll, lockscroll)
+ );
+
+ var mudOverlay = comp.Instance;
+
+ // Initial unlock state
+ scrollManagerMock.Verify(s => s.UnlockScrollAsync(It.IsAny(), It.IsAny()), Times.Never());
+
+ if (!absolute && lockscroll)
+ {
+ scrollManagerMock.Verify(s => s.LockScrollAsync("body", mudOverlay.LockScrollClass), Times.Once());
+ }
+ else
+ {
+ scrollManagerMock.Verify(s => s.LockScrollAsync(It.IsAny(), It.IsAny()), Times.Never());
+ }
+
+ // === Manually re-trigger HandleLockScrollChange (should not change counts) ===
+ await mudOverlay.HandleLockScrollChange();
+
+ if (!absolute && lockscroll)
+ {
+ scrollManagerMock.Verify(s => s.LockScrollAsync("body", mudOverlay.LockScrollClass), Times.Once());
+ }
+ else
+ {
+ scrollManagerMock.Verify(s => s.LockScrollAsync(It.IsAny(), It.IsAny()), Times.Never());
+ }
+
+ // === Toggle visible to false, expect unlock ===
+ visible = false;
+ comp.SetParametersAndRender(p => p.Add(p => p.Visible, visible));
+
+ if (!absolute && lockscroll)
+ {
+ scrollManagerMock.Verify(s => s.UnlockScrollAsync("body", mudOverlay.LockScrollClass), Times.Once());
+ }
+ else
+ {
+ scrollManagerMock.Verify(s => s.UnlockScrollAsync(It.IsAny(), It.IsAny()), Times.Never());
+ }
+
+ // open it
+ visible = true;
+ comp.SetParametersAndRender(p => p.Add(p => p.Visible, visible));
+
+ // close it by method
+ await mudOverlay.CloseOverlayAsync();
+
+ if (!absolute && lockscroll)
+ {
+ scrollManagerMock.Verify(s => s.UnlockScrollAsync("body", mudOverlay.LockScrollClass), Times.Exactly(2));
+ }
+ else
+ {
+ scrollManagerMock.Verify(s => s.UnlockScrollAsync(It.IsAny(), It.IsAny()), Times.Never());
+ }
+
+ // === Dispose component ===
+ await mudOverlay.DisposeAsync();
+
+ if (!absolute && lockscroll)
+ {
+ scrollManagerMock.Verify(s => s.UnlockScrollAsync("body", mudOverlay.LockScrollClass), Times.AtLeast(2));
+ }
+ else
+ {
+ scrollManagerMock.Verify(s => s.UnlockScrollAsync(It.IsAny(), It.IsAny()), Times.AtMostOnce());
+ }
+ }
}
diff --git a/src/MudBlazor.UnitTests/Components/PopoverTests.cs b/src/MudBlazor.UnitTests/Components/PopoverTests.cs
index a7d9e238eab5..07e94aace1e5 100644
--- a/src/MudBlazor.UnitTests/Components/PopoverTests.cs
+++ b/src/MudBlazor.UnitTests/Components/PopoverTests.cs
@@ -14,7 +14,8 @@ public void PopoverOptions_Defaults()
{
var options = new PopoverOptions();
- options.ContainerClass.Should().Be("mudblazor-main-content");
+ options.OverflowPadding.Should().Be(24);
+ options.ContainerClass.Should().Be("mud-popover-provider");
options.FlipMargin.Should().Be(0);
options.ThrowOnDuplicateProvider.Should().Be(true);
}
diff --git a/src/MudBlazor.UnitTests/Components/ThemeProviderTests.cs b/src/MudBlazor.UnitTests/Components/ThemeProviderTests.cs
index 7da11c5e3e32..19495f9af4cc 100644
--- a/src/MudBlazor.UnitTests/Components/ThemeProviderTests.cs
+++ b/src/MudBlazor.UnitTests/Components/ThemeProviderTests.cs
@@ -153,85 +153,85 @@ public void DifferentCultures(string cultureString)
"--mud-drawer-width-mini-left: 56px;",
"--mud-drawer-width-mini-right: 56px;",
"--mud-appbar-height: 64px;",
- "--mud-typography-default-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-default-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-default-size: .875rem;",
"--mud-typography-default-weight: 400;",
"--mud-typography-default-lineheight: 1.43;",
"--mud-typography-default-letterspacing: .01071em;",
"--mud-typography-default-text-transform: none;",
- "--mud-typography-h1-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-h1-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-h1-size: 6rem;",
"--mud-typography-h1-weight: 300;",
"--mud-typography-h1-lineheight: 1.167;",
"--mud-typography-h1-letterspacing: -.01562em;",
"--mud-typography-h1-text-transform: none;",
- "--mud-typography-h2-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-h2-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-h2-size: 3.75rem;",
"--mud-typography-h2-weight: 300;",
"--mud-typography-h2-lineheight: 1.2;",
"--mud-typography-h2-letterspacing: -.00833em;",
"--mud-typography-h2-text-transform: none;",
- "--mud-typography-h3-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-h3-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-h3-size: 3rem;",
"--mud-typography-h3-weight: 400;",
"--mud-typography-h3-lineheight: 1.167;",
"--mud-typography-h3-letterspacing: 0;",
"--mud-typography-h3-text-transform: none;",
- "--mud-typography-h4-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-h4-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-h4-size: 2.125rem;",
"--mud-typography-h4-weight: 400;",
"--mud-typography-h4-lineheight: 1.235;",
"--mud-typography-h4-letterspacing: .00735em;",
"--mud-typography-h4-text-transform: none;",
- "--mud-typography-h5-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-h5-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-h5-size: 1.5rem;",
"--mud-typography-h5-weight: 400;",
"--mud-typography-h5-lineheight: 1.334;",
"--mud-typography-h5-letterspacing: 0;",
"--mud-typography-h5-text-transform: none;",
- "--mud-typography-h6-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-h6-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-h6-size: 1.25rem;",
"--mud-typography-h6-weight: 500;",
"--mud-typography-h6-lineheight: 1.6;",
"--mud-typography-h6-letterspacing: .0075em;",
"--mud-typography-h6-text-transform: none;",
- "--mud-typography-subtitle1-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-subtitle1-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-subtitle1-size: 1rem;",
"--mud-typography-subtitle1-weight: 400;",
"--mud-typography-subtitle1-lineheight: 1.75;",
"--mud-typography-subtitle1-letterspacing: .00938em;",
"--mud-typography-subtitle1-text-transform: none;",
- "--mud-typography-subtitle2-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-subtitle2-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-subtitle2-size: .875rem;",
"--mud-typography-subtitle2-weight: 500;",
"--mud-typography-subtitle2-lineheight: 1.57;",
"--mud-typography-subtitle2-letterspacing: .00714em;",
"--mud-typography-subtitle2-text-transform: none;",
- "--mud-typography-body1-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-body1-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-body1-size: 1rem;",
"--mud-typography-body1-weight: 400;",
"--mud-typography-body1-lineheight: 1.5;",
"--mud-typography-body1-letterspacing: .00938em;",
"--mud-typography-body1-text-transform: none;",
- "--mud-typography-body2-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-body2-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-body2-size: .875rem;",
"--mud-typography-body2-weight: 400;",
"--mud-typography-body2-lineheight: 1.43;",
"--mud-typography-body2-letterspacing: .01071em;",
"--mud-typography-body2-text-transform: none;",
- "--mud-typography-button-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-button-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-button-size: .875rem;",
"--mud-typography-button-weight: 500;",
"--mud-typography-button-lineheight: 1.75;",
"--mud-typography-button-letterspacing: .02857em;",
"--mud-typography-button-text-transform: uppercase;",
- "--mud-typography-caption-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-caption-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-caption-size: .75rem;",
"--mud-typography-caption-weight: 400;",
"--mud-typography-caption-lineheight: 1.66;",
"--mud-typography-caption-letterspacing: .03333em;",
"--mud-typography-caption-text-transform: none;",
- "--mud-typography-overline-family: 'Roboto','Helvetica','Arial','sans-serif';",
+ "--mud-typography-overline-family: Roboto, Helvetica, Arial, sans-serif;",
"--mud-typography-overline-size: .75rem;",
"--mud-typography-overline-weight: 400;",
"--mud-typography-overline-lineheight: 2.66;",
diff --git a/src/MudBlazor.UnitTests/Components/ToolTipTests.cs b/src/MudBlazor.UnitTests/Components/ToolTipTests.cs
index fb112497bba3..8a48dacff932 100644
--- a/src/MudBlazor.UnitTests/Components/ToolTipTests.cs
+++ b/src/MudBlazor.UnitTests/Components/ToolTipTests.cs
@@ -42,23 +42,25 @@ public async Task RenderContent(bool usingFocusout)
button.ParentElement.ClassList.Should().Contain("mud-tooltip-root");
- //the button [0] and the popover node doesn't exist yet
- button.ParentElement.Children.Should().HaveCount(1);
+ //the button [0] and [1] the popover npde
+ button.ParentElement.Children.Should().HaveCount(2);
+
+ var popoverNode = button.ParentElement.Children[1];
+ popoverNode.Id.Should().StartWith("popover-");
+
+ var popoverContentNode = () => comp.Find($"#popovercontent-{popoverNode.Id.Substring(8)}");
+
+ //no content for the popover node
+ popoverContentNode().Children.Should().BeEmpty();
//not visible by default
tooltipComp.GetState(x => x.Visible).Should().BeFalse();
//trigger pointerover
-
await button.ParentElement.TriggerEventAsync("onpointerenter", new PointerEventArgs());
- //content should be visible
- var popoverNode = button.ParentElement.Children[1];
- popoverNode.Id.Should().StartWith("popover-");
-
- var popoverContentNode = comp.Find($"#popovercontent-{popoverNode.Id.Substring(8)}");
- popoverContentNode.TextContent.Should().Be("my tooltip content text");
- popoverContentNode.ClassList.Should().Contain("d-flex");
+ popoverContentNode().TextContent.Should().Be("my tooltip content text");
+ popoverContentNode().ClassList.Should().Contain("d-flex");
tooltipComp.GetState(x => x.Visible).Should().BeTrue();
@@ -72,9 +74,7 @@ public async Task RenderContent(bool usingFocusout)
button.ParentElement.FocusOut();
}
//no content should be visible
- comp.Markup.Should().NotContain("my tooltip content text");
- //the button [0] and the popover node doesn't exist again
- button.ParentElement.Children.Should().HaveCount(1);
+ popoverContentNode().Children.Should().BeEmpty();
tooltipComp.GetState(x => x.Visible).Should().BeFalse();
}
@@ -110,17 +110,20 @@ public async Task RenderTooltipFragment(bool usingFocusout)
button.ParentElement.ClassList.Should().Contain("mud-tooltip-root");
//the button [0] and [1] the popover node
- button.ParentElement.Children.Should().HaveCount(1);
-
- //trigger pointerover
-
- await button.ParentElement.TriggerEventAsync("onpointerenter", new PointerEventArgs());
+ button.ParentElement.Children.Should().HaveCount(2);
var popoverNode = button.ParentElement.Children[1];
popoverNode.Id.Should().StartWith("popover-");
var popoverContentNode = comp.Find($"#popovercontent-{popoverNode.Id.Substring(8)}");
+
+ //no content for the popover node
+ popoverContentNode.Children.Should().BeEmpty();
+
+ //trigger pointerover
+ await button.ParentElement.TriggerEventAsync("onpointerenter", new PointerEventArgs());
+
//content should be visible
popoverContentNode.ClassList.Should().Contain("mud-tooltip");
popoverContentNode.ClassList.Should().Contain("d-flex");
@@ -137,9 +140,7 @@ public async Task RenderTooltipFragment(bool usingFocusout)
button.ParentElement.FocusOut();
}
//no content should be visible
- comp.Markup.Should().NotContain("My content");
- //the button [0] and the popover node doesn't exist again
- button.ParentElement.Children.Should().HaveCount(1);
+ popoverContentNode.Children.Should().BeEmpty();
}
[Test]
@@ -357,81 +358,39 @@ public async Task Tooltip_Disabled_Button_OnPointerEnter_NoPopover()
comp.FindAll("div.mud-popover-open").Count.Should().Be(0);
}
- [TestCase(0, 0)]
- [TestCase(500, 500)]
- [Test]
- public void Tooltip_Debouncer_Initials(double duration, double delay)
- {
- var comp = Context.RenderComponent(p =>
- {
- p.Add(x => x.Delay, delay);
- p.Add(x => x.Duration, duration);
- });
-
- var tooltipComp = comp.FindComponent().Instance;
- tooltipComp.Delay.Should().Be(delay);
- tooltipComp.Duration.Should().Be(duration);
- tooltipComp._previousDelay.Should().Be(delay);
- tooltipComp._previousDuration.Should().Be(duration);
- var button = comp.Find("button");
- button.Should().NotBeNull();
- }
-
- [TestCase(0, 0)]
- [TestCase(500, 500)]
[Test]
- public async Task Tooltip_Debouncer_Duration_and_Delay(double duration, double delay)
+ [TestCase(true)]
+ [TestCase(false)]
+ public async Task Tooltip_Handle_Pointer_Events(bool showOnHover)
{
- var comp = Context.RenderComponent(p =>
- {
- p.Add(x => x.Delay, delay);
- p.Add(x => x.Duration, duration);
- });
-
- var tooltipComp = comp.FindComponent().Instance;
-
- // cannot await or it waits until the debounce happens
- var eventTask = tooltipComp.HandlePointerEnterAsync();
- if (delay > 0)
- tooltipComp.ShowToolTip().Should().BeFalse();
-
- await Task.Delay((int)delay + 50);
- tooltipComp.ShowToolTip().Should().BeTrue();
+ var comp = Context.RenderComponent(parameters => parameters
+ .Add(x => x.ShowOnHover, showOnHover)
+ .Add(x => x.ShowOnClick, true)
+ .Add(x => x.Text, "tooltip text")
+ );
- await eventTask; // ensure all completed
+ var div = comp.Find(".mud-tooltip-root");
+ div.Should().NotBeNull();
- // cannot await or it waits until the debounce happens
- eventTask = tooltipComp.HandlePointerLeaveAsync();
- if (duration > 0)
- tooltipComp.ShowToolTip().Should().BeTrue();
+ var tooltip = comp.Instance;
+ tooltip.Should().NotBeNull();
- await Task.Delay((int)(duration + delay) + 50);
- tooltipComp.ShowToolTip().Should().BeFalse();
+ await tooltip.HandlePointerEnterAsync();
+ tooltip.GetState(x => x.Visible).Should().Be(showOnHover);
- await eventTask;
- }
-
- [TestCase(true)]
- [TestCase(false)]
- [Test]
- public async Task Tooltip_ShowOnHover(bool showOnHover)
- {
- var comp = Context.RenderComponent(p =>
+ if (showOnHover)
{
- p.Add(x => x.ShowOnHover, showOnHover);
- });
- // we don't need to await Task.Delay to account for Delay/Duration since the await Handle takes care of it.
- var tooltipComp = comp.FindComponent().Instance;
- tooltipComp.ShowOnHover.Should().Be(showOnHover);
- if (!showOnHover)
- {
- await tooltipComp.HandlePointerEnterAsync();
- tooltipComp.ShowToolTip().Should().BeFalse();
+ await tooltip.HandlePointerLeaveAsync();
+ tooltip.GetState(x => x.Visible).Should().Be(!showOnHover);
}
- else
+
+ await div.PointerEnterAsync(new PointerEventArgs());
+ tooltip.GetState(x => x.Visible).Should().Be(showOnHover);
+
+ if (showOnHover)
{
- await tooltipComp.HandlePointerEnterAsync();
- tooltipComp.ShowToolTip().Should().BeTrue();
+ await div.PointerLeaveAsync(new PointerEventArgs());
+ tooltip.GetState(x => x.Visible).Should().Be(!showOnHover);
}
}
}
diff --git a/src/MudBlazor.UnitTests/Components/UserAttributes/UserAttributesTests.cs b/src/MudBlazor.UnitTests/Components/UserAttributes/UserAttributesTests.cs
index 67309a85b955..5b3c8d35a755 100644
--- a/src/MudBlazor.UnitTests/Components/UserAttributes/UserAttributesTests.cs
+++ b/src/MudBlazor.UnitTests/Components/UserAttributes/UserAttributesTests.cs
@@ -23,6 +23,8 @@ static UserAttributesTests()
Exclude(typeof(MudPicker<>)); // Internal component, skip
Exclude(typeof(MudRadioGroup<>)); // Wrapping component, skip
Exclude(typeof(MudOverlay)); // Sectioned component, skip
+ Exclude(typeof(DataGridGroupRow<>)); // Internal component, skip
+ Exclude(typeof(DataGridVirtualizeRow<>)); // Internal component, skip
}
[Test]
diff --git a/src/MudBlazor.UnitTests/Extensions/ServiceCollectionExtensionsTests.cs b/src/MudBlazor.UnitTests/Extensions/ServiceCollectionExtensionsTests.cs
index 495c4a19bdd5..e8bf381a047f 100644
--- a/src/MudBlazor.UnitTests/Extensions/ServiceCollectionExtensionsTests.cs
+++ b/src/MudBlazor.UnitTests/Extensions/ServiceCollectionExtensionsTests.cs
@@ -377,6 +377,23 @@ public void AddMudEventManager_ShouldRegisterServices()
eventListenerFactory.Should().NotBeNull();
}
+ [Test]
+ public void AddMudBlazorPointerEventsNoneService_ShouldRegisterServices()
+ {
+ // Arrange
+ var services = new ServiceCollection()
+ .AddLogging()
+ .AddSingleton();
+
+ // Act
+ services.AddMudBlazorPointerEventsNoneService();
+ var serviceProvider = services.BuildServiceProvider();
+ var pointerEventsNoneService = serviceProvider.GetService();
+
+ // Assert
+ pointerEventsNoneService.Should().NotBeNull();
+ }
+
[Test]
public void AddMudLocalization_ShouldRegisterServices()
{
diff --git a/src/MudBlazor.UnitTests/Services/PointerEvents/Mocks/PointerEventsNoneObserverMock.cs b/src/MudBlazor.UnitTests/Services/PointerEvents/Mocks/PointerEventsNoneObserverMock.cs
new file mode 100644
index 000000000000..a7d1298b6853
--- /dev/null
+++ b/src/MudBlazor.UnitTests/Services/PointerEvents/Mocks/PointerEventsNoneObserverMock.cs
@@ -0,0 +1,29 @@
+๏ปฟ// Copyright (c) MudBlazor 2021
+// MudBlazor licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace MudBlazor.UnitTests.Services.PointerEvents.Mocks;
+
+public class PointerEventsNoneObserverMock : IPointerEventsNoneObserver
+{
+ public string ElementId { get; }
+
+ public List<(string elemendId, EventArgs eventArgs)> Notifications { get; } = new();
+
+ public PointerEventsNoneObserverMock(string elementId)
+ {
+ ElementId = elementId;
+ }
+
+ public Task NotifyOnPointerDownAsync(EventArgs args)
+ {
+ Notifications.Add((ElementId, args));
+ return Task.CompletedTask;
+ }
+
+ public Task NotifyOnPointerUpAsync(EventArgs args)
+ {
+ Notifications.Add((ElementId, args));
+ return Task.CompletedTask;
+ }
+}
diff --git a/src/MudBlazor.UnitTests/Services/PointerEvents/PointerEventsNoneObserverTests.cs b/src/MudBlazor.UnitTests/Services/PointerEvents/PointerEventsNoneObserverTests.cs
new file mode 100644
index 000000000000..6e2cf2f77b90
--- /dev/null
+++ b/src/MudBlazor.UnitTests/Services/PointerEvents/PointerEventsNoneObserverTests.cs
@@ -0,0 +1,139 @@
+๏ปฟ// Copyright (c) MudBlazor 2021
+// MudBlazor licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Moq;
+using NUnit.Framework;
+
+namespace MudBlazor.UnitTests.Services.PointerEvents;
+
+[TestFixture]
+public class PointerEventsNoneObserverTests
+{
+ [Test]
+ public void Constructor_WhenCalled_DoesNotInvokePointerObservers()
+ {
+ // Arrange
+ var pointerDownMock = new Mock();
+ pointerDownMock
+ .Setup(x => x.NotifyOnPointerDownAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ var pointerUpMock = new Mock();
+ pointerUpMock
+ .Setup(x => x.NotifyOnPointerUpAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ // Act
+ var observer = new PointerEventsNoneObserver("observer1", pointerDownMock.Object, pointerUpMock.Object);
+
+ // Assert
+ pointerDownMock.Verify(x => x.NotifyOnPointerDownAsync(It.IsAny()), Times.Never);
+ pointerUpMock.Verify(x => x.NotifyOnPointerUpAsync(It.IsAny()), Times.Never);
+ }
+
+ [Test]
+ public async Task NotifyOnPointerDownAsync_WhenCalled_InvokesPointerDownObserver()
+ {
+ // Arrange
+ var pointerDownMock = new Mock();
+ pointerDownMock
+ .Setup(x => x.NotifyOnPointerDownAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ IPointerEventsNoneObserver observer = new PointerEventsNoneObserver("observer1", pointerDownMock.Object, null);
+
+ // Act
+ await observer.NotifyOnPointerDownAsync(EventArgs.Empty);
+
+ // Assert
+ pointerDownMock.Verify(x => x.NotifyOnPointerDownAsync(It.IsAny()), Times.Once);
+ }
+
+ [Test]
+ public async Task NotifyOnPointerDownAsync_WhenCalled_DoesNotInvokePointerUpObserver()
+ {
+ // Arrange
+ var pointerUpMock = new Mock();
+ pointerUpMock
+ .Setup(x => x.NotifyOnPointerUpAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ IPointerEventsNoneObserver observer = new PointerEventsNoneObserver("observer1", null, pointerUpMock.Object);
+
+ // Act
+ await observer.NotifyOnPointerDownAsync(EventArgs.Empty);
+
+ // Assert
+ pointerUpMock.Verify(x => x.NotifyOnPointerUpAsync(It.IsAny()), Times.Never);
+ }
+
+ [Test]
+ public async Task NotifyOnPointerUpAsync_WhenCalled_InvokesPointerUpObserver()
+ {
+ // Arrange
+ var pointerUpMock = new Mock();
+ pointerUpMock
+ .Setup(x => x.NotifyOnPointerUpAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ IPointerEventsNoneObserver observer = new PointerEventsNoneObserver("observer1", null, pointerUpMock.Object);
+
+ // Act
+ await observer.NotifyOnPointerUpAsync(EventArgs.Empty);
+
+ // Assert
+ pointerUpMock.Verify(x => x.NotifyOnPointerUpAsync(It.IsAny()), Times.Once);
+ }
+
+ [Test]
+ public async Task NotifyOnPointerUpAsync_WhenCalled_DoesNotInvokePointerDownObserver()
+ {
+ // Arrange
+ var pointerDownMock = new Mock();
+ pointerDownMock
+ .Setup(x => x.NotifyOnPointerDownAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ IPointerEventsNoneObserver observer = new PointerEventsNoneObserver("observer1", pointerDownMock.Object, null);
+
+ // Act
+ await observer.NotifyOnPointerUpAsync(EventArgs.Empty);
+
+ // Assert
+ pointerDownMock.Verify(x => x.NotifyOnPointerDownAsync(It.IsAny()), Times.Never);
+ }
+
+ [Test]
+ public async Task NotifyOnPointerDownAndUpAsync_WhenCalled_InvokesBothObservers()
+ {
+ // Arrange
+ var pointerDownMock = new Mock();
+ pointerDownMock
+ .Setup(x => x.NotifyOnPointerDownAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ var pointerUpMock = new Mock();
+ pointerUpMock
+ .Setup(x => x.NotifyOnPointerUpAsync(It.IsAny()))
+ .Returns(Task.CompletedTask)
+ .Verifiable();
+
+ IPointerEventsNoneObserver observer = new PointerEventsNoneObserver("observer1", pointerDownMock.Object, pointerUpMock.Object);
+
+ // Act
+ await observer.NotifyOnPointerDownAsync(EventArgs.Empty);
+ await observer.NotifyOnPointerUpAsync(EventArgs.Empty);
+
+ // Assert
+ pointerDownMock.Verify(x => x.NotifyOnPointerDownAsync(It.IsAny()), Times.Once);
+ pointerUpMock.Verify(x => x.NotifyOnPointerUpAsync(It.IsAny()), Times.Once);
+ }
+}
diff --git a/src/MudBlazor.UnitTests/Services/PointerEvents/PointerEventsNoneServiceTests.cs b/src/MudBlazor.UnitTests/Services/PointerEvents/PointerEventsNoneServiceTests.cs
new file mode 100644
index 000000000000..0ea42e15b6f1
--- /dev/null
+++ b/src/MudBlazor.UnitTests/Services/PointerEvents/PointerEventsNoneServiceTests.cs
@@ -0,0 +1,172 @@
+๏ปฟ// Copyright (c) MudBlazor 2021
+// MudBlazor licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using FluentAssertions;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.JSInterop;
+using Microsoft.JSInterop.Infrastructure;
+using Moq;
+using MudBlazor.UnitTests.Services.PointerEvents.Mocks;
+using NUnit.Framework;
+
+namespace MudBlazor.UnitTests.Services.PointerEvents;
+
+#nullable enable
+
+[TestFixture]
+public class PointerEventsNoneServiceTests
+{
+ [Test]
+ public async Task SubscribeAsync_WithObserver_ShouldSubscribe()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var observer = new PointerEventsNoneObserverMock("observer1");
+ var options = new PointerEventsNoneOptions();
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+
+ // Act
+ await service.SubscribeAsync(observer, options);
+
+ // Assert
+ observer.Notifications.Count.Should().Be(0);
+ service.ObserversCount.Should().Be(1);
+ jsRuntimeMock.Verify(x => x.InvokeAsync("mudPointerEventsNone.listenForPointerEvents", It.IsAny(), It.IsAny()), Times.Once);
+ }
+
+ [Test]
+ public async Task SubscribeAsync_ReSubscribeWithSameObserverIdentifier()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var observer = new PointerEventsNoneObserverMock("observer1");
+ var options = new PointerEventsNoneOptions();
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+
+ // Act
+ await service.SubscribeAsync(observer, options);
+ await service.SubscribeAsync(observer, options);
+ await service.SubscribeAsync(observer, options);
+
+ // Assert
+ observer.Notifications.Count.Should().Be(0);
+ service.ObserversCount.Should().Be(1);
+ jsRuntimeMock.Verify(x => x.InvokeAsync("mudPointerEventsNone.listenForPointerEvents", It.IsAny(), It.IsAny()), Times.Once);
+ }
+
+ [Test]
+ public async Task SubscribeAsync_MultipleObservers_ShouldNotifyCorrectObserver()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var observer1 = new PointerEventsNoneObserverMock("observer1");
+ var observer2 = new PointerEventsNoneObserverMock("observer2");
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+
+ await service.SubscribeAsync(observer1, new());
+ await service.SubscribeAsync(observer2, new());
+
+ // Act
+ await service.RaiseOnPointerDown([observer2.ElementId]);
+
+ // Assert
+ service.ObserversCount.Should().Be(2);
+ observer1.Notifications.Count.Should().Be(0);
+ observer2.Notifications.Count.Should().Be(1);
+ observer2.Notifications.Should().ContainSingle().Which.Should().BeEquivalentTo((observer2.ElementId, EventArgs.Empty));
+ }
+
+ [Test]
+ public async Task SubscribeAsync_Overloads()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+
+ // Act
+ await service.SubscribeAsync("observer1", new());
+ await service.SubscribeAsync("observer2", new(), PointerEventsNoneObserver.PointerDownIgnore(), PointerEventsNoneObserver.PointerUpIgnore());
+
+ // Assert
+ service.ObserversCount.Should().Be(2);
+ }
+
+ [Test]
+ public async Task RaiseOnPointerDown_ShouldNotifyObservers()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var observer = new PointerEventsNoneObserverMock("observer1");
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+ await service.SubscribeAsync(observer, new());
+
+ // Act
+ await service.RaiseOnPointerDown([observer.ElementId]);
+
+ // Assert
+ service.ObserversCount.Should().Be(1);
+ observer.Notifications.Count.Should().Be(1);
+ observer.Notifications.Should().ContainSingle().Which.Should().BeEquivalentTo((observer.ElementId, EventArgs.Empty));
+ }
+
+ [Test]
+ public async Task RaiseOnPointerUp_ShouldNotifyObservers()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var observer = new PointerEventsNoneObserverMock("observer1");
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+ await service.SubscribeAsync(observer, new());
+
+ // Act
+ await service.RaiseOnPointerUp([observer.ElementId]);
+
+ // Assert
+ service.ObserversCount.Should().Be(1);
+ observer.Notifications.Count.Should().Be(1);
+ observer.Notifications.Should().ContainSingle().Which.Should().BeEquivalentTo((observer.ElementId, EventArgs.Empty));
+ }
+
+ [Test]
+ public async Task UnsubscribeAsync_UnsubscribeObserver()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var observer = new PointerEventsNoneObserverMock("observer1");
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+ await service.SubscribeAsync(observer, new());
+
+ // Act
+ await service.UnsubscribeAsync(observer);
+
+ // Assert
+ service.ObserversCount.Should().Be(0);
+ jsRuntimeMock.Verify(x => x.InvokeAsync("mudPointerEventsNone.listenForPointerEvents", It.IsAny(), It.IsAny()), Times.Once);
+ jsRuntimeMock.Verify(x => x.InvokeAsync("mudPointerEventsNone.cancelListener", It.IsAny(), It.IsAny()), Times.Once);
+ }
+
+ [Test]
+ public async Task DisposeAsync_ShouldClearAllObservers()
+ {
+ // Arrange
+ var jsRuntimeMock = new Mock();
+ var service = new PointerEventsNoneService(NullLogger.Instance, jsRuntimeMock.Object);
+ await service.SubscribeAsync("observer1", new());
+ await service.SubscribeAsync("observer2", new());
+ await service.SubscribeAsync("observer3", new());
+ await service.SubscribeAsync("observer4", new());
+ await service.SubscribeAsync("observer5", new());
+ var beforeObserversCount = service.ObserversCount;
+
+ // Act
+ await service.DisposeAsync();
+ var afterObserversCount = service.ObserversCount;
+
+ // Assert
+ beforeObserversCount.Should().Be(5);
+ afterObserversCount.Should().Be(0);
+ jsRuntimeMock.Verify(x => x.InvokeAsync("mudPointerEventsNone.listenForPointerEvents", It.IsAny(), It.IsAny()), Times.Exactly(5));
+ jsRuntimeMock.Verify(x => x.InvokeAsync("mudPointerEventsNone.dispose", It.IsAny(), It.IsAny()), Times.Once);
+ }
+}
diff --git a/src/MudBlazor.UnitTests/Services/Popover/PopoverServiceTests.cs b/src/MudBlazor.UnitTests/Services/Popover/PopoverServiceTests.cs
index fe3d6f0ac746..f8ab51148fc1 100644
--- a/src/MudBlazor.UnitTests/Services/Popover/PopoverServiceTests.cs
+++ b/src/MudBlazor.UnitTests/Services/Popover/PopoverServiceTests.cs
@@ -2,11 +2,6 @@
// MudBlazor licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.AspNetCore.Components;
using Microsoft.Extensions.Logging.Abstractions;
@@ -545,7 +540,7 @@ public async Task CreatePopoverAsync_UpdatePopoverAsync_DestroyPopoverAsync_Shou
.Callback(signalEvent.Set);
jsRuntimeMock.Setup(x => x.InvokeAsync("mudPopover.initialize", It.IsAny |