Merge pull request #134 from grafana/fix/132-special-chars

Fix/132 special chars

Author: inancgumus

common/keyboard.go

@@ -30,44 +30,92 @@ import (
 	"github.com/dop251/goja"
 	"github.com/grafana/xk6-browser/api"
 	"github.com/grafana/xk6-browser/keyboardlayout"
-	k6common "go.k6.io/k6/js/common"
 )
 
-// Ensure Keyboard implements the api.Keyboard interface
 var _ api.Keyboard = &Keyboard{}
 
 const (
-	ModifierKeyAlt     int64 = 1
-	ModifierKeyControl       = 2
-	ModifierKeyMeta          = 4
-	ModifierKeyShift         = 8
+	ModifierKeyAlt int64 = 1 << iota
+	ModifierKeyControl
+	ModifierKeyMeta
+	ModifierKeyShift
 )
 
-// Keyboard represents a keyboard input device
+// Keyboard represents a keyboard input device.
+// Each Page has a publicly accessible Keyboard.
 type Keyboard struct {
-	ctx         context.Context
-	session     *Session
-	modifiers   int64
-	pressedKeys map[int64]bool
-	layoutName  string
+	ctx     context.Context
+	session *Session
+
+	modifiers   int64          // like shift, alt, ctrl, ...
+	pressedKeys map[int64]bool // tracks keys through down() and up()
+	layoutName  string         // us by default
+	layout      keyboardlayout.KeyboardLayout
 }
 
