+16

cmd/cli/main.go

reviewed

··· 217 217 218 218 rootCmd.AddCommand(bookCmd) 219 219 220 220 + noteCmd := &cobra.Command{ 221 221 + Use: "note", 222 222 + Short: "Manage notes", 223 223 + } 224 224 + 225 225 + noteCmd.AddCommand(&cobra.Command{ 226 226 + Use: "create [title] [content...]", 227 227 + Short: "Create a new note", 228 228 + Aliases: []string{"new"}, 229 229 + RunE: func(cmd *cobra.Command, args []string) error { 230 230 + return handlers.Create(cmd.Context(), args) 231 231 + }, 232 232 + }) 233 233 + 234 234 + rootCmd.AddCommand(noteCmd) 235 235 + 220 236 rootCmd.AddCommand(&cobra.Command{ 221 237 Use: "config [key] [value]", 222 238 Short: "Manage configuration",

+363

cmd/handlers/notes.go

reviewed

··· 1 1 + package handlers 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "fmt" 6 6 + "os" 7 7 + "os/exec" 8 8 + "path/filepath" 9 9 + "strings" 10 10 + 11 11 + "github.com/stormlightlabs/noteleaf/internal/models" 12 12 + "github.com/stormlightlabs/noteleaf/internal/repo" 13 13 + "github.com/stormlightlabs/noteleaf/internal/store" 14 14 + "github.com/stormlightlabs/noteleaf/internal/utils" 15 15 + ) 16 16 + 17 17 + // NoteHandler handles all note-related commands 18 18 + type NoteHandler struct { 19 19 + db *store.Database 20 20 + config *store.Config 21 21 + repos *repo.Repositories 22 22 + openInEditorFunc editorFunc 23 23 + } 24 24 + 25 25 + // NewNoteHandler creates a new note handler 26 26 + func NewNoteHandler() (*NoteHandler, error) { 27 27 + db, err := store.NewDatabase() 28 28 + if err != nil { 29 29 + return nil, fmt.Errorf("failed to initialize database: %w", err) 30 30 + } 31 31 + 32 32 + config, err := store.LoadConfig() 33 33 + if err != nil { 34 34 + return nil, fmt.Errorf("failed to load configuration: %w", err) 35 35 + } 36 36 + 37 37 + repos := repo.NewRepositories(db.DB) 38 38 + 39 39 + return &NoteHandler{ 40 40 + db: db, 41 41 + config: config, 42 42 + repos: repos, 43 43 + }, nil 44 44 + } 45 45 + 46 46 + // Close cleans up resources 47 47 + func (h *NoteHandler) Close() error { 48 48 + if h.db != nil { 49 49 + return h.db.Close() 50 50 + } 51 51 + return nil 52 52 + } 53 53 + 54 54 + // Create handles note creation subcommands 55 55 + func Create(ctx context.Context, args []string) error { 56 56 + handler, err := NewNoteHandler() 57 57 + if err != nil { 58 58 + return err 59 59 + } 60 60 + defer handler.Close() 61 61 + 62 62 + if len(args) == 0 { 63 63 + return handler.createInteractive(ctx) 64 64 + } 65 65 + 66 66 + if len(args) == 1 && isFile(args[0]) { 67 67 + return handler.createFromFile(ctx, args[0]) 68 68 + } 69 69 + 70 70 + title := args[0] 71 71 + content := "" 72 72 + if len(args) > 1 { 73 73 + content = strings.Join(args[1:], " ") 74 74 + } 75 75 + 76 76 + return handler.createFromArgs(ctx, title, content) 77 77 + } 78 78 + 79 79 + // New is an alias for Create 80 80 + func New(ctx context.Context, args []string) error { 81 81 + return Create(ctx, args) 82 82 + } 83 83 + 84 84 + func (h *NoteHandler) createInteractive(ctx context.Context) error { 85 85 + logger := utils.GetLogger() 86 86 + 87 87 + tempFile, err := os.CreateTemp("", "noteleaf-note-*.md") 88 88 + if err != nil { 89 89 + return fmt.Errorf("failed to create temporary file: %w", err) 90 90 + } 91 91 + defer os.Remove(tempFile.Name()) 92 92 + 93 93 + template := `# New Note 94 94 + 95 95 + Enter your note content here... 96 96 + 97 97 + <!-- Tags: personal, work --> 98 98 + ` 99 99 + if _, err := tempFile.WriteString(template); err != nil { 100 100 + return fmt.Errorf("failed to write template: %w", err) 101 101 + } 102 102 + tempFile.Close() 103 103 + 104 104 + editor := h.getEditor() 105 105 + if editor == "" { 106 106 + return fmt.Errorf("no editor configured. Set EDITOR environment variable or configure editor in settings") 107 107 + } 108 108 + 109 109 + logger.Info("Opening editor", "editor", editor, "file", tempFile.Name()) 110 110 + if err := h.openInEditor(editor, tempFile.Name()); err != nil { 111 111 + return fmt.Errorf("failed to open editor: %w", err) 112 112 + } 113 113 + 114 114 + content, err := os.ReadFile(tempFile.Name()) 115 115 + if err != nil { 116 116 + return fmt.Errorf("failed to read edited content: %w", err) 117 117 + } 118 118 + 119 119 + contentStr := string(content) 120 120 + if strings.TrimSpace(contentStr) == strings.TrimSpace(template) { 121 121 + fmt.Println("Note creation cancelled (no changes made)") 122 122 + return nil 123 123 + } 124 124 + 125 125 + title, noteContent, tags := h.parseNoteContent(contentStr) 126 126 + if title == "" { 127 127 + title = "Untitled Note" 128 128 + } 129 129 + 130 130 + note := &models.Note{ 131 131 + Title: title, 132 132 + Content: noteContent, 133 133 + Tags: tags, 134 134 + } 135 135 + 136 136 + id, err := h.repos.Notes.Create(ctx, note) 137 137 + if err != nil { 138 138 + return fmt.Errorf("failed to create note: %w", err) 139 139 + } 140 140 + 141 141 + fmt.Printf("Created note: %s (ID: %d)\n", title, id) 142 142 + if len(tags) > 0 { 143 143 + fmt.Printf("Tags: %s\n", strings.Join(tags, ", ")) 144 144 + } 145 145 + 146 146 + return nil 147 147 + } 148 148 + 149 149 + func (h *NoteHandler) createFromFile(ctx context.Context, filePath string) error { 150 150 + if _, err := os.Stat(filePath); os.IsNotExist(err) { 151 151 + return fmt.Errorf("file does not exist: %s", filePath) 152 152 + } 153 153 + 154 154 + content, err := os.ReadFile(filePath) 155 155 + if err != nil { 156 156 + return fmt.Errorf("failed to read file: %w", err) 157 157 + } 158 158 + 159 159 + contentStr := string(content) 160 160 + if strings.TrimSpace(contentStr) == "" { 161 161 + return fmt.Errorf("file is empty: %s", filePath) 162 162 + } 163 163 + 164 164 + title, noteContent, tags := h.parseNoteContent(contentStr) 165 165 + if title == "" { 166 166 + title = strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath)) 167 167 + } 168 168 + 169 169 + note := &models.Note{ 170 170 + Title: title, 171 171 + Content: noteContent, 172 172 + Tags: tags, 173 173 + FilePath: filePath, 174 174 + } 175 175 + 176 176 + id, err := h.repos.Notes.Create(ctx, note) 177 177 + if err != nil { 178 178 + return fmt.Errorf("failed to create note: %w", err) 179 179 + } 180 180 + 181 181 + fmt.Printf("Created note from file: %s\n", filePath) 182 182 + fmt.Printf("Note: %s (ID: %d)\n", title, id) 183 183 + if len(tags) > 0 { 184 184 + fmt.Printf("Tags: %s\n", strings.Join(tags, ", ")) 185 185 + } 186 186 + 187 187 + return nil 188 188 + } 189 189 + 190 190 + func (h *NoteHandler) createFromArgs(ctx context.Context, title, content string) error { 191 191 + note := &models.Note{ 192 192 + Title: title, 193 193 + Content: content, 194 194 + } 195 195 + 196 196 + id, err := h.repos.Notes.Create(ctx, note) 197 197 + if err != nil { 198 198 + return fmt.Errorf("failed to create note: %w", err) 199 199 + } 200 200 + 201 201 + fmt.Printf("Created note: %s (ID: %d)\n", title, id) 202 202 + 203 203 + editor := h.getEditor() 204 204 + if editor != "" { 205 205 + fmt.Print("Open in editor? [y/N]: ") 206 206 + var response string 207 207 + fmt.Scanln(&response) 208 208 + if strings.ToLower(response) == "y" || strings.ToLower(response) == "yes" { 209 209 + return h.editNote(ctx, id) 210 210 + } 211 211 + } 212 212 + 213 213 + return nil 214 214 + } 215 215 + 216 216 + func (h *NoteHandler) editNote(ctx context.Context, id int64) error { 217 217 + note, err := h.repos.Notes.Get(ctx, id) 218 218 + if err != nil { 219 219 + return fmt.Errorf("failed to get note: %w", err) 220 220 + } 221 221 + 222 222 + tempFile, err := os.CreateTemp("", fmt.Sprintf("noteleaf-note-%d-*.md", id)) 223 223 + if err != nil { 224 224 + return fmt.Errorf("failed to create temporary file: %w", err) 225 225 + } 226 226 + defer os.Remove(tempFile.Name()) 227 227 + 228 228 + fullContent := h.formatNoteForEdit(note) 229 229 + if _, err := tempFile.WriteString(fullContent); err != nil { 230 230 + return fmt.Errorf("failed to write note content: %w", err) 231 231 + } 232 232 + tempFile.Close() 233 233 + 234 234 + editor := h.getEditor() 235 235 + if err := h.openInEditor(editor, tempFile.Name()); err != nil { 236 236 + return fmt.Errorf("failed to open editor: %w", err) 237 237 + } 238 238 + 239 239 + editedContent, err := os.ReadFile(tempFile.Name()) 240 240 + if err != nil { 241 241 + return fmt.Errorf("failed to read edited content: %w", err) 242 242 + } 243 243 + 244 244 + editedStr := string(editedContent) 245 245 + if editedStr == fullContent { 246 246 + fmt.Println("No changes made") 247 247 + return nil 248 248 + } 249 249 + 250 250 + title, content, tags := h.parseNoteContent(editedStr) 251 251 + if title == "" { 252 252 + title = note.Title 253 253 + } 254 254 + note.Title = title 255 255 + note.Content = content 256 256 + note.Tags = tags 257 257 + 258 258 + if err := h.repos.Notes.Update(ctx, note); err != nil { 259 259 + return fmt.Errorf("failed to update note: %w", err) 260 260 + } 261 261 + 262 262 + fmt.Printf("Updated note: %s (ID: %d)\n", title, id) 263 263 + return nil 264 264 + } 265 265 + 266 266 + func (h *NoteHandler) getEditor() string { 267 267 + // TODO: Add editor to config structure 268 268 + // For now, check environment variable 269 269 + if editor := os.Getenv("EDITOR"); editor != "" { 270 270 + return editor 271 271 + } 272 272 + 273 273 + editors := []string{"vim", "nano", "code", "emacs"} 274 274 + for _, editor := range editors { 275 275 + if _, err := exec.LookPath(editor); err == nil { 276 276 + return editor 277 277 + } 278 278 + } 279 279 + 280 280 + return "" 281 281 + } 282 282 + 283 283 + type editorFunc func(editor, filePath string) error 284 284 + 285 285 + func defaultOpenInEditor(editor, filePath string) error { 286 286 + cmd := exec.Command(editor, filePath) 287 287 + cmd.Stdin = os.Stdin 288 288 + cmd.Stdout = os.Stdout 289 289 + cmd.Stderr = os.Stderr 290 290 + return cmd.Run() 291 291 + } 292 292 + 293 293 + func (h *NoteHandler) openInEditor(editor, filePath string) error { 294 294 + if h.openInEditorFunc != nil { 295 295 + return h.openInEditorFunc(editor, filePath) 296 296 + } 297 297 + return defaultOpenInEditor(editor, filePath) 298 298 + } 299 299 + 300 300 + func (h *NoteHandler) parseNoteContent(content string) (title, noteContent string, tags []string) { 301 301 + lines := strings.Split(content, "\n") 302 302 + 303 303 + for _, line := range lines { 304 304 + line = strings.TrimSpace(line) 305 305 + if strings.HasPrefix(line, "# ") { 306 306 + title = strings.TrimPrefix(line, "# ") 307 307 + break 308 308 + } 309 309 + } 310 310 + 311 311 + for _, line := range lines { 312 312 + line = strings.TrimSpace(line) 313 313 + if strings.HasPrefix(line, "<!-- Tags:") && strings.HasSuffix(line, "-->") { 314 314 + tagStr := strings.TrimPrefix(line, "<!-- Tags:") 315 315 + tagStr = strings.TrimSuffix(tagStr, "-->") 316 316 + tagStr = strings.TrimSpace(tagStr) 317 317 + 318 318 + if tagStr != "" { 319 319 + for _, tag := range strings.Split(tagStr, ",") { 320 320 + tag = strings.TrimSpace(tag) 321 321 + if tag != "" { 322 322 + tags = append(tags, tag) 323 323 + } 324 324 + } 325 325 + } 326 326 + } 327 327 + } 328 328 + 329 329 + noteContent = content 330 330 + 331 331 + return title, noteContent, tags 332 332 + } 333 333 + 334 334 + func (h *NoteHandler) formatNoteForEdit(note *models.Note) string { 335 335 + var content strings.Builder 336 336 + 337 337 + if !strings.Contains(note.Content, "# "+note.Title) { 338 338 + content.WriteString("# " + note.Title + "\n\n") 339 339 + } 340 340 + 341 341 + content.WriteString(note.Content) 342 342 + 343 343 + if len(note.Tags) > 0 { 344 344 + if !strings.HasSuffix(note.Content, "\n") { 345 345 + content.WriteString("\n") 346 346 + } 347 347 + content.WriteString("\n<!-- Tags: " + strings.Join(note.Tags, ", ") + " -->\n") 348 348 + } 349 349 + 350 350 + return content.String() 351 351 + } 352 352 + 353 353 + func isFile(arg string) bool { 354 354 + if filepath.Ext(arg) != "" { 355 355 + return true 356 356 + } 357 357 + 358 358 + if info, err := os.Stat(arg); err == nil && !info.IsDir() { 359 359 + return true 360 360 + } 361 361 + 362 362 + return strings.Contains(arg, "/") || strings.Contains(arg, "\\") 363 363 + }

+697

cmd/handlers/notes_test.go

reviewed

··· 1 1 + package handlers 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "os" 6 6 + "path/filepath" 7 7 + "runtime" 8 8 + "strings" 9 9 + "testing" 10 10 + ) 11 11 + 12 12 + func setupNoteTest(t *testing.T) (string, func()) { 13 13 + tempDir, err := os.MkdirTemp("", "noteleaf-note-test-*") 14 14 + if err != nil { 15 15 + t.Fatalf("Failed to create temp dir: %v", err) 16 16 + } 17 17 + 18 18 + oldConfigHome := os.Getenv("XDG_CONFIG_HOME") 19 19 + os.Setenv("XDG_CONFIG_HOME", tempDir) 20 20 + 21 21 + cleanup := func() { 22 22 + os.Setenv("XDG_CONFIG_HOME", oldConfigHome) 23 23 + os.RemoveAll(tempDir) 24 24 + } 25 25 + 26 26 + ctx := context.Background() 27 27 + err = Setup(ctx, []string{}) 28 28 + if err != nil { 29 29 + cleanup() 30 30 + t.Fatalf("Failed to setup database: %v", err) 31 31 + } 32 32 + 33 33 + return tempDir, cleanup 34 34 + } 35 35 + 36 36 + func createTestMarkdownFile(t *testing.T, dir, filename, content string) string { 37 37 + filePath := filepath.Join(dir, filename) 38 38 + err := os.WriteFile(filePath, []byte(content), 0644) 39 39 + if err != nil { 40 40 + t.Fatalf("Failed to create test file: %v", err) 41 41 + } 42 42 + return filePath 43 43 + } 44 44 + 45 45 + func TestNoteHandler_NewNoteHandler(t *testing.T) { 46 46 + t.Run("creates handler successfully", func(t *testing.T) { 47 47 + _, cleanup := setupNoteTest(t) 48 48 + defer cleanup() 49 49 + 50 50 + handler, err := NewNoteHandler() 51 51 + if err != nil { 52 52 + t.Errorf("NewNoteHandler failed: %v", err) 53 53 + } 54 54 + if handler == nil { 55 55 + t.Error("Handler should not be nil") 56 56 + } 57 57 + defer handler.Close() 58 58 + 59 59 + if handler.db == nil { 60 60 + t.Error("Handler database should not be nil") 61 61 + } 62 62 + if handler.config == nil { 63 63 + t.Error("Handler config should not be nil") 64 64 + } 65 65 + if handler.repos == nil { 66 66 + t.Error("Handler repos should not be nil") 67 67 + } 68 68 + }) 69 69 + 70 70 + t.Run("handles database initialization error", func(t *testing.T) { 71 71 + originalXDG := os.Getenv("XDG_CONFIG_HOME") 72 72 + originalHome := os.Getenv("HOME") 73 73 + 74 74 + if runtime.GOOS == "windows" { 75 75 + originalAppData := os.Getenv("APPDATA") 76 76 + os.Unsetenv("APPDATA") 77 77 + defer os.Setenv("APPDATA", originalAppData) 78 78 + } else { 79 79 + os.Unsetenv("XDG_CONFIG_HOME") 80 80 + os.Unsetenv("HOME") 81 81 + } 82 82 + 83 83 + defer func() { 84 84 + os.Setenv("XDG_CONFIG_HOME", originalXDG) 85 85 + os.Setenv("HOME", originalHome) 86 86 + }() 87 87 + 88 88 + _, err := NewNoteHandler() 89 89 + if err == nil { 90 90 + t.Error("NewNoteHandler should fail when database initialization fails") 91 91 + } 92 92 + if !strings.Contains(err.Error(), "failed to initialize database") { 93 93 + t.Errorf("Expected database error, got: %v", err) 94 94 + } 95 95 + }) 96 96 + } 97 97 + 98 98 + func TestNoteHandler_parseNoteContent(t *testing.T) { 99 99 + handler := &NoteHandler{} 100 100 + 101 101 + testCases := []struct { 102 102 + name string 103 103 + input string 104 104 + expectedTitle string 105 105 + expectedContent string 106 106 + expectedTags []string 107 107 + }{ 108 108 + { 109 109 + name: "note with title and tags", 110 110 + input: `# My Test Note 111 111 + 112 112 + This is the content. 113 113 + 114 114 + <!-- Tags: personal, work, important -->`, 115 115 + expectedTitle: "My Test Note", 116 116 + expectedContent: `# My Test Note 117 117 + 118 118 + This is the content. 119 119 + 120 120 + <!-- Tags: personal, work, important -->`, 121 121 + expectedTags: []string{"personal", "work", "important"}, 122 122 + }, 123 123 + { 124 124 + name: "note without title", 125 125 + input: `Just some content here. 126 126 + 127 127 + No title heading. 128 128 + 129 129 + <!-- Tags: test -->`, 130 130 + expectedTitle: "", 131 131 + expectedContent: `Just some content here. 132 132 + 133 133 + No title heading. 134 134 + 135 135 + <!-- Tags: test -->`, 136 136 + expectedTags: []string{"test"}, 137 137 + }, 138 138 + { 139 139 + name: "note without tags", 140 140 + input: `# Title Only 141 141 + 142 142 + Content without tags.`, 143 143 + expectedTitle: "Title Only", 144 144 + expectedContent: `# Title Only 145 145 + 146 146 + Content without tags.`, 147 147 + expectedTags: nil, 148 148 + }, 149 149 + { 150 150 + name: "empty tags comment", 151 151 + input: `# Test Note 152 152 + 153 153 + Content here. 154 154 + 155 155 + <!-- Tags: -->`, 156 156 + expectedTitle: "Test Note", 157 157 + expectedContent: `# Test Note 158 158 + 159 159 + Content here. 160 160 + 161 161 + <!-- Tags: -->`, 162 162 + expectedTags: nil, 163 163 + }, 164 164 + { 165 165 + name: "malformed tags comment", 166 166 + input: `# Test Note 167 167 + 168 168 + Content here. 169 169 + 170 170 + <!-- Tags: tag1, , tag2,, tag3 -->`, 171 171 + expectedTitle: "Test Note", 172 172 + expectedContent: `# Test Note 173 173 + 174 174 + Content here. 175 175 + 176 176 + <!-- Tags: tag1, , tag2,, tag3 -->`, 177 177 + expectedTags: []string{"tag1", "tag2", "tag3"}, 178 178 + }, 179 179 + { 180 180 + name: "multiple headings", 181 181 + input: `## Secondary Heading 182 182 + 183 183 + # Main Title 184 184 + 185 185 + Content here.`, 186 186 + expectedTitle: "Main Title", 187 187 + expectedContent: `## Secondary Heading 188 188 + 189 189 + # Main Title 190 190 + 191 191 + Content here.`, 192 192 + expectedTags: nil, 193 193 + }, 194 194 + } 195 195 + 196 196 + for _, tc := range testCases { 197 197 + t.Run(tc.name, func(t *testing.T) { 198 198 + title, content, tags := handler.parseNoteContent(tc.input) 199 199 + 200 200 + if title != tc.expectedTitle { 201 201 + t.Errorf("Expected title %q, got %q", tc.expectedTitle, title) 202 202 + } 203 203 + 204 204 + if content != tc.expectedContent { 205 205 + t.Errorf("Expected content %q, got %q", tc.expectedContent, content) 206 206 + } 207 207 + 208 208 + if len(tags) != len(tc.expectedTags) { 209 209 + t.Errorf("Expected %d tags, got %d", len(tc.expectedTags), len(tags)) 210 210 + } 211 211 + 212 212 + for i, expectedTag := range tc.expectedTags { 213 213 + if i >= len(tags) || tags[i] != expectedTag { 214 214 + t.Errorf("Expected tag %q at position %d, got %q", expectedTag, i, tags[i]) 215 215 + } 216 216 + } 217 217 + }) 218 218 + } 219 219 + } 220 220 + 221 221 + func TestIsFile(t *testing.T) { 222 222 + testCases := []struct { 223 223 + name string 224 224 + input string 225 225 + expected bool 226 226 + }{ 227 227 + {"file with extension", "test.md", true}, 228 228 + {"file with multiple extensions", "test.tar.gz", true}, 229 229 + {"path with slash", "/path/to/file", true}, 230 230 + {"path with backslash", "path\\to\\file", true}, 231 231 + {"relative path", "./file", true}, 232 232 + {"just text", "hello", false}, 233 233 + {"empty string", "", false}, 234 234 + } 235 235 + 236 236 + tempDir, err := os.MkdirTemp("", "isfile-test-*") 237 237 + if err != nil { 238 238 + t.Fatalf("Failed to create temp dir: %v", err) 239 239 + } 240 240 + defer os.RemoveAll(tempDir) 241 241 + 242 242 + existingFile := filepath.Join(tempDir, "existing") 243 243 + err = os.WriteFile(existingFile, []byte("test"), 0644) 244 244 + if err != nil { 245 245 + t.Fatalf("Failed to create test file: %v", err) 246 246 + } 247 247 + 248 248 + testCases = append(testCases, struct { 249 249 + name string 250 250 + input string 251 251 + expected bool 252 252 + }{"existing file without extension", existingFile, true}) 253 253 + 254 254 + for _, tc := range testCases { 255 255 + t.Run(tc.name, func(t *testing.T) { 256 256 + result := isFile(tc.input) 257 257 + if result != tc.expected { 258 258 + t.Errorf("isFile(%q) = %v, expected %v", tc.input, result, tc.expected) 259 259 + } 260 260 + }) 261 261 + } 262 262 + } 263 263 + 264 264 + func TestNoteHandler_getEditor(t *testing.T) { 265 265 + handler := &NoteHandler{} 266 266 + 267 267 + t.Run("uses EDITOR environment variable", func(t *testing.T) { 268 268 + originalEditor := os.Getenv("EDITOR") 269 269 + os.Setenv("EDITOR", "test-editor") 270 270 + defer os.Setenv("EDITOR", originalEditor) 271 271 + 272 272 + editor := handler.getEditor() 273 273 + if editor != "test-editor" { 274 274 + t.Errorf("Expected 'test-editor', got %q", editor) 275 275 + } 276 276 + }) 277 277 + 278 278 + t.Run("finds available editor", func(t *testing.T) { 279 279 + originalEditor := os.Getenv("EDITOR") 280 280 + os.Unsetenv("EDITOR") 281 281 + defer os.Setenv("EDITOR", originalEditor) 282 282 + 283 283 + editor := handler.getEditor() 284 284 + if editor == "" { 285 285 + t.Skip("No common editors found on system, skipping test") 286 286 + } 287 287 + }) 288 288 + 289 289 + t.Run("returns empty when no editor available", func(t *testing.T) { 290 290 + originalEditor := os.Getenv("EDITOR") 291 291 + originalPath := os.Getenv("PATH") 292 292 + 293 293 + os.Unsetenv("EDITOR") 294 294 + os.Setenv("PATH", "") 295 295 + 296 296 + defer func() { 297 297 + os.Setenv("EDITOR", originalEditor) 298 298 + os.Setenv("PATH", originalPath) 299 299 + }() 300 300 + 301 301 + editor := handler.getEditor() 302 302 + if editor != "" { 303 303 + t.Errorf("Expected empty string when no editor available, got %q", editor) 304 304 + } 305 305 + }) 306 306 + } 307 307 + 308 308 + func TestNoteCreateErrorScenarios(t *testing.T) { 309 309 + errorTests := []struct { 310 310 + name string 311 311 + setupFunc func(t *testing.T) (cleanup func()) 312 312 + args []string 313 313 + expectError bool 314 314 + errorSubstr string 315 315 + }{ 316 316 + { 317 317 + name: "database initialization error", 318 318 + setupFunc: func(t *testing.T) func() { 319 319 + if runtime.GOOS == "windows" { 320 320 + original := os.Getenv("APPDATA") 321 321 + os.Unsetenv("APPDATA") 322 322 + return func() { os.Setenv("APPDATA", original) } 323 323 + } else { 324 324 + originalXDG := os.Getenv("XDG_CONFIG_HOME") 325 325 + originalHome := os.Getenv("HOME") 326 326 + os.Unsetenv("XDG_CONFIG_HOME") 327 327 + os.Unsetenv("HOME") 328 328 + return func() { 329 329 + os.Setenv("XDG_CONFIG_HOME", originalXDG) 330 330 + os.Setenv("HOME", originalHome) 331 331 + } 332 332 + } 333 333 + }, 334 334 + args: []string{"Test Note"}, 335 335 + expectError: true, 336 336 + errorSubstr: "failed to initialize database", 337 337 + }, 338 338 + { 339 339 + name: "note creation in database fails", 340 340 + setupFunc: func(t *testing.T) func() { 341 341 + tempDir, cleanup := setupNoteTest(t) 342 342 + 343 343 + configDir := filepath.Join(tempDir, "noteleaf") 344 344 + dbPath := filepath.Join(configDir, "noteleaf.db") 345 345 + 346 346 + err := os.WriteFile(dbPath, []byte("invalid sqlite content"), 0644) 347 347 + if err != nil { 348 348 + t.Fatalf("Failed to corrupt database: %v", err) 349 349 + } 350 350 + 351 351 + return cleanup 352 352 + }, 353 353 + args: []string{"Test Note"}, 354 354 + expectError: true, 355 355 + errorSubstr: "failed to initialize database", 356 356 + }, 357 357 + } 358 358 + 359 359 + for _, tt := range errorTests { 360 360 + t.Run(tt.name, func(t *testing.T) { 361 361 + cleanup := tt.setupFunc(t) 362 362 + defer cleanup() 363 363 + 364 364 + oldStdin := os.Stdin 365 365 + r, w, _ := os.Pipe() 366 366 + os.Stdin = r 367 367 + defer func() { os.Stdin = oldStdin }() 368 368 + 369 369 + go func() { 370 370 + w.WriteString("n\n") 371 371 + w.Close() 372 372 + }() 373 373 + 374 374 + ctx := context.Background() 375 375 + err := Create(ctx, tt.args) 376 376 + 377 377 + if tt.expectError && err == nil { 378 378 + t.Errorf("Expected error containing %q, got nil", tt.errorSubstr) 379 379 + } else if !tt.expectError && err != nil { 380 380 + t.Errorf("Expected no error, got: %v", err) 381 381 + } else if tt.expectError && err != nil && !strings.Contains(err.Error(), tt.errorSubstr) { 382 382 + t.Errorf("Expected error containing %q, got: %v", tt.errorSubstr, err) 383 383 + } 384 384 + }) 385 385 + } 386 386 + } 387 387 + 388 388 + func TestCreate_WithArgs(t *testing.T) { 389 389 + t.Run("creates note from title only", func(t *testing.T) { 390 390 + _, cleanup := setupNoteTest(t) 391 391 + defer cleanup() 392 392 + 393 393 + oldStdin := os.Stdin 394 394 + r, w, _ := os.Pipe() 395 395 + os.Stdin = r 396 396 + defer func() { os.Stdin = oldStdin }() 397 397 + 398 398 + go func() { 399 399 + w.WriteString("n\n") 400 400 + w.Close() 401 401 + }() 402 402 + 403 403 + ctx := context.Background() 404 404 + err := Create(ctx, []string{"Test Note"}) 405 405 + if err != nil { 406 406 + t.Errorf("Create failed: %v", err) 407 407 + } 408 408 + }) 409 409 + 410 410 + t.Run("creates note from title and content", func(t *testing.T) { 411 411 + _, cleanup := setupNoteTest(t) 412 412 + defer cleanup() 413 413 + 414 414 + oldStdin := os.Stdin 415 415 + r, w, _ := os.Pipe() 416 416 + os.Stdin = r 417 417 + defer func() { os.Stdin = oldStdin }() 418 418 + 419 419 + go func() { 420 420 + w.WriteString("n\n") 421 421 + w.Close() 422 422 + }() 423 423 + 424 424 + ctx := context.Background() 425 425 + err := Create(ctx, []string{"Test Note", "This", "is", "test", "content"}) 426 426 + if err != nil { 427 427 + t.Errorf("Create failed: %v", err) 428 428 + } 429 429 + }) 430 430 + 431 431 + t.Run("handles database connection error", func(t *testing.T) { 432 432 + tempDir, cleanup := setupNoteTest(t) 433 433 + defer cleanup() 434 434 + 435 435 + configDir := filepath.Join(tempDir, "noteleaf") 436 436 + dbPath := filepath.Join(configDir, "noteleaf.db") 437 437 + os.Remove(dbPath) 438 438 + 439 439 + os.MkdirAll(dbPath, 0755) 440 440 + defer os.RemoveAll(dbPath) 441 441 + 442 442 + ctx := context.Background() 443 443 + err := Create(ctx, []string{"Test Note"}) 444 444 + if err == nil { 445 445 + t.Error("Create should fail when database is inaccessible") 446 446 + } 447 447 + }) 448 448 + 449 449 + t.Run("New is alias for Create", func(t *testing.T) { 450 450 + _, cleanup := setupNoteTest(t) 451 451 + defer cleanup() 452 452 + 453 453 + oldStdin := os.Stdin 454 454 + r, w, _ := os.Pipe() 455 455 + os.Stdin = r 456 456 + defer func() { os.Stdin = oldStdin }() 457 457 + 458 458 + go func() { 459 459 + w.WriteString("n\n") 460 460 + w.Close() 461 461 + }() 462 462 + 463 463 + ctx := context.Background() 464 464 + err := New(ctx, []string{"Test Note via New"}) 465 465 + if err != nil { 466 466 + t.Errorf("New failed: %v", err) 467 467 + } 468 468 + }) 469 469 + } 470 470 + 471 471 + func TestCreate_FromFile(t *testing.T) { 472 472 + t.Run("creates note from markdown file", func(t *testing.T) { 473 473 + tempDir, cleanup := setupNoteTest(t) 474 474 + defer cleanup() 475 475 + 476 476 + content := `# My Test Note 477 477 + 478 478 + This is the content of my test note. 479 479 + 480 480 + ## Section 2 481 481 + 482 482 + More content here. 483 483 + 484 484 + <!-- Tags: personal, work -->` 485 485 + 486 486 + filePath := createTestMarkdownFile(t, tempDir, "test.md", content) 487 487 + 488 488 + ctx := context.Background() 489 489 + err := Create(ctx, []string{filePath}) 490 490 + if err != nil { 491 491 + t.Errorf("Create from file failed: %v", err) 492 492 + } 493 493 + }) 494 494 + 495 495 + t.Run("handles non-existent file", func(t *testing.T) { 496 496 + _, cleanup := setupNoteTest(t) 497 497 + defer cleanup() 498 498 + 499 499 + ctx := context.Background() 500 500 + err := Create(ctx, []string{"/non/existent/file.md"}) 501 501 + if err == nil { 502 502 + t.Error("Create should fail for non-existent file") 503 503 + } 504 504 + if !strings.Contains(err.Error(), "file does not exist") { 505 505 + t.Errorf("Expected file not found error, got: %v", err) 506 506 + } 507 507 + }) 508 508 + 509 509 + t.Run("handles empty file", func(t *testing.T) { 510 510 + tempDir, cleanup := setupNoteTest(t) 511 511 + defer cleanup() 512 512 + 513 513 + filePath := createTestMarkdownFile(t, tempDir, "empty.md", "") 514 514 + 515 515 + ctx := context.Background() 516 516 + err := Create(ctx, []string{filePath}) 517 517 + if err == nil { 518 518 + t.Error("Create should fail for empty file") 519 519 + } 520 520 + if !strings.Contains(err.Error(), "file is empty") { 521 521 + t.Errorf("Expected empty file error, got: %v", err) 522 522 + } 523 523 + }) 524 524 + 525 525 + t.Run("handles whitespace-only file", func(t *testing.T) { 526 526 + tempDir, cleanup := setupNoteTest(t) 527 527 + defer cleanup() 528 528 + 529 529 + filePath := createTestMarkdownFile(t, tempDir, "whitespace.md", " \n\t \n ") 530 530 + 531 531 + ctx := context.Background() 532 532 + err := Create(ctx, []string{filePath}) 533 533 + if err == nil { 534 534 + t.Error("Create should fail for whitespace-only file") 535 535 + } 536 536 + if !strings.Contains(err.Error(), "file is empty") { 537 537 + t.Errorf("Expected empty file error, got: %v", err) 538 538 + } 539 539 + }) 540 540 + 541 541 + t.Run("creates note without title in file", func(t *testing.T) { 542 542 + tempDir, cleanup := setupNoteTest(t) 543 543 + defer cleanup() 544 544 + 545 545 + content := `This note has no title heading. 546 546 + 547 547 + Just some content here.` 548 548 + 549 549 + filePath := createTestMarkdownFile(t, tempDir, "notitle.md", content) 550 550 + 551 551 + ctx := context.Background() 552 552 + err := Create(ctx, []string{filePath}) 553 553 + if err != nil { 554 554 + t.Errorf("Create from file without title failed: %v", err) 555 555 + } 556 556 + }) 557 557 + 558 558 + t.Run("handles file read error", func(t *testing.T) { 559 559 + tempDir, cleanup := setupNoteTest(t) 560 560 + defer cleanup() 561 561 + 562 562 + filePath := createTestMarkdownFile(t, tempDir, "unreadable.md", "test content") 563 563 + err := os.Chmod(filePath, 0000) 564 564 + if err != nil { 565 565 + t.Fatalf("Failed to make file unreadable: %v", err) 566 566 + } 567 567 + defer os.Chmod(filePath, 0644) 568 568 + 569 569 + ctx := context.Background() 570 570 + err = Create(ctx, []string{filePath}) 571 571 + if err == nil { 572 572 + t.Error("Create should fail for unreadable file") 573 573 + } 574 574 + if !strings.Contains(err.Error(), "failed to read file") { 575 575 + t.Errorf("Expected file read error, got: %v", err) 576 576 + } 577 577 + }) 578 578 + } 579 579 + 580 580 + func TestCreate_Interactive(t *testing.T) { 581 581 + t.Run("handles no editor configured", func(t *testing.T) { 582 582 + _, cleanup := setupNoteTest(t) 583 583 + defer cleanup() 584 584 + 585 585 + originalEditor := os.Getenv("EDITOR") 586 586 + originalPath := os.Getenv("PATH") 587 587 + os.Unsetenv("EDITOR") 588 588 + os.Setenv("PATH", "") 589 589 + defer func() { 590 590 + os.Setenv("EDITOR", originalEditor) 591 591 + os.Setenv("PATH", originalPath) 592 592 + }() 593 593 + 594 594 + ctx := context.Background() 595 595 + err := Create(ctx, []string{}) 596 596 + if err == nil { 597 597 + t.Error("Create should fail when no editor is configured") 598 598 + } 599 599 + if !strings.Contains(err.Error(), "no editor configured") { 600 600 + t.Errorf("Expected no editor error, got: %v", err) 601 601 + } 602 602 + }) 603 603 + 604 604 + t.Run("handles editor command failure", func(t *testing.T) { 605 605 + _, cleanup := setupNoteTest(t) 606 606 + defer cleanup() 607 607 + 608 608 + originalEditor := os.Getenv("EDITOR") 609 609 + os.Setenv("EDITOR", "nonexistent-editor-12345") 610 610 + defer os.Setenv("EDITOR", originalEditor) 611 611 + 612 612 + ctx := context.Background() 613 613 + err := Create(ctx, []string{}) 614 614 + if err == nil { 615 615 + t.Error("Create should fail when editor command fails") 616 616 + } 617 617 + if !strings.Contains(err.Error(), "failed to open editor") { 618 618 + t.Errorf("Expected editor failure error, got: %v", err) 619 619 + } 620 620 + }) 621 621 + 622 622 + t.Run("creates note successfully with mocked editor", func(t *testing.T) { 623 623 + _, cleanup := setupNoteTest(t) 624 624 + defer cleanup() 625 625 + 626 626 + originalEditor := os.Getenv("EDITOR") 627 627 + os.Setenv("EDITOR", "test-editor") 628 628 + defer os.Setenv("EDITOR", originalEditor) 629 629 + 630 630 + handler, err := NewNoteHandler() 631 631 + if err != nil { 632 632 + t.Fatalf("NewNoteHandler failed: %v", err) 633 633 + } 634 634 + defer handler.Close() 635 635 + 636 636 + handler.openInEditorFunc = func(editor, filePath string) error { 637 637 + content := `# Test Note 638 638 + 639 639 + This is edited content. 640 640 + 641 641 + <!-- Tags: test, created -->` 642 642 + return os.WriteFile(filePath, []byte(content), 0644) 643 643 + } 644 644 + 645 645 + ctx := context.Background() 646 646 + err = handler.createInteractive(ctx) 647 647 + if err != nil { 648 648 + t.Errorf("Interactive create failed: %v", err) 649 649 + } 650 650 + }) 651 651 + 652 652 + t.Run("handles editor cancellation", func(t *testing.T) { 653 653 + _, cleanup := setupNoteTest(t) 654 654 + defer cleanup() 655 655 + 656 656 + originalEditor := os.Getenv("EDITOR") 657 657 + os.Setenv("EDITOR", "test-editor") 658 658 + defer os.Setenv("EDITOR", originalEditor) 659 659 + 660 660 + handler, err := NewNoteHandler() 661 661 + if err != nil { 662 662 + t.Fatalf("NewNoteHandler failed: %v", err) 663 663 + } 664 664 + defer handler.Close() 665 665 + 666 666 + handler.openInEditorFunc = func(editor, filePath string) error { 667 667 + return nil 668 668 + } 669 669 + 670 670 + ctx := context.Background() 671 671 + err = handler.createInteractive(ctx) 672 672 + if err != nil { 673 673 + t.Errorf("Interactive create should handle cancellation gracefully: %v", err) 674 674 + } 675 675 + }) 676 676 + } 677 677 + 678 678 + func TestNoteHandlerClosesResources(t *testing.T) { 679 679 + _, cleanup := setupNoteTest(t) 680 680 + defer cleanup() 681 681 + 682 682 + handler, err := NewNoteHandler() 683 683 + if err != nil { 684 684 + t.Fatalf("NewNoteHandler failed: %v", err) 685 685 + } 686 686 + 687 687 + err = handler.Close() 688 688 + if err != nil { 689 689 + t.Errorf("Close should not return error: %v", err) 690 690 + } 691 691 + 692 692 + handler.db = nil 693 693 + err = handler.Close() 694 694 + if err != nil { 695 695 + t.Errorf("Close should handle nil database gracefully: %v", err) 696 696 + } 697 697 + }