build: test command execution

cmd/commands.go

···
 		Aliases: []string{"new"},
 		RunE: func(cmd *cobra.Command, args []string) error {
 			interactive, _ := cmd.Flags().GetBool("interactive")
+			editor, _ := cmd.Flags().GetBool("editor")
 			filePath, _ := cmd.Flags().GetString("file")
 
 			var title, content string
···
 			}
 
 			defer c.handler.Close()
-			return c.handler.Create(cmd.Context(), title, content, filePath, interactive)
+			return c.handler.CreateWithOptions(cmd.Context(), title, content, filePath, interactive, editor)
 		},
 	}
 	createCmd.Flags().BoolP("interactive", "i", false, "Open interactive editor")
+	createCmd.Flags().BoolP("editor", "e", false, "Prompt to open note in editor after creation")
 	createCmd.Flags().StringP("file", "f", "", "Create note from markdown file")
 	root.AddCommand(createCmd)
 
 	listCmd := &cobra.Command{
-		Use:     "list [--archived] [--tags=tag1,tag2]",
+		Use:     "list [--archived] [--static] [--tags=tag1,tag2]",
 		Short:   "Opens interactive TUI browser for navigating and viewing notes",
 		Aliases: []string{"ls"},
 		RunE: func(cmd *cobra.Command, args []string) error {
 			archived, _ := cmd.Flags().GetBool("archived")
+			static, _ := cmd.Flags().GetBool("static")
 			tagsStr, _ := cmd.Flags().GetString("tags")
 
 			var tags []string
···
 			}
 
 			defer c.handler.Close()
-			return c.handler.List(cmd.Context(), false, archived, tags)
+			return c.handler.List(cmd.Context(), static, archived, tags)
 		},
 	}
 	listCmd.Flags().BoolP("archived", "a", false, "Show archived notes")
+	listCmd.Flags().BoolP("static", "s", false, "Show static list instead of interactive TUI")
 	listCmd.Flags().String("tags", "", "Filter by tags (comma-separated)")
 	root.AddCommand(listCmd)
 

cmd/commands_test.go

···
 
 			expectedSubcommands := []string{
 				"create [title] [content...]",
-				"list [--archived] [--tags=tag1,tag2]",
+				"list [--archived] [--static] [--tags=tag1,tag2]",
 				"read [note-id]",
 				"edit [note-id]",
 				"remove [note-id]",
···
 	})
 
 }
+
+func TestCommandExecution(t *testing.T) {
+	t.Run("Movie Commands", func(t *testing.T) {
+		handler, cleanup := createTestMovieHandler(t)
+		defer cleanup()
+
+		t.Run("list command - default", func(t *testing.T) {
+			cmd := NewMovieCommand(handler).Create()
+			cmd.SetArgs([]string{"list"})
+			err := cmd.Execute()
+			if err != nil {
+				t.Errorf("movie list command failed: %v", err)
+			}
+		})
+
+		t.Run("add command with empty args", func(t *testing.T) {
+			cmd := NewMovieCommand(handler).Create()
+			cmd.SetArgs([]string{"add"})
+			err := cmd.Execute()
+			if err == nil {
+				t.Error("expected movie add command to fail with empty args")
+			}
+		})
+	})
+
+	t.Run("TV Commands", func(t *testing.T) {
+		handler, cleanup := createTestTVHandler(t)
+		defer cleanup()
+
+		t.Run("list command - default", func(t *testing.T) {
+			cmd := NewTVCommand(handler).Create()
+			cmd.SetArgs([]string{"list"})
+			err := cmd.Execute()
+			if err != nil {
+				t.Errorf("tv list command failed: %v", err)
+			}
+		})
+
+		t.Run("add command with empty args", func(t *testing.T) {
+			cmd := NewTVCommand(handler).Create()
+			cmd.SetArgs([]string{"add"})
+			err := cmd.Execute()
+			if err == nil {
+				t.Error("expected tv add command to fail with empty args")
+			}
+		})
+	})
+
+	t.Run("Book Commands", func(t *testing.T) {
+		handler, cleanup := createTestBookHandler(t)
+		defer cleanup()
+
+		t.Run("list command - default", func(t *testing.T) {
+			cmd := NewBookCommand(handler).Create()
+			cmd.SetArgs([]string{"list"})
+			err := cmd.Execute()
+			if err != nil {
+				t.Errorf("book list command failed: %v", err)
+			}
+		})
+	})
+
+	t.Run("Note Commands", func(t *testing.T) {
+
+		t.Run("create command - non-interactive", func(t *testing.T) {
+			handler, cleanup := createTestNoteHandler(t)
+			defer cleanup()
+
+			cmd := NewNoteCommand(handler).Create()
+			cmd.SetArgs([]string{"create", "test title", "test content"})
+			err := cmd.Execute()
+			if err != nil {
+				t.Errorf("note create command failed: %v", err)
+			}
+		})
+
+		t.Run("list command - static mode", func(t *testing.T) {
+			handler, cleanup := createTestNoteHandler(t)
+			defer cleanup()
+
+			cmd := NewNoteCommand(handler).Create()
+			cmd.SetArgs([]string{"list", "--static"})
+			err := cmd.Execute()
+			if err != nil {
+				t.Errorf("note list command failed: %v", err)
+			}
+		})
+	})
+}

go.mod

···
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	golang.org/x/sys v0.36.0 // indirect
 	golang.org/x/text v0.29.0
-	golang.org/x/tools v0.37.0
 )

go.sum

···
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
-golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=

internal/handlers/notes.go

···
 
 // Create handles note creation with optional title, content, and file path
 func (h *NoteHandler) Create(ctx context.Context, title string, content string, filePath string, interactive bool) error {
+	return h.CreateWithOptions(ctx, title, content, filePath, interactive, false)
+}
+
+// CreateWithOptions handles note creation with additional options
+func (h *NoteHandler) CreateWithOptions(ctx context.Context, title string, content string, filePath string, interactive bool, promptEditor bool) error {
 	if interactive || (title == "" && content == "" && filePath == "") {
 		return h.createInteractive(ctx)
 	}
···
 		return h.createFromFile(ctx, filePath)
 	}
 
-	return h.createFromArgs(ctx, title, content)
+	return h.createFromArgsWithOptions(ctx, title, content, promptEditor)
 }
 
 func (h *NoteHandler) createInteractive(ctx context.Context) error {
···
 }
 
 func (h *NoteHandler) createFromArgs(ctx context.Context, title, content string) error {
+	return h.createFromArgsWithOptions(ctx, title, content, false)
+}
+
+func (h *NoteHandler) createFromArgsWithOptions(ctx context.Context, title, content string, promptEditor bool) error {
 	note := &models.Note{
 		Title:   title,
 		Content: content,
···
 
 	fmt.Printf("Created note: %s (ID: %d)\n", title, id)
 
-	editor := h.getEditor()
-	if editor != "" {
-		fmt.Print("Open in editor? [y/N]: ")
-		var response string
-		fmt.Scanln(&response)
-		if strings.ToLower(response) == "y" || strings.ToLower(response) == "yes" {
-			return h.Edit(ctx, id)
+	if promptEditor {
+		editor := h.getEditor()
+		if editor != "" {
+			fmt.Print("Open in editor? [y/N]: ")
+			var response string
+			fmt.Scanln(&response)
+			if strings.ToLower(response) == "y" || strings.ToLower(response) == "yes" {
+				return h.Edit(ctx, id)
+			}
 		}
 	}