1use std::sync::Arc;
2
3use kcode_k1_access::{
4 AccessContext, AccessId, AccessPolicy, Authority, FilteredAuthorities, K1Access, ModelId,
5 ProfileId, SubsystemId, Target, TxId, UserId, ViewerSubject,
6};
7use kcode_k1_groups::{ALL_MODELS, ALL_USERS, GroupId, GroupName, GroupRole, K1Groups};
8use kcode_k1_peering::K1Peering;
9use kcode_k1_txn_ordering::K1TxnOrdering;
10
11struct Stack {
12 _ordering: Arc<K1TxnOrdering>,
13 _peering: Arc<K1Peering>,
14 groups: Arc<K1Groups>,
15 access: Arc<K1Access>,
16}
17
18impl Stack {
19 fn open(root: &std::path::Path) -> Result<Self, String> {
20 let ordering = Arc::new(at(
21 "open ordering",
22 K1TxnOrdering::open(&root.join("ordering")),
23 )?);
24 let peering = Arc::new(at(
25 "open peering",
26 K1Peering::open(&root.join("peering"), ordering.clone()),
27 )?);
28 let groups = Arc::new(at(
29 "open groups",
30 K1Groups::open(&root.join("groups"), ordering.clone(), peering.clone()),
31 )?);
32 let access = Arc::new(at(
33 "open access",
34 K1Access::open(
35 &root.join("access"),
36 ordering.clone(),
37 peering.clone(),
38 groups.clone(),
39 ),
40 )?);
41 Ok(Self {
42 _ordering: ordering,
43 _peering: peering,
44 groups,
45 access,
46 })
47 }
48
49 fn group(&self, owner: UserId, label: &str) -> Result<GroupId, String> {
50 let name = GroupName::new(label.to_owned())?;
51 Ok(at(label, self.groups.create(owner, name))?.group_id())
52 }
53
54 fn role(
55 &self,
56 owner: UserId,
57 group: GroupId,
58 member: UserId,
59 value: Option<GroupRole>,
60 ) -> Result<(), String> {
61 at(
62 "set user role",
63 self.groups.set_user_role(owner, group, member, value),
64 )?;
65 Ok(())
66 }
67
68 fn model_member(
69 &self,
70 owner: UserId,
71 group: GroupId,
72 model: ModelId,
73 present: bool,
74 ) -> Result<(), String> {
75 at(
76 "set model membership",
77 self.groups
78 .set_model_membership(owner, group, model, present),
79 )?;
80 Ok(())
81 }
82}
83
84fn at<T>(label: &str, result: Result<T, String>) -> Result<T, String> {
85 result.map_err(|error| format!("{label}: {error}"))
86}
87
88fn require(condition: bool, label: &str) -> Result<(), String> {
89 condition.then_some(()).ok_or_else(|| label.to_owned())
90}
91
92fn require_error<T>(result: Result<T, String>, expected: &str, label: &str) -> Result<(), String> {
93 match result {
94 Err(error) if error == expected => Ok(()),
95 _ => Err(label.to_owned()),
96 }
97}
98
99fn user(byte: u8) -> UserId {
100 UserId::from_tx_id(TxId::from_bytes([byte; 12]))
101}
102
103fn profile(byte: u8) -> ProfileId {
104 ProfileId::new(TxId::from_bytes([byte; 12]))
105}
106
107fn model(byte: u8) -> ModelId {
108 ModelId::from_bytes([byte; 32])
109}
110
111fn context(user: UserId, model: ModelId) -> Result<AccessContext, String> {
112 AccessContext::new(user, model, FilteredAuthorities::empty())
113}
114
115fn exact(user: UserId, model: ModelId, group: GroupId) -> Result<AccessContext, String> {
116 AccessContext::new(
117 user,
118 model,
119 FilteredAuthorities::new(vec![Authority::Group(group)])?,
120 )
121}
122
123fn editors(user: UserId, group: GroupId) -> Vec<Authority> {
124 vec![Authority::User(user), Authority::Group(group)]
125}
126
127fn viewers(
128 user: UserId,
129 outsider: UserId,
130 user_group: GroupId,
131 model_group: GroupId,
132 model: ModelId,
133) -> Vec<ViewerSubject> {
134 vec![
135 ViewerSubject::User(user),
136 ViewerSubject::User(outsider),
137 ViewerSubject::Group(user_group),
138 ViewerSubject::Group(model_group),
139 ViewerSubject::Model(model),
140 ]
141}
142
143struct Scenario<'a> {
144 stack: &'a Stack,
145 access: AccessId,
146 subsystem: SubsystemId,
147}
148
149impl Scenario<'_> {
150 fn rights(
151 &self,
152 user: UserId,
153 model: ModelId,
154 view: bool,
155 edit: bool,
156 label: &str,
157 ) -> Result<(), String> {
158 let result = at(
159 label,
160 self.stack
161 .access
162 .check(&context(user, model)?, self.access, self.subsystem),
163 )?;
164 require(
165 result.can_view() == view
166 && result.can_edit() == edit
167 && result.target().is_some() == view,
168 label,
169 )
170 }
171
172 fn group_list(
173 &self,
174 user: UserId,
175 model: ModelId,
176 group: GroupId,
177 expected: &[AccessId],
178 label: &str,
179 ) -> Result<(), String> {
180 let actual = at(
181 label,
182 self.stack
183 .access
184 .list_group(&context(user, model)?, group, self.subsystem),
185 )?;
186 require(actual == expected, label)
187 }
188
189 fn user_list(
190 &self,
191 user: UserId,
192 model: ModelId,
193 expected: &[AccessId],
194 label: &str,
195 ) -> Result<(), String> {
196 let actual = at(
197 label,
198 self.stack
199 .access
200 .list_user(&context(user, model)?, self.subsystem),
201 )?;
202 require(actual == expected, label)
203 }
204
205 fn concealed(&self, context: &AccessContext, label: &str) -> Result<(), String> {
206 let result = at(
207 label,
208 self.stack
209 .access
210 .check(context, self.access, self.subsystem),
211 )?;
212 require(
213 !result.can_view()
214 && !result.can_edit()
215 && result.target().is_none()
216 && result.access_revision().is_none()
217 && result.groups_revision().is_none(),
218 label,
219 )
220 }
221}
222
223pub fn verify() -> Result<(), String> {
224 let root = tempfile::tempdir().map_err(|error| format!("create root: {error}"))?;
225 let stack = Stack::open(root.path())?;
226 let owner = user(1);
227 let member = user(2);
228 let admin = user(3);
229 let group_editor = user(4);
230 let viewer = user(5);
231 let outsider = user(6);
232 let late = user(7);
233 let model_only = user(8);
234 let direct_editor = user(9);
235 let authority_model = model(11);
236 let editor_model = model(12);
237 let viewer_model = model(13);
238 let direct_model = model(14);
239 let no_view_model = model(15);
240 let subsystem = SubsystemId::from_str("audio-fragment")?;
241
242 let authority_group = stack.group(owner, "authority group")?;
243 let editor_group = stack.group(owner, "editor group")?;
244 let user_viewer_group = stack.group(owner, "user viewer group")?;
245 let model_viewer_group = stack.group(owner, "model viewer group")?;
246 let replacement_group = stack.group(owner, "replacement viewer group")?;
247 for (group, member, value) in [
248 (authority_group, member, GroupRole::User),
249 (authority_group, admin, GroupRole::Admin),
250 (editor_group, group_editor, GroupRole::User),
251 (user_viewer_group, viewer, GroupRole::User),
252 (replacement_group, late, GroupRole::User),
253 ] {
254 stack.role(owner, group, member, Some(value))?;
255 }
256 for (group, member) in [
257 (authority_group, authority_model),
258 (editor_group, editor_model),
259 (model_viewer_group, viewer_model),
260 ] {
261 stack.model_member(owner, group, member, true)?;
262 }
263
264 let group_profile = profile(21);
265 let group_access = at(
266 "create group access",
267 stack.access.create(
268 &context(owner, authority_model)?,
269 Target::new(subsystem, vec![0, 255, 7, 0]),
270 group_profile,
271 AccessPolicy::new(
272 Authority::Group(authority_group),
273 editors(direct_editor, editor_group),
274 viewers(
275 member,
276 outsider,
277 user_viewer_group,
278 model_viewer_group,
279 direct_model,
280 ),
281 )?,
282 ),
283 )?
284 .access_id();
285 require(
286 at("group profile link", stack.access.profile_id(group_access))? == Some(group_profile),
287 "group profile link was incorrect",
288 )?;
289 let personal_profile = profile(22);
290 let personal_access = at(
291 "create personal access",
292 stack.access.create(
293 &context(member, direct_model)?,
294 Target::new(subsystem, vec![2, 0, 2, 0]),
295 personal_profile,
296 AccessPolicy::new(
297 Authority::User(member),
298 Vec::new(),
299 vec![
300 ViewerSubject::Group(ALL_USERS),
301 ViewerSubject::Group(ALL_MODELS),
302 ],
303 )?,
304 ),
305 )?
306 .access_id();
307 require(
308 at(
309 "personal profile link",
310 stack.access.profile_id(personal_access),
311 )? == Some(personal_profile),
312 "personal profile link was incorrect",
313 )?;
314 let scenario = Scenario {
315 stack: &stack,
316 access: group_access,
317 subsystem,
318 };
319
320 for (user, model, view, edit, label) in [
321 (owner, no_view_model, false, true, "authority owner edit"),
322 (member, no_view_model, false, true, "authority user edit"),
323 (admin, no_view_model, false, true, "authority admin edit"),
324 (
325 outsider,
326 authority_model,
327 true,
328 false,
329 "authority model view",
330 ),
331 (
332 group_editor,
333 no_view_model,
334 false,
335 true,
336 "editor human edit",
337 ),
338 (outsider, editor_model, true, false, "editor model view"),
339 (
340 group_editor,
341 editor_model,
342 true,
343 true,
344 "editor combined rights",
345 ),
346 (viewer, viewer_model, true, false, "split viewer groups"),
347 (viewer, direct_model, true, false, "direct model viewer"),
348 (viewer, no_view_model, false, false, "user-only viewer"),
349 (model_only, direct_model, false, false, "model-only viewer"),
350 ] {
351 scenario.rights(user, model, view, edit, label)?;
352 }
353
354 for (user, group, label) in [
355 (owner, authority_group, "authority discovery"),
356 (group_editor, editor_group, "group editor discovery"),
357 (viewer, user_viewer_group, "user viewer group discovery"),
358 (owner, model_viewer_group, "model viewer group discovery"),
359 ] {
360 scenario.group_list(user, no_view_model, group, &[group_access], label)?;
361 }
362 for (user, expected, label) in [
363 (
364 direct_editor,
365 &[group_access][..],
366 "direct editor discovery",
367 ),
368 (
369 outsider,
370 &[group_access][..],
371 "direct user viewer discovery",
372 ),
373 (
374 member,
375 &[group_access, personal_access][..],
376 "member discovery",
377 ),
378 (model_only, &[][..], "models excluded from discovery"),
379 ] {
380 scenario.user_list(user, direct_model, expected, label)?;
381 }
382 scenario.group_list(
383 model_only,
384 direct_model,
385 ALL_USERS,
386 &[personal_access],
387 "all users discovery",
388 )?;
389
390 let filtered = exact(member, direct_model, authority_group)?;
391 scenario.concealed(&filtered, "filtered check was not concealed")?;
392 let personal = at(
393 "filtered personal authority",
394 stack.access.check(&filtered, personal_access, subsystem),
395 )?;
396 require(
397 personal.can_view() && personal.can_edit() && personal.target().is_some(),
398 "filter hid personal authority",
399 )?;
400 let listed = at(
401 "filtered group listing",
402 stack
403 .access
404 .list_group(&filtered, authority_group, subsystem),
405 )?;
406 require(listed.is_empty(), "filtered group listing was visible")?;
407 let listed = at(
408 "filtered user listing",
409 stack.access.list_user(&filtered, subsystem),
410 )?;
411 require(
412 listed == [personal_access],
413 "filtered user listing was incorrect",
414 )?;
415
416 stack.role(owner, user_viewer_group, late, Some(GroupRole::User))?;
417 scenario.group_list(
418 late,
419 no_view_model,
420 user_viewer_group,
421 &[group_access],
422 "late member discovery",
423 )?;
424 stack.role(owner, user_viewer_group, late, None)?;
425 require_error(
426 stack
427 .access
428 .list_group(&context(late, no_view_model)?, user_viewer_group, subsystem),
429 "access group is unavailable",
430 "former member group listing",
431 )?;
432
433 for (group, user, model, value, label) in [
434 (
435 authority_group,
436 admin,
437 authority_model,
438 GroupRole::Admin,
439 "authority",
440 ),
441 (
442 editor_group,
443 group_editor,
444 editor_model,
445 GroupRole::User,
446 "editor",
447 ),
448 (
449 user_viewer_group,
450 viewer,
451 viewer_model,
452 GroupRole::User,
453 "viewer",
454 ),
455 ] {
456 stack.role(owner, group, user, None)?;
457 scenario.rights(user, model, false, false, label)?;
458 stack.role(owner, group, user, Some(value))?;
459 }
460 for (group, user, model, view, edit, label) in [
461 (
462 authority_group,
463 owner,
464 authority_model,
465 false,
466 true,
467 "authority model",
468 ),
469 (
470 editor_group,
471 group_editor,
472 editor_model,
473 false,
474 true,
475 "editor model",
476 ),
477 (
478 model_viewer_group,
479 viewer,
480 viewer_model,
481 false,
482 false,
483 "viewer model",
484 ),
485 ] {
486 stack.model_member(owner, group, model, false)?;
487 scenario.rights(user, model, view, edit, label)?;
488 stack.model_member(owner, group, model, true)?;
489 }
490
491 scenario.rights(
492 direct_editor,
493 no_view_model,
494 false,
495 true,
496 "editor without model view",
497 )?;
498 require_error(
499 stack.access.replace_policy(
500 &exact(direct_editor, no_view_model, authority_group)?,
501 group_access,
502 editors(direct_editor, editor_group),
503 viewers(
504 member,
505 outsider,
506 replacement_group,
507 model_viewer_group,
508 direct_model,
509 ),
510 ),
511 "access is unavailable",
512 "filtered replacement",
513 )?;
514 at(
515 "replace policy",
516 stack.access.replace_policy(
517 &context(direct_editor, no_view_model)?,
518 group_access,
519 editors(direct_editor, editor_group),
520 viewers(
521 member,
522 outsider,
523 replacement_group,
524 model_viewer_group,
525 direct_model,
526 ),
527 ),
528 )?;
529 require(
530 at(
531 "profile after replacement",
532 stack.access.profile_id(group_access),
533 )? == Some(group_profile),
534 "replacement changed group profile link",
535 )?;
536 scenario.rights(
537 owner,
538 authority_model,
539 true,
540 true,
541 "authority after replacement",
542 )?;
543 scenario.concealed(&filtered, "replacement changed filtered authority")?;
544 scenario.group_list(
545 late,
546 no_view_model,
547 replacement_group,
548 &[group_access],
549 "replacement discovery",
550 )?;
551 scenario.group_list(
552 viewer,
553 no_view_model,
554 user_viewer_group,
555 &[group_access],
556 "monotonic discovery",
557 )
558}
559
560#[cfg(test)]
561mod tests {
562 #[test]
563 fn groups_backed_access_conformance() {
564 super::verify().unwrap();
565 }
566}