-// NewKeyboard creates a new keyboard
+// NewKeyboard returns a new keyboard with a "us" layout.
 func NewKeyboard(ctx context.Context, session *Session) *Keyboard {
-	k := &Keyboard{
+	return &Keyboard{
 		ctx:         ctx,
 		session:     session,
-		modifiers:   0,
 		pressedKeys: make(map[int64]bool),
 		layoutName:  "us",
+		layout:      keyboardlayout.GetKeyboardLayout("us"),
+	}
+}
+
+// Down sends a key down message to a session target.
+func (k *Keyboard) Down(key string) {
+	if err := k.down(key); err != nil {
+		k6Throw(k.ctx, "cannot send key down: %w", err)
+	}
+}
+
+// Up sends a key up message to a session target.
+func (k *Keyboard) Up(key string) {
+	if err := k.up(key); err != nil {
+		k6Throw(k.ctx, "cannot send key up: %w", err)
+	}
+}
+
+// Press sends a key press message to a session target.
+// It delays the action if `Delay` option is specified.
+// A press message consists of successive key down and up messages.
+func (k *Keyboard) Press(key string, opts goja.Value) {
+	kbdOpts := NewKeyboardOptions()
+	if err := kbdOpts.Parse(k.ctx, opts); err != nil {
+		k6Throw(k.ctx, "cannot parse keyboard options: %w", err)
+	}
+	if err := k.press(key, kbdOpts); err != nil {
+		k6Throw(k.ctx, "cannot press key: %w", err)
+	}
+}
+
+// InsertText inserts a text without dispatching key events.
+func (k *Keyboard) InsertText(text string) {
+	if err := k.insertText(text); err != nil {
+		k6Throw(k.ctx, "cannot insert text: %w", err)
+	}
+}
+
+// Type sends a press message to a session target for each character in text.
+// It delays the action if `Delay` option is specified.
+//
+// It sends an insertText message if a character is not among
+// valid characters in the keyboard's layout.
+func (k *Keyboard) Type(text string, opts goja.Value) {
+	kbdOpts := NewKeyboardOptions()
+	if err := kbdOpts.Parse(k.ctx, opts); err != nil {
+		k6Throw(k.ctx, "cannot parse keyboard options: %w", err)
+	}
+	if err := k.typ(text, kbdOpts); err != nil {
+		k6Throw(k.ctx, "cannot type text: %w", err)
 	}
-	return k
 }
 
 func (k *Keyboard) down(key string) error {
 	keyInput := keyboardlayout.KeyInput(key)
-	layout := keyboardlayout.GetKeyboardLayout(k.layoutName)
-	if _, ok := layout.ValidKeys[keyInput]; !ok {
+	if _, ok := k.layout.ValidKeys[keyInput]; !ok {
 		return fmt.Errorf("%q is not a valid key for layout %q", key, k.layoutName)
 	}
 
@@ -93,7 +141,30 @@ func (k *Keyboard) down(key string) error {
 		WithUnmodifiedText(text).
 		WithAutoRepeat(autoRepeat)
 	if err := action.Do(cdp.WithExecutor(k.ctx, k.session)); err != nil {
-		return fmt.Errorf("unable to mouse down: %w", err)
+		return fmt.Errorf("cannot execute dispatch key event down: %w", err)
+	}
+
+	return nil
+}
+
+func (k *Keyboard) up(key string) error {
+	keyInput := keyboardlayout.KeyInput(key)
+	if _, ok := k.layout.ValidKeys[keyInput]; !ok {
+		return fmt.Errorf("'%s' is not a valid key for layout '%s'", key, k.layoutName)
+	}
+
+	keyDef := k.keyDefinitionFromKey(keyInput)
+	k.modifiers &= ^k.modifierBitFromKeyName(keyDef.Key)
+	delete(k.pressedKeys, keyDef.KeyCode)
+
+	action := input.DispatchKeyEvent(input.KeyUp).
+		WithModifiers(input.Modifier(k.modifiers)).
+		WithKey(keyDef.Key).
+		WithWindowsVirtualKeyCode(keyDef.KeyCode).
+		WithCode(keyDef.Code).
+		WithLocation(keyDef.Location)
+	if err := action.Do(cdp.WithExecutor(k.ctx, k.session)); err != nil {
+		return fmt.Errorf("cannot execute dispatch key event up: %w", err)
 	}
 
 	return nil
@@ -102,206 +173,107 @@ func (k *Keyboard) down(key string) error {
 func (k *Keyboard) insertText(text string) error {
 	action := input.InsertText(text)
 	if err := action.Do(cdp.WithExecutor(k.ctx, k.session)); err != nil {
-		return fmt.Errorf("unable to send character: %w", err)
+		return fmt.Errorf("cannot execute insert text: %w", err)
 	}
 	return nil
 }
 
-func (k *Keyboard) keyDefinitionFromKey(keyString keyboardlayout.KeyInput) keyboardlayout.KeyDefinition {
+func (k *Keyboard) keyDefinitionFromKey(key keyboardlayout.KeyInput) keyboardlayout.KeyDefinition {
 	shift := k.modifiers & ModifierKeyShift
-	keyDef := keyboardlayout.KeyDefinition{}
-	layout := keyboardlayout.GetKeyboardLayout(k.layoutName)
-	code := keyString
-	srcKeyDef, ok := layout.Keys[keyString]
 
+	// Find directly from the keyboard layout
+	srcKeyDef, ok := k.layout.Keys[key]
+	// Try to find based on key value instead of code
 	if !ok {
-		// Find based on key value instead of code
-		for k, v := range layout.Keys {
-			if v.Key == string(keyString) {
-				code = k
-				srcKeyDef = v
-				break
-			}
-		}
+		srcKeyDef, ok = k.layout.KeyDefinition(key)
+	}
+	// Try to find with the shift key value
+	if !ok {
+		srcKeyDef = k.layout.ShiftKeyDefinition(key)
+		shift = k.modifiers | ModifierKeyShift
 	}
 
+	var keyDef keyboardlayout.KeyDefinition
 	if srcKeyDef.Key != "" {
 		keyDef.Key = srcKeyDef.Key
-	}
-	if shift != 0 && srcKeyDef.ShiftKey != "" {
-		keyDef.Key = srcKeyDef.ShiftKey
-	}
-	if srcKeyDef.KeyCode != 0 {
-		keyDef.KeyCode = srcKeyDef.KeyCode
+		keyDef.Text = srcKeyDef.Key
 	}
 	if shift != 0 && srcKeyDef.ShiftKeyCode != 0 {
 		keyDef.KeyCode = srcKeyDef.ShiftKeyCode
 	}
 	if srcKeyDef.KeyCode != 0 {
 		keyDef.KeyCode = srcKeyDef.KeyCode
 	}
-	if code != "" {
-		keyDef.Code = string(code)
+	if key != "" {
+		keyDef.Code = string(key)
 	}
 	if srcKeyDef.Location != 0 {
 		keyDef.Location = srcKeyDef.Location
 	}
-	if len(srcKeyDef.Key) == 1 {
-		keyDef.Text = srcKeyDef.Key
-	}
 	if srcKeyDef.Text != "" {
 		keyDef.Text = srcKeyDef.Text
 	}
-	if shift != 0 && keyDef.ShiftKey != "" {
-		keyDef.Text = keyDef.ShiftKey
+	if shift != 0 && srcKeyDef.ShiftKey != "" {
+		keyDef.Key = srcKeyDef.ShiftKey
+		keyDef.Text = srcKeyDef.ShiftKey
 	}
-
 	// If any modifiers besides shift are pressed, no text should be sent
 	if k.modifiers & ^ModifierKeyShift != 0 {
 		keyDef.Text = ""
 	}
-
 	return keyDef
 }
 
 func (k *Keyboard) modifierBitFromKeyName(key string) int64 {
-	if key == "Alt" {
+	switch key {
+	case "Alt":
 		return ModifierKeyAlt
-	}
-	if key == "Control" {
+	case "Control":
 		return ModifierKeyControl
-	}
-	if key == "Meta" {
+	case "Meta":
 		return ModifierKeyMeta
-	}
-	if key == "Shift" {
+	case "Shift":
 		return ModifierKeyShift
 	}
 	return 0
 }
 
 func (k *Keyboard) press(key string, opts *KeyboardOptions) error {
-	err := k.down(key)
-	if err != nil {
-		return err
-	}
 	if opts.Delay != 0 {
-		t := time.NewTimer(time.Duration(opts.Delay * time.Hour.Milliseconds()))
+		t := time.NewTimer(time.Duration(opts.Delay) * time.Millisecond)
 		select {
 		case <-k.ctx.Done():
 			t.Stop()
 		case <-t.C:
 		}
 	}
-	err = k.up(key)
-	if err != nil {
-		return err
+	if err := k.down(key); err != nil {
+		return fmt.Errorf("cannot do key down: %w", err)
 	}
-	return nil
+	return k.up(key)
 }
 
 func (k *Keyboard) typ(text string, opts *KeyboardOptions) error {
 	layout := keyboardlayout.GetKeyboardLayout(k.layoutName)
 	for _, c := range text {
+		if opts.Delay != 0 {
+			t := time.NewTimer(time.Duration(opts.Delay) * time.Millisecond)
+			select {
+			case <-k.ctx.Done():
+				t.Stop()
+			case <-t.C:
+			}
+		}
 		keyInput := keyboardlayout.KeyInput(c)
 		if _, ok := layout.ValidKeys[keyInput]; ok {
-			err := k.press(string(c), opts)
-			if err != nil {
-				return nil
-			}
-		} else {
-			if opts.Delay != 0 {
-				t := time.NewTimer(time.Duration(opts.Delay * time.Hour.Milliseconds()))
-				select {
-				case <-k.ctx.Done():
-					t.Stop()
-				case <-t.C:
-				}
-			}
-			err := k.insertText(string(c))
-			if err != nil {
-				return nil
+			if err := k.press(string(c), opts); err != nil {
+				return fmt.Errorf("cannot press key: %w", err)
 			}
+			continue
+		}
+		if err := k.insertText(string(c)); err != nil {
+			return fmt.Errorf("cannot insert text: %w", err)
 		}
 	}
 	return nil
 }
-
-func (k *Keyboard) up(key string) error {
-	keyInput := keyboardlayout.KeyInput(key)
-	layout := keyboardlayout.GetKeyboardLayout(k.layoutName)
-	if _, ok := layout.ValidKeys[keyInput]; !ok {
-		return fmt.Errorf("'%s' is not a valid key for layout '%s'", key, k.layoutName)
-	}
-
-	keyDef := k.keyDefinitionFromKey(keyInput)
-	k.modifiers &= ^k.modifierBitFromKeyName(keyDef.Key)
-	delete(k.pressedKeys, keyDef.KeyCode)
-
-	action := input.DispatchKeyEvent(input.KeyUp).
-		WithModifiers(input.Modifier(k.modifiers)).
-		WithKey(keyDef.Key).
-		WithWindowsVirtualKeyCode(keyDef.KeyCode).
-		WithCode(keyDef.Code).
-		WithLocation(keyDef.Location)
-	if err := action.Do(cdp.WithExecutor(k.ctx, k.session)); err != nil {
-		return fmt.Errorf("unable to mouse down: %w", err)
-	}
-
-	return nil
-}
-
-// Down
-func (k *Keyboard) Down(key string) {
-	rt := k6common.GetRuntime(k.ctx)
-	err := k.down(key)
-	if err != nil {
-		k6common.Throw(rt, err)
-	}
-}
-
-// Press
-func (k *Keyboard) Press(key string, opts goja.Value) {
-	rt := k6common.GetRuntime(k.ctx)
-	kbdOpts := NewKeyboardOptions()
-	if err := kbdOpts.Parse(k.ctx, opts); err != nil {
-		k6common.Throw(rt, fmt.Errorf("failed parsing options: %w", err))
-	}
-
-	err := k.press(key, kbdOpts)
-	if err != nil {
-		k6common.Throw(rt, err)
-	}
-}
-
-// InsertText
-func (k *Keyboard) InsertText(text string) {
-	rt := k6common.GetRuntime(k.ctx)
-	err := k.insertText(text)
-	if err != nil {
-		k6common.Throw(rt, err)
-	}
-}
-
-// Type
-func (k *Keyboard) Type(text string, opts goja.Value) {
-	rt := k6common.GetRuntime(k.ctx)
-	kbdOpts := NewKeyboardOptions()
-	if err := kbdOpts.Parse(k.ctx, opts); err != nil {
-		k6common.Throw(rt, fmt.Errorf("failed parsing options: %w", err))
-	}
-
-	err := k.typ(text, kbdOpts)
-	if err != nil {
-		k6common.Throw(rt, err)
-	}
-}
-
-// Up
-func (k *Keyboard) Up(key string) {
-	rt := k6common.GetRuntime(k.ctx)
-	err := k.up(key)
-	if err != nil {
-		k6common.Throw(rt, err)
-	}
-}