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
import app/domain/role
2
import app/domain/user/sql as u_sql
3
import app/http_router
4
import app_dev/sql as dev_sql
5
import app_test
6
import dummy
···
51
52
let body = simulate.read_body(resp)
53
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
let user_role_decoder = {
65
use maybe_role <- decode.then(decode.string)
66
case role.from_string_pt_br(maybe_role) {
···
69
}
70
}
71
72
-
use user_uuid <- decode.field("id", uuid_decoder)
73
use full_name <- decode.field("full_name", decode.string)
74
use email <- decode.field("email", decode.string)
75
use user_role <- decode.field("user_role", user_role_decoder)
···
1
import app/domain/role
2
import app/domain/user/sql as u_sql
3
import app/http_router
4
+
import app/web
5
import app_dev/sql as dev_sql
6
import app_test
7
import dummy
···
52
53
let body = simulate.read_body(resp)
54
let body_decoder = {
55
let user_role_decoder = {
56
use maybe_role <- decode.then(decode.string)
57
case role.from_string_pt_br(maybe_role) {
···
60
}
61
}
62
63
+
use user_uuid <- decode.field("id", web.uuid_decoder("user_uuid"))
64
use full_name <- decode.field("full_name", decode.string)
65
use email <- decode.field("email", decode.string)
66
use user_role <- decode.field("user_role", user_role_decoder)
+7
-31
test/brigade_test.gleam
+7
-31
test/brigade_test.gleam
···
1
import app/domain/role
2
import app/http_router
3
import app_dev/sql as dev_sql
4
import app_test
5
import dummy
···
55
56
let assert Ok(_) =
57
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
let members_decoder = {
67
-
use members <- decode.then(decode.list(of: uuid_decoder))
68
decode.success(members)
69
}
70
71
-
use _ <- decode.field("id", uuid_decoder)
72
use _ <- decode.field("created_at", decode.float)
73
use members <- decode.field("members", members_decoder)
74
···
118
let body = simulate.read_body(resp)
119
let assert Ok(returned_members_list) =
120
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
let role_decoder = {
132
use maybe_role <- decode.then(decode.string)
133
case role.from_string_pt_br(maybe_role) {
···
136
}
137
}
138
139
-
// DECODER
140
decode.list({
141
-
use user_uuid <- decode.field("id", uuid_decoder)
142
use _ <- decode.field("full_name", decode.string)
143
use _ <- decode.field("user_role", role_decoder)
144
decode.success(user_uuid)
···
185
json.parse(
186
body,
187
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)
197
use _ <- decode.field("brigade_name", decode.string)
198
use _ <- decode.field("leader_name", decode.optional(decode.string))
199
use _ <- decode.field("is_active", decode.bool)
···
1
import app/domain/role
2
import app/http_router
3
+
import app/web
4
import app_dev/sql as dev_sql
5
import app_test
6
import dummy
···
56
57
let assert Ok(_) =
58
json.parse(body, {
59
let members_decoder = {
60
+
use members <- decode.then(
61
+
decode.list(of: web.uuid_decoder("member_uuid")),
62
+
)
63
decode.success(members)
64
}
65
66
+
use _ <- decode.field("id", web.uuid_decoder("uuid"))
67
use _ <- decode.field("created_at", decode.float)
68
use members <- decode.field("members", members_decoder)
69
···
113
let body = simulate.read_body(resp)
114
let assert Ok(returned_members_list) =
115
json.parse(body, {
116
let role_decoder = {
117
use maybe_role <- decode.then(decode.string)
118
case role.from_string_pt_br(maybe_role) {
···
121
}
122
}
123
124
decode.list({
125
+
use user_uuid <- decode.field("id", web.uuid_decoder("user_uuid"))
126
use _ <- decode.field("full_name", decode.string)
127
use _ <- decode.field("user_role", role_decoder)
128
decode.success(user_uuid)
···
169
json.parse(
170
body,
171
decode.list({
172
+
use brigade_uuid <- decode.field("id", web.uuid_decoder("brigade_uuid"))
173
use _ <- decode.field("brigade_name", decode.string)
174
use _ <- decode.field("leader_name", decode.optional(decode.string))
175
use _ <- decode.field("is_active", decode.bool)
+23
-53
test/occurrence_test.gleam
+23
-53
test/occurrence_test.gleam
···
3
import app/domain/occurrence/sql as o_sql
4
import app/domain/occurrence/subcategory
5
import app/http_router
6
import app_dev/sql as dev_sql
7
import app_test
8
import dummy
···
71
let body = simulate.read_body(resp)
72
let assert Ok(dummy_occurrence_id) =
73
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
let priority_decoder = {
85
use maybe_priority <- decode.then(decode.string)
86
case priority.from_string_pt_br(maybe_priority) {
···
89
}
90
}
91
92
-
use dummy_occurrence_id <- decode.field("id", uuid_decoder)
93
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))
96
use _ <- decode.field("created_at", decode.float)
97
98
decode.success(dummy_occurrence_id)
···
160
// JSON PARSING --------------------------------------------------------------
161
let assert Ok(_) =
162
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
let priority_decoder = {
172
use maybe_priority <- decode.then(decode.string)
173
case priority.from_string_pt_br(maybe_priority) {
···
194
}
195
196
let occurrence_metadata_decoder = {
197
-
use _ <- decode.field("usuarioId", uuid_decoder)
198
use _ <- decode.field("matriculaUsuario", decode.string)
199
use _ <- decode.field("nomeUsuario", decode.string)
200
decode.success(Nil)
201
}
202
203
let occurrence_brigade_decoder = {
204
-
use _ <- decode.field("id", uuid_decoder)
205
use _ <- decode.field("nomeEquipe", decode.string)
206
use _ <- decode.field("codigoViatura", decode.string)
207
use _ <- decode.field("lider", decode.string)
···
209
}
210
211
decode.list({
212
-
use id <- decode.field("id", uuid_decoder)
213
use _ <- decode.field("status", decode.string)
214
use _ <- decode.field("prioridade", priority_decoder)
215
use _ <- decode.field("chamado", call_decoder)
···
260
let body = simulate.read_body(resp)
261
let assert Ok(deleted_occurrence) =
262
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)
272
decode.success(id)
273
})
274
···
307
308
// Response decoder
309
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
let resolved_at_decoder = decode.optional(decode.float)
319
320
-
use occ_id <- decode.field("id", uuid_decoder)
321
use resolved_at <- decode.field("resolved_at", resolved_at_decoder)
322
use _ <- decode.field("updated_at", decode.float)
323
···
385
386
let assert Ok(_) =
387
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
let resolved_at_decoder = decode.optional(decode.float)
397
398
-
// PARSE
399
-
use occ_id <- decode.field("id", uuid_decoder)
400
use resolved_at <- decode.field("resolved_at", resolved_at_decoder)
401
use _ <- decode.field("updated_at", decode.float)
402
403
-
// ASSERT
404
assert option.is_none(resolved_at) as "Occurrence should be open"
405
assert occ_id == dummy_occurrence as "Update the correct occurrence"
406
decode.success(Nil)
···
3
import app/domain/occurrence/sql as o_sql
4
import app/domain/occurrence/subcategory
5
import app/http_router
6
+
import app/web
7
import app_dev/sql as dev_sql
8
import app_test
9
import dummy
···
72
let body = simulate.read_body(resp)
73
let assert Ok(dummy_occurrence_id) =
74
json.parse(body, {
75
let priority_decoder = {
76
use maybe_priority <- decode.then(decode.string)
77
case priority.from_string_pt_br(maybe_priority) {
···
80
}
81
}
82
83
use _ <- decode.field("priority", priority_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
+
100
use _ <- decode.field("created_at", decode.float)
101
102
decode.success(dummy_occurrence_id)
···
164
// JSON PARSING --------------------------------------------------------------
165
let assert Ok(_) =
166
json.parse(body, {
167
let priority_decoder = {
168
use maybe_priority <- decode.then(decode.string)
169
case priority.from_string_pt_br(maybe_priority) {
···
190
}
191
192
let occurrence_metadata_decoder = {
193
+
use _ <- decode.field("usuarioId", web.uuid_decoder("user_uuid"))
194
use _ <- decode.field("matriculaUsuario", decode.string)
195
use _ <- decode.field("nomeUsuario", decode.string)
196
decode.success(Nil)
197
}
198
199
let occurrence_brigade_decoder = {
200
+
use _ <- decode.field("id", web.uuid_decoder("brigade_uuid"))
201
use _ <- decode.field("nomeEquipe", decode.string)
202
use _ <- decode.field("codigoViatura", decode.string)
203
use _ <- decode.field("lider", decode.string)
···
205
}
206
207
decode.list({
208
+
use id <- decode.field("id", web.uuid_decoder("call_uuid?"))
209
use _ <- decode.field("status", decode.string)
210
use _ <- decode.field("prioridade", priority_decoder)
211
use _ <- decode.field("chamado", call_decoder)
···
256
let body = simulate.read_body(resp)
257
let assert Ok(deleted_occurrence) =
258
json.parse(body, {
259
+
use id <- decode.field("id", web.uuid_decoder("occurrence_uuid"))
260
decode.success(id)
261
})
262
···
295
296
// Response decoder
297
let resp_decoder = {
298
let resolved_at_decoder = decode.optional(decode.float)
299
300
+
use occ_id <- decode.field("id", web.uuid_decoder("occurrence_uuid"))
301
use resolved_at <- decode.field("resolved_at", resolved_at_decoder)
302
use _ <- decode.field("updated_at", decode.float)
303
···
365
366
let assert Ok(_) =
367
json.parse(body, {
368
let resolved_at_decoder = decode.optional(decode.float)
369
370
+
use occ_id <- decode.field("id", web.uuid_decoder("occurrence_uuid"))
371
use resolved_at <- decode.field("resolved_at", resolved_at_decoder)
372
use _ <- decode.field("updated_at", decode.float)
373
374
assert option.is_none(resolved_at) as "Occurrence should be open"
375
assert occ_id == dummy_occurrence as "Update the correct occurrence"
376
decode.success(Nil)