cli + tui to publish to leaflet (wip) & manage tasks, notes & watch/read lists 🍃
charm
leaflet
readability
golang
refactor(wip): use helpers in note handler tests
+39
-116
+39
-116
internal/handlers/notes_test.go
+39
-116
internal/handlers/notes_test.go
···
59
59
t.Run("New", func(t *testing.T) {
60
60
t.Run("creates handler successfully", func(t *testing.T) {
61
61
testHandler, err := NewNoteHandler()
62
-
if err != nil {
63
-
t.Fatalf("NewNoteHandler failed: %v", err)
64
-
}
62
+
Expect.AssertNoError(t, err, "NewNoteHandler should succeed")
65
63
if testHandler == nil {
66
64
t.Fatal("Handler should not be nil")
67
65
}
···
79
77
})
80
78
81
79
t.Run("handles database initialization error", func(t *testing.T) {
82
-
originalXDG := os.Getenv("XDG_CONFIG_HOME")
83
-
originalHome := os.Getenv("HOME")
80
+
envHelper := NewEnvironmentTestHelper()
81
+
defer envHelper.RestoreEnv()
84
82
85
83
if runtime.GOOS == "windows" {
86
-
originalAppData := os.Getenv("APPDATA")
87
-
os.Unsetenv("APPDATA")
88
-
defer os.Setenv("APPDATA", originalAppData)
84
+
envHelper.UnsetEnv("APPDATA")
89
85
} else {
90
-
os.Unsetenv("XDG_CONFIG_HOME")
91
-
os.Unsetenv("HOME")
86
+
envHelper.UnsetEnv("XDG_CONFIG_HOME")
87
+
envHelper.UnsetEnv("HOME")
92
88
}
93
89
94
-
defer func() {
95
-
os.Setenv("XDG_CONFIG_HOME", originalXDG)
96
-
os.Setenv("HOME", originalHome)
97
-
}()
98
-
99
90
_, err := NewNoteHandler()
100
-
if err == nil {
101
-
t.Error("NewNoteHandler should fail when database initialization fails")
102
-
}
103
-
if !strings.Contains(err.Error(), "failed to initialize database") {
104
-
t.Errorf("Expected database error, got: %v", err)
105
-
}
91
+
Expect.AssertError(t, err, "failed to initialize database", "NewNoteHandler should fail when database initialization fails")
106
92
})
107
93
})
108
94
···
111
97
112
98
t.Run("creates note from title only", func(t *testing.T) {
113
99
err := handler.Create(ctx, "Test Note 1", "", "", false)
114
-
if err != nil {
115
-
t.Errorf("Create failed: %v", err)
116
-
}
100
+
Expect.AssertNoError(t, err, "Create should succeed")
117
101
})
118
102
119
103
t.Run("creates note from title and content", func(t *testing.T) {
120
104
err := handler.Create(ctx, "Test Note 2", "This is test content", "", false)
121
-
if err != nil {
122
-
t.Errorf("Create failed: %v", err)
123
-
}
105
+
Expect.AssertNoError(t, err, "Create should succeed")
124
106
})
125
107
126
108
t.Run("creates note from markdown file", func(t *testing.T) {
···
131
113
filePath := createTestMarkdownFile(t, tempDir, "test.md", content)
132
114
133
115
err := handler.Create(ctx, "", "", filePath, false)
134
-
if err != nil {
135
-
t.Errorf("Create from file failed: %v", err)
136
-
}
116
+
Expect.AssertNoError(t, err, "Create from file should succeed")
137
117
})
138
118
139
119
t.Run("handles non-existent file", func(t *testing.T) {
140
120
err := handler.Create(ctx, "", "", "/non/existent/file.md", false)
141
-
if err == nil {
142
-
t.Error("Create should fail with non-existent file")
143
-
}
121
+
Expect.AssertError(t, err, "", "Create should fail with non-existent file")
144
122
})
145
123
})
146
124
···
149
127
150
128
t.Run("handles non-existent note", func(t *testing.T) {
151
129
err := handler.Edit(ctx, 999)
152
-
if err == nil {
153
-
t.Error("Edit should fail with non-existent note ID")
154
-
}
155
-
if !strings.Contains(err.Error(), "failed to get note") && !strings.Contains(err.Error(), "failed to find note") {
156
-
t.Errorf("Expected note not found error, got: %v", err)
157
-
}
130
+
Expect.AssertError(t, err, "failed to get note", "Edit should fail with non-existent note ID")
158
131
})
159
132
160
133
t.Run("handles no editor configured", func(t *testing.T) {
161
-
originalEditor := os.Getenv("EDITOR")
162
-
originalPath := os.Getenv("PATH")
163
-
os.Setenv("EDITOR", "")
164
-
os.Setenv("PATH", "")
165
-
defer func() {
166
-
os.Setenv("EDITOR", originalEditor)
167
-
os.Setenv("PATH", originalPath)
168
-
}()
134
+
envHelper := NewEnvironmentTestHelper()
135
+
defer envHelper.RestoreEnv()
136
+
137
+
envHelper.SetEnv("EDITOR", "")
138
+
envHelper.SetEnv("PATH", "")
169
139
170
140
err := handler.Edit(ctx, 1)
171
-
if err == nil {
172
-
t.Error("Edit should fail when no editor is configured")
173
-
}
174
-
if !strings.Contains(err.Error(), "no editor configured") && !strings.Contains(err.Error(), "failed to open editor") {
175
-
t.Errorf("Expected no editor error, got: %v", err)
176
-
}
141
+
Expect.AssertError(t, err, "failed to open editor", "Edit should fail when no editor is configured")
177
142
})
178
143
179
144
t.Run("handles database connection error", func(t *testing.T) {
···
181
146
defer func() {
182
147
var err error
183
148
handler.db, err = store.NewDatabase()
184
-
if err != nil {
185
-
t.Fatalf("Failed to reconnect to database: %v", err)
186
-
}
149
+
Expect.AssertNoError(t, err, "Failed to reconnect to database")
187
150
}()
188
151
189
152
err := handler.Edit(ctx, 1)
190
-
if err == nil {
191
-
t.Error("Edit should fail when database is closed")
192
-
}
193
-
if !strings.Contains(err.Error(), "failed to get note") {
194
-
t.Errorf("Expected database error, got: %v", err)
195
-
}
153
+
Expect.AssertError(t, err, "failed to get note", "Edit should fail when database is closed")
196
154
})
197
155
198
156
t.Run("handles temp file creation error", func(t *testing.T) {
199
157
testHandler, err := NewNoteHandler()
200
-
if err != nil {
201
-
t.Fatalf("Failed to create test handler: %v", err)
202
-
}
158
+
Expect.AssertNoError(t, err, "Failed to create test handler")
203
159
defer testHandler.Close()
204
160
205
161
err = testHandler.Create(ctx, "Temp File Test Note", "Test content", "", false)
206
-
if err != nil {
207
-
t.Fatalf("Failed to create test note: %v", err)
208
-
}
162
+
Expect.AssertNoError(t, err, "Failed to create test note")
209
163
210
-
originalTempDir := os.Getenv("TMPDIR")
211
-
os.Setenv("TMPDIR", "/non/existent/path")
212
-
defer os.Setenv("TMPDIR", originalTempDir)
164
+
envHelper := NewEnvironmentTestHelper()
165
+
defer envHelper.RestoreEnv()
166
+
envHelper.SetEnv("TMPDIR", "/non/existent/path")
213
167
214
168
err = testHandler.Edit(ctx, 1)
215
-
if err == nil {
216
-
t.Error("Edit should fail when temp file creation fails")
217
-
}
218
-
if !strings.Contains(err.Error(), "failed to create temporary file") {
219
-
t.Errorf("Expected temp file error, got: %v", err)
220
-
}
169
+
Expect.AssertError(t, err, "failed to create temporary file", "Edit should fail when temp file creation fails")
221
170
})
222
171
223
172
t.Run("handles editor failure", func(t *testing.T) {
224
173
testHandler, err := NewNoteHandler()
225
-
if err != nil {
226
-
t.Fatalf("Failed to create test handler: %v", err)
227
-
}
174
+
Expect.AssertNoError(t, err, "Failed to create test handler")
228
175
defer testHandler.Close()
229
176
230
177
err = testHandler.Create(ctx, "Editor Failure Test Note", "Test content", "", false)
231
-
if err != nil {
232
-
t.Fatalf("Failed to create test note: %v", err)
233
-
}
178
+
Expect.AssertNoError(t, err, "Failed to create test note")
234
179
235
-
mockEditor := func(editor, filePath string) error {
236
-
return fmt.Errorf("editor process failed")
237
-
}
238
-
testHandler.openInEditorFunc = mockEditor
180
+
mockEditor := NewMockEditor().WithFailure("editor process failed")
181
+
testHandler.openInEditorFunc = mockEditor.GetEditorFunc()
239
182
240
183
err = testHandler.Edit(ctx, 1)
241
-
if err == nil {
242
-
t.Error("Edit should fail when editor fails")
243
-
}
244
-
if !strings.Contains(err.Error(), "failed to open editor") {
245
-
t.Errorf("Expected editor error, got: %v", err)
246
-
}
184
+
Expect.AssertError(t, err, "failed to open editor", "Edit should fail when editor fails")
247
185
})
248
186
249
187
t.Run("handles temp file write error", func(t *testing.T) {
250
188
originalHandler := handler.openInEditorFunc
251
189
defer func() { handler.openInEditorFunc = originalHandler }()
252
190
253
-
mockEditor := func(editor, filePath string) error {
254
-
return os.Chmod(filePath, 0444)
255
-
}
256
-
handler.openInEditorFunc = mockEditor
191
+
mockEditor := NewMockEditor().WithReadOnly()
192
+
handler.openInEditorFunc = mockEditor.GetEditorFunc()
257
193
258
194
err := handler.Edit(ctx, 1)
259
-
if err == nil {
260
-
t.Error("Edit should handle temp file write issues")
261
-
}
195
+
Expect.AssertError(t, err, "", "Edit should handle temp file write issues")
262
196
})
263
197
264
198
t.Run("handles file read error after editing", func(t *testing.T) {
265
199
testHandler, err := NewNoteHandler()
266
-
if err != nil {
267
-
t.Fatalf("Failed to create test handler: %v", err)
268
-
}
200
+
Expect.AssertNoError(t, err, "Failed to create test handler")
269
201
defer testHandler.Close()
270
202
271
203
err = testHandler.Create(ctx, "File Read Error Test Note", "Test content", "", false)
272
-
if err != nil {
273
-
t.Fatalf("Failed to create test note: %v", err)
274
-
}
204
+
Expect.AssertNoError(t, err, "Failed to create test note")
275
205
276
-
mockEditor := func(editor, filePath string) error {
277
-
return os.Remove(filePath)
278
-
}
279
-
testHandler.openInEditorFunc = mockEditor
206
+
mockEditor := NewMockEditor().WithFileDeleted()
207
+
testHandler.openInEditorFunc = mockEditor.GetEditorFunc()
280
208
281
209
err = testHandler.Edit(ctx, 1)
282
-
if err == nil {
283
-
t.Error("Edit should fail when temp file is deleted")
284
-
}
285
-
if !strings.Contains(err.Error(), "failed to read edited content") {
286
-
t.Errorf("Expected file read error, got: %v", err)
287
-
}
210
+
Expect.AssertError(t, err, "failed to read edited content", "Edit should fail when temp file is deleted")
288
211
})
289
212
290
213
t.Run("handles database update error", func(t *testing.T) {