Feature/367/missing numpad key mappings (#368)

* (#367) Added mappings for missing numpad keys

* (#367) Updated keyboard tests

Author: s1hofmann

lib/provider/native/libnut-keyboard.class.spec.ts

@@ -10,12 +10,12 @@ beforeEach(() => {
 
 describe("libnut keyboard action", () => {
   describe("click", () => {
-    it("should forward the keyTap call to libnut for a known key", () => {
+    it("should forward the keyTap call to libnut for a known key", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.click(Key.A);
+      await SUT.click(Key.A);
 
       // THEN
       expect(libnut.keyTap).toBeCalledTimes(1);
@@ -31,29 +31,29 @@ describe("libnut keyboard action", () => {
       // WHEN
 
       // THEN
-      expect(SUT.click(Key.A)).rejects.toThrowError("Test error");
+      await expect(SUT.click(Key.A)).rejects.toThrowError("Test error");
     });
 
-    it("should not forward the keyTap call to libnut for an unknown key", () => {
+    it("should not forward the keyTap call to libnut for an unknown key", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.click(Key.Add);
+      await SUT.click(Key.Pause);
 
       // THEN
       expect(libnut.keyTap).not.toBeCalled();
     });
   });
 
   describe("type", () => {
-    it("should forward the type call to libnut", () => {
+    it("should forward the type call to libnut", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
       const payload = "testInput";
 
       // WHEN
-      SUT.type(payload);
+      await SUT.type(payload);
 
       // THEN
       expect(libnut.typeString).toBeCalledTimes(1);
@@ -70,42 +70,42 @@ describe("libnut keyboard action", () => {
       // WHEN
 
       // THEN
-      expect(SUT.type("foo")).rejects.toThrowError("Test error");
+      await expect(SUT.type("foo")).rejects.toThrowError("Test error");
     });
   });
 
   describe("pressKey", () => {
-    it("should forward the pressKey call to libnut for a known key", () => {
+    it("should forward the pressKey call to libnut for a known key", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.pressKey(Key.A);
+      await SUT.pressKey(Key.A);
 
       // THEN
       expect(libnut.keyToggle).toBeCalledTimes(1);
       expect(libnut.keyToggle).toBeCalledWith(KeyboardAction.keyLookup(Key.A), "down", []);
     });
 
-    it("should treat a list of keys as modifiers + the actual key to press", () => {
+    it("should treat a list of keys as modifiers + the actual key to press", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.pressKey(Key.LeftControl, Key.A);
+      await SUT.pressKey(Key.LeftControl, Key.A);
 
       // THEN
       expect(libnut.keyToggle).toBeCalledTimes(1);
       expect(libnut.keyToggle)
         .toBeCalledWith(KeyboardAction.keyLookup(Key.A), "down", [KeyboardAction.keyLookup(Key.LeftControl)]);
     });
 
-    it("should not forward the pressKey call to libnut for an unknown key", () => {
+    it("should not forward the pressKey call to libnut for an unknown key", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.pressKey(Key.Add);
+      await SUT.pressKey(Key.Pause);
 
       // THEN
       expect(libnut.keyToggle).not.toBeCalled();
@@ -121,42 +121,42 @@ describe("libnut keyboard action", () => {
       // WHEN
 
       // THEN
-      expect(SUT.pressKey(Key.A)).rejects.toThrowError("Test error");
+      await expect(SUT.pressKey(Key.A)).rejects.toThrowError("Test error");
     });
   });
 
   describe("releaseKey", () => {
-    it("should forward the releaseKey call to libnut for a known key", () => {
+    it("should forward the releaseKey call to libnut for a known key", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.releaseKey(Key.A);
+      await SUT.releaseKey(Key.A);
 
       // THEN
       expect(libnut.keyToggle).toBeCalledTimes(1);
       expect(libnut.keyToggle).toBeCalledWith(KeyboardAction.keyLookup(Key.A), "up", []);
     });
 
-    it("should treat a list of keys as modifiers + the actual key to release", () => {
+    it("should treat a list of keys as modifiers + the actual key to release", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.releaseKey(Key.LeftControl, Key.A);
+      await SUT.releaseKey(Key.LeftControl, Key.A);
 
       // THEN
       expect(libnut.keyToggle).toBeCalledTimes(1);
       expect(libnut.keyToggle)
         .toBeCalledWith(KeyboardAction.keyLookup(Key.A), "up", [KeyboardAction.keyLookup(Key.LeftControl)]);
     });
 
-    it("should not forward the releaseKey call to libnut for an unknown key", () => {
+    it("should not forward the releaseKey call to libnut for an unknown key", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.releaseKey(Key.Add);
+      await SUT.releaseKey(Key.Pause);
 
       // THEN
       expect(libnut.keyToggle).not.toBeCalled();
@@ -172,29 +172,29 @@ describe("libnut keyboard action", () => {
       // WHEN
 
       // THEN
-      expect(SUT.releaseKey(Key.A)).rejects.toThrowError("Test error");
+      await expect(SUT.releaseKey(Key.A)).rejects.toThrowError("Test error");
     });
   });
 
   describe("bugfix #260", () => {
-    it("should forward the pressKey call to libnut for 'delete'", () => {
+    it("should forward the pressKey call to libnut for 'delete'", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.pressKey(Key.Delete);
+      await SUT.pressKey(Key.Delete);
 
       // THEN
       expect(libnut.keyToggle).toBeCalledTimes(1);
       expect(libnut.keyToggle).toBeCalledWith("delete", "down", []);
     });
 
-    it("should forward the releaseKey call to libnut for 'delete'", () => {
+    it("should forward the releaseKey call to libnut for 'delete'", async () => {
       // GIVEN
       const SUT = new KeyboardAction();
 
       // WHEN
-      SUT.releaseKey(Key.Delete);
+      await SUT.releaseKey(Key.Delete);
 
       // THEN
       expect(libnut.keyToggle).toBeCalledTimes(1);

lib/provider/native/libnut-keyboard.class.ts

@@ -77,6 +77,7 @@ export default class KeyboardAction implements KeyboardProviderInterface {
         [Key.NumPad7, "numpad_7"],
         [Key.NumPad8, "numpad_8"],
         [Key.NumPad9, "numpad_9"],
+        [Key.Decimal, "numpad_decimal"],
 
         [Key.Space, "space"],
         [Key.Escape, "escape"],
@@ -119,16 +120,15 @@ export default class KeyboardAction implements KeyboardProviderInterface {
         [Key.PageUp, "pageup"],
         [Key.PageDown, "pagedown"],
 
-        [Key.Add, null],
-        [Key.Subtract, null],
-        [Key.Multiply, null],
-        [Key.Divide, null],
-        [Key.Decimal, null],
+        [Key.Add, "add"],
+        [Key.Subtract, "subtract"],
+        [Key.Multiply, "multiply"],
+        [Key.Divide, "divide"],
         [Key.Enter, "enter"],
 
-        [Key.CapsLock, null],
-        [Key.ScrollLock, null],
-        [Key.NumLock, null],
+        [Key.CapsLock, "caps_lock"],
+        [Key.ScrollLock, "scroll_lock"],
+        [Key.NumLock, "num_lock"],
 
         [Key.AudioMute, "audio_mute"],
         [Key.AudioVolDown, "audio_vol_down"],