kacaii.dev
wip: currently rewriting the project as a full stack application
tangled.org/kacaii.dev/sigo
gleam
1import app/domain/role
2import app/http_router
3import app/web
4import app_dev/sql as dev_sql
5import app_test
6import dummy
7import gleam/dynamic/decode
8import gleam/http
9import gleam/json
10import gleam/list
11import gleam/set
12import wisp
13import wisp/simulate
14import youid/uuid
15
16pub fn register_new_brigade_test() {
17 let path = "/admin/brigade/new"
18 use ctx <- app_test.global_data()
19 use _ <- list.each(list.range(1, app_test.n_tests))
20
21 // DUMMY ------------------------------------------------------------------
22 let dummy_leader = dummy.random_user(ctx.db)
23 let dummy_members =
24 list.map(list.range(1, 10), fn(_) { dummy.random_user(ctx.db) })
25
26 // START ---------------------------------------------------------------------
27
28 let dummy_members_json =
29 json.array(dummy_members, fn(member) { json.string(uuid.to_string(member)) })
30
31 let req =
32 simulate.browser_request(http.Post, path)
33 |> simulate.json_body(
34 json.object([
35 #("liderId", json.string(uuid.to_string(dummy_leader))),
36 #("nome", json.string(wisp.random_string(6))),
37 #("codigoViatura", json.string(wisp.random_string(6))),
38 #("ativo", json.bool(True)),
39 #("membros", dummy_members_json),
40 ]),
41 )
42
43 // REGULAR REQUEST
44 let resp = http_router.handle_request(req, ctx)
45 assert resp.status == 401 as "Endpoint restricted to Admin users"
46
47 // AS ADMIN
48 let with_auth = app_test.with_authorization(req)
49
50 // AUTHORIZED REQUEST
51 let resp = http_router.handle_request(with_auth, ctx)
52 assert resp.status == 201 as "Response sould be HTTP 201 CREATED"
53
54 // READ BODY -----------------------------------------------------------------
55 let body = simulate.read_body(resp)
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
70 let members_set = set.from_list(members)
71 let dummy_members_set = set.from_list(dummy_members)
72
73 // ASSERTIONS ------------------------------------------------------------
74 assert set.difference(members_set, dummy_members_set) |> set.to_list()
75 == []
76 as "Returned members contain unexpected users"
77 assert set.difference(dummy_members_set, members_set) |> set.to_list()
78 == []
79 as "Some brigade members were not returned"
80
81 decode.success(Nil)
82 })
83 as "Response should contain valid JSON"
84
85 // CLEANUP ----------------------------------------------------------------
86 let assert Ok(_) = dev_sql.soft_truncate_user_account(ctx.db)
87 let assert Ok(_) = dev_sql.truncate_brigade(ctx.db)
88}
89
90pub fn get_brigade_members_test() {
91 use ctx <- app_test.global_data()
92 use _ <- list.each(list.range(1, app_test.n_tests))
93
94 // DUMMY LEADER -----------------------------------------------------------
95 let leader_id = dummy.random_user(ctx.db)
96
97 // DUMMY MEMBERS ----------------------------------------------------------
98 let dummy_members =
99 list.map(list.range(1, 10), fn(_) { dummy.random_user(ctx.db) })
100
101 // DUMMY BRIGADE ----------------------------------------------------
102 let dummy_brigade =
103 dummy.random_brigade(conn: ctx.db, leader_id:, members: dummy_members)
104
105 // START ---------------------------------------------------------------------
106
107 let path = "/brigade/" <> uuid.to_string(dummy_brigade) <> "/members"
108 let req = simulate.browser_request(http.Get, path)
109
110 let resp = http_router.handle_request(req, ctx)
111 assert resp.status == 200 as "Response should be HTTP 200 OK"
112
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) {
119 Error(_) -> decode.failure(role.Firefighter, "user_role")
120 Ok(value) -> decode.success(value)
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)
129 })
130 })
131
132 let returned_members_set = set.from_list(returned_members_list)
133 let dummy_members_set = set.from_list(dummy_members)
134
135 assert set.difference(returned_members_set, dummy_members_set)
136 |> set.to_list()
137 == []
138 as "Returned list should be the same as the members list"
139
140 // CLEANUP ----------------------------------------------------------------
141 let assert Ok(_) = dev_sql.truncate_brigade(ctx.db)
142 let assert Ok(_) = dev_sql.soft_truncate_user_account(ctx.db)
143}
144
145pub fn get_all_brigades_test() {
146 use ctx <- app_test.global_data()
147 use _ <- list.each(list.range(1, app_test.n_tests))
148 let path = "/admin/brigade"
149
150 // DUMMY LEADER -----------------------------------------------------------
151 let leader_id = dummy.random_user(ctx.db)
152
153 // DUMMY MEMBERS ----------------------------------------------------------
154 let dummy_members =
155 list.map(list.range(1, 10), fn(_) { dummy.random_user(ctx.db) })
156
157 // DUMMY BRIGADE ----------------------------------------------------
158 let dummy_brigade =
159 dummy.random_brigade(conn: ctx.db, leader_id:, members: dummy_members)
160
161 // START ---------------------------------------------------------------------
162 let req = simulate.browser_request(http.Get, path)
163 let resp = http_router.handle_request(req, ctx)
164
165 assert resp.status == 200 as "Enpoint should be accessible"
166
167 let body = simulate.read_body(resp)
168 let assert Ok(returned_list) =
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)
176 decode.success(brigade_uuid)
177 }),
178 )
179 as "Response should contain valid JSON"
180
181 assert list.contains(returned_list, dummy_brigade)
182 as "Response should contain the dummy brigade"
183
184 // CLEANUP ---------------------------------------------------------------
185 let assert Ok(_) = dev_sql.truncate_brigade(ctx.db)
186 let assert Ok(_) = dev_sql.soft_truncate_user_account(ctx.db)
187}