Add KeyboardEventDispatcher test for special keys

Author: duracellko

src/bunit.web/EventDispatchExtensions/Key.cs

@@ -60,14 +60,14 @@ private Key(string value, string code, bool controlKey, bool shiftKey, bool altK
 
 		/// <summary>
 		/// Gets the key value of the key represented. If the value has a printed
-        /// representation, this attribute's value is the same as the char attribute.
+		/// representation, this attribute's value is the same as the char attribute.
 		/// </summary>
 		public string Value { get; }
 
 		/// <summary>
 		/// Gets the string that identifies the physical key being pressed. The value is not
-        /// affected by the current keyboard layout or modifier state, so a particular key
-        /// will always return the same value.
+		/// affected by the current keyboard layout or modifier state, so a particular key
+		/// will always return the same value.
 		/// </summary>
 		public string Code { get; }
 
@@ -337,23 +337,23 @@ private Key(string value, string code, bool controlKey, bool shiftKey, bool altK
 		/// <param name="value">The key value.</param>
 		public static Key FromChar(char value) => new Key(value);
 
-        /// <summary>
-        /// Gets the value indicating whether the current object is equal to another object of the same type.
-        /// </summary>
-        /// <param name="obj">The object to compare with this object.</param>
-        /// <returns><c>True</c> if the current object is equal to the other parameter; otherwise, <c>false</c>.</returns>
-        public override bool Equals(object? obj)
-        {
-            return obj is Key key && Equals(key);
-        }
+		/// <summary>
+		/// Gets the value indicating whether the current object is equal to another object of the same type.
+		/// </summary>
+		/// <param name="obj">The object to compare with this object.</param>
+		/// <returns><c>True</c> if the current object is equal to the other parameter; otherwise, <c>false</c>.</returns>
+		public override bool Equals(object? obj)
+		{
+			return obj is Key key && Equals(key);
+		}
 
 		/// <summary>
 		/// Gets the value indicating whether the current object is equal to another object of the same type.
 		/// </summary>
 		/// <param name="other">A key to compare with this object.</param>
 		/// <returns><c>True</c> if the current object is equal to the other parameter; otherwise, <c>false</c>.</returns>
-        public bool Equals(Key? other)
-        {
+		public bool Equals(Key? other)
+		{
 			if (other is null)
 			{
 				return false;
@@ -365,25 +365,25 @@ public bool Equals(Key? other)
 				ShiftKey == other.ShiftKey &&
 				AltKey == other.AltKey &&
 				CommandKey == other.CommandKey;
-        }
+		}
 
 		/// <summary>
 		/// Gets hash code of this object.
 		/// </summary>
 		/// <returns>A hash code for the current object.</returns>
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(Value, Code, ControlKey, ShiftKey, AltKey, CommandKey);
-        }
+		public override int GetHashCode()
+		{
+			return HashCode.Combine(Value, Code, ControlKey, ShiftKey, AltKey, CommandKey);
+		}
 
 		/// <summary>
 		/// Gets a string that represents the current object.
 		/// </summary>
 		/// <returns>A string that represents the current object.</returns>
-        public override string ToString()
-        {
-            return Value;
-        }
+		public override string ToString()
+		{
+			return Value;
+		}
 
 		/// <summary>
 		/// Gets the key with new value of Control key.
@@ -526,11 +526,14 @@ static bool IsSuitableForCombination(Key key)
 		/// <returns>The Key instance with character value.</returns>
 		[return: NotNullIfNotNull("key")]
 		[SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Key should have minimal relation to KeyboardEventArgs type")]
-		public static implicit operator KeyboardEventArgs?(Key? key)
+		public static implicit operator KeyboardEventArgs(Key key)
 		{
 			if (key is null)
 			{
-				return null;
+				// In future the operator should support null as input.
+				// However, NotNullIfNotNull does not work correctly with operators.
+				// Therfore workaround is to make input non-nullable. 
+				return null!;
 			}
 
 			return new KeyboardEventArgs
@@ -543,5 +546,5 @@ static bool IsSuitableForCombination(Key key)
 				MetaKey = key.CommandKey
 			};
 		}
-    }
+	}
 }

