Skip to main content

kcode_k1_access_groups_testkit/
lib.rs

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}