diff --git a/internal/handlers/loadHandler.go b/internal/handlers/loadHandler.go new file mode 100644 index 0000000..04ec035 --- /dev/null +++ b/internal/handlers/loadHandler.go @@ -0,0 +1,48 @@ +package handlers + +import ( + "slices" + + "github.com/StevanFreeborn/term-tier/internal/core" + "github.com/StevanFreeborn/term-tier/internal/state" + tea "github.com/charmbracelet/bubbletea" +) + +type loadHandler struct { + keys []string + description string + saver core.Saver +} + +func NewLoadHandler(saver core.Saver) KeyMsgHandler { + return loadHandler{ + keys: []string{"ctrl+o"}, + description: "Load tiers", + saver: saver, + } +} + +func (h loadHandler) KeysHandled() []string { + return h.keys +} + +func (h loadHandler) Description() string { + return h.description +} + +func (h loadHandler) Match(s state.State, msg tea.KeyMsg) bool { + return s.Mode() == state.NavigationMode && slices.Contains(h.keys, msg.String()) +} + +func (h loadHandler) Handle(s state.State, msg tea.KeyMsg) tea.Cmd { + return s.StartInputMode("Load tiers", func(val string, s state.State) tea.Cmd { + if data, err := h.saver.Load(val); err != nil { + s.SetStatus("Error: " + err.Error()) + } else { + s.Load(data) + s.SetStatus("Loaded " + val) + } + + return nil + }) +} diff --git a/internal/handlers/loadHandler_test.go b/internal/handlers/loadHandler_test.go new file mode 100644 index 0000000..0d9d09e --- /dev/null +++ b/internal/handlers/loadHandler_test.go @@ -0,0 +1,141 @@ +package handlers_test + +import ( + "slices" + "testing" + + "github.com/StevanFreeborn/term-tier/internal/core" + "github.com/StevanFreeborn/term-tier/internal/handlers" + "github.com/StevanFreeborn/term-tier/internal/state" + tea "github.com/charmbracelet/bubbletea" +) + +func TestNewLoadHandler(t *testing.T) { + saver := &mockSaver{} + + h := handlers.NewLoadHandler(saver) + + if h.Description() != "Load tiers" { + t.Errorf("Expected description 'Load tiers', got %q", h.Description()) + } + + keys := h.KeysHandled() + + if !slices.Contains(keys, "ctrl+o") { + t.Errorf("Expected keys ['ctrl+o'], got %v", keys) + } +} + +func TestLoadHandler_Match(t *testing.T) { + saver := &mockSaver{} + + h := handlers.NewLoadHandler(saver) + + tests := []struct { + name string + mode state.Mode + msg tea.KeyMsg + expected bool + }{ + { + name: "Matches ctrl+o in NavigationMode", + mode: state.NavigationMode, + msg: tea.KeyMsg{Type: tea.KeyCtrlO}, + expected: true, + }, + { + name: "Ignores ctrl+o in InputMode", + mode: state.InputMode, + msg: tea.KeyMsg{Type: tea.KeyCtrlO}, + expected: false, + }, + { + name: "Ignores other keys", + mode: state.NavigationMode, + msg: tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("a")}, + expected: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := state.New(state.WithMode(tt.mode)) + if got := h.Match(s, tt.msg); got != tt.expected { + t.Errorf("Match() = %v, want %v", got, tt.expected) + } + }) + } +} + +func TestLoadHandler_Handle(t *testing.T) { + t.Run("Successfully loads data", func(t *testing.T) { + mockData := core.SaveState{ + Tiers: []struct { + Name string `json:"name"` + Items []core.Item `json:"items"` + }{ + {Name: "Tier 1", Items: []core.Item{"Loaded Item"}}, + }, + } + + saver := &mockSaver{dataToReturn: mockData} + h := handlers.NewLoadHandler(saver) + + initialTiers := []core.Tier{{Name: "Tier 1", Items: []core.Item{}}} + + s := state.New( + state.WithMode(state.NavigationMode), + state.WithTiers(initialTiers), + ) + + msg := tea.KeyMsg{Type: tea.KeyCtrlO} + h.Handle(s, msg) + + if s.Mode() != state.InputMode { + t.Fatal("Expected state to switch to InputMode") + } + + for _, r := range "savefile.json" { + s.UpdateInput(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}}) + } + + s.SubmitInput() + + if s.Mode() != state.NavigationMode { + t.Error("Expected to return to NavigationMode after loading") + } + + expectedStatus := "Loaded savefile.json" + + if s.StatusMsg() != expectedStatus { + t.Errorf("Expected status %q, got %q", expectedStatus, s.StatusMsg()) + } + + currentItems := s.Tiers()[0].Items + + if len(currentItems) != 1 || currentItems[0] != "Loaded Item" { + t.Errorf("Expected loaded items ['Loaded Item'], got %v", currentItems) + } + }) + + t.Run("Handles load errors gracefully", func(t *testing.T) { + saver := &mockSaver{shouldError: true} + + h := handlers.NewLoadHandler(saver) + s := state.New(state.WithMode(state.NavigationMode)) + + h.Handle(s, tea.KeyMsg{Type: tea.KeyCtrlO}) + + for _, r := range "missing.json" { + s.UpdateInput(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}}) + } + + s.SubmitInput() + + expectedPrefix := "Error:" + + if len(s.StatusMsg()) < len(expectedPrefix) || s.StatusMsg()[:len(expectedPrefix)] != expectedPrefix { + t.Errorf("Expected error status, got %q", s.StatusMsg()) + } + }) +} diff --git a/internal/handlers/saveHandler.go b/internal/handlers/saveHandler.go new file mode 100644 index 0000000..b36b7ff --- /dev/null +++ b/internal/handlers/saveHandler.go @@ -0,0 +1,47 @@ +package handlers + +import ( + "slices" + + "github.com/StevanFreeborn/term-tier/internal/core" + "github.com/StevanFreeborn/term-tier/internal/state" + tea "github.com/charmbracelet/bubbletea" +) + +type saveHandler struct { + keys []string + description string + saver core.Saver +} + +func NewSaveHandler(saver core.Saver) KeyMsgHandler { + return saveHandler{ + keys: []string{"ctrl+s"}, + description: "Save tiers", + saver: saver, + } +} + +func (h saveHandler) KeysHandled() []string { + return h.keys +} + +func (h saveHandler) Description() string { + return h.description +} + +func (h saveHandler) Match(s state.State, msg tea.KeyMsg) bool { + return s.Mode() == state.NavigationMode && slices.Contains(h.keys, msg.String()) +} + +func (h saveHandler) Handle(s state.State, msg tea.KeyMsg) tea.Cmd { + return s.StartInputMode("Save tiers", func(val string, s state.State) tea.Cmd { + if err := h.saver.Save(val, s.Save()); err != nil { + s.SetStatus("Error: " + err.Error()) + } else { + s.SetStatus("Saved to " + val) + } + + return nil + }) +} diff --git a/internal/handlers/saveHandler_test.go b/internal/handlers/saveHandler_test.go new file mode 100644 index 0000000..347873d --- /dev/null +++ b/internal/handlers/saveHandler_test.go @@ -0,0 +1,132 @@ +package handlers_test + +import ( + "slices" + "testing" + + "github.com/StevanFreeborn/term-tier/internal/core" + "github.com/StevanFreeborn/term-tier/internal/handlers" + "github.com/StevanFreeborn/term-tier/internal/state" + tea "github.com/charmbracelet/bubbletea" +) + +func TestNewSaveHandler(t *testing.T) { + saver := &mockSaver{} + + h := handlers.NewSaveHandler(saver) + + if h.Description() != "Save tiers" { + t.Errorf("Expected description 'Save tiers', got %q", h.Description()) + } + + keys := h.KeysHandled() + + if !slices.Contains(keys, "ctrl+s") { + t.Errorf("Expected keys ['ctrl+s'], got %v", keys) + } +} + +func TestSaveHandler_Match(t *testing.T) { + saver := &mockSaver{} + h := handlers.NewSaveHandler(saver) + + tests := []struct { + name string + mode state.Mode + msg tea.KeyMsg + expected bool + }{ + { + name: "Matches ctrl+s in NavigationMode", + mode: state.NavigationMode, + msg: tea.KeyMsg{Type: tea.KeyCtrlS}, + expected: true, + }, + { + name: "Ignores ctrl+s in InputMode", + mode: state.InputMode, + msg: tea.KeyMsg{Type: tea.KeyCtrlS}, + expected: false, + }, + { + name: "Ignores other keys", + mode: state.NavigationMode, + msg: tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("s")}, + expected: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := state.New(state.WithMode(tt.mode)) + if got := h.Match(s, tt.msg); got != tt.expected { + t.Errorf("Match() = %v, want %v", got, tt.expected) + } + }) + } +} + +func TestSaveHandler_Handle(t *testing.T) { + t.Run("Successfully saves data", func(t *testing.T) { + saver := &mockSaver{} + + h := handlers.NewSaveHandler(saver) + + tiers := []core.Tier{{Name: "S Tier", Items: []core.Item{"Godzilla"}}} + + s := state.New( + state.WithMode(state.NavigationMode), + state.WithTiers(tiers), + ) + + msg := tea.KeyMsg{Type: tea.KeyCtrlS} + cmd := h.Handle(s, msg) + + if s.Mode() != state.InputMode { + t.Fatal("Expected state to switch to InputMode") + } + + if cmd == nil { + t.Error("Expected command from Handle (blink)") + } + + filename := "my_list.json" + + for _, r := range filename { + s.UpdateInput(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}}) + } + + s.SubmitInput() + + if len(saver.savedData.Tiers) != 1 { + t.Error("Expected saver to receive 1 tier") + } + + expectedStatusMsg := "Saved to " + filename + + if s.StatusMsg() != expectedStatusMsg { + t.Errorf("Expected status message %q, got %q", expectedStatusMsg, s.StatusMsg()) + } + }) + + t.Run("Handles save errors", func(t *testing.T) { + saver := &mockSaver{shouldError: true} + + h := handlers.NewSaveHandler(saver) + s := state.New(state.WithMode(state.NavigationMode)) + + h.Handle(s, tea.KeyMsg{Type: tea.KeyCtrlS}) + + for _, r := range "bad_perms.json" { + s.UpdateInput(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}}) + } + + s.SubmitInput() + + expectedPrefix := "Error:" + + if len(s.StatusMsg()) < len(expectedPrefix) || s.StatusMsg()[:len(expectedPrefix)] != expectedPrefix { + t.Errorf("Expected error status, got %q", s.StatusMsg()) + } + }) +}