kacaii.dev
wip: currently rewriting the project as a full stack application
tangled.org/kacaii.dev/sigo
gleam
:recycle: add uuid_decoder to `web`
+2
-11
test/admin_test.gleam
+2
-11
test/admin_test.gleam
···
1
1
import app/domain/role
2
2
import app/domain/user/sql as u_sql
3
3
import app/http_router
4
+
import app/web
4
5
import app_dev/sql as dev_sql
5
6
import app_test
6
7
import dummy
···
51
52
52
53
let body = simulate.read_body(resp)
53
54
let body_decoder = {
54
-
// USER Uuid Decoder
55
-
let uuid_decoder = {
56
-
use maybe_uuid <- decode.then(decode.string)
57
-
case uuid.from_string(maybe_uuid) {
58
-
Error(_) -> decode.failure(uuid.v7(), "uuid")
59
-
Ok(value) -> decode.success(value)
60
-
}
61
-
}
62
-
63
-
// User role decoder
64
55
let user_role_decoder = {
65
56
use maybe_role <- decode.then(decode.string)
66
57
case role.from_string_pt_br(maybe_role) {
···
69
60
}
70
61
}
71
62
72
-
use user_uuid <- decode.field("id", uuid_decoder)
63
+
use user_uuid <- decode.field("id", web.uuid_decoder("user_uuid"))
73
64
use full_name <- decode.field("full_name", decode.string)
74
65
use email <- decode.field("email", decode.string)
75
66
use user_role <- decode.field("user_role", user_role_decoder)
+7
-31
test/brigade_test.gleam
+7
-31
test/brigade_test.gleam
···
1
1
import app/domain/role
2
2
import app/http_router
3
+
import app/web
3
4
import app_dev/sql as dev_sql
4
5
import app_test
5
6
import dummy
···
55
56
56
57
let assert Ok(_) =
57
58
json.parse(body, {
58
-
let uuid_decoder = {
59
-
use maybe_uuid <- decode.then(decode.string)
60
-
case uuid.from_string(maybe_uuid) {
61
-
Error(_) -> decode.failure(uuid.v7(), "uuid")
62
-
Ok(value) -> decode.success(value)
63
-
}
64
-
}
65
-
66
59
let members_decoder = {
67
-
use members <- decode.then(decode.list(of: uuid_decoder))
60
+
use members <- decode.then(
61
+
decode.list(of: web.uuid_decoder("member_uuid")),
62
+
)
68
63
decode.success(members)
69
64
}
70
65
71
-
use _ <- decode.field("id", uuid_decoder)
66
+
use _ <- decode.field("id", web.uuid_decoder("uuid"))
72
67
use _ <- decode.field("created_at", decode.float)
73
68
use members <- decode.field("members", members_decoder)
74
69
···
118
113
let body = simulate.read_body(resp)
119
114
let assert Ok(returned_members_list) =
120
115
json.parse(body, {
121
-
// UUID DECODER
122
-
let uuid_decoder = {
123
-
use maybe_id <- decode.then(decode.string)
124
-
case uuid.from_string(maybe_id) {
125
-
Error(_) -> decode.failure(uuid.v7(), "user_uuid")
126
-
Ok(value) -> decode.success(value)
127
-
}
128
-
}
129
-
130
-
// ROLE DECODER
131
116
let role_decoder = {
132
117
use maybe_role <- decode.then(decode.string)
133
118
case role.from_string_pt_br(maybe_role) {
···
136
121
}
137
122
}
138
123
139
-
// DECODER
140
124
decode.list({
141
-
use user_uuid <- decode.field("id", uuid_decoder)
125
+
use user_uuid <- decode.field("id", web.uuid_decoder("user_uuid"))
142
126
use _ <- decode.field("full_name", decode.string)
143
127
use _ <- decode.field("user_role", role_decoder)
144
128
decode.success(user_uuid)
···
185
169
json.parse(
186
170
body,
187
171
decode.list({
188
-
let uuid_decoder = {
189
-
use maybe_uuid <- decode.then(decode.string)
190
-
case uuid.from_string(maybe_uuid) {
191
-
Error(_) -> decode.failure(uuid.v7(), "brigade_uuid")
192
-
Ok(value) -> decode.success(value)
193
-
}
194
-
}
195
-
196
-
use brigade_uuid <- decode.field("id", uuid_decoder)
172
+
use brigade_uuid <- decode.field("id", web.uuid_decoder("brigade_uuid"))
197
173
use _ <- decode.field("brigade_name", decode.string)
198
174
use _ <- decode.field("leader_name", decode.optional(decode.string))
199
175
use _ <- decode.field("is_active", decode.bool)
+23
-53
test/occurrence_test.gleam
+23
-53
test/occurrence_test.gleam
···
3
3
import app/domain/occurrence/sql as o_sql
4
4
import app/domain/occurrence/subcategory
5
5
import app/http_router
6
+
import app/web
6
7
import app_dev/sql as dev_sql
7
8
import app_test
8
9
import dummy
···
71
72
let body = simulate.read_body(resp)
72
73
let assert Ok(dummy_occurrence_id) =
73
74
json.parse(body, {
74
-
// Decoder for UUIDs
75
-
let uuid_decoder = {
76
-
use maybe_uuid <- decode.then(decode.string)
77
-
case uuid.from_string(maybe_uuid) {
78
-
Error(_) -> decode.failure(uuid.v7(), "id")
79
-
Ok(value) -> decode.success(value)
80
-
}
81
-
}
82
-
83
-
// Decoder for Priority
84
75
let priority_decoder = {
85
76
use maybe_priority <- decode.then(decode.string)
86
77
case priority.from_string_pt_br(maybe_priority) {
···
89
80
}
90
81
}
91
82
92
-
use dummy_occurrence_id <- decode.field("id", uuid_decoder)
93
83
use _ <- decode.field("priority", priority_decoder)
94
-
use _ <- decode.field("applicant_id", decode.optional(uuid_decoder))
95
-
use _ <- decode.field("assigned_brigades", decode.list(uuid_decoder))
84
+
85
+
use dummy_occurrence_id <- decode.field(
86
+
"id",
87
+
web.uuid_decoder("occurrence_uuid"),
88
+
)
89
+
90
+
use _ <- decode.field(
91
+
"applicant_id",
92
+
decode.optional(web.uuid_decoder("applicant_uuid")),
93
+
)
94
+
95
+
use _ <- decode.field(
96
+
"assigned_brigades",
97
+
decode.list(web.uuid_decoder("brigade_uuid")),
98
+
)
99
+
96
100
use _ <- decode.field("created_at", decode.float)
97
101
98
102
decode.success(dummy_occurrence_id)
···
160
164
// JSON PARSING --------------------------------------------------------------
161
165
let assert Ok(_) =
162
166
json.parse(body, {
163
-
let uuid_decoder = {
164
-
use maybe_uuid <- decode.then(decode.string)
165
-
case uuid.from_string(maybe_uuid) {
166
-
Error(_) -> decode.failure(uuid.v7(), "id")
167
-
Ok(value) -> decode.success(value)
168
-
}
169
-
}
170
-
171
167
let priority_decoder = {
172
168
use maybe_priority <- decode.then(decode.string)
173
169
case priority.from_string_pt_br(maybe_priority) {
···
194
190
}
195
191
196
192
let occurrence_metadata_decoder = {
197
-
use _ <- decode.field("usuarioId", uuid_decoder)
193
+
use _ <- decode.field("usuarioId", web.uuid_decoder("user_uuid"))
198
194
use _ <- decode.field("matriculaUsuario", decode.string)
199
195
use _ <- decode.field("nomeUsuario", decode.string)
200
196
decode.success(Nil)
201
197
}
202
198
203
199
let occurrence_brigade_decoder = {
204
-
use _ <- decode.field("id", uuid_decoder)
200
+
use _ <- decode.field("id", web.uuid_decoder("brigade_uuid"))
205
201
use _ <- decode.field("nomeEquipe", decode.string)
206
202
use _ <- decode.field("codigoViatura", decode.string)
207
203
use _ <- decode.field("lider", decode.string)
···
209
205
}
210
206
211
207
decode.list({
212
-
use id <- decode.field("id", uuid_decoder)
208
+
use id <- decode.field("id", web.uuid_decoder("call_uuid?"))
213
209
use _ <- decode.field("status", decode.string)
214
210
use _ <- decode.field("prioridade", priority_decoder)
215
211
use _ <- decode.field("chamado", call_decoder)
···
260
256
let body = simulate.read_body(resp)
261
257
let assert Ok(deleted_occurrence) =
262
258
json.parse(body, {
263
-
let uuid_decoder = {
264
-
use maybe_uuid <- decode.then(decode.string)
265
-
case uuid.from_string(maybe_uuid) {
266
-
Error(_) -> decode.failure(uuid.v7(), "occurrence_uuid")
267
-
Ok(value) -> decode.success(value)
268
-
}
269
-
}
270
-
271
-
use id <- decode.field("id", uuid_decoder)
259
+
use id <- decode.field("id", web.uuid_decoder("occurrence_uuid"))
272
260
decode.success(id)
273
261
})
274
262
···
307
295
308
296
// Response decoder
309
297
let resp_decoder = {
310
-
let uuid_decoder = {
311
-
use maybe_uuid <- decode.then(decode.string)
312
-
case uuid.from_string(maybe_uuid) {
313
-
Error(_) -> decode.failure(uuid.v7(), "occurrence_uuid")
314
-
Ok(value) -> decode.success(value)
315
-
}
316
-
}
317
-
318
298
let resolved_at_decoder = decode.optional(decode.float)
319
299
320
-
use occ_id <- decode.field("id", uuid_decoder)
300
+
use occ_id <- decode.field("id", web.uuid_decoder("occurrence_uuid"))
321
301
use resolved_at <- decode.field("resolved_at", resolved_at_decoder)
322
302
use _ <- decode.field("updated_at", decode.float)
323
303
···
385
365
386
366
let assert Ok(_) =
387
367
json.parse(body, {
388
-
let uuid_decoder = {
389
-
use maybe_uuid <- decode.then(decode.string)
390
-
case uuid.from_string(maybe_uuid) {
391
-
Error(_) -> decode.failure(uuid.v7(), "occurrence_uuid")
392
-
Ok(value) -> decode.success(value)
393
-
}
394
-
}
395
-
396
368
let resolved_at_decoder = decode.optional(decode.float)
397
369
398
-
// PARSE
399
-
use occ_id <- decode.field("id", uuid_decoder)
370
+
use occ_id <- decode.field("id", web.uuid_decoder("occurrence_uuid"))
400
371
use resolved_at <- decode.field("resolved_at", resolved_at_decoder)
401
372
use _ <- decode.field("updated_at", decode.float)
402
373
403
-
// ASSERT
404
374
assert option.is_none(resolved_at) as "Occurrence should be open"
405
375
assert occ_id == dummy_occurrence as "Update the correct occurrence"
406
376
decode.success(Nil)