1// SPDX-FileCopyrightText: Amolith <amolith@secluded.site>
2//
3// SPDX-License-Identifier: AGPL-3.0-or-later
4
5package lunatask_test
6
7import (
8 "testing"
9
10 lunatask "git.secluded.site/go-lunatask"
11)
12
13// --- Eisenhower Type Constants ---
14
15func TestEisenhower_Constants(t *testing.T) {
16 t.Parallel()
17
18 tests := []struct {
19 name string
20 value lunatask.Eisenhower
21 want int
22 }{
23 {"uncategorized", lunatask.EisenhowerUncategorized, 0},
24 {"do_now", lunatask.EisenhowerDoNow, 1},
25 {"delegate", lunatask.EisenhowerDelegate, 2},
26 {"do_later", lunatask.EisenhowerDoLater, 3},
27 {"eliminate", lunatask.EisenhowerEliminate, 4},
28 }
29
30 for _, tc := range tests {
31 t.Run(tc.name, func(t *testing.T) {
32 t.Parallel()
33
34 if int(tc.value) != tc.want {
35 t.Errorf("Eisenhower constant = %d, want %d", tc.value, tc.want)
36 }
37 })
38 }
39}
40
41// --- Eisenhower Helper Methods ---
42
43func TestEisenhower_IsUrgent(t *testing.T) {
44 t.Parallel()
45
46 tests := []struct {
47 name string
48 value lunatask.Eisenhower
49 want bool
50 }{
51 {"uncategorized", lunatask.EisenhowerUncategorized, false},
52 {"do_now", lunatask.EisenhowerDoNow, true}, // urgent + important
53 {"delegate", lunatask.EisenhowerDelegate, true}, // urgent only
54 {"do_later", lunatask.EisenhowerDoLater, false}, // important only
55 {"eliminate", lunatask.EisenhowerEliminate, false}, // neither
56 }
57
58 for _, tc := range tests {
59 t.Run(tc.name, func(t *testing.T) {
60 t.Parallel()
61
62 if got := tc.value.IsUrgent(); got != tc.want {
63 t.Errorf("Eisenhower(%d).IsUrgent() = %v, want %v", tc.value, got, tc.want)
64 }
65 })
66 }
67}
68
69func TestEisenhower_IsImportant(t *testing.T) {
70 t.Parallel()
71
72 tests := []struct {
73 name string
74 value lunatask.Eisenhower
75 want bool
76 }{
77 {"uncategorized", lunatask.EisenhowerUncategorized, false},
78 {"do_now", lunatask.EisenhowerDoNow, true}, // urgent + important
79 {"delegate", lunatask.EisenhowerDelegate, false}, // urgent only
80 {"do_later", lunatask.EisenhowerDoLater, true}, // important only
81 {"eliminate", lunatask.EisenhowerEliminate, false}, // neither
82 }
83
84 for _, tc := range tests {
85 t.Run(tc.name, func(t *testing.T) {
86 t.Parallel()
87
88 if got := tc.value.IsImportant(); got != tc.want {
89 t.Errorf("Eisenhower(%d).IsImportant() = %v, want %v", tc.value, got, tc.want)
90 }
91 })
92 }
93}
94
95// --- Eisenhower Helper Function ---
96
97func TestNewEisenhower(t *testing.T) {
98 t.Parallel()
99
100 tests := []struct {
101 name string
102 important bool
103 urgent bool
104 want lunatask.Eisenhower
105 }{
106 {"both", true, true, lunatask.EisenhowerDoNow},
107 {"urgent_only", false, true, lunatask.EisenhowerDelegate},
108 {"important_only", true, false, lunatask.EisenhowerDoLater},
109 {"neither", false, false, lunatask.EisenhowerEliminate},
110 }
111
112 for _, testCase := range tests {
113 t.Run(testCase.name, func(t *testing.T) {
114 t.Parallel()
115
116 got := lunatask.NewEisenhower(testCase.important, testCase.urgent)
117 if got != testCase.want {
118 t.Errorf("NewEisenhower(%v, %v) = %d, want %d", testCase.important, testCase.urgent, got, testCase.want)
119 }
120 })
121 }
122}
123
124// --- TaskBuilder Semantic Methods ---
125
126func TestTaskBuilder_Important(t *testing.T) {
127 t.Parallel()
128
129 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
130 defer server.Close()
131
132 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
133
134 _, err := client.NewTask("Important task").
135 Important().
136 Create(ctx())
137 if err != nil {
138 t.Fatalf("error = %v", err)
139 }
140
141 // Important only = 3 (DoLater)
142 assertBodyFieldFloat(t, capture.Body, "eisenhower", 3)
143}
144
145func TestTaskBuilder_Urgent(t *testing.T) {
146 t.Parallel()
147
148 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
149 defer server.Close()
150
151 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
152
153 _, err := client.NewTask("Urgent task").
154 Urgent().
155 Create(ctx())
156 if err != nil {
157 t.Fatalf("error = %v", err)
158 }
159
160 // Urgent only = 2 (Delegate)
161 assertBodyFieldFloat(t, capture.Body, "eisenhower", 2)
162}
163
164func TestTaskBuilder_ImportantAndUrgent(t *testing.T) {
165 t.Parallel()
166
167 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
168 defer server.Close()
169
170 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
171
172 _, err := client.NewTask("Do now task").
173 Important().
174 Urgent().
175 Create(ctx())
176 if err != nil {
177 t.Fatalf("error = %v", err)
178 }
179
180 // Both = 1 (DoNow)
181 assertBodyFieldFloat(t, capture.Body, "eisenhower", 1)
182}
183
184func TestTaskBuilder_UrgentAndImportant_ReverseOrder(t *testing.T) {
185 t.Parallel()
186
187 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
188 defer server.Close()
189
190 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
191
192 _, err := client.NewTask("Do now task").
193 Urgent().
194 Important().
195 Create(ctx())
196 if err != nil {
197 t.Fatalf("error = %v", err)
198 }
199
200 // Both = 1 (DoNow), order shouldn't matter
201 assertBodyFieldFloat(t, capture.Body, "eisenhower", 1)
202}
203
204func TestTaskBuilder_NeitherImportantNorUrgent(t *testing.T) {
205 t.Parallel()
206
207 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
208 defer server.Close()
209
210 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
211
212 // Explicitly set neither - should result in Eliminate (4)
213 _, err := client.NewTask("Eliminate task").
214 NotImportant().
215 NotUrgent().
216 Create(ctx())
217 if err != nil {
218 t.Fatalf("error = %v", err)
219 }
220
221 // Neither = 4 (Eliminate)
222 assertBodyFieldFloat(t, capture.Body, "eisenhower", 4)
223}
224
225// --- TaskUpdateBuilder Semantic Methods ---
226
227func TestTaskUpdateBuilder_Important(t *testing.T) {
228 t.Parallel()
229
230 server, capture := newPUTServer(t, "/tasks/"+taskID, singleTaskResponseBody)
231 defer server.Close()
232
233 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
234
235 _, err := client.NewTaskUpdate(taskID).
236 Important().
237 Update(ctx())
238 if err != nil {
239 t.Fatalf("error = %v", err)
240 }
241
242 // Important only = 3 (DoLater)
243 assertBodyFieldFloat(t, capture.Body, "eisenhower", 3)
244}
245
246func TestTaskUpdateBuilder_Urgent(t *testing.T) {
247 t.Parallel()
248
249 server, capture := newPUTServer(t, "/tasks/"+taskID, singleTaskResponseBody)
250 defer server.Close()
251
252 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
253
254 _, err := client.NewTaskUpdate(taskID).
255 Urgent().
256 Update(ctx())
257 if err != nil {
258 t.Fatalf("error = %v", err)
259 }
260
261 // Urgent only = 2 (Delegate)
262 assertBodyFieldFloat(t, capture.Body, "eisenhower", 2)
263}
264
265func TestTaskUpdateBuilder_ImportantAndUrgent(t *testing.T) {
266 t.Parallel()
267
268 server, capture := newPUTServer(t, "/tasks/"+taskID, singleTaskResponseBody)
269 defer server.Close()
270
271 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
272
273 _, err := client.NewTaskUpdate(taskID).
274 Important().
275 Urgent().
276 Update(ctx())
277 if err != nil {
278 t.Fatalf("error = %v", err)
279 }
280
281 // Both = 1 (DoNow)
282 assertBodyFieldFloat(t, capture.Body, "eisenhower", 1)
283}
284
285func TestTaskUpdateBuilder_NeitherImportantNorUrgent(t *testing.T) {
286 t.Parallel()
287
288 server, capture := newPUTServer(t, "/tasks/"+taskID, singleTaskResponseBody)
289 defer server.Close()
290
291 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
292
293 _, err := client.NewTaskUpdate(taskID).
294 NotImportant().
295 NotUrgent().
296 Update(ctx())
297 if err != nil {
298 t.Fatalf("error = %v", err)
299 }
300
301 // Neither = 4 (Eliminate)
302 assertBodyFieldFloat(t, capture.Body, "eisenhower", 4)
303}
304
305// --- WithEisenhower still works with typed constant ---
306
307func TestTaskBuilder_WithEisenhowerTyped(t *testing.T) {
308 t.Parallel()
309
310 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
311 defer server.Close()
312
313 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
314
315 _, err := client.NewTask("Typed eisenhower").
316 WithEisenhower(lunatask.EisenhowerDoNow).
317 Create(ctx())
318 if err != nil {
319 t.Fatalf("error = %v", err)
320 }
321
322 assertBodyFieldFloat(t, capture.Body, "eisenhower", 1)
323}
324
325func TestTaskUpdateBuilder_WithEisenhowerTyped(t *testing.T) {
326 t.Parallel()
327
328 server, capture := newPUTServer(t, "/tasks/"+taskID, singleTaskResponseBody)
329 defer server.Close()
330
331 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
332
333 _, err := client.NewTaskUpdate(taskID).
334 WithEisenhower(lunatask.EisenhowerDelegate).
335 Update(ctx())
336 if err != nil {
337 t.Fatalf("error = %v", err)
338 }
339
340 assertBodyFieldFloat(t, capture.Body, "eisenhower", 2)
341}