test: improve app package coverage\

internal/app/lazytable.go

@@ -77,9 +77,10 @@ func (m lazyTableModel) handleKey(msg tea.KeyMsg, render bool) (lazyTableModel,
 	// this function increases the viewport offset by 1 if possible.  (scrolls down)
 	increaseOffset := func() {
 		maxOffset := max(m.entries.Len()-m.table.Height(), 0)
-		o := min(m.offset+1, maxOffset)
-		if o != m.offset {
-			m.offset = o
+
+		offset := min(m.offset+1, maxOffset)
+		if offset != m.offset {
+			m.offset = offset
 			render = true
 		} else {
 			// we were at the last item, so we should follow the log
@@ -111,12 +112,14 @@ func (m lazyTableModel) handleKey(msg tea.KeyMsg, render bool) (lazyTableModel,
 			increaseOffset() // move the viewport
 		}
 	}
+
 	if key.Matches(msg, m.Application.keys.Up) {
 		m.follow = false
 		if m.table.Cursor() == 0 {
 			decreaseOffset() // move the viewport
 		}
 	}
+
 	if key.Matches(msg, m.Application.keys.GotoTop) {
 		if m.reverse {
 			// when follow is enabled, rendering will handle setting the offset to the correct value
@@ -127,6 +130,7 @@ func (m lazyTableModel) handleKey(msg tea.KeyMsg, render bool) (lazyTableModel,
 		}
 		render = true
 	}
+
 	if key.Matches(msg, m.Application.keys.GotoBottom) {
 		if m.reverse {
 			m.follow = false

internal/app/stateerror_test.go

@@ -23,26 +23,41 @@ func TestStateError(t *testing.T) {
 
 		_, ok := model.(app.StateErrorModel)
 		assert.Truef(t, ok, "%s", model)
+
 		return model
 	}
 
 	t.Run("rendered", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 		rendered := model.View()
 		assert.Contains(t, rendered, errTest.Error())
 	})
 
 	t.Run("any_key_msg", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 
 		_, cmd := model.Update(tea.KeyMsg{})
 		assert.Equal(t, tea.Quit(), cmd())
 	})
 
+	t.Run("unknown_message", func(t *testing.T) {
+		t.Parallel()
+
+		model := setup()
+
+		model, _ = model.Update(nil)
+
+		_, ok := model.(app.StateErrorModel)
+		assert.Truef(t, ok, "%s", model)
+	})
+
 	t.Run("stringer", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 
 		stringer, ok := model.(fmt.Stringer)

internal/app/statefiltered.go

@@ -56,55 +56,76 @@ func (s StateFilteredModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 	s.Application.Update(msg)
 
-	switch typedMsg := msg.(type) {
-	case *StateFilteredModel:
-		entries, err := s.Application.Entries.Filter(s.filterText)
-		if err != nil {
-			return s, events.ShowError(err)
-		}
-		s.logEntries = entries
-		s.table = newLogsTableModel(s.Application, entries)
-		msg = events.LogEntriesUpdateMsg(entries)
-	case events.LogEntriesUpdateMsg:
-		entries, err := s.Application.Entries.Filter(s.filterText)
-		if err != nil {
-			return s, events.ShowError(err)
-		}
-		s.logEntries = entries
-		msg = events.LogEntriesUpdateMsg(entries)
+	if _, ok := msg.(*StateFilteredModel); ok {
+		s, msg = s.handleStateFilteredModel()
+	}
+
+	if _, ok := msg.(*events.LogEntriesUpdateMsg); ok {
+		s, msg = s.handleLogEntriesUpdateMsg()
+	}
 
+	switch typedMsg := msg.(type) {
 	case events.ErrorOccuredMsg:
 		return s.handleErrorOccuredMsg(typedMsg)
 	case events.OpenJSONRowRequestedMsg:
 		return s.handleOpenJSONRowRequestedMsg(typedMsg, s)
 	case tea.KeyMsg:
-		switch {
-		case key.Matches(typedMsg, s.keys.Back):
-			return s.previousState.refresh()
-		case key.Matches(typedMsg, s.keys.Filter):
-			return s.handleFilterKeyClickedMsg()
-		case key.Matches(typedMsg, s.keys.ToggleViewArrow), key.Matches(typedMsg, s.keys.Open):
-			return s.handleRequestOpenJSON()
-		}
-		if cmd := s.handleKeyMsg(typedMsg); cmd != nil {
-			return s, cmd
+		if mdl, cmd := s.handleKeyMsg(typedMsg); mdl != nil {
+			return mdl, cmd
 		}
 	default:
 		s.table, cmdBatch = batched(s.table.Update(typedMsg))(cmdBatch)
 	}
 
 	s.table, cmdBatch = batched(s.table.Update(msg))(cmdBatch)
+
 	return s, tea.Batch(cmdBatch...)
 }
 
+func (s StateFilteredModel) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch {
+	case key.Matches(msg, s.keys.Back):
+		return s.previousState.refresh()
+	case key.Matches(msg, s.keys.Filter):
+		return s.handleFilterKeyClickedMsg()
+	case key.Matches(msg, s.keys.ToggleViewArrow), key.Matches(msg, s.keys.Open):
+		return s.handleRequestOpenJSON()
+	default:
+		return nil, nil
+	}
+}
+
+func (s StateFilteredModel) handleLogEntriesUpdateMsg() (StateFilteredModel, tea.Msg) {
+	entries, err := s.Application.Entries.Filter(s.filterText)
+	if err != nil {
+		return s, events.ShowError(err)()
+	}
+
+	s.logEntries = entries
+
+	return s, events.LogEntriesUpdateMsg(entries)
+}
+
+func (s StateFilteredModel) handleStateFilteredModel() (StateFilteredModel, tea.Msg) {
+	entries, err := s.Application.Entries.Filter(s.filterText)
+	if err != nil {
+		return s, events.ShowError(err)()
+	}
+
+	s.logEntries = entries
+	s.table = newLogsTableModel(s.Application, entries)
+
+	return s, events.LogEntriesUpdateMsg(entries)
+}
+
 func (s StateFilteredModel) handleFilterKeyClickedMsg() (tea.Model, tea.Cmd) {
 	state := newStateFiltering(s.previousState)
 	return initializeModel(state)
 }
 
 func (s StateFilteredModel) handleRequestOpenJSON() (tea.Model, tea.Cmd) {
 	if s.logEntries.Len() == 0 {
-		return s, events.BackKeyClicked
+		return s, events.EscKeyClicked
 	}
 
 	return s, events.OpenJSONRowRequested(s.logEntries, s.table.Cursor())
@@ -114,9 +135,9 @@ func (s StateFilteredModel) getApplication() *Application {
 	return s.Application
 }
 
-func (s StateFilteredModel) refresh() (stateModel, tea.Cmd) {
-	var cmd tea.Cmd
+func (s StateFilteredModel) refresh() (_ stateModel, cmd tea.Cmd) {
 	s.table, cmd = s.table.Update(s.Application.LastWindowSize)
+
 	return s, cmd
 }
 

internal/app/statefiltered_test.go

@@ -47,7 +47,7 @@ func TestStateFiltered(t *testing.T) {
 		// Write term to search by.
 		model = handleUpdate(model, tea.KeyMsg{
 			Type:  tea.KeyRunes,
-			Runes: []rune(termIncluded),
+			Runes: []rune(termIncluded[1:]),
 		})
 
 		// Filter.
@@ -59,14 +59,16 @@ func TestStateFiltered(t *testing.T) {
 		if assert.Truef(t, ok, "%s", model) {
 			rendered = model.View()
 			assert.Contains(t, rendered, termIncluded)
-			assert.Contains(t, rendered, "filtered 1 by: "+termIncluded)
+			assert.Contains(t, rendered, "filtered 1 by: "+termIncluded[1:])
 			assert.NotContains(t, rendered, termExcluded)
 		}
+
 		return model
 	}
 
 	t.Run("reopen_filter", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 		model = handleUpdate(model, tea.KeyMsg{
 			Type:  tea.KeyRunes,
@@ -79,6 +81,7 @@ func TestStateFiltered(t *testing.T) {
 
 	t.Run("open_hide_json_view", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 		model = handleUpdate(model, tea.KeyMsg{
 			Type: tea.KeyEnter,
@@ -97,6 +100,7 @@ func TestStateFiltered(t *testing.T) {
 
 	t.Run("error", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 		model = handleUpdate(model, events.ErrorOccuredMsg{Err: getTestError()})
 
@@ -106,6 +110,7 @@ func TestStateFiltered(t *testing.T) {
 
 	t.Run("navigation", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 		model = handleUpdate(model, tea.KeyMsg{
 			Type: tea.KeyUp,
@@ -117,6 +122,7 @@ func TestStateFiltered(t *testing.T) {
 
 	t.Run("returned", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 		model = handleUpdate(model, tea.KeyMsg{
 			Type: tea.KeyEsc,
@@ -128,10 +134,21 @@ func TestStateFiltered(t *testing.T) {
 
 	t.Run("stringer", func(t *testing.T) {
 		t.Parallel()
+
 		model := setup()
 		stringer, ok := model.(fmt.Stringer)
 		if assert.True(t, ok) {
 			assert.Contains(t, stringer.String(), "StateFiltered")
 		}
 	})
+
+	t.Run("updated", func(t *testing.T) {
+		t.Parallel()
+
+		model := setup()
+		model = handleUpdate(model, &events.LogEntriesUpdateMsg{})
+
+		rendered := model.View()
+		assert.Contains(t, rendered, termIncluded)
+	})
 }

internal/app/statefiltering.go

@@ -56,15 +56,8 @@ func (s StateFilteringModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case events.ErrorOccuredMsg:
 		return s.handleErrorOccuredMsg(msg)
 	case tea.KeyMsg:
-		switch {
-		case key.Matches(msg, s.keys.Back):
-			return s.previousState.refresh()
-		case key.Matches(msg, s.keys.Open):
-			return s.handleEnterKeyClickedMsg()
-		}
-		if cmd := s.handleKeyMsg(msg); cmd != nil {
-			// Intercept table update.
-			return s, cmd
+		if mdl, cmd := s.handleKeyMsg(msg); mdl != nil {
+			return mdl, cmd
 		}
 	default:
 		s.table, cmdBatch = batched(s.table.Update(msg))(cmdBatch)
@@ -75,17 +68,20 @@ func (s StateFilteringModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return s, tea.Batch(cmdBatch...)
 }
 
-func (s StateFilteringModel) handleKeyMsg(msg tea.KeyMsg) tea.Cmd {
-	if len(msg.Runes) == 1 {
-		return nil
+func (s StateFilteringModel) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch {
+	case key.Matches(msg, s.keys.Back):
+		return s.previousState.refresh()
+	case key.Matches(msg, s.keys.Open):
+		return s.handleEnterKeyClickedMsg()
+	default:
+		return nil, nil
 	}
-
-	return s.Application.handleKeyMsg(msg)
 }
 
 func (s StateFilteringModel) handleEnterKeyClickedMsg() (tea.Model, tea.Cmd) {
 	if s.textInput.Value() == "" {
-		return s, events.BackKeyClicked
+		return s, events.EscKeyClicked
 	}
 
 	return initializeModel(newStateFiltered(

internal/app/statefiltering_test.go

@@ -99,6 +99,61 @@ func TestStateFiltering(t *testing.T) {
 		_, ok := model.(app.StateFilteringModel)
 		assert.Truef(t, ok, "%s", model)
 	})
+
+	t.Run("runes", func(t *testing.T) {
+		model := setup()
+
+		const content = "hello world"
+
+		for _, r := range content {
+			model = handleUpdate(model, tea.KeyMsg{
+				Type:  tea.KeyRunes,
+				Runes: []rune{r},
+			})
+		}
+
+		assert.Contains(t, model.View(), content)
+	})
+
+	t.Run("arrow_right", func(t *testing.T) {
+		model := setup()
+
+		model = handleUpdate(model, events.ArrowRightKeyClicked())
+
+		const content = "hello word"
+
+		// 1. Input "hello word".
+		// 2. Press "Left" 2 times: "hello wo|rd"
+		// 3. Press "Right" 1 time: "hello wor|d".
+		// 4. Input "r".
+		// 5. Expect to see "hello world".
+		for _, r := range content {
+			model = handleUpdate(model, tea.KeyMsg{
+				Type:  tea.KeyRunes,
+				Runes: []rune{r},
+			})
+		}
+
+		model = handleUpdate(model, tea.KeyMsg{Type: tea.KeyLeft})
+		model = handleUpdate(model, tea.KeyMsg{Type: tea.KeyLeft})
+		model = handleUpdate(model, tea.KeyMsg{Type: tea.KeyRight})
+
+		model = handleUpdate(model, tea.KeyMsg{
+			Type:  tea.KeyRunes,
+			Runes: []rune{'l'},
+		})
+
+		assert.Contains(t, model.View(), "hello world")
+	})
+
+	t.Run("unknown_message", func(t *testing.T) {
+		model := setup()
+
+		model = handleUpdate(model, nil)
+
+		_, ok := model.(app.StateFilteringModel)
+		assert.Truef(t, ok, "%s", model)
+	})
 }
 
 func TestStateFilteringReset(t *testing.T) {