wip: currently rewriting the project as a full stack application
tangled.org/kacaii.dev/sigo
gleam
:recycle: asserting the happy path
+67
-94
+67
-94
dev/dummy.gleam
+67
-94
dev/dummy.gleam
···
7
7
import app/routes/occurrence/subcategory
8
8
import app/routes/role
9
9
import app/routes/user/sql as u_sql
10
-
import gleam/dict
11
10
import gleam/float
12
-
import gleam/int
13
11
import gleam/list
14
12
import gleam/set
15
13
import pog
···
18
16
19
17
/// Panics on failure
20
18
pub fn random_role() -> role.Role {
21
-
let samples =
22
-
dict.from_list([
23
-
#(0, role.Firefighter),
24
-
#(1, role.Admin),
25
-
#(2, role.Analyst),
26
-
#(3, role.Captain),
27
-
#(4, role.Developer),
28
-
#(5, role.Sargeant),
29
-
])
19
+
let samples = [
20
+
role.Firefighter,
21
+
role.Admin,
22
+
role.Analyst,
23
+
role.Captain,
24
+
role.Developer,
25
+
role.Sargeant,
26
+
]
30
27
31
-
let assert Ok(chosen) =
32
-
dict.get(samples, {
33
-
dict.to_list(samples)
34
-
|> list.length()
35
-
|> int.random()
36
-
})
37
-
as "Failed to pick a random user role"
28
+
let assert Ok(chosen) = list.first(list.sample(samples, 1))
29
+
as "Picked a random user role"
38
30
39
31
chosen
40
32
}
41
33
42
34
/// Panics on failure
43
-
pub fn random_priority() {
44
-
let samples =
45
-
dict.from_list([
46
-
#(0, priority.Low),
47
-
#(1, priority.Medium),
48
-
#(2, priority.High),
49
-
])
35
+
pub fn random_priority() -> priority.Priority {
36
+
let samples = [
37
+
priority.Low,
38
+
priority.Medium,
39
+
priority.High,
40
+
]
50
41
51
-
let assert Ok(chosen) =
52
-
dict.get(samples, {
53
-
dict.to_list(samples)
54
-
|> list.length()
55
-
|> int.random()
56
-
})
57
-
as "Failed to pick a random occurrence priority"
42
+
let assert Ok(chosen) = list.first(list.sample(samples, 1))
43
+
as "Picked a random occurrence priority"
58
44
59
45
chosen
60
46
}
···
64
50
conn conn: pog.Connection,
65
51
leader_id leader_id: uuid.Uuid,
66
52
members dummy_members: List(uuid.Uuid),
67
-
) {
53
+
) -> uuid.Uuid {
68
54
let assert Ok(returned) =
69
55
b_sql.insert_new_brigade(
70
56
conn,
···
73
59
"VEHICLE " <> wisp.random_string(3),
74
60
True,
75
61
)
76
-
as "Failed to create dummy brigade"
62
+
as "Dummy brigade is generated"
77
63
78
64
let assert Ok(inserted_brigade_row) = list.first(returned.rows)
79
-
as "Database returned no results after creating new Brigade"
65
+
as "Database returned results after creating new Brigade"
80
66
81
67
let assert Ok(assigments) =
82
68
b_sql.assign_brigade_members(conn, inserted_brigade_row.id, dummy_members)
83
-
as "Failed to assign dummy members to a brigade"
69
+
as "Dummy members were assigned"
84
70
85
71
let assigned_members =
86
72
list.map(assigments.rows, fn(row) { row.inserted_user_id })
···
91
77
assert set.difference(assigned_members_set, dummy_members_set)
92
78
|> set.to_list
93
79
== []
94
-
as "Returned members contain unexpected users"
80
+
as "Returned members expected users"
95
81
96
82
assert set.difference(dummy_members_set, assigned_members_set)
97
83
|> set.to_list
98
84
== []
99
-
as "Some brigade members were not returned"
85
+
as "All brigade members were returned"
100
86
101
87
inserted_brigade_row.id
102
88
}
103
89
104
90
/// Panic on failure
105
-
pub fn clean_brigade(conn: pog.Connection, dummy: uuid.Uuid) {
91
+
pub fn clean_brigade(conn: pog.Connection, dummy: uuid.Uuid) -> Nil {
106
92
let cleanup_brigade_id = {
107
93
let assert Ok(returned) = b_sql.delete_brigade_by_id(conn, dummy)
108
94
as "Failed to delete dummy brigade"
···
117
103
}
118
104
119
105
/// Panics on failure
120
-
pub fn random_category() {
121
-
let samples =
122
-
dict.from_list([
123
-
#(0, category.Other),
124
-
#(1, category.Fire),
125
-
#(2, category.MedicEmergency),
126
-
#(3, category.TrafficAccident),
127
-
])
106
+
pub fn random_category() -> category.Category {
107
+
let samples = [
108
+
category.Other,
109
+
category.Fire,
110
+
category.MedicEmergency,
111
+
category.TrafficAccident,
112
+
]
128
113
129
-
let assert Ok(chosen) =
130
-
dict.get(samples, {
131
-
dict.to_list(samples)
132
-
|> list.length()
133
-
|> int.random()
134
-
})
114
+
let assert Ok(chosen) = list.first(list.sample(samples, 1))
135
115
as "Failed to pick a random user occurrence category"
136
116
137
117
chosen
138
118
}
139
119
140
120
/// Panics on failure
141
-
pub fn random_subcategory() {
142
-
let samples =
143
-
dict.from_list([
144
-
#(0, subcategory.InjuredAnimal),
145
-
#(1, subcategory.Flood),
146
-
#(2, subcategory.TreeCrash),
147
-
#(3, subcategory.MotorcycleCrash),
148
-
#(4, subcategory.Rollover),
149
-
#(5, subcategory.RunOver),
150
-
#(6, subcategory.Collision),
151
-
#(7, subcategory.Vehicle),
152
-
#(8, subcategory.Vegetation),
153
-
#(9, subcategory.Comercial),
154
-
#(10, subcategory.Residential),
155
-
#(11, subcategory.Intoxication),
156
-
#(12, subcategory.SeriousInjury),
157
-
#(13, subcategory.Seizure),
158
-
#(14, subcategory.PreHospitalCare),
159
-
#(15, subcategory.HeartStop),
160
-
])
121
+
pub fn random_subcategory() -> subcategory.Subcategory {
122
+
let samples = [
123
+
subcategory.InjuredAnimal,
124
+
subcategory.Flood,
125
+
subcategory.TreeCrash,
126
+
subcategory.MotorcycleCrash,
127
+
subcategory.Rollover,
128
+
subcategory.RunOver,
129
+
subcategory.Collision,
130
+
subcategory.Vehicle,
131
+
subcategory.Vegetation,
132
+
subcategory.Comercial,
133
+
subcategory.Residential,
134
+
subcategory.Intoxication,
135
+
subcategory.SeriousInjury,
136
+
subcategory.Seizure,
137
+
subcategory.PreHospitalCare,
138
+
subcategory.HeartStop,
139
+
]
161
140
162
-
let assert Ok(chosen) =
163
-
dict.get(samples, {
164
-
dict.to_list(samples)
165
-
|> list.length()
166
-
|> int.random()
167
-
})
141
+
let assert Ok(chosen) = list.first(list.sample(samples, 1))
168
142
as "Failed to pick a random occurrence subcategory"
169
143
170
144
chosen
···
201
175
}
202
176
203
177
/// Panic on failure
204
-
pub fn clean_user(conn: pog.Connection, dummy: uuid.Uuid) {
205
-
let assert Ok(cleanup_applicant) = {
206
-
let assert Ok(returned) = u_sql.delete_user_by_id(conn, dummy)
207
-
as "Failed to cleanup dummy user"
178
+
pub fn clean_user(conn: pog.Connection, dummy: uuid.Uuid) -> Nil {
179
+
let assert Ok(returned) = u_sql.delete_user_by_id(conn, dummy)
180
+
as "Database has been accessed"
208
181
209
-
list.first(returned.rows)
210
-
}
182
+
let assert Ok(row) = list.first(returned.rows)
183
+
as "Database returned row after deletion"
211
184
212
-
assert cleanup_applicant.id == dummy as "Deleted the wrong User"
185
+
assert row.id == dummy as "Deleted the correct user"
213
186
}
214
187
215
188
/// Panic on failure
···
276
249
[float.random() *. 100.0, float.random() *. 100.0],
277
250
"Next to: " <> wisp.random_string(12),
278
251
)
279
-
as "Failed to generate a dummy Occurrence"
252
+
as "Database has been accessed"
280
253
281
254
let assert Ok(created_occurrence_row) = list.first(returned.rows)
282
-
as "Database returned no results"
255
+
as "Database returned results after registering occurrence"
283
256
284
257
let assert Ok(assigned_brigades_row) =
285
258
o_sql.assign_brigades_to_occurrence(
···
287
260
created_occurrence_row.id,
288
261
dummy_brigade_list,
289
262
)
263
+
as "Brigades were assigned to occurrence"
290
264
291
265
let dummy_brigades_set = set.from_list(dummy_brigade_list)
292
266
let assigned_brigades_set =
···
311
285
312
286
/// Panic on failure
313
287
pub fn clean_occurrence(conn: pog.Connection, dummy: uuid.Uuid) {
314
-
let assert Ok(cleanup_occurrence) = {
315
-
let assert Ok(returned) = o_sql.delete_occurrence_by_id(conn, dummy)
316
-
as "Failed to cleanup dummy occurrence"
317
-
list.first(returned.rows)
318
-
}
288
+
let assert Ok(returned) = o_sql.delete_occurrence_by_id(conn, dummy)
289
+
as "DataBase has been accessed"
290
+
let assert Ok(row) = list.first(returned.rows)
291
+
as "DataBase returned row after deleting"
319
292
320
-
assert cleanup_occurrence.id == dummy as "Deleted the wrong Occurrence"
293
+
assert row.id == dummy as "Deleted the wrong Occurrence"
321
294
}