github.com/wtfutil/wtf@v0.43.0/view/keyboard_widget_test.go (about)

     1  package view
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gdamore/tcell/v2"
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/wtfutil/wtf/cfg"
     9  )
    10  
    11  func test() {}
    12  
    13  func testKeyboardWidget() *KeyboardWidget {
    14  	keyWid := NewKeyboardWidget(
    15  		&cfg.Common{
    16  			Module: cfg.Module{
    17  				Name: "testWidget",
    18  				Type: "testType",
    19  			},
    20  		},
    21  	)
    22  	return keyWid
    23  }
    24  
    25  func Test_SetKeyboardChar(t *testing.T) {
    26  	tests := []struct {
    27  		name     string
    28  		char     string
    29  		fn       func()
    30  		helpText string
    31  		mapChar  string
    32  		expected bool
    33  	}{
    34  		{
    35  			name:     "with blank char",
    36  			char:     "",
    37  			fn:       test,
    38  			helpText: "help",
    39  			mapChar:  "",
    40  			expected: false,
    41  		},
    42  		{
    43  			name:     "with undefined char",
    44  			char:     "d",
    45  			fn:       test,
    46  			helpText: "help",
    47  			mapChar:  "m",
    48  			expected: false,
    49  		},
    50  		{
    51  			name:     "with defined char",
    52  			char:     "d",
    53  			fn:       test,
    54  			helpText: "help",
    55  			mapChar:  "d",
    56  			expected: true,
    57  		},
    58  	}
    59  
    60  	for _, tt := range tests {
    61  		t.Run(tt.name, func(t *testing.T) {
    62  			keyWid := testKeyboardWidget()
    63  			keyWid.SetKeyboardChar(tt.char, tt.fn, tt.helpText)
    64  
    65  			actual := keyWid.charMap[tt.mapChar]
    66  
    67  			if tt.expected != (actual != nil) {
    68  				t.Errorf("\nexpected: %s\n     got: %T", "actual != nil", actual)
    69  			}
    70  		})
    71  	}
    72  }
    73  
    74  func Test_SetKeyboardKey(t *testing.T) {
    75  	tests := []struct {
    76  		name     string
    77  		key      tcell.Key
    78  		fn       func()
    79  		helpText string
    80  		mapKey   tcell.Key
    81  		expected bool
    82  	}{
    83  		{
    84  			name:     "with undefined key",
    85  			key:      tcell.KeyCtrlA,
    86  			fn:       test,
    87  			helpText: "help",
    88  			mapKey:   tcell.KeyCtrlZ,
    89  			expected: false,
    90  		},
    91  		{
    92  			name:     "with defined key",
    93  			key:      tcell.KeyCtrlA,
    94  			fn:       test,
    95  			helpText: "help",
    96  			mapKey:   tcell.KeyCtrlA,
    97  			expected: true,
    98  		},
    99  	}
   100  
   101  	for _, tt := range tests {
   102  		t.Run(tt.name, func(t *testing.T) {
   103  			keyWid := testKeyboardWidget()
   104  			keyWid.SetKeyboardKey(tt.key, tt.fn, tt.helpText)
   105  
   106  			actual := keyWid.keyMap[tt.mapKey]
   107  
   108  			if tt.expected != (actual != nil) {
   109  				t.Errorf("\nexpected: %s\n     got: %T", "actual != nil", actual)
   110  			}
   111  		})
   112  	}
   113  }
   114  
   115  func Test_InputCapture(t *testing.T) {
   116  	tests := []struct {
   117  		name     string
   118  		before   func(keyWid *KeyboardWidget) *KeyboardWidget
   119  		event    *tcell.EventKey
   120  		expected *tcell.EventKey
   121  	}{
   122  		{
   123  			name:     "with nil event",
   124  			before:   func(keyWid *KeyboardWidget) *KeyboardWidget { return keyWid },
   125  			event:    nil,
   126  			expected: nil,
   127  		},
   128  		{
   129  			name:     "with undefined event",
   130  			before:   func(keyWid *KeyboardWidget) *KeyboardWidget { return keyWid },
   131  			event:    tcell.NewEventKey(tcell.KeyRune, 'a', tcell.ModNone),
   132  			expected: tcell.NewEventKey(tcell.KeyRune, 'a', tcell.ModNone),
   133  		},
   134  		{
   135  			name: "with defined event and char handler",
   136  			before: func(keyWid *KeyboardWidget) *KeyboardWidget {
   137  				keyWid.SetKeyboardChar("a", test, "help")
   138  				return keyWid
   139  			},
   140  			event:    tcell.NewEventKey(tcell.KeyRune, 'a', tcell.ModNone),
   141  			expected: nil,
   142  		},
   143  		{
   144  			name: "with defined event and key handler",
   145  			before: func(keyWid *KeyboardWidget) *KeyboardWidget {
   146  				keyWid.SetKeyboardKey(tcell.KeyRune, test, "help")
   147  				return keyWid
   148  			},
   149  			event:    tcell.NewEventKey(tcell.KeyRune, 'a', tcell.ModNone),
   150  			expected: nil,
   151  		},
   152  	}
   153  
   154  	for _, tt := range tests {
   155  		t.Run(tt.name, func(t *testing.T) {
   156  			keyWid := testKeyboardWidget()
   157  			keyWid = tt.before(keyWid)
   158  			actual := keyWid.InputCapture(tt.event)
   159  
   160  			if tt.expected == nil {
   161  				if actual != nil {
   162  					t.Errorf("\nexpected: %v\n     got: %v", tt.expected, actual.Rune())
   163  				}
   164  				return
   165  			}
   166  
   167  			if tt.expected.Rune() != actual.Rune() {
   168  				t.Errorf("\nexpected: %v\n     got: %v", tt.expected.Rune(), actual.Rune())
   169  			}
   170  		})
   171  	}
   172  }
   173  
   174  func Test_initializeCommonKeyboardControls(t *testing.T) {
   175  	t.Run("nil refreshFunc", func(t *testing.T) {
   176  		keyWid := testKeyboardWidget()
   177  
   178  		assert.NotNil(t, keyWid.charMap["\\"])
   179  	})
   180  }
   181  
   182  func Test_InitializeRefreshKeyboardControl(t *testing.T) {
   183  	t.Run("nil refreshFunc", func(t *testing.T) {
   184  		keyWid := testKeyboardWidget()
   185  		keyWid.InitializeRefreshKeyboardControl(nil)
   186  
   187  		assert.Nil(t, keyWid.charMap["r"])
   188  	})
   189  
   190  	t.Run("non-nil refreshFunc", func(t *testing.T) {
   191  		keyWid := testKeyboardWidget()
   192  		keyWid.InitializeRefreshKeyboardControl(func() {})
   193  
   194  		assert.NotNil(t, keyWid.charMap["r"])
   195  	})
   196  }
   197  
   198  func Test_HelpText(t *testing.T) {
   199  	keyWid := testKeyboardWidget()
   200  	keyWid.SetKeyboardChar("a", test, "a help")
   201  	keyWid.SetKeyboardKey(tcell.KeyCtrlO, test, "keyCtrlO help")
   202  
   203  	assert.NotNil(t, keyWid.HelpText())
   204  }