1// SPDX-FileCopyrightText: Amolith <amolith@secluded.site>
2//
3// SPDX-License-Identifier: AGPL-3.0-or-later
4
5package lunatask_test
6
7import (
8 "encoding/json"
9 "testing"
10
11 lunatask "git.secluded.site/go-lunatask"
12)
13
14// --- Priority Type Constants ---
15
16func TestPriority_Constants(t *testing.T) {
17 t.Parallel()
18
19 tests := []struct {
20 name string
21 value lunatask.Priority
22 want int
23 }{
24 {"lowest", lunatask.PriorityLowest, -2},
25 {"low", lunatask.PriorityLow, -1},
26 {"normal", lunatask.PriorityNormal, 0},
27 {"high", lunatask.PriorityHigh, 1},
28 {"highest", lunatask.PriorityHighest, 2},
29 }
30
31 for _, tc := range tests {
32 t.Run(tc.name, func(t *testing.T) {
33 t.Parallel()
34
35 if int(tc.value) != tc.want {
36 t.Errorf("Priority constant = %d, want %d", tc.value, tc.want)
37 }
38 })
39 }
40}
41
42// --- Priority String Method ---
43
44func TestPriority_String(t *testing.T) {
45 t.Parallel()
46
47 tests := []struct {
48 name string
49 value lunatask.Priority
50 want string
51 }{
52 {"lowest", lunatask.PriorityLowest, "lowest"},
53 {"low", lunatask.PriorityLow, "low"},
54 {"normal", lunatask.PriorityNormal, "normal"},
55 {"high", lunatask.PriorityHigh, "high"},
56 {"highest", lunatask.PriorityHighest, "highest"},
57 }
58
59 for _, tc := range tests {
60 t.Run(tc.name, func(t *testing.T) {
61 t.Parallel()
62
63 if got := tc.value.String(); got != tc.want {
64 t.Errorf("Priority(%d).String() = %q, want %q", tc.value, got, tc.want)
65 }
66 })
67 }
68}
69
70func TestPriority_String_Unknown(t *testing.T) {
71 t.Parallel()
72
73 p := lunatask.Priority(99)
74 if got := p.String(); got != "Priority(99)" {
75 t.Errorf("Priority(99).String() = %q, want %q", got, "Priority(99)")
76 }
77}
78
79// --- Priority Valid Method ---
80
81func TestPriority_Valid(t *testing.T) {
82 t.Parallel()
83
84 tests := []struct {
85 name string
86 value lunatask.Priority
87 want bool
88 }{
89 {"lowest", lunatask.PriorityLowest, true},
90 {"low", lunatask.PriorityLow, true},
91 {"normal", lunatask.PriorityNormal, true},
92 {"high", lunatask.PriorityHigh, true},
93 {"highest", lunatask.PriorityHighest, true},
94 {"below_range", lunatask.Priority(-3), false},
95 {"above_range", lunatask.Priority(3), false},
96 {"way_above", lunatask.Priority(99), false},
97 }
98
99 for _, tc := range tests {
100 t.Run(tc.name, func(t *testing.T) {
101 t.Parallel()
102
103 if got := tc.value.Valid(); got != tc.want {
104 t.Errorf("Priority(%d).Valid() = %v, want %v", tc.value, got, tc.want)
105 }
106 })
107 }
108}
109
110// --- ParsePriority Function ---
111
112func TestParsePriority(t *testing.T) {
113 t.Parallel()
114
115 tests := []struct {
116 name string
117 input string
118 want lunatask.Priority
119 wantErr bool
120 }{
121 {"lowest_lower", "lowest", lunatask.PriorityLowest, false},
122 {"lowest_upper", "LOWEST", lunatask.PriorityLowest, false},
123 {"lowest_mixed", "LoWeSt", lunatask.PriorityLowest, false},
124 {"low_lower", "low", lunatask.PriorityLow, false},
125 {"low_upper", "LOW", lunatask.PriorityLow, false},
126 {"normal_lower", "normal", lunatask.PriorityNormal, false},
127 {"normal_upper", "NORMAL", lunatask.PriorityNormal, false},
128 {"high_lower", "high", lunatask.PriorityHigh, false},
129 {"high_upper", "HIGH", lunatask.PriorityHigh, false},
130 {"highest_lower", "highest", lunatask.PriorityHighest, false},
131 {"highest_upper", "HIGHEST", lunatask.PriorityHighest, false},
132 {"invalid", "invalid", 0, true},
133 {"empty", "", 0, true},
134 {"numeric", "1", 0, true},
135 }
136
137 for _, testCase := range tests {
138 t.Run(testCase.name, func(t *testing.T) {
139 t.Parallel()
140
141 got, err := lunatask.ParsePriority(testCase.input)
142 if (err != nil) != testCase.wantErr {
143 t.Errorf("ParsePriority(%q) error = %v, wantErr %v", testCase.input, err, testCase.wantErr)
144
145 return
146 }
147
148 if !testCase.wantErr && got != testCase.want {
149 t.Errorf("ParsePriority(%q) = %d, want %d", testCase.input, got, testCase.want)
150 }
151 })
152 }
153}
154
155// --- Priority JSON Marshaling ---
156
157func TestPriority_MarshalJSON(t *testing.T) {
158 t.Parallel()
159
160 tests := []struct {
161 name string
162 value lunatask.Priority
163 want string
164 }{
165 {"lowest", lunatask.PriorityLowest, "-2"},
166 {"low", lunatask.PriorityLow, "-1"},
167 {"normal", lunatask.PriorityNormal, "0"},
168 {"high", lunatask.PriorityHigh, "1"},
169 {"highest", lunatask.PriorityHighest, "2"},
170 }
171
172 for _, testCase := range tests {
173 t.Run(testCase.name, func(t *testing.T) {
174 t.Parallel()
175
176 got, err := json.Marshal(testCase.value)
177 if err != nil {
178 t.Fatalf("Marshal error: %v", err)
179 }
180
181 if string(got) != testCase.want {
182 t.Errorf("json.Marshal(Priority) = %s, want %s", got, testCase.want)
183 }
184 })
185 }
186}
187
188func TestPriority_UnmarshalJSON(t *testing.T) {
189 t.Parallel()
190
191 tests := []struct {
192 name string
193 input string
194 want lunatask.Priority
195 wantErr bool
196 }{
197 {"lowest", "-2", lunatask.PriorityLowest, false},
198 {"low", "-1", lunatask.PriorityLow, false},
199 {"normal", "0", lunatask.PriorityNormal, false},
200 {"high", "1", lunatask.PriorityHigh, false},
201 {"highest", "2", lunatask.PriorityHighest, false},
202 {"null", "null", lunatask.PriorityNormal, false},
203 {"out_of_range_high", "5", 0, true},
204 {"out_of_range_low", "-5", 0, true},
205 {"string", `"high"`, 0, true},
206 }
207
208 for _, testCase := range tests {
209 t.Run(testCase.name, func(t *testing.T) {
210 t.Parallel()
211
212 var got lunatask.Priority
213
214 err := json.Unmarshal([]byte(testCase.input), &got)
215
216 if (err != nil) != testCase.wantErr {
217 t.Errorf("Unmarshal error = %v, wantErr %v", err, testCase.wantErr)
218
219 return
220 }
221
222 if !testCase.wantErr && got != testCase.want {
223 t.Errorf("Unmarshal(%s) = %d, want %d", testCase.input, got, testCase.want)
224 }
225 })
226 }
227}
228
229// --- TaskBuilder Priority Method ---
230
231func TestTaskBuilder_Priority(t *testing.T) {
232 t.Parallel()
233
234 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
235 defer server.Close()
236
237 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
238
239 _, err := client.NewTask("High priority task").
240 Priority(lunatask.PriorityHigh).
241 Create(ctx())
242 if err != nil {
243 t.Fatalf("error = %v", err)
244 }
245
246 assertBodyFieldFloat(t, capture.Body, "priority", 1)
247}
248
249func TestTaskBuilder_Priority_AllValues(t *testing.T) {
250 t.Parallel()
251
252 tests := []struct {
253 name string
254 priority lunatask.Priority
255 want float64
256 }{
257 {"lowest", lunatask.PriorityLowest, -2},
258 {"low", lunatask.PriorityLow, -1},
259 {"normal", lunatask.PriorityNormal, 0},
260 {"high", lunatask.PriorityHigh, 1},
261 {"highest", lunatask.PriorityHighest, 2},
262 }
263
264 for _, testCase := range tests {
265 t.Run(testCase.name, func(t *testing.T) {
266 t.Parallel()
267
268 server, capture := newPOSTServer(t, "/tasks", singleTaskResponseBody)
269 defer server.Close()
270
271 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
272
273 _, err := client.NewTask("Task").
274 Priority(testCase.priority).
275 Create(ctx())
276 if err != nil {
277 t.Fatalf("error = %v", err)
278 }
279
280 assertBodyFieldFloat(t, capture.Body, "priority", testCase.want)
281 })
282 }
283}
284
285// --- TaskUpdateBuilder Priority Method ---
286
287func TestTaskUpdateBuilder_Priority(t *testing.T) {
288 t.Parallel()
289
290 server, capture := newPUTServer(t, "/tasks/"+taskID, singleTaskResponseBody)
291 defer server.Close()
292
293 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
294
295 _, err := client.NewTaskUpdate(taskID).
296 Priority(lunatask.PriorityLowest).
297 Update(ctx())
298 if err != nil {
299 t.Fatalf("error = %v", err)
300 }
301
302 assertBodyFieldFloat(t, capture.Body, "priority", -2)
303}
304
305func TestTaskUpdateBuilder_Priority_AllValues(t *testing.T) {
306 t.Parallel()
307
308 tests := []struct {
309 name string
310 priority lunatask.Priority
311 want float64
312 }{
313 {"lowest", lunatask.PriorityLowest, -2},
314 {"low", lunatask.PriorityLow, -1},
315 {"normal", lunatask.PriorityNormal, 0},
316 {"high", lunatask.PriorityHigh, 1},
317 {"highest", lunatask.PriorityHighest, 2},
318 }
319
320 for _, testCase := range tests {
321 t.Run(testCase.name, func(t *testing.T) {
322 t.Parallel()
323
324 server, capture := newPUTServer(t, "/tasks/"+taskID, singleTaskResponseBody)
325 defer server.Close()
326
327 client := lunatask.NewClient(testToken, lunatask.BaseURL(server.URL))
328
329 _, err := client.NewTaskUpdate(taskID).
330 Priority(testCase.priority).
331 Update(ctx())
332 if err != nil {
333 t.Fatalf("error = %v", err)
334 }
335
336 assertBodyFieldFloat(t, capture.Body, "priority", testCase.want)
337 })
338 }
339}