1use std::collections::BTreeMap;
49
50use super::label::SecurityLabel;
51use crate::envelope::{validate_service_domain, MAX_SERVICE_DOMAIN_BYTES};
52
53pub const MAX_TRACK_SEGMENTS: usize = 8;
57
58pub const MAX_TRACK_SEGMENT_BYTES: usize = 128;
62
63pub const SUPPORTED_TRACK_POLICY_REVISION: u32 = 1;
68
69const _: () = assert!(
74 MAX_SERVICE_DOMAIN_BYTES == 128,
75 "the shared canonical service-domain cap changed; re-review the MoQ/event plane grammar bounds"
76);
77
78#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
81pub enum MoqEventPlane {
82 Event,
85 Stream,
88}
89
90impl MoqEventPlane {
91 pub const fn discriminant(self) -> u16 {
93 match self {
94 MoqEventPlane::Event => 0,
95 MoqEventPlane::Stream => 1,
96 }
97 }
98
99 pub const fn from_discriminant(value: u16) -> Option<Self> {
102 match value {
103 0 => Some(MoqEventPlane::Event),
104 1 => Some(MoqEventPlane::Stream),
105 _ => None,
106 }
107 }
108}
109
110#[derive(Debug, Clone, PartialEq, Eq, Hash)]
117pub struct MoqEventObjectRef {
118 plane: MoqEventPlane,
119 service_domain: String,
120 segments: Box<[String]>,
121}
122
123impl MoqEventObjectRef {
124 pub fn parse(plane: MoqEventPlane, coordinate: &str) -> Option<Self> {
132 match plane {
133 MoqEventPlane::Event => Self::parse_dot_coordinate(coordinate),
134 MoqEventPlane::Stream => Self::parse_slash_coordinate(coordinate),
135 }
136 }
137
138 fn parse_dot_coordinate(coordinate: &str) -> Option<Self> {
148 let mut segments = Vec::with_capacity(MAX_TRACK_SEGMENTS);
149 for segment in coordinate.split('.') {
150 if segments.len() == MAX_TRACK_SEGMENTS {
151 return None;
152 }
153 check_segment(segment)?;
154 if segment.contains('/') {
158 return None;
159 }
160 segments.push(segment.to_owned());
161 }
162 let service_domain = canonical_domain(&segments[0])?;
163 Some(Self {
164 plane: MoqEventPlane::Event,
165 service_domain,
166 segments: segments.into(),
167 })
168 }
169
170 fn parse_slash_coordinate(coordinate: &str) -> Option<Self> {
180 let mut segments = Vec::with_capacity(MAX_TRACK_SEGMENTS);
181 for segment in coordinate.split('/') {
182 if segments.len() == MAX_TRACK_SEGMENTS {
183 return None;
184 }
185 check_segment(segment)?;
186 segments.push(segment.to_owned());
187 }
188 if segments.len() < 2 {
189 return None;
190 }
191 let service_domain = canonical_domain(&segments[1])?;
192 Some(Self {
193 plane: MoqEventPlane::Stream,
194 service_domain,
195 segments: segments.into(),
196 })
197 }
198
199 pub fn plane(&self) -> MoqEventPlane {
201 self.plane
202 }
203
204 pub fn service_domain(&self) -> &str {
206 &self.service_domain
207 }
208
209 pub fn segments(&self) -> &[String] {
211 &self.segments
212 }
213
214 pub fn audit_coordinate(&self) -> String {
217 let separator = match self.plane {
218 MoqEventPlane::Event => '.',
219 MoqEventPlane::Stream => '/',
220 };
221 let mut out = String::new();
222 for segment in &self.segments[..] {
223 if !out.is_empty() {
224 out.push(separator);
225 }
226 out.push_str(segment);
227 }
228 out
229 }
230}
231
232fn check_segment(segment: &str) -> Option<()> {
236 if segment.is_empty()
237 || segment.len() > MAX_TRACK_SEGMENT_BYTES
238 || segment == "."
239 || segment == ".."
240 || segment.as_bytes().contains(&0)
241 {
242 return None;
243 }
244 Some(())
245}
246
247fn canonical_domain(segment: &str) -> Option<String> {
250 validate_service_domain(segment).ok()?;
251 Some(segment.to_owned())
252}
253
254pub trait MoqEventLabelResolver: Send + Sync {
259 fn resolve(&self, object: &MoqEventObjectRef) -> Option<SecurityLabel>;
260}
261
262#[derive(Debug, Default, Clone, Copy)]
266pub struct DenyAllMoqEventResolver;
267
268impl MoqEventLabelResolver for DenyAllMoqEventResolver {
269 fn resolve(&self, _object: &MoqEventObjectRef) -> Option<SecurityLabel> {
270 None
271 }
272}
273
274#[derive(Debug, Clone, PartialEq, Eq)]
277pub enum TrackPolicyError {
278 UnsupportedRevision { table: u32, supported: u32 },
282 NoncanonicalServiceDomain(String),
284 DuplicateDeclaration {
287 plane: MoqEventPlane,
288 service_domain: String,
289 },
290 UnrepresentableServiceDomain {
296 plane: MoqEventPlane,
297 service_domain: String,
298 },
299}
300
301impl std::fmt::Display for TrackPolicyError {
302 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
303 match self {
304 TrackPolicyError::UnsupportedRevision { table, supported } => write!(
305 f,
306 "track-policy revision {table} is newer than supported revision {supported}"
307 ),
308 TrackPolicyError::NoncanonicalServiceDomain(domain) => write!(
309 f,
310 "track-policy row declares noncanonical service domain {domain:?}"
311 ),
312 TrackPolicyError::DuplicateDeclaration {
313 plane,
314 service_domain,
315 } => write!(
316 f,
317 "duplicate track-policy declaration for plane {:?} service {service_domain:?}",
318 plane
319 ),
320 TrackPolicyError::UnrepresentableServiceDomain {
321 plane,
322 service_domain,
323 } => write!(
324 f,
325 "track-policy row declares service domain {service_domain:?} that the {:?} \
326 plane grammar can never represent",
327 plane
328 ),
329 }
330 }
331}
332
333impl std::error::Error for TrackPolicyError {}
334
335#[derive(Debug, Clone, PartialEq, Eq)]
339pub struct MoqEventPolicyRow {
340 pub plane: MoqEventPlane,
342 pub service_domain: String,
344 pub label: SecurityLabel,
346}
347
348fn check_plane_representable(
363 plane: MoqEventPlane,
364 service_domain: &str,
365) -> Result<(), TrackPolicyError> {
366 let unrepresentable = match plane {
367 MoqEventPlane::Event => service_domain.contains('.') || service_domain.contains('/'),
368 MoqEventPlane::Stream => service_domain.contains('/'),
369 };
370 if unrepresentable {
371 return Err(TrackPolicyError::UnrepresentableServiceDomain {
372 plane,
373 service_domain: service_domain.to_owned(),
374 });
375 }
376 Ok(())
377}
378
379impl MoqEventPolicyRow {
380 pub fn new(
386 plane: MoqEventPlane,
387 service_domain: impl Into<String>,
388 label: SecurityLabel,
389 ) -> Result<Self, TrackPolicyError> {
390 let service_domain = service_domain.into();
391 if validate_service_domain(&service_domain).is_err() {
392 return Err(TrackPolicyError::NoncanonicalServiceDomain(service_domain));
393 }
394 check_plane_representable(plane, &service_domain)?;
395 Ok(Self {
396 plane,
397 service_domain,
398 label,
399 })
400 }
401}
402
403#[derive(Debug, Clone, PartialEq, Eq)]
411pub struct MoqEventPolicyTable {
412 revision: u32,
413 rows: BTreeMap<(MoqEventPlane, String), SecurityLabel>,
414}
415
416impl MoqEventPolicyTable {
417 pub fn build(
428 revision: u32,
429 rows: impl IntoIterator<Item = MoqEventPolicyRow>,
430 ) -> Result<Self, TrackPolicyError> {
431 if revision > SUPPORTED_TRACK_POLICY_REVISION {
432 return Err(TrackPolicyError::UnsupportedRevision {
433 table: revision,
434 supported: SUPPORTED_TRACK_POLICY_REVISION,
435 });
436 }
437 let mut map = BTreeMap::new();
438 for row in rows {
439 if validate_service_domain(&row.service_domain).is_err() {
440 return Err(TrackPolicyError::NoncanonicalServiceDomain(
441 row.service_domain,
442 ));
443 }
444 check_plane_representable(row.plane, &row.service_domain)?;
445 let key = (row.plane, row.service_domain);
446 if let Some(existing) = map.get(&key) {
447 if *existing != row.label {
448 return Err(TrackPolicyError::DuplicateDeclaration {
449 plane: row.plane,
450 service_domain: key.1,
451 });
452 }
453 continue;
454 }
455 map.insert(key, row.label);
456 }
457 Ok(Self {
458 revision,
459 rows: map,
460 })
461 }
462
463 pub fn empty() -> Self {
466 Self {
467 revision: SUPPORTED_TRACK_POLICY_REVISION,
468 rows: BTreeMap::new(),
469 }
470 }
471
472 pub fn revision(&self) -> u32 {
474 self.revision
475 }
476
477 pub fn len(&self) -> usize {
479 self.rows.len()
480 }
481
482 pub fn is_empty(&self) -> bool {
484 self.rows.is_empty()
485 }
486
487 pub fn resolve(&self, object: &MoqEventObjectRef) -> Option<SecurityLabel> {
490 self.rows
491 .get(&(object.plane, object.service_domain.clone()))
492 .copied()
493 }
494}
495
496#[derive(Debug, Clone)]
499pub struct DeclaredTrackPolicyResolver {
500 table: MoqEventPolicyTable,
501}
502
503impl DeclaredTrackPolicyResolver {
504 pub fn new(table: MoqEventPolicyTable) -> Self {
506 Self { table }
507 }
508
509 pub fn table(&self) -> &MoqEventPolicyTable {
511 &self.table
512 }
513}
514
515impl MoqEventLabelResolver for DeclaredTrackPolicyResolver {
516 fn resolve(&self, object: &MoqEventObjectRef) -> Option<SecurityLabel> {
517 self.table.resolve(object)
518 }
519}
520
521#[cfg(test)]
522#[allow(clippy::unwrap_used, clippy::expect_used)]
523mod tests {
524 use super::*;
525 use crate::auth::mac::{Assurance, CompartmentSet, Level};
526
527 fn public_label() -> SecurityLabel {
528 SecurityLabel::new(Level::Public, Assurance::Classical, CompartmentSet::EMPTY)
529 }
530
531 fn secret_label() -> SecurityLabel {
532 SecurityLabel::new(Level::Secret, Assurance::PqHybrid, CompartmentSet::EMPTY)
533 }
534
535 #[test]
538 fn plane_discriminants_decode_exactly_the_known_set() {
539 assert_eq!(
540 MoqEventPlane::from_discriminant(MoqEventPlane::Event.discriminant()),
541 Some(MoqEventPlane::Event)
542 );
543 assert_eq!(
544 MoqEventPlane::from_discriminant(MoqEventPlane::Stream.discriminant()),
545 Some(MoqEventPlane::Stream)
546 );
547 for unknown in [2u16, 3, 7, u16::MAX] {
548 assert_eq!(MoqEventPlane::from_discriminant(unknown), None);
549 }
550 }
551
552 #[test]
555 fn event_prefix_parses_source_as_canonical_service_domain() {
556 let object =
557 MoqEventObjectRef::parse(MoqEventPlane::Event, "worker").expect("bare source parses");
558 assert_eq!(object.plane(), MoqEventPlane::Event);
559 assert_eq!(object.service_domain(), "worker");
560 assert_eq!(object.segments(), ["worker"].map(String::from).as_slice());
561
562 let object = MoqEventObjectRef::parse(MoqEventPlane::Event, "registry.repo789.push")
563 .expect("topic prefix parses");
564 assert_eq!(object.service_domain(), "registry");
565 assert_eq!(
566 object.segments(),
567 ["registry", "repo789", "push"].map(String::from).as_slice()
568 );
569 }
570
571 #[test]
572 fn event_prefix_rejects_noncanonical_service_domains() {
573 for bad in [
576 "", "Worker", "_worker", "wor ker", "wo:rker", "wor/ker", ] {
582 assert!(
583 MoqEventObjectRef::parse(MoqEventPlane::Event, bad).is_none(),
584 "{bad:?} must not parse as an event prefix"
585 );
586 }
587 }
588
589 #[test]
590 fn event_prefix_rejects_oversized_segments_and_domain() {
591 let long_segment = "w".repeat(MAX_TRACK_SEGMENT_BYTES + 1);
592 assert!(MoqEventObjectRef::parse(MoqEventPlane::Event, &long_segment).is_none());
593
594 let oversized_domain = "w".repeat(MAX_SERVICE_DOMAIN_BYTES + 1);
595 assert!(
596 MoqEventObjectRef::parse(MoqEventPlane::Event, &oversized_domain).is_none(),
597 "service domain beyond the shared 128-byte rule denies"
598 );
599 }
600
601 fn dot_name(count: usize) -> String {
604 vec!["worker"; count].join(".")
605 }
606
607 fn slash_name(count: usize) -> String {
608 vec!["worker"; count].join("/")
609 }
610
611 #[test]
612 fn exactly_eight_segments_parse_in_both_syntaxes() {
613 let event = MoqEventObjectRef::parse(MoqEventPlane::Event, &dot_name(MAX_TRACK_SEGMENTS))
614 .expect("eight dot segments parse");
615 assert_eq!(event.segments().len(), MAX_TRACK_SEGMENTS);
616
617 let stream =
618 MoqEventObjectRef::parse(MoqEventPlane::Stream, &slash_name(MAX_TRACK_SEGMENTS))
619 .expect("eight slash segments parse");
620 assert_eq!(stream.segments().len(), MAX_TRACK_SEGMENTS);
621 }
622
623 #[test]
624 fn ninth_segment_rejects_in_both_syntaxes() {
625 assert!(
627 MoqEventObjectRef::parse(MoqEventPlane::Event, &dot_name(MAX_TRACK_SEGMENTS + 1))
628 .is_none()
629 );
630 assert!(MoqEventObjectRef::parse(
631 MoqEventPlane::Stream,
632 &slash_name(MAX_TRACK_SEGMENTS + 1)
633 )
634 .is_none());
635 }
636
637 #[test]
638 fn very_large_names_reject_without_segment_amplification() {
639 let million_dots = ["a"; 1_000_000].join(".");
644 assert!(MoqEventObjectRef::parse(MoqEventPlane::Event, &million_dots).is_none());
645 let million_slashes = ["a"; 1_000_000].join("/");
646 assert!(MoqEventObjectRef::parse(MoqEventPlane::Stream, &million_slashes).is_none());
647
648 let huge_tail = format!(
652 "{}.{}",
653 dot_name(MAX_TRACK_SEGMENTS),
654 "x".repeat(4 * 1024 * 1024)
655 );
656 assert!(MoqEventObjectRef::parse(MoqEventPlane::Event, &huge_tail).is_none());
657 let huge_tail = format!(
658 "{}/{}",
659 slash_name(MAX_TRACK_SEGMENTS),
660 "x".repeat(4 * 1024 * 1024)
661 );
662 assert!(MoqEventObjectRef::parse(MoqEventPlane::Stream, &huge_tail).is_none());
663 }
664
665 #[test]
666 fn event_prefix_rejects_empty_segments() {
667 for bad in [".worker", "worker.", "worker..push", "wor..ker"] {
668 assert!(MoqEventObjectRef::parse(MoqEventPlane::Event, bad).is_none());
669 }
670 }
671
672 #[test]
675 fn stream_track_parses_service_at_second_segment() {
676 let object = MoqEventObjectRef::parse(MoqEventPlane::Stream, "alice/streams/run-1/i0")
677 .expect("tenant track parses");
678 assert_eq!(object.plane(), MoqEventPlane::Stream);
679 assert_eq!(object.service_domain(), "streams");
680 assert_eq!(
681 object.segments(),
682 ["alice", "streams", "run-1", "i0"]
683 .map(String::from)
684 .as_slice()
685 );
686
687 let object = MoqEventObjectRef::parse(MoqEventPlane::Stream, "local/streams/deadbeef")
688 .expect("broadcast path parses");
689 assert_eq!(object.service_domain(), "streams");
690
691 let object = MoqEventObjectRef::parse(MoqEventPlane::Stream, "local/events/worker")
692 .expect("event broadcast path parses under the stream grammar");
693 assert_eq!(object.service_domain(), "events");
694 }
695
696 #[test]
697 fn stream_track_rejects_single_segment_and_bad_grammar() {
698 assert!(MoqEventObjectRef::parse(MoqEventPlane::Stream, "alice").is_none());
700 for bad in [
702 "/streams/x",
703 "alice//run",
704 "alice/streams/run/",
705 "./streams/x",
706 "alice/../streams/run",
707 ] {
708 assert!(
709 MoqEventObjectRef::parse(MoqEventPlane::Stream, bad).is_none(),
710 "{bad:?} must not parse"
711 );
712 }
713 assert!(MoqEventObjectRef::parse(MoqEventPlane::Stream, "alice/Streams/x").is_none());
715 }
716
717 #[test]
718 fn identities_are_not_reinterpretable_across_grammars() {
719 assert!(MoqEventObjectRef::parse(MoqEventPlane::Event, "local/events/worker").is_none());
721 let stream = MoqEventObjectRef::parse(MoqEventPlane::Stream, "local/events/worker")
724 .expect("stream grammar applies");
725 let event = MoqEventObjectRef::parse(MoqEventPlane::Event, "events.worker")
726 .expect("event grammar applies");
727 assert_eq!(stream.service_domain(), "events");
728 assert_eq!(event.service_domain(), "events");
729 assert_ne!(stream, event, "plane is part of identity");
730 }
731
732 #[test]
733 fn audit_coordinate_round_trips_the_decoded_segments() {
734 let object = MoqEventObjectRef::parse(MoqEventPlane::Stream, "alice/streams/run-1/i0")
735 .expect("parses");
736 assert_eq!(object.audit_coordinate(), "alice/streams/run-1/i0");
737 let object =
738 MoqEventObjectRef::parse(MoqEventPlane::Event, "registry.repo789.push").unwrap();
739 assert_eq!(object.audit_coordinate(), "registry.repo789.push");
740 }
741
742 fn declared_table() -> MoqEventPolicyTable {
745 MoqEventPolicyTable::build(
746 SUPPORTED_TRACK_POLICY_REVISION,
747 [
748 MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", secret_label()).unwrap(),
749 MoqEventPolicyRow::new(MoqEventPlane::Event, "registry", public_label()).unwrap(),
750 MoqEventPolicyRow::new(MoqEventPlane::Stream, "streams", public_label()).unwrap(),
751 ],
752 )
753 .unwrap()
754 }
755
756 #[test]
757 fn table_resolves_exactly_the_declared_plane_and_service() {
758 let table = declared_table();
759 let worker =
760 MoqEventObjectRef::parse(MoqEventPlane::Event, "worker.sandbox1.started").unwrap();
761 assert_eq!(table.resolve(&worker), Some(secret_label()));
762
763 let worker_as_stream =
767 MoqEventObjectRef::parse(MoqEventPlane::Stream, "tenant/worker/topic1/i0").unwrap();
768 assert_eq!(worker_as_stream.service_domain(), "worker");
769 assert_eq!(table.resolve(&worker_as_stream), None);
770
771 let streams = MoqEventObjectRef::parse(MoqEventPlane::Stream, "a/streams/b/c").unwrap();
772 assert_eq!(table.resolve(&streams), Some(public_label()));
773 }
774
775 #[test]
776 fn unlisted_services_and_empty_table_deny() {
777 let table = declared_table();
778 let unknown = MoqEventObjectRef::parse(MoqEventPlane::Event, "inference.session.x")
779 .expect("parses, but is unlisted");
780 assert_eq!(table.resolve(&unknown), None);
781
782 let empty = MoqEventPolicyTable::empty();
783 assert!(empty.is_empty());
784 let declared = MoqEventObjectRef::parse(MoqEventPlane::Event, "worker").unwrap();
785 assert_eq!(
786 empty.resolve(&declared),
787 None,
788 "empty table denies everything"
789 );
790 }
791
792 #[test]
793 fn newer_table_revision_is_rejected_not_partially_interpreted() {
794 let err = MoqEventPolicyTable::build(
795 SUPPORTED_TRACK_POLICY_REVISION + 1,
796 [MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", public_label()).unwrap()],
797 )
798 .unwrap_err();
799 assert_eq!(
800 err,
801 TrackPolicyError::UnsupportedRevision {
802 table: SUPPORTED_TRACK_POLICY_REVISION + 1,
803 supported: SUPPORTED_TRACK_POLICY_REVISION,
804 }
805 );
806 MoqEventPolicyTable::build(
809 SUPPORTED_TRACK_POLICY_REVISION,
810 [MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", public_label()).unwrap()],
811 )
812 .unwrap();
813 }
814
815 #[test]
816 fn table_construction_is_fail_closed() {
817 let err =
819 MoqEventPolicyRow::new(MoqEventPlane::Event, "Worker", public_label()).unwrap_err();
820 assert_eq!(
821 err,
822 TrackPolicyError::NoncanonicalServiceDomain("Worker".to_owned())
823 );
824
825 let err = MoqEventPolicyTable::build(
827 SUPPORTED_TRACK_POLICY_REVISION,
828 [
829 MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", public_label()).unwrap(),
830 MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", secret_label()).unwrap(),
831 ],
832 )
833 .unwrap_err();
834 assert_eq!(
835 err,
836 TrackPolicyError::DuplicateDeclaration {
837 plane: MoqEventPlane::Event,
838 service_domain: "worker".to_owned(),
839 }
840 );
841
842 MoqEventPolicyTable::build(
844 SUPPORTED_TRACK_POLICY_REVISION,
845 [
846 MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", public_label()).unwrap(),
847 MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", public_label()).unwrap(),
848 ],
849 )
850 .unwrap();
851 }
852
853 #[test]
861 fn unrepresentable_event_domain_cannot_downgrade_declared_label() {
862 let err =
864 MoqEventPolicyRow::new(MoqEventPlane::Event, "foo.bar", secret_label()).unwrap_err();
865 assert_eq!(
866 err,
867 TrackPolicyError::UnrepresentableServiceDomain {
868 plane: MoqEventPlane::Event,
869 service_domain: "foo.bar".to_owned(),
870 }
871 );
872 MoqEventPolicyRow::new(MoqEventPlane::Event, "foo/bar", secret_label()).unwrap_err();
874
875 let literal_row = MoqEventPolicyRow {
878 plane: MoqEventPlane::Event,
879 service_domain: "foo.bar".to_owned(),
880 label: secret_label(),
881 };
882 let prefix_row =
883 MoqEventPolicyRow::new(MoqEventPlane::Event, "foo", public_label()).unwrap();
884 let err =
885 MoqEventPolicyTable::build(SUPPORTED_TRACK_POLICY_REVISION, [literal_row, prefix_row])
886 .unwrap_err();
887 assert_eq!(
888 err,
889 TrackPolicyError::UnrepresentableServiceDomain {
890 plane: MoqEventPlane::Event,
891 service_domain: "foo.bar".to_owned(),
892 }
893 );
894
895 let table = MoqEventPolicyTable::build(
901 SUPPORTED_TRACK_POLICY_REVISION,
902 [MoqEventPolicyRow::new(MoqEventPlane::Event, "foo", public_label()).unwrap()],
903 )
904 .unwrap();
905 let object = MoqEventObjectRef::parse(MoqEventPlane::Event, "foo.bar.created").unwrap();
906 assert_eq!(object.service_domain(), "foo");
907 assert_eq!(table.resolve(&object), Some(public_label()));
908 }
909
910 #[test]
913 fn unrepresentable_stream_domain_cannot_downgrade_declared_label() {
914 let err = MoqEventPolicyRow::new(MoqEventPlane::Stream, "a/b", secret_label()).unwrap_err();
915 assert_eq!(
916 err,
917 TrackPolicyError::UnrepresentableServiceDomain {
918 plane: MoqEventPlane::Stream,
919 service_domain: "a/b".to_owned(),
920 }
921 );
922
923 let literal_row = MoqEventPolicyRow {
925 plane: MoqEventPlane::Stream,
926 service_domain: "a/b".to_owned(),
927 label: secret_label(),
928 };
929 let prefix_row =
930 MoqEventPolicyRow::new(MoqEventPlane::Stream, "a", public_label()).unwrap();
931 let err =
932 MoqEventPolicyTable::build(SUPPORTED_TRACK_POLICY_REVISION, [literal_row, prefix_row])
933 .unwrap_err();
934 assert_eq!(
935 err,
936 TrackPolicyError::UnrepresentableServiceDomain {
937 plane: MoqEventPlane::Stream,
938 service_domain: "a/b".to_owned(),
939 }
940 );
941
942 let table = MoqEventPolicyTable::build(
945 SUPPORTED_TRACK_POLICY_REVISION,
946 [MoqEventPolicyRow::new(MoqEventPlane::Stream, "a", public_label()).unwrap()],
947 )
948 .unwrap();
949 let object = MoqEventObjectRef::parse(MoqEventPlane::Stream, "t/a/b/c").unwrap();
950 assert_eq!(object.service_domain(), "a");
951 assert_eq!(table.resolve(&object), Some(public_label()));
952 }
953
954 #[test]
955 fn deny_all_resolver_labels_nothing() {
956 let resolver = DenyAllMoqEventResolver;
957 let object = MoqEventObjectRef::parse(MoqEventPlane::Event, "worker").unwrap();
958 assert_eq!(resolver.resolve(&object), None);
959 }
960}