tests/bunit.web.tests/EventDispatchExtensions/KeyTest.cs

@@ -11,7 +11,7 @@ public class KeyTest
 	{
 		public static IEnumerable<object[]> CharTestData { get; } = new[] { ' ', 'x', 'A', '2', '0', '&', (char)0 }
 			.Select(c => new object[] { c }).ToList();
-		
+
 		public static IEnumerable<Key[]> EqualsTestData { get; } = GetEqualsTestData().Select(i => new[] { i.Item1, i.Item2 });
 
 		public static IEnumerable<Key?[]> NonEqualsTestData { get; } = GetNonEqualsTestData().Select(i => new[] { i.Item1, i.Item2 });
@@ -308,7 +308,7 @@ public void Combine2MainKeys(Key key1, Key key2)
 		[MemberData(nameof(KeyboardEventArgsTestData))]
 		public void ToKeyboardEventArgs(Key key, string value, string code, bool ctrlKey, bool shiftKey, bool altKey, bool metaKey)
 		{
-			KeyboardEventArgs result = key!;
+			KeyboardEventArgs result = key;
 			result.Key.ShouldBe(value);
 			result.Code.ShouldBe(code);
 			result.CtrlKey.ShouldBe(ctrlKey);
@@ -319,6 +319,14 @@ public void ToKeyboardEventArgs(Key key, string value, string code, bool ctrlKey
 			result.Type.ShouldBe(null);
 		}
 
+		[Fact(DisplayName = "Can convert null to KeyboardEventArgs")]
+		public void NullToKeyboardEventArgs()
+		{
+			Key key = null!;
+			KeyboardEventArgs result = key;
+			result.ShouldBeNull();
+		}
+
 		private static IEnumerable<ValueTuple<Key, Key>> GetEqualsTestData()
 		{
 			var xKey = Key.FromChar('x');

tests/bunit.web.tests/EventDispatchExtensions/KeyboardEventDispatchExtensionsTest.cs

@@ -1,10 +1,11 @@
 using System.Reflection;
 using Microsoft.AspNetCore.Components.Web;
+using Shouldly;
 using Xunit;
 
 namespace Bunit
 {
-    public class KeyboardEventDispatchExtensionsTest : EventDispatchExtensionsTest<KeyboardEventArgs>
+	public class KeyboardEventDispatchExtensionsTest : EventDispatchExtensionsTest<KeyboardEventArgs>
 	{
 		protected override string ElementName => "input";
 
@@ -27,5 +28,40 @@ public void CanRaiseEvents(MethodInfo helper)
 
 			VerifyEventRaisesCorrectly(helper, expected);
 		}
+
+		[Fact(DisplayName = "KeyDown event is raised correctly through helper using special key")]
+		public void CanRaiseKeyDownWithCtrlEnter()
+		{
+			var spy = CreateTriggerSpy(ElementName, "onkeydown");
+			spy.Trigger(element =>
+			{
+				element.KeyDown(Key.Enter + Key.Control);
+			});
+
+			var expected = new KeyboardEventArgs
+			{
+				Key = "Enter",
+				Code = "Enter",
+				CtrlKey = true
+			};
+			spy.RaisedEvent.ShouldBeEquivalentTo(expected);
+		}
+
+		[Fact(DisplayName = "KeyDown event is raised correctly through helper using character keys")]
+		public void CanRaiseKeyUpWithAKey()
+		{
+			var spy = CreateTriggerSpy(ElementName, "onkeyup");
+			spy.Trigger(element =>
+			{
+				element.KeyUp((Key)'A');
+			});
+
+			var expected = new KeyboardEventArgs
+			{
+				Key = "A",
+				Code = "A"
+			};
+			spy.RaisedEvent.ShouldBeEquivalentTo(expected);
+		}
 	}
 }