Merge pull request #1001 from bUnit-dev/release/v1.18

Release of new minor version v1.18

Author: egil

.editorconfig

@@ -504,3 +504,4 @@ dotnet_diagnostic.S125.severity = none # S125: Sections of code should not be co
 dotnet_diagnostic.S3459.severity = none # S3459: Unassigned members should be removed
 dotnet_diagnostic.S3871.severity = none # S3871: Exception types should be "public"
 dotnet_diagnostic.S1186.severity = none # S1186: Methods should not be empty
+dotnet_diagnostic.S1133.severity = none # S1133: Deprecated code should be removed

CHANGELOG.md

@@ -6,6 +6,11 @@ All notable changes to **bUnit** will be documented in this file. The project ad
 
 ## [Unreleased]
 
+### Fixed
+
+-   Some characters where not properly escaped. Reported by [@pwhe23](https://github.com/pwhe23). Fixed by [@linkdotnet](https://github.com/linkdotnet).
+-	Clicking a submit button or submit input element inside a form, submits the form, if the submit button or submit input element does not have the `@onclick:preventDefault` attribute set. Reported by [@linkdotnet](https://github.com/linkdotnet). Fixed by [@egil](https://github.com/egil).
+
 ## [1.17.2] - 2023-02-22
 
 -   Submit buttons and input fields now no longer cause a form submit when they have the `@onclick:preventDefault` attribute. By [@JelleHissink](https://github.com/JelleHissink).

Directory.Build.props

@@ -50,7 +50,7 @@
 	<!-- Shared code analyzers used for all projects in the solution -->
 	<ItemGroup Label="Code Analyzers">
 		<PackageReference Include="AsyncFixer" Version="1.6.0" PrivateAssets="All" />
-		<PackageReference Include="SonarAnalyzer.CSharp" Version="8.52.0.60960" PrivateAssets="All" />
+		<PackageReference Include="SonarAnalyzer.CSharp" Version="8.53.0.62665" PrivateAssets="All" />
 	</ItemGroup>
 
 	<ItemGroup Label="Implicit usings"

src/.editorconfig

@@ -36,3 +36,5 @@
 ##########################################
 # Custom - Code Analyzers Rules
 ##########################################
+
+dotnet_diagnostic.S1133.severity = none # S1133: Deprecated code should be removed

src/bunit.web/ComponentFactories/StubComponentFactory.cs

@@ -22,7 +22,7 @@ public bool CanCreate(Type componentType)
 	public IComponent Create(Type componentType)
 	{
 		var typeToCreate = StubType.MakeGenericType(componentType);
-		return (IComponent)Activator.CreateInstance(typeToCreate, new object?[] { replacementContent })!;
+		return (IComponent)Activator.CreateInstance(typeToCreate, replacementContent)!;
 	}
 }
 #endif

src/bunit.web/EventDispatchExtensions/TriggerEventDispatchExtensions.cs

@@ -60,9 +60,14 @@ public static void TriggerEvent(this IElement element, string eventName, EventAr
 	public static Task TriggerEventAsync(this IElement element, string eventName, EventArgs eventArgs)
 	{
 		if (element is null)
+		{
 			throw new ArgumentNullException(nameof(element));
+		}
+
 		if (eventName is null)
+		{
 			throw new ArgumentNullException(nameof(eventName));
+		}
 
 		var renderer = element.GetTestContext()?.Renderer
 			?? throw new InvalidOperationException($"Blazor events can only be raised on elements rendered with the Blazor test renderer '{nameof(ITestRenderer)}'.");
@@ -80,49 +85,41 @@ public static Task TriggerEventAsync(this IElement element, string eventName, Ev
 	}
 
 	[SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "HTML events are standardize to lower case and safe in this context.")]
-	private static async Task TriggerEventsAsync(ITestRenderer renderer, IElement element, string eventName, EventArgs eventArgs)
+	private static Task TriggerEventsAsync(ITestRenderer renderer, IElement element, string eventName, EventArgs eventArgs)
 	{
 		var isNonBubblingEvent = NonBubblingEvents.Contains(eventName.ToLowerInvariant());
 		var unwrappedElement = element.Unwrap();
-		if (isNonBubblingEvent)
-			await TriggerNonBubblingEventAsync(renderer, unwrappedElement, eventName, eventArgs);
-		else
-			await TriggerBubblingEventAsync(renderer, unwrappedElement, eventName, eventArgs);
 
-		switch (unwrappedElement)
-		{
-			case IHtmlInputElement { Type: "submit", Form: not null } input when eventName is "onclick":
-				await TriggerFormSubmitAsync(renderer, input, eventArgs, input.Form);
-				break;
-			case IHtmlButtonElement { Type: "submit", Form: not null } button when eventName is "onclick":
-				await TriggerFormSubmitAsync(renderer, button, eventArgs, button.Form);
-				break;
-		}
+		return isNonBubblingEvent
+			? TriggerNonBubblingEventAsync(renderer, unwrappedElement, eventName, eventArgs)
+			: TriggerBubblingEventAsync(renderer, unwrappedElement, eventName, eventArgs);
 	}
 
-	private static Task TriggerFormSubmitAsync(ITestRenderer renderer, IElement element, EventArgs eventArgs, IHtmlFormElement form)
+	private static Task TriggerNonBubblingEventAsync(ITestRenderer renderer, IElement element, string eventName, EventArgs eventArgs)
 	{
-		const string eventName = "onclick";
-
 		var eventAttrName = Htmlizer.ToBlazorAttribute(eventName);
-		var preventDefaultAttrName = $"{eventAttrName}:preventdefault";
-		if (element.HasAttribute(preventDefaultAttrName))
-			return Task.CompletedTask;
 
-		var events = GetDispatchEventTasks(renderer, form, "onsubmit", eventArgs);
+		if (string.Equals(eventName, "onsubmit", StringComparison.Ordinal) && element is not IHtmlFormElement)
+		{
+			throw new InvalidOperationException("Only forms can have a onsubmit event");
+		}
 
-		if (events.Count == 0)
-			throw new MissingEventHandlerException(element, eventName);
+		if (element.TryGetEventId(eventAttrName, out var id))
+		{
+			return renderer.DispatchEventAsync(id, new EventFieldInfo { FieldValue = eventName }, eventArgs);
+		}
 
-		return Task.WhenAll(events);
+		throw new MissingEventHandlerException(element, eventName);
 	}
 
 	private static Task TriggerBubblingEventAsync(ITestRenderer renderer, IElement element, string eventName, EventArgs eventArgs)
 	{
 		var eventTasks = GetDispatchEventTasks(renderer, element, eventName, eventArgs);
 
 		if (eventTasks.Count == 0)
+		{
 			throw new MissingEventHandlerException(element, eventName);
+		}
 
 		return Task.WhenAll(eventTasks);
 	}
@@ -139,10 +136,17 @@ private static List<Task> GetDispatchEventTasks(
 
 		foreach (var candidate in element.GetParentsAndSelf())
 		{
-			if (candidate.TryGetEventId(eventAttrName, out var id))
+			if (candidate.TryGetEventId(eventAttrName, out var eventId))
 			{
 				var info = new EventFieldInfo { FieldValue = eventName };
-				eventTasks.Add(renderer.DispatchEventAsync(id, info, eventArgs, ignoreUnknownEventHandlers: eventTasks.Count > 0));
+				eventTasks.Add(renderer.DispatchEventAsync(eventId, info, eventArgs, ignoreUnknownEventHandlers: eventTasks.Count > 0));
+			}
+
+			// Special case for elements inside form elements
+			if (TryGetParentFormElementSpecialCase(candidate, eventName, out var formEventId))
+			{
+				var info = new EventFieldInfo { FieldValue = "onsubmit" };
+				eventTasks.Add(renderer.DispatchEventAsync(formEventId, info, eventArgs, ignoreUnknownEventHandlers: true));
 			}
 
 			if (candidate.HasAttribute(eventStopPropagationAttrName) || candidate.EventIsDisabled(eventName))
@@ -154,34 +158,46 @@ private static List<Task> GetDispatchEventTasks(
 		return eventTasks;
 	}
 
-	private static Task TriggerNonBubblingEventAsync(ITestRenderer renderer, IElement element, string eventName, EventArgs eventArgs)
+	private static bool TryGetParentFormElementSpecialCase(
+		IElement element,
+		string eventName,
+		out ulong eventId)
 	{
-		var eventAttrName = Htmlizer.ToBlazorAttribute(eventName);
+		eventId = default;
 
-		if (string.Equals(eventName, "onsubmit", StringComparison.Ordinal) && element is not IHtmlFormElement)
-			throw new InvalidOperationException("Only forms can have a onsubmit event");
+		if (!eventName.Equals("onclick", StringComparison.OrdinalIgnoreCase))
+		{
+			return false;
+		}
 
-		if (element.TryGetEventId(eventAttrName, out var id))
-			return renderer.DispatchEventAsync(id, new EventFieldInfo { FieldValue = eventName }, eventArgs);
+		var eventAttrName = Htmlizer.ToBlazorAttribute(eventName);
+		var preventDefaultAttrName = $"{eventAttrName}:preventdefault";
+		if (element.HasAttribute(preventDefaultAttrName))
+		{
+			return false;
+		}
 
-		throw new MissingEventHandlerException(element, eventName);
+		var form = element switch
+		{
+			IHtmlInputElement { Type: "submit", Form: not null } input => input.Form,
+			IHtmlButtonElement { Type: "submit", Form: not null } button => button.Form,
+			_ => null
+		};
+
+		return form is not null
+			&& form.TryGetEventId(Htmlizer.ToBlazorAttribute("onsubmit"), out eventId);
 	}
 
 	private static bool EventIsDisabled(this IElement element, string eventName)
 	{
 		// We want to replicate the normal DOM event behavior that, for 'interactive' elements
 		// with a 'disabled' attribute, certain mouse events are suppressed
 
-		switch (element)
+		return element switch
 		{
-			case IHtmlButtonElement:
-			case IHtmlInputElement:
-			case IHtmlTextAreaElement:
-			case IHtmlSelectElement:
-				return DisabledEventNames.Contains(eventName) && element.IsDisabled();
-			default:
-				return false;
-		}
+			IHtmlButtonElement or IHtmlInputElement or IHtmlTextAreaElement or IHtmlSelectElement => DisabledEventNames.Contains(eventName) && element.IsDisabled(),
+			_ => false,
+		};
 	}
 
 	private static bool TryGetEventId(this IElement element, string blazorEventName, out ulong id)