1use crate::{
5 evaluation::{
6 coordinator::{EvalCoordinator, EvalCoordinatorMessage},
7 response::{EvaluatorError, ResponseSummary},
8 worker::{EvalWorker, EvalWorkerMessage},
9 },
10 governance::model::Quorum,
11 helpers::network::service::NetworkSender,
12 model::{
13 common::{
14 abort_req, emit_fail, send_reboot_to_req, take_random_signers,
15 },
16 event::{EvaluationData, EvaluationResponse},
17 },
18 request::manager::{RebootType, RequestManager, RequestManagerMessage},
19};
20use ave_actors::{
21 Actor, ActorContext, ActorError, ActorPath, ChildAction, Handler, Message,
22 NotPersistentActor,
23};
24
25use async_trait::async_trait;
26use ave_common::{
27 ValueWrapper,
28 identity::{
29 CryptoError, DigestIdentifier, HashAlgorithm, PublicKey, Signature,
30 Signed, hash_borsh,
31 },
32};
33
34use request::EvaluationReq;
35use response::{EvaluationRes, EvaluatorResponse as EvalRes};
36
37use tracing::{Span, debug, error, info_span, warn};
38
39pub mod compiler;
40pub mod coordinator;
41pub mod request;
42pub mod response;
43pub mod runner;
44pub mod schema;
45pub mod worker;
46
47use std::{collections::HashSet, sync::Arc};
48pub struct Evaluation {
49 our_key: Arc<PublicKey>,
50 quorum: Quorum,
52 evaluators_response: Vec<EvalRes>,
54 evaluators_quantity: u32,
56
57 evaluators_signatures: Vec<Signature>,
58
59 request: Signed<EvaluationReq>,
60
61 hash: HashAlgorithm,
62
63 network: Arc<NetworkSender>,
64
65 request_id: DigestIdentifier,
66
67 version: u64,
68
69 errors: Vec<EvaluatorError>,
70
71 evaluation_request_hash: DigestIdentifier,
72
73 reboot: bool,
74
75 current_evaluators: HashSet<PublicKey>,
76
77 pending_evaluators: HashSet<PublicKey>,
78
79 init_state: Option<ValueWrapper>,
80}
81
82impl Evaluation {
83 pub fn new(
84 our_key: Arc<PublicKey>,
85 request: Signed<EvaluationReq>,
86 quorum: Quorum,
87 init_state: Option<ValueWrapper>,
88 hash: HashAlgorithm,
89 network: Arc<NetworkSender>,
90 ) -> Self {
91 Self {
92 our_key,
93 hash,
94 network,
95 request,
96 quorum,
97 init_state,
98 current_evaluators: HashSet::new(),
99 errors: vec![],
100 evaluation_request_hash: DigestIdentifier::default(),
101 evaluators_quantity: 0,
102 evaluators_response: vec![],
103 evaluators_signatures: vec![],
104 pending_evaluators: HashSet::new(),
105 reboot: false,
106 request_id: DigestIdentifier::default(),
107 version: 0,
108 }
109 }
110
111 fn check_evaluator(&mut self, evaluator: PublicKey) -> bool {
112 self.current_evaluators.remove(&evaluator)
113 }
114
115 async fn create_evaluators(
116 &self,
117 ctx: &mut ActorContext<Self>,
118 signer: PublicKey,
119 ) -> Result<(), ActorError> {
120 if signer != *self.our_key {
121 let child = ctx
122 .create_child(
123 &format!("{}", signer),
124 EvalCoordinator::new(
125 signer.clone(),
126 self.request_id.to_string(),
127 self.version,
128 self.network.clone(),
129 ),
130 )
131 .await?;
132
133 child
134 .tell(EvalCoordinatorMessage::NetworkEvaluation {
135 evaluation_req: Box::new(self.request.clone()),
136 node_key: signer,
137 })
138 .await?
139 } else {
140 let child = ctx
141 .create_child(
142 &format!("{}", signer),
143 EvalWorker {
144 init_state: self.init_state.clone(),
145 node_key: (*self.our_key).clone(),
146 our_key: self.our_key.clone(),
147 governance_id: self
148 .request
149 .content()
150 .governance_id
151 .clone(),
152 gov_version: self.request.content().gov_version,
153 sn: self.request.content().sn,
154 hash: self.hash,
155 network: self.network.clone(),
156 stop: true,
157 },
158 )
159 .await?;
160
161 child
162 .tell(EvalWorkerMessage::LocalEvaluation {
163 evaluation_req: self.request.clone(),
164 })
165 .await?
166 }
167
168 Ok(())
169 }
170
171 fn check_responses(&self) -> ResponseSummary {
172 let res_set: HashSet<EvalRes> =
173 HashSet::from_iter(self.evaluators_response.iter().cloned());
174 let error_set: HashSet<EvaluatorError> =
175 HashSet::from_iter(self.errors.iter().cloned());
176
177 if res_set.len() == 1 && error_set.is_empty() {
178 ResponseSummary::Ok
179 } else if error_set.len() == 1 && res_set.is_empty() {
180 ResponseSummary::Error
181 } else {
182 ResponseSummary::Reboot
183 }
184 }
185
186 fn build_evaluation_data(
187 &self,
188 is_ok: bool,
189 ) -> Result<EvaluationData, ActorError> {
190 if is_ok {
191 Ok(EvaluationData {
192 eval_req_signature: self.request.signature().clone(),
193 eval_req_hash: self.evaluation_request_hash.clone(),
194 evaluators_signatures: self.evaluators_signatures.clone(),
195 response: EvaluationResponse::Ok(
196 self.evaluators_response[0].clone(),
197 ),
198 })
199 } else {
200 Ok(EvaluationData {
201 eval_req_signature: self.request.signature().clone(),
202 eval_req_hash: self.evaluation_request_hash.clone(),
203 evaluators_signatures: self.evaluators_signatures.clone(),
204 response: EvaluationResponse::Error(self.errors[0].clone()),
205 })
206 }
207 }
208
209 async fn send_evaluation_to_req(
210 &self,
211 ctx: &ActorContext<Self>,
212 response: EvaluationData,
213 ) -> Result<(), ActorError> {
214 let req_actor = ctx.get_parent::<RequestManager>().await?;
215
216 req_actor
217 .tell(RequestManagerMessage::EvaluationRes {
218 request_id: self.request_id.clone(),
219 eval_req: Box::new(self.request.content().clone()),
220 eval_res: response,
221 })
222 .await
223 }
224
225 fn create_eval_req_hash(&self) -> Result<DigestIdentifier, CryptoError> {
226 hash_borsh(&*self.hash.hasher(), &self.request)
227 }
228}
229
230#[derive(Debug, Clone)]
231pub enum EvaluationMessage {
232 Create {
233 request_id: DigestIdentifier,
234 version: u64,
235 signers: HashSet<PublicKey>,
236 },
237 Response {
238 evaluation_res: EvaluationRes,
239 sender: PublicKey,
240 signature: Option<Signature>,
241 },
242}
243
244impl Message for EvaluationMessage {}
245
246impl NotPersistentActor for Evaluation {}
247
248#[async_trait]
249impl Actor for Evaluation {
250 type Event = ();
251 type Message = EvaluationMessage;
252 type Response = ();
253
254 fn get_span(_id: &str, parent_span: Option<Span>) -> tracing::Span {
255 parent_span.map_or_else(
256 || info_span!("Evaluation"),
257 |parent_span| info_span!(parent: parent_span, "Evaluation"),
258 )
259 }
260}
261
262#[async_trait]
263impl Handler<Self> for Evaluation {
264 async fn handle_message(
265 &mut self,
266 _sender: ActorPath,
267 msg: EvaluationMessage,
268 ctx: &mut ActorContext<Self>,
269 ) -> Result<(), ActorError> {
270 match msg {
271 EvaluationMessage::Create {
272 request_id,
273 version,
274 signers,
275 } => {
276 let eval_req_hash = match self.create_eval_req_hash() {
277 Ok(digest) => digest,
278 Err(e) => {
279 error!(
280 msg_type = "Create",
281 error = %e,
282 "Failed to create evaluation request hash"
283 );
284 return Err(emit_fail(
285 ctx,
286 ActorError::FunctionalCritical {
287 description: format!(
288 "Cannot create evaluation request hash: {}",
289 e
290 ),
291 },
292 )
293 .await);
294 }
295 };
296
297 self.evaluation_request_hash = eval_req_hash;
298 self.evaluators_quantity = signers.len() as u32;
299 self.request_id = request_id.clone();
300 self.version = version;
301
302 let evaluators_quantity = self.quorum.get_signers(
303 self.evaluators_quantity,
304 signers.len() as u32,
305 );
306
307 let (current_eval, pending_eval) =
308 take_random_signers(signers, evaluators_quantity as usize);
309 self.current_evaluators.clone_from(¤t_eval);
310 self.pending_evaluators.clone_from(&pending_eval);
311
312 for signer in current_eval.clone() {
313 if let Err(e) =
314 self.create_evaluators(ctx, signer.clone()).await
315 {
316 error!(
317 msg_type = "Create",
318 error = %e,
319 signer = %signer,
320 "Failed to create evaluator"
321 );
322 }
323 }
324
325 debug!(
326 msg_type = "Create",
327 request_id = %request_id,
328 version = version,
329 evaluators_count = current_eval.len(),
330 "Evaluation created and evaluators initialized"
331 );
332 }
333 EvaluationMessage::Response {
334 evaluation_res,
335 sender,
336 signature,
337 } => {
338 if !self.reboot {
339 if self.check_evaluator(sender.clone()) {
341 match evaluation_res {
343 EvaluationRes::Response {
344 response,
345 eval_req_hash,
346 ..
347 } => {
348 let Some(signature) = signature else {
349 error!(
350 msg_type = "Response",
351 sender = %sender,
352 "Evaluation response without signature"
353 );
354 return Err(ActorError::Functional {
355 description: "Evaluation Response solver without signature".to_owned(),
356 });
357 };
358
359 if eval_req_hash != self.evaluation_request_hash
360 {
361 error!(
362 msg_type = "Response",
363 expected_hash = %self.evaluation_request_hash,
364 received_hash = %eval_req_hash,
365 "Invalid evaluation request hash"
366 );
367 return Err(ActorError::Functional {
368 description: "Evaluation Response, Invalid evaluation request hash".to_owned(),
369 });
370 }
371
372 self.evaluators_signatures.push(signature);
373 self.evaluators_response.push(response);
374 }
375 EvaluationRes::TimeOut => {
376 }
378 EvaluationRes::Abort(error) => {
379 if let Err(e) = abort_req(
380 ctx,
381 self.request_id.clone(),
382 sender.clone(),
383 error.clone(),
384 self.request.content().sn,
385 )
386 .await
387 {
388 error!(
389 msg_type = "Response",
390 request_id = %self.request_id,
391 sender = %sender,
392 abort_reason = %error,
393 error = %e,
394 "Failed to abort request"
395 );
396 return Err(emit_fail(ctx, e).await);
397 };
398
399 debug!(
400 msg_type = "Response",
401 request_id = %self.request_id,
402 sender = %sender,
403 abort_reason = %error,
404 "Evaluation aborted"
405 );
406
407 return Ok(());
408 }
409 EvaluationRes::Error {
410 error,
411 eval_req_hash,
412 ..
413 } => {
414 if let Some(signature) = signature {
415 self.evaluators_signatures.push(signature);
416 } else {
417 error!(
418 msg_type = "Response",
419 sender = %sender,
420 "Evaluation error without signature"
421 );
422 return Err(ActorError::Functional {
423 description: "Evaluation Error solver without signature".to_owned(),
424 });
425 }
426
427 if eval_req_hash != self.evaluation_request_hash
428 {
429 error!(
430 msg_type = "Response",
431 expected_hash = %self.evaluation_request_hash,
432 received_hash = %eval_req_hash,
433 "Invalid evaluation request hash"
434 );
435 return Err(ActorError::Functional {
436 description: "Evaluation Response, Invalid evaluation request hash".to_owned(),
437 });
438 }
439 self.errors.push(error);
440 }
441 EvaluationRes::Reboot => {
442 if let Err(e) = send_reboot_to_req(
443 ctx,
444 self.request_id.clone(),
445 self.request
446 .content()
447 .governance_id
448 .clone(),
449 RebootType::Normal,
450 )
451 .await
452 {
453 error!(
454 msg_type = "Response",
455 error = %e,
456 "Failed to send reboot to request actor"
457 );
458 return Err(emit_fail(ctx, e).await);
459 }
460
461 self.reboot = true;
462
463 return Ok(());
464 }
465 };
466
467 if self.quorum.check_quorum(
468 self.evaluators_quantity,
469 (self.evaluators_response.len() + self.errors.len())
470 as u32,
471 ) {
472 let summary = self.check_responses();
473 if matches!(summary, ResponseSummary::Reboot)
474 && let Err(e) = send_reboot_to_req(
475 ctx,
476 self.request_id.clone(),
477 self.request
478 .content()
479 .governance_id
480 .clone(),
481 RebootType::Diff,
482 )
483 .await
484 {
485 error!(
486 msg_type = "Response",
487 error = %e,
488 "Failed to send reboot to request actor"
489 );
490 return Err(emit_fail(ctx, e).await);
491 }
492
493 let response = match self
494 .build_evaluation_data(summary.is_ok())
495 {
496 Ok(response) => response,
497 Err(e) => {
498 error!(
499 msg_type = "Response",
500 error = %e,
501 "Failed to create evaluation response"
502 );
503 return Err(emit_fail(ctx, e).await);
504 }
505 };
506
507 if let Err(e) = self
508 .send_evaluation_to_req(ctx, response.clone())
509 .await
510 {
511 error!(
512 msg_type = "Response",
513 error = %e,
514 "Failed to send evaluation to request actor"
515 );
516 return Err(emit_fail(ctx, e).await);
517 };
518
519 debug!(
520 msg_type = "Response",
521 request_id = %self.request_id,
522 version = self.version,
523 is_ok = summary.is_ok(),
524 "Evaluation completed and sent to request"
525 );
526 } else if self.current_evaluators.is_empty()
527 && !self.pending_evaluators.is_empty()
528 {
529 let evaluators_quantity = self.quorum.get_signers(
530 self.evaluators_quantity,
531 self.pending_evaluators.len() as u32,
532 );
533
534 let (current_eval, pending_eval) =
535 take_random_signers(
536 self.pending_evaluators.clone(),
537 evaluators_quantity as usize,
538 );
539 self.current_evaluators.clone_from(¤t_eval);
540 self.pending_evaluators.clone_from(&pending_eval);
541
542 for signer in current_eval.clone() {
543 if let Err(e) = self
544 .create_evaluators(ctx, signer.clone())
545 .await
546 {
547 error!(
548 msg_type = "Response",
549 error = %e,
550 signer = %signer,
551 "Failed to create evaluator from pending pool"
552 );
553 }
554 }
555
556 debug!(
557 msg_type = "Response",
558 new_evaluators = current_eval.len(),
559 "Created additional evaluators from pending pool"
560 );
561 } else if self.current_evaluators.is_empty()
562 && let Err(e) = send_reboot_to_req(
563 ctx,
564 self.request_id.clone(),
565 self.request.content().governance_id.clone(),
566 RebootType::TimeOut,
567 )
568 .await
569 {
570 error!(
571 msg_type = "Response",
572 error = %e,
573 "Failed to send reboot to request actor"
574 );
575 return Err(emit_fail(ctx, e).await);
576 }
577 } else {
578 warn!(
579 msg_type = "Response",
580 sender = %sender,
581 "Response from unexpected sender"
582 );
583 }
584 }
585 }
586 }
587
588 Ok(())
589 }
590
591 async fn on_child_fault(
592 &mut self,
593 error: ActorError,
594 ctx: &mut ActorContext<Self>,
595 ) -> ChildAction {
596 error!(
597 request_id = %self.request_id,
598 version = self.version,
599 error = %error,
600 "Child fault in evaluation actor"
601 );
602 emit_fail(ctx, error).await;
603 ChildAction::Stop
604 }
605}
606
607#[cfg(test)]
608pub mod tests {
609 use std::{str::FromStr, sync::Arc, time::Duration};
610
611 use ave_actors::{ActorPath, ActorRef, SystemRef};
612 use ave_common::{
613 Namespace, SchemaType, ValueWrapper,
614 bridge::request::{ApprovalState, ApprovalStateRes},
615 identity::{DigestIdentifier, PublicKey, Signed},
616 request::{CreateRequest, FactRequest, TransferRequest},
617 response::{EvalResDB, RequestEventDB, RequestState},
618 };
619 use serde_json::json;
620 use tempfile::TempDir;
621 use test_log::test;
622
623 use crate::{
624 EventRequest, NodeMessage, NodeResponse,
625 governance::{
626 Governance, GovernanceMessage, GovernanceResponse,
627 data::GovernanceData,
628 },
629 helpers::db::{ExternalDB, ReadStore},
630 model::common::node::SignTypesNode,
631 node::Node,
632 request::{
633 RequestData, RequestHandler, RequestHandlerMessage,
634 RequestHandlerResponse,
635 tracking::{
636 RequestTracking, RequestTrackingMessage,
637 RequestTrackingResponse,
638 },
639 },
640 tracker::{Tracker, TrackerMessage, TrackerResponse},
641 validation::tests::create_gov,
642 };
643
644 async fn get_subject_state(
645 db: &Arc<ExternalDB>,
646 subject_id: &DigestIdentifier,
647 expected_sn: u64,
648 ) -> ave_common::response::SubjectDB {
649 let started = tokio::time::Instant::now();
650 loop {
651 match db.get_subject_state(&subject_id.to_string()).await {
652 Ok(state) if state.sn >= expected_sn => return state,
653 Ok(_) | Err(_) if started.elapsed() < Duration::from_secs(5) => {
654 tokio::time::sleep(Duration::from_millis(10)).await;
655 }
656 Ok(state) => {
657 panic!(
658 "subject state not updated in time for {}: expected sn >= {}, got {}",
659 subject_id, expected_sn, state.sn
660 );
661 }
662 Err(error) => {
663 panic!(
664 "subject state not available in time for {}: {}",
665 subject_id, error
666 );
667 }
668 }
669 }
670 }
671
672 async fn get_event_sn(
673 db: &Arc<ExternalDB>,
674 subject_id: &DigestIdentifier,
675 sn: u64,
676 ) -> ave_common::response::LedgerDB {
677 let started = tokio::time::Instant::now();
678 loop {
679 match db.get_event_sn(&subject_id.to_string(), sn).await {
680 Ok(event) => return event,
681 Err(_) if started.elapsed() < Duration::from_secs(5) => {
682 tokio::time::sleep(Duration::from_millis(10)).await;
683 }
684 Err(error) => {
685 panic!(
686 "event {} for {} not available in time: {}",
687 sn, subject_id, error
688 );
689 }
690 }
691 }
692 }
693
694 pub async fn emit_request(
695 request: EventRequest,
696 node_actor: &ActorRef<Node>,
697 request_actor: &ActorRef<RequestHandler>,
698 tracking_actor: &ActorRef<RequestTracking>,
699 wait_request_state: bool,
700 ) -> RequestData {
701 let response = node_actor
702 .ask(NodeMessage::SignRequest(SignTypesNode::EventRequest(
703 request.clone(),
704 )))
705 .await
706 .unwrap();
707 let NodeResponse::SignRequest(signature) = response else {
708 panic!("Invalid Response")
709 };
710
711 let signed_event_req = Signed::from_parts(request, signature);
712
713 let RequestHandlerResponse::Ok(request_data) = request_actor
714 .ask(RequestHandlerMessage::NewRequest {
715 request: signed_event_req.clone(),
716 })
717 .await
718 .unwrap()
719 else {
720 panic!("Invalid response")
721 };
722
723 if wait_request_state {
724 wait_request(tracking_actor, request_data.request_id.clone()).await;
725 }
726
727 request_data
728 }
729
730 pub async fn wait_request(
731 tracking_actor: &ActorRef<RequestTracking>,
732 request_id: DigestIdentifier,
733 ) {
734 loop {
735 if let Ok(RequestTrackingResponse::Info(state)) = tracking_actor
736 .ask(RequestTrackingMessage::SearchRequest(request_id.clone()))
737 .await
738 {
739 match state.state {
740 RequestState::Approval
741 | RequestState::Abort { .. }
742 | RequestState::Invalid { .. }
743 | RequestState::Finish => break,
744 _ => {}
745 }
746 } else {
747 tokio::time::sleep(Duration::from_secs(1)).await;
748 };
749 }
750 }
751
752 #[test(tokio::test)]
753 async fn test_fact_gov() {
754 let (
755 _system,
756 node_actor,
757 request_actor,
758 db,
759 subject_actor,
760 tracking,
761 subject_id,
762 _dir,
763 ) = create_gov().await;
764
765 let payload = ValueWrapper(json!({
766 "members": {
767 "add": [
768 {
769 "name": "AveNode1",
770 "key": "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
771 }
772 ]
773 }
774 }));
775 let fact_request = EventRequest::Fact(FactRequest {
776 subject_id: subject_id.clone(),
777 payload: payload.clone(),
778 });
779
780 let request_data = emit_request(
781 fact_request,
782 &node_actor,
783 &request_actor,
784 &tracking,
785 true,
786 )
787 .await;
788
789 let RequestHandlerResponse::Approval(Some((.., state))) = request_actor
790 .ask(RequestHandlerMessage::GetApproval {
791 subject_id: subject_id.clone(),
792 state: Some(ApprovalState::Pending),
793 })
794 .await
795 .unwrap()
796 else {
797 panic!("Invalid response")
798 };
799
800 assert_eq!(state.to_string(), "pending");
801
802 let RequestHandlerResponse::Response(res) = request_actor
803 .ask(RequestHandlerMessage::ChangeApprovalState {
804 subject_id: subject_id.clone(),
805 state: ApprovalStateRes::Accepted,
806 })
807 .await
808 .unwrap()
809 else {
810 panic!("Invalid response")
811 };
812
813 assert_eq!(
814 res,
815 format!(
816 "The approval request for subject {} has changed to accepted",
817 subject_id.to_string()
818 )
819 );
820
821 wait_request(&tracking, request_data.request_id).await;
822
823 let GovernanceResponse::Metadata(metadata) = subject_actor
824 .ask(GovernanceMessage::GetMetadata)
825 .await
826 .unwrap()
827 else {
828 panic!("Invalid response")
829 };
830
831 let subject_data = get_subject_state(&db, &subject_id, 1).await;
832 let event = get_event_sn(&db, &subject_id, 1).await;
833
834 let RequestEventDB::GovernanceFact {
835 payload: request_payload,
836 evaluation_response,
837 approval_success,
838 } = event.event
839 else {
840 panic!()
841 };
842
843 let EvalResDB::Patch(_) = evaluation_response else {
844 panic!("");
845 };
846
847 assert!(approval_success.unwrap());
848
849 assert_eq!(metadata.name, subject_data.name);
850 assert_eq!(metadata.name.unwrap(), "Name");
851
852 assert_eq!(metadata.description, subject_data.description);
853 assert_eq!(metadata.description.unwrap(), "Description");
854
855 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
856 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
857 assert_eq!(metadata.subject_id, subject_id);
858
859 assert_eq!(
860 metadata.governance_id.to_string(),
861 subject_data.governance_id
862 );
863 assert_eq!(metadata.governance_id, subject_id);
864
865 assert_eq!(
866 metadata.genesis_gov_version,
867 subject_data.genesis_gov_version
868 );
869 assert_eq!(metadata.genesis_gov_version, 0);
870
871 assert_eq!(
872 metadata.schema_id.to_string(),
873 subject_data.schema_id.to_string()
874 );
875 assert_eq!(metadata.schema_id, SchemaType::Governance);
876
877 assert_eq!(
878 metadata.namespace.to_string(),
879 subject_data.namespace.to_string()
880 );
881 assert_eq!(metadata.namespace, Namespace::new());
882
883 assert!(subject_data.new_owner.is_none());
884 assert!(metadata.new_owner.is_none());
885
886 assert_eq!(metadata.sn, event.sn);
887 assert_eq!(metadata.sn, subject_data.sn);
888 assert_eq!(metadata.sn, 1);
889
890 assert!(subject_data.active);
891 assert!(metadata.active);
892
893 assert_eq!(payload.0, request_payload);
894 assert_eq!(metadata.properties.0, subject_data.properties);
895 let gov = GovernanceData::try_from(metadata.properties).unwrap();
896 assert_eq!(gov.version, 1);
897 assert!(!gov.members.is_empty());
899 assert!(gov.roles_schema.is_empty());
900 assert!(gov.schemas.is_empty());
901 assert!(gov.policies_schema.is_empty());
902 }
903
904 #[test(tokio::test)]
905 async fn test_fact_fail_gov() {
906 let (
907 _system,
908 node_actor,
909 request_actor,
910 db,
911 subject_actor,
912 tracking,
913 subject_id,
914 _dir,
915 ) = create_gov().await;
916
917 let payload = ValueWrapper(json!({
918 "members": {
919 "add": [
920 {
921 "name": "Owner",
922 "key": "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
923 }
924 ]
925 }
926 }));
927 let fact_request = EventRequest::Fact(FactRequest {
928 subject_id: subject_id.clone(),
929 payload: payload.clone(),
930 });
931
932 let _request_data = emit_request(
933 fact_request,
934 &node_actor,
935 &request_actor,
936 &tracking,
937 true,
938 )
939 .await;
940
941 let GovernanceResponse::Metadata(metadata) = subject_actor
942 .ask(GovernanceMessage::GetMetadata)
943 .await
944 .unwrap()
945 else {
946 panic!("Invalid response")
947 };
948
949 let subject_data = get_subject_state(&db, &subject_id, 1).await;
950 let event = get_event_sn(&db, &subject_id, 1).await;
951
952 let RequestEventDB::GovernanceFact {
953 payload: request_payload,
954 evaluation_response,
955 approval_success,
956 } = event.event
957 else {
958 panic!()
959 };
960
961 let EvalResDB::Error(e) = evaluation_response else {
962 panic!("");
963 };
964
965 assert_eq!(
966 "runner error: invalid event: [check_members] invalid event: member name cannot be 'Owner' (reserved word)",
967 e
968 );
969 assert!(approval_success.is_none());
970
971 assert_eq!(metadata.name, subject_data.name);
972 assert_eq!(metadata.name.unwrap(), "Name");
973
974 assert_eq!(metadata.description, subject_data.description);
975 assert_eq!(metadata.description.unwrap(), "Description");
976
977 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
978 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
979 assert_eq!(metadata.subject_id, subject_id);
980
981 assert_eq!(
982 metadata.governance_id.to_string(),
983 subject_data.governance_id
984 );
985 assert_eq!(metadata.governance_id, subject_id);
986
987 assert_eq!(
988 metadata.genesis_gov_version,
989 subject_data.genesis_gov_version
990 );
991 assert_eq!(metadata.genesis_gov_version, 0);
992
993 assert_eq!(
994 metadata.schema_id.to_string(),
995 subject_data.schema_id.to_string()
996 );
997 assert_eq!(metadata.schema_id, SchemaType::Governance);
998
999 assert_eq!(
1000 metadata.namespace.to_string(),
1001 subject_data.namespace.to_string()
1002 );
1003 assert_eq!(metadata.namespace, Namespace::new());
1004
1005 assert!(subject_data.new_owner.is_none());
1006 assert!(metadata.new_owner.is_none());
1007
1008 assert_eq!(metadata.sn, event.sn);
1009 assert_eq!(metadata.sn, subject_data.sn);
1010 assert_eq!(metadata.sn, 1);
1011
1012 assert!(subject_data.active);
1013 assert!(metadata.active);
1014
1015 assert_eq!(payload.0, request_payload);
1016 assert_eq!(metadata.properties.0, subject_data.properties);
1017 let gov = GovernanceData::try_from(metadata.properties).unwrap();
1018 assert_eq!(gov.version, 0);
1019 assert!(!gov.members.is_empty());
1021 assert!(gov.roles_schema.is_empty());
1022 assert!(gov.schemas.is_empty());
1023 assert!(gov.policies_schema.is_empty());
1024 }
1025
1026 #[test(tokio::test)]
1027 async fn test_transfer_gov() {
1028 let (
1029 _system,
1030 node_actor,
1031 request_actor,
1032 db,
1033 subject_actor,
1034 tracking,
1035 subject_id,
1036 _dir,
1037 ) = create_gov().await;
1038
1039 let fact_request = EventRequest::Fact(FactRequest {
1040 subject_id: subject_id.clone(),
1041 payload: ValueWrapper(json!({
1042 "members": {
1043 "add": [
1044 {
1045 "name": "TestMember",
1046 "key": "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
1047 }
1048 ]
1049 }
1050 })),
1051 });
1052
1053 let _request_data = emit_request(
1054 fact_request,
1055 &node_actor,
1056 &request_actor,
1057 &tracking,
1058 true,
1059 )
1060 .await;
1061
1062 let RequestHandlerResponse::Response(res) = request_actor
1063 .ask(RequestHandlerMessage::ChangeApprovalState {
1064 subject_id: subject_id.clone(),
1065 state: ApprovalStateRes::Accepted,
1066 })
1067 .await
1068 .unwrap()
1069 else {
1070 panic!("Invalid response")
1071 };
1072
1073 assert_eq!(
1074 res,
1075 format!(
1076 "The approval request for subject {} has changed to accepted",
1077 subject_id.to_string()
1078 )
1079 );
1080
1081 let transfer_request = EventRequest::Transfer(TransferRequest {
1082 subject_id: subject_id.clone(),
1083 new_owner: PublicKey::from_str(
1084 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE",
1085 )
1086 .unwrap(),
1087 });
1088
1089 let _request_data = emit_request(
1090 transfer_request.clone(),
1091 &node_actor,
1092 &request_actor,
1093 &tracking,
1094 true,
1095 )
1096 .await;
1097
1098 let GovernanceResponse::Metadata(metadata) = subject_actor
1099 .ask(GovernanceMessage::GetMetadata)
1100 .await
1101 .unwrap()
1102 else {
1103 panic!("Invalid response")
1104 };
1105
1106 let subject_data = get_subject_state(&db, &subject_id, 2).await;
1107 let event = get_event_sn(&db, &subject_id, 2).await;
1108
1109 let RequestEventDB::Transfer {
1110 evaluation_error,
1111 new_owner: new_owner_transfer,
1112 } = event.event
1113 else {
1114 panic!()
1115 };
1116
1117 assert!(evaluation_error.is_none());
1118
1119 assert_eq!(metadata.name, subject_data.name);
1120 assert_eq!(metadata.name.unwrap(), "Name");
1121
1122 assert_eq!(metadata.description, subject_data.description);
1123 assert_eq!(metadata.description.unwrap(), "Description");
1124
1125 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
1126 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
1127 assert_eq!(metadata.subject_id, subject_id);
1128
1129 assert_eq!(
1130 metadata.governance_id.to_string(),
1131 subject_data.governance_id
1132 );
1133 assert_eq!(metadata.governance_id, subject_id);
1134
1135 assert_eq!(
1136 metadata.genesis_gov_version,
1137 subject_data.genesis_gov_version
1138 );
1139 assert_eq!(metadata.genesis_gov_version, 0);
1140
1141 assert_eq!(
1142 metadata.schema_id.to_string(),
1143 subject_data.schema_id.to_string()
1144 );
1145 assert_eq!(metadata.schema_id, SchemaType::Governance);
1146
1147 assert_eq!(
1148 metadata.namespace.to_string(),
1149 subject_data.namespace.to_string()
1150 );
1151 assert_eq!(metadata.namespace, Namespace::new());
1152
1153 assert_eq!(
1154 new_owner_transfer,
1155 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
1156 );
1157 assert_eq!(
1158 subject_data.new_owner.unwrap(),
1159 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
1160 );
1161 assert_eq!(
1162 metadata.new_owner.unwrap().to_string(),
1163 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
1164 );
1165
1166 assert_eq!(metadata.sn, event.sn);
1167 assert_eq!(metadata.sn, subject_data.sn);
1168 assert_eq!(metadata.sn, 2);
1169
1170 assert!(subject_data.active);
1171 assert!(metadata.active);
1172
1173 assert_eq!(metadata.properties.0, subject_data.properties);
1174 let gov = GovernanceData::try_from(metadata.properties).unwrap();
1175 assert_eq!(gov.version, 2);
1176 assert!(!gov.members.is_empty());
1178 assert!(gov.roles_schema.is_empty());
1179 assert!(gov.schemas.is_empty());
1180 assert!(gov.policies_schema.is_empty());
1181
1182 let response = node_actor
1183 .ask(NodeMessage::SignRequest(SignTypesNode::EventRequest(
1184 transfer_request.clone(),
1185 )))
1186 .await
1187 .unwrap();
1188 let NodeResponse::SignRequest(signature) = response else {
1189 panic!("Invalid Response")
1190 };
1191
1192 let signed_event_req = Signed::from_parts(transfer_request, signature);
1193
1194 if !request_actor
1195 .ask(RequestHandlerMessage::NewRequest {
1196 request: signed_event_req.clone(),
1197 })
1198 .await
1199 .is_err()
1200 {
1201 panic!("Invalid response")
1202 }
1203 }
1204
1205 #[test(tokio::test)]
1206 async fn test_transfer_fail_gov() {
1207 let (
1208 _system,
1209 node_actor,
1210 request_actor,
1211 db,
1212 subject_actor,
1213 tracking,
1214 subject_id,
1215 _dir,
1216 ) = create_gov().await;
1217
1218 let fact_request = EventRequest::Fact(FactRequest {
1219 subject_id: subject_id.clone(),
1220 payload: ValueWrapper(json!({
1221 "members": {
1222 "add": [
1223 {
1224 "name": "TestMember",
1225 "key": "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
1226 }
1227 ]
1228 }
1229 })),
1230 });
1231
1232 let _request_data = emit_request(
1233 fact_request,
1234 &node_actor,
1235 &request_actor,
1236 &tracking,
1237 true,
1238 )
1239 .await;
1240
1241 let RequestHandlerResponse::Response(res) = request_actor
1242 .ask(RequestHandlerMessage::ChangeApprovalState {
1243 subject_id: subject_id.clone(),
1244 state: ApprovalStateRes::Accepted,
1245 })
1246 .await
1247 .unwrap()
1248 else {
1249 panic!("Invalid response")
1250 };
1251
1252 assert_eq!(
1253 res,
1254 format!(
1255 "The approval request for subject {} has changed to accepted",
1256 subject_id.to_string()
1257 )
1258 );
1259
1260 let transfer_request = EventRequest::Transfer(TransferRequest {
1261 subject_id: subject_id.clone(),
1262 new_owner: PublicKey::from_str(
1263 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbA",
1264 )
1265 .unwrap(),
1266 });
1267
1268 let _request_data = emit_request(
1269 transfer_request,
1270 &node_actor,
1271 &request_actor,
1272 &tracking,
1273 true,
1274 )
1275 .await;
1276
1277 let GovernanceResponse::Metadata(metadata) = subject_actor
1278 .ask(GovernanceMessage::GetMetadata)
1279 .await
1280 .unwrap()
1281 else {
1282 panic!("Invalid response")
1283 };
1284
1285 let subject_data = get_subject_state(&db, &subject_id, 2).await;
1286 let event = get_event_sn(&db, &subject_id, 2).await;
1287
1288 let RequestEventDB::Transfer {
1289 evaluation_error,
1290 new_owner: new_owner_transfer,
1291 } = event.event
1292 else {
1293 panic!()
1294 };
1295
1296 assert_eq!(
1297 "runner error: invalid event: [execute_transfer_gov] invalid event: 'new owner EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbA' is not a member of governance",
1298 evaluation_error.unwrap()
1299 );
1300
1301 assert_eq!(metadata.name, subject_data.name);
1302 assert_eq!(metadata.name.unwrap(), "Name");
1303
1304 assert_eq!(metadata.description, subject_data.description);
1305 assert_eq!(metadata.description.unwrap(), "Description");
1306
1307 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
1308 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
1309 assert_eq!(metadata.subject_id, subject_id);
1310
1311 assert_eq!(
1312 metadata.governance_id.to_string(),
1313 subject_data.governance_id
1314 );
1315 assert_eq!(metadata.governance_id, subject_id);
1316
1317 assert_eq!(
1318 metadata.genesis_gov_version,
1319 subject_data.genesis_gov_version
1320 );
1321 assert_eq!(metadata.genesis_gov_version, 0);
1322
1323 assert_eq!(
1324 metadata.schema_id.to_string(),
1325 subject_data.schema_id.to_string()
1326 );
1327 assert_eq!(metadata.schema_id, SchemaType::Governance);
1328
1329 assert_eq!(
1330 metadata.namespace.to_string(),
1331 subject_data.namespace.to_string()
1332 );
1333 assert_eq!(metadata.namespace, Namespace::new());
1334
1335 assert_eq!(
1336 new_owner_transfer,
1337 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbA"
1338 );
1339 assert!(subject_data.new_owner.is_none());
1340 assert!(metadata.new_owner.is_none());
1341
1342 assert_eq!(metadata.sn, event.sn);
1343 assert_eq!(metadata.sn, subject_data.sn);
1344 assert_eq!(metadata.sn, 2);
1345
1346 assert!(subject_data.active);
1347 assert!(metadata.active);
1348
1349 assert_eq!(metadata.properties.0, subject_data.properties);
1350 let gov = GovernanceData::try_from(metadata.properties).unwrap();
1351 assert_eq!(gov.version, 1);
1352 assert!(!gov.members.is_empty());
1354 assert!(gov.roles_schema.is_empty());
1355 assert!(gov.schemas.is_empty());
1356 assert!(gov.policies_schema.is_empty());
1357 }
1358
1359 async fn init_gov_with_member_and_schema() -> (
1360 SystemRef,
1361 ActorRef<Node>,
1362 ActorRef<RequestHandler>,
1363 Arc<ExternalDB>,
1364 ActorRef<Governance>,
1365 ActorRef<RequestTracking>,
1366 DigestIdentifier,
1367 Vec<TempDir>,
1368 ) {
1369 let (
1370 system,
1371 node_actor,
1372 request_actor,
1373 db,
1374 subject_actor,
1375 tracking,
1376 subject_id,
1377 _dir,
1378 ) = create_gov().await;
1379
1380 let fact_request = EventRequest::Fact(FactRequest {
1381 subject_id: subject_id.clone(),
1382 payload: ValueWrapper(json!({
1383 "members": {
1384 "add": [
1385 {
1386 "name": "TestMember",
1387 "key": "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
1388 }
1389 ]
1390 },
1391 "schemas": {
1392 "add": [
1393 {
1394 "id": "Example",
1395 "contract": "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",
1396 "initial_value": {
1397 "one": 0,
1398 "two": 0,
1399 "three": 0
1400 }
1401 }
1402 ]
1403 },
1404 "roles": {
1405 "tracker_schemas": {
1406 "add": {
1407 "evaluator": [
1408 {
1409 "name": "Owner",
1410 "namespace": []
1411 }
1412 ],
1413 "validator": [
1414 {
1415 "name": "Owner",
1416 "namespace": []
1417 }
1418 ],
1419 "witness": [
1420 {
1421 "name": "Owner",
1422 "namespace": []
1423 }
1424 ],
1425 }
1426 },
1427 "schema":
1428 [
1429 {
1430 "schema_id": "Example",
1431 "add": {
1432 "creator": [
1433 {
1434 "name": "Owner",
1435 "namespace": [],
1436 "quantity": 2
1437 },
1438 {
1439 "name": "TestMember",
1440 "namespace": [],
1441 "quantity": 2
1442 }
1443 ],
1444 "issuer": [
1445 {
1446 "name": "Owner",
1447 "namespace": [],
1448 }
1449 ]
1450 }
1451 }
1452 ]
1453 }
1454 })),
1455 });
1456
1457 let request_data = emit_request(
1458 fact_request,
1459 &node_actor,
1460 &request_actor,
1461 &tracking,
1462 true,
1463 )
1464 .await;
1465
1466 let RequestHandlerResponse::Approval(Some((.., state))) = request_actor
1467 .ask(RequestHandlerMessage::GetApproval {
1468 subject_id: subject_id.clone(),
1469 state: Some(ApprovalState::Pending),
1470 })
1471 .await
1472 .unwrap()
1473 else {
1474 panic!("Invalid response")
1475 };
1476
1477 assert_eq!(state.to_string(), "pending");
1478
1479 let RequestHandlerResponse::Response(res) = request_actor
1480 .ask(RequestHandlerMessage::ChangeApprovalState {
1481 subject_id: subject_id.clone(),
1482 state: ApprovalStateRes::Accepted,
1483 })
1484 .await
1485 .unwrap()
1486 else {
1487 panic!("Invalid response")
1488 };
1489
1490 assert_eq!(
1491 res,
1492 format!(
1493 "The approval request for subject {} has changed to accepted",
1494 subject_id.to_string()
1495 )
1496 );
1497
1498 wait_request(&tracking, request_data.request_id).await;
1499
1500 let GovernanceResponse::Metadata(metadata) = subject_actor
1501 .ask(GovernanceMessage::GetMetadata)
1502 .await
1503 .unwrap()
1504 else {
1505 panic!("Invalid response")
1506 };
1507 let subject_data = get_subject_state(&db, &subject_id, 1).await;
1508
1509 assert_eq!(metadata.name, subject_data.name);
1510 assert_eq!(metadata.name.unwrap(), "Name");
1511
1512 assert_eq!(metadata.description, subject_data.description);
1513 assert_eq!(metadata.description.unwrap(), "Description");
1514
1515 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
1516 assert_eq!(metadata.subject_id, subject_id);
1517
1518 assert_eq!(
1519 metadata.governance_id.to_string(),
1520 subject_data.governance_id
1521 );
1522 assert_eq!(metadata.governance_id, subject_id);
1523
1524 assert_eq!(
1525 metadata.genesis_gov_version,
1526 subject_data.genesis_gov_version
1527 );
1528 assert_eq!(metadata.genesis_gov_version, 0);
1529
1530 assert_eq!(
1531 metadata.schema_id.to_string(),
1532 subject_data.schema_id.to_string()
1533 );
1534 assert_eq!(metadata.schema_id, SchemaType::Governance);
1535
1536 assert_eq!(
1537 metadata.namespace.to_string(),
1538 subject_data.namespace.to_string()
1539 );
1540 assert_eq!(metadata.namespace, Namespace::new());
1541
1542 assert!(subject_data.new_owner.is_none());
1543 assert!(metadata.new_owner.is_none());
1544
1545 assert_eq!(metadata.sn, subject_data.sn);
1546 assert_eq!(metadata.sn, 1);
1547
1548 assert!(subject_data.active);
1549 assert!(metadata.active);
1550
1551 assert_eq!(metadata.properties.0, subject_data.properties);
1552 let gov = GovernanceData::try_from(metadata.properties).unwrap();
1553 assert_eq!(gov.version, 1);
1554 assert!(!gov.members.is_empty());
1556 assert!(!gov.roles_schema.is_empty());
1557 assert!(!gov.schemas.is_empty());
1558 assert!(!gov.policies_schema.is_empty());
1559
1560 (
1561 system,
1562 node_actor,
1563 request_actor,
1564 db,
1565 subject_actor,
1566 tracking,
1567 subject_id,
1568 _dir,
1569 )
1570 }
1571
1572 #[test(tokio::test)]
1573 async fn test_fact_gov_2() {
1574 init_gov_with_member_and_schema().await;
1575 }
1576
1577 async fn create_tracker() -> (
1578 SystemRef,
1579 ActorRef<Node>,
1580 ActorRef<RequestHandler>,
1581 Arc<ExternalDB>,
1582 ActorRef<Tracker>,
1583 ActorRef<RequestTracking>,
1584 DigestIdentifier,
1585 DigestIdentifier,
1586 Vec<TempDir>,
1587 ) {
1588 let (
1589 system,
1590 node_actor,
1591 request_actor,
1592 db,
1593 _subject_actor,
1594 tracking,
1595 gov_id,
1596 _dir,
1597 ) = init_gov_with_member_and_schema().await;
1598
1599 let create_request = EventRequest::Create(CreateRequest {
1600 name: Some("Subject Name".to_owned()),
1601 description: Some("Subject Description".to_owned()),
1602 governance_id: gov_id.clone(),
1603 schema_id: SchemaType::Type("Example".to_owned()),
1604 namespace: Namespace::new(),
1605 });
1606
1607 let request_data = emit_request(
1608 create_request,
1609 &node_actor,
1610 &request_actor,
1611 &tracking,
1612 true,
1613 )
1614 .await;
1615
1616 let subject_actor: ActorRef<Tracker> = system
1617 .get_actor(&ActorPath::from(format!(
1618 "/user/node/{}",
1619 request_data.subject_id
1620 )))
1621 .await
1622 .unwrap();
1623
1624 let subject_id = request_data.subject_id.clone();
1625
1626 let TrackerResponse::Metadata(metadata) = subject_actor
1627 .ask(TrackerMessage::GetMetadata)
1628 .await
1629 .unwrap()
1630 else {
1631 panic!("Invalid response")
1632 };
1633
1634 let subject_data = get_subject_state(&db, &subject_id, 0).await;
1635 let event = get_event_sn(&db, &subject_id, 0).await;
1636
1637 let RequestEventDB::Create {
1638 name,
1639 description,
1640 schema_id,
1641 namespace,
1642 } = event.event
1643 else {
1644 panic!()
1645 };
1646
1647 assert_eq!(metadata.name, name);
1648 assert_eq!(metadata.name, subject_data.name);
1649 assert_eq!(metadata.name.unwrap(), "Subject Name");
1650
1651 assert_eq!(metadata.description, description);
1652 assert_eq!(metadata.description, subject_data.description);
1653 assert_eq!(metadata.description.unwrap(), "Subject Description");
1654
1655 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
1656 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
1657 assert_eq!(metadata.subject_id, subject_id);
1658
1659 assert_eq!(
1660 metadata.governance_id.to_string(),
1661 subject_data.governance_id
1662 );
1663 assert_eq!(metadata.governance_id, gov_id);
1664
1665 assert_eq!(
1666 metadata.genesis_gov_version,
1667 subject_data.genesis_gov_version
1668 );
1669 assert_eq!(metadata.genesis_gov_version, 1);
1670
1671 assert_eq!(metadata.schema_id.to_string(), schema_id);
1672 assert_eq!(
1673 metadata.schema_id.to_string(),
1674 subject_data.schema_id.to_string()
1675 );
1676 assert_eq!(metadata.schema_id, SchemaType::Type("Example".to_string()));
1677
1678 assert_eq!(metadata.namespace.to_string(), namespace);
1679 assert_eq!(
1680 metadata.namespace.to_string(),
1681 subject_data.namespace.to_string()
1682 );
1683 assert_eq!(metadata.namespace, Namespace::new());
1684
1685 assert!(subject_data.new_owner.is_none());
1686 assert!(metadata.new_owner.is_none());
1687
1688 assert_eq!(metadata.sn, event.sn);
1689 assert_eq!(metadata.sn, subject_data.sn);
1690 assert_eq!(metadata.sn, 0);
1691
1692 assert!(subject_data.active);
1693 assert!(metadata.active);
1694
1695 assert_eq!(metadata.properties.0, subject_data.properties);
1696 assert!(metadata.properties.0["one"].as_u64().unwrap() == 0);
1697 assert!(metadata.properties.0["two"].as_u64().unwrap() == 0);
1698 assert!(metadata.properties.0["three"].as_u64().unwrap() == 0);
1699
1700 (
1701 system,
1702 node_actor,
1703 request_actor,
1704 db,
1705 subject_actor,
1706 tracking,
1707 request_data.subject_id,
1708 gov_id,
1709 _dir,
1710 )
1711 }
1712
1713 #[test(tokio::test)]
1714 async fn test_create_tracker() {
1715 let _ = create_tracker().await;
1716 }
1717
1718 #[test(tokio::test)]
1719 async fn test_fact_tracker() {
1720 let (
1721 _system,
1722 node_actor,
1723 request_actor,
1724 db,
1725 subject_actor,
1726 tracking,
1727 subject_id,
1728 gov_id,
1729 _dir,
1730 ) = create_tracker().await;
1731
1732 let payload = json!({
1733 "ModOne": {
1734 "data": 100
1735 }
1736 });
1737
1738 let fact_request = EventRequest::Fact(FactRequest {
1739 subject_id: subject_id.clone(),
1740 payload: ValueWrapper(payload.clone()),
1741 });
1742
1743 let request_data = emit_request(
1744 fact_request,
1745 &node_actor,
1746 &request_actor,
1747 &tracking,
1748 true,
1749 )
1750 .await;
1751
1752 let TrackerResponse::Metadata(metadata) = subject_actor
1753 .ask(TrackerMessage::GetMetadata)
1754 .await
1755 .unwrap()
1756 else {
1757 panic!("Invalid response")
1758 };
1759
1760 let subject_data =
1761 get_subject_state(&db, &request_data.subject_id, 1).await;
1762 let event = get_event_sn(&db, &subject_id, 1).await;
1763
1764 let RequestEventDB::TrackerFact {
1765 payload: payload_db,
1766 evaluation_response,
1767 } = event.event
1768 else {
1769 panic!()
1770 };
1771
1772 let EvalResDB::Patch(_) = evaluation_response else {
1773 panic!("");
1774 };
1775
1776 assert_eq!(metadata.name, subject_data.name);
1777 assert_eq!(metadata.name.unwrap(), "Subject Name");
1778
1779 assert_eq!(metadata.description, subject_data.description);
1780 assert_eq!(metadata.description.unwrap(), "Subject Description");
1781
1782 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
1783 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
1784 assert_eq!(metadata.subject_id, subject_id);
1785
1786 assert_eq!(
1787 metadata.governance_id.to_string(),
1788 subject_data.governance_id
1789 );
1790 assert_eq!(metadata.governance_id, gov_id);
1791
1792 assert_eq!(
1793 metadata.genesis_gov_version,
1794 subject_data.genesis_gov_version
1795 );
1796 assert_eq!(metadata.genesis_gov_version, 1);
1797
1798 assert_eq!(
1799 metadata.schema_id.to_string(),
1800 subject_data.schema_id.to_string()
1801 );
1802 assert_eq!(metadata.schema_id, SchemaType::Type("Example".to_string()));
1803
1804 assert_eq!(
1805 metadata.namespace.to_string(),
1806 subject_data.namespace.to_string()
1807 );
1808 assert_eq!(metadata.namespace, Namespace::new());
1809
1810 assert!(subject_data.new_owner.is_none());
1811 assert!(metadata.new_owner.is_none());
1812
1813 assert_eq!(metadata.sn, event.sn);
1814 assert_eq!(metadata.sn, subject_data.sn);
1815 assert_eq!(metadata.sn, 1);
1816
1817 assert!(subject_data.active);
1818 assert!(metadata.active);
1819
1820 assert_eq!(payload, payload_db);
1821 assert_eq!(metadata.properties.0, subject_data.properties);
1822 assert!(metadata.properties.0["one"].as_u64().unwrap() == 100);
1823 assert!(metadata.properties.0["two"].as_u64().unwrap() == 0);
1824 assert!(metadata.properties.0["three"].as_u64().unwrap() == 0);
1825 }
1826
1827 #[test(tokio::test)]
1828 async fn test_fact_fail_tracker() {
1829 let (
1830 _system,
1831 node_actor,
1832 request_actor,
1833 db,
1834 subject_actor,
1835 tracking,
1836 subject_id,
1837 gov_id,
1838 _dir,
1839 ) = create_tracker().await;
1840
1841 let payload = json!({
1842 "ModOne": {
1843 "not_exist": "error"
1844 }
1845 });
1846
1847 let fact_request = EventRequest::Fact(FactRequest {
1848 subject_id: subject_id.clone(),
1849 payload: ValueWrapper(payload.clone()),
1850 });
1851
1852 let request_data = emit_request(
1853 fact_request,
1854 &node_actor,
1855 &request_actor,
1856 &tracking,
1857 true,
1858 )
1859 .await;
1860
1861 let TrackerResponse::Metadata(metadata) = subject_actor
1862 .ask(TrackerMessage::GetMetadata)
1863 .await
1864 .unwrap()
1865 else {
1866 panic!("Invalid response")
1867 };
1868
1869 let subject_data =
1870 get_subject_state(&db, &request_data.subject_id, 1).await;
1871 let event = get_event_sn(&db, &subject_id, 1).await;
1872
1873 let RequestEventDB::TrackerFact {
1874 payload: payload_db,
1875 evaluation_response,
1876 } = event.event
1877 else {
1878 panic!()
1879 };
1880
1881 let EvalResDB::Error(e) = evaluation_response else {
1882 panic!("");
1883 };
1884
1885 assert_eq!(
1886 "runner error: contract failed: contract returned failure: Contract execution in running was not successful: Can not convert Event from value",
1887 e
1888 );
1889 assert_eq!(metadata.name, subject_data.name);
1890 assert_eq!(metadata.name.unwrap(), "Subject Name");
1891
1892 assert_eq!(metadata.description, subject_data.description);
1893 assert_eq!(metadata.description.unwrap(), "Subject Description");
1894
1895 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
1896 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
1897 assert_eq!(metadata.subject_id, subject_id);
1898
1899 assert_eq!(
1900 metadata.governance_id.to_string(),
1901 subject_data.governance_id
1902 );
1903 assert_eq!(metadata.governance_id, gov_id);
1904
1905 assert_eq!(
1906 metadata.genesis_gov_version,
1907 subject_data.genesis_gov_version
1908 );
1909 assert_eq!(metadata.genesis_gov_version, 1);
1910
1911 assert_eq!(
1912 metadata.schema_id.to_string(),
1913 subject_data.schema_id.to_string()
1914 );
1915 assert_eq!(metadata.schema_id, SchemaType::Type("Example".to_string()));
1916
1917 assert_eq!(
1918 metadata.namespace.to_string(),
1919 subject_data.namespace.to_string()
1920 );
1921 assert_eq!(metadata.namespace, Namespace::new());
1922
1923 assert!(subject_data.new_owner.is_none());
1924 assert!(metadata.new_owner.is_none());
1925
1926 assert_eq!(metadata.sn, event.sn);
1927 assert_eq!(metadata.sn, subject_data.sn);
1928 assert_eq!(metadata.sn, 1);
1929
1930 assert!(subject_data.active);
1931 assert!(metadata.active);
1932
1933 assert_eq!(payload, payload_db);
1934 assert_eq!(metadata.properties.0, subject_data.properties);
1935 assert!(metadata.properties.0["one"].as_u64().unwrap() == 0);
1936 assert!(metadata.properties.0["two"].as_u64().unwrap() == 0);
1937 assert!(metadata.properties.0["three"].as_u64().unwrap() == 0);
1938 }
1939
1940 #[test(tokio::test)]
1941 async fn test_transfer_tracker() {
1942 let (
1943 _system,
1944 node_actor,
1945 request_actor,
1946 db,
1947 subject_actor,
1948 tracking,
1949 subject_id,
1950 gov_id,
1951 _dir,
1952 ) = create_tracker().await;
1953
1954 let transfer_request = EventRequest::Transfer(TransferRequest {
1955 subject_id: subject_id.clone(),
1956 new_owner: PublicKey::from_str(
1957 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE",
1958 )
1959 .unwrap(),
1960 });
1961
1962 let _request_data = emit_request(
1963 transfer_request.clone(),
1964 &node_actor,
1965 &request_actor,
1966 &tracking,
1967 true,
1968 )
1969 .await;
1970
1971 let TrackerResponse::Metadata(metadata) = subject_actor
1972 .ask(TrackerMessage::GetMetadata)
1973 .await
1974 .unwrap()
1975 else {
1976 panic!("Invalid response")
1977 };
1978
1979 let subject_data = get_subject_state(&db, &subject_id, 1).await;
1980 let event = get_event_sn(&db, &subject_id, 1).await;
1981
1982 let RequestEventDB::Transfer {
1983 evaluation_error,
1984 new_owner: new_owner_transfer,
1985 } = event.event
1986 else {
1987 panic!()
1988 };
1989
1990 assert!(evaluation_error.is_none());
1991
1992 assert_eq!(metadata.name, subject_data.name);
1993 assert_eq!(metadata.name.unwrap(), "Subject Name");
1994
1995 assert_eq!(metadata.description, subject_data.description);
1996 assert_eq!(metadata.description.unwrap(), "Subject Description");
1997
1998 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
1999 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
2000 assert_eq!(metadata.subject_id, subject_id);
2001
2002 assert_eq!(
2003 metadata.governance_id.to_string(),
2004 subject_data.governance_id
2005 );
2006 assert_eq!(metadata.governance_id, gov_id);
2007
2008 assert_eq!(
2009 metadata.genesis_gov_version,
2010 subject_data.genesis_gov_version
2011 );
2012 assert_eq!(metadata.genesis_gov_version, 1);
2013
2014 assert_eq!(
2015 metadata.schema_id.to_string(),
2016 subject_data.schema_id.to_string()
2017 );
2018 assert_eq!(metadata.schema_id, SchemaType::Type("Example".to_string()));
2019
2020 assert_eq!(
2021 metadata.namespace.to_string(),
2022 subject_data.namespace.to_string()
2023 );
2024 assert_eq!(metadata.namespace, Namespace::new());
2025
2026 assert_eq!(
2027 new_owner_transfer,
2028 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
2029 );
2030 assert_eq!(
2031 subject_data.new_owner.unwrap(),
2032 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
2033 );
2034 assert_eq!(
2035 metadata.new_owner.unwrap().to_string(),
2036 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbE"
2037 );
2038
2039 assert_eq!(metadata.sn, event.sn);
2040 assert_eq!(metadata.sn, subject_data.sn);
2041 assert_eq!(metadata.sn, 1);
2042
2043 assert!(subject_data.active);
2044 assert!(metadata.active);
2045
2046 assert_eq!(metadata.properties.0, subject_data.properties);
2047 assert!(metadata.properties.0["one"].as_u64().unwrap() == 0);
2048 assert!(metadata.properties.0["two"].as_u64().unwrap() == 0);
2049 assert!(metadata.properties.0["three"].as_u64().unwrap() == 0);
2050
2051 let response = node_actor
2052 .ask(NodeMessage::SignRequest(SignTypesNode::EventRequest(
2053 transfer_request.clone(),
2054 )))
2055 .await
2056 .unwrap();
2057 let NodeResponse::SignRequest(signature) = response else {
2058 panic!("Invalid Response")
2059 };
2060
2061 let signed_event_req = Signed::from_parts(transfer_request, signature);
2062
2063 if !request_actor
2064 .ask(RequestHandlerMessage::NewRequest {
2065 request: signed_event_req.clone(),
2066 })
2067 .await
2068 .is_err()
2069 {
2070 panic!("Invalid response")
2071 }
2072 }
2073
2074 #[test(tokio::test)]
2075 async fn test_transfer_fail_tracker() {
2076 let (
2077 _system,
2078 node_actor,
2079 request_actor,
2080 db,
2081 subject_actor,
2082 tracking,
2083 subject_id,
2084 gov_id,
2085 _dir,
2086 ) = create_tracker().await;
2087
2088 let transfer_request = EventRequest::Transfer(TransferRequest {
2089 subject_id: subject_id.clone(),
2090 new_owner: PublicKey::from_str(
2091 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbA",
2092 )
2093 .unwrap(),
2094 });
2095
2096 let _request_data = emit_request(
2097 transfer_request.clone(),
2098 &node_actor,
2099 &request_actor,
2100 &tracking,
2101 true,
2102 )
2103 .await;
2104
2105 let TrackerResponse::Metadata(metadata) = subject_actor
2106 .ask(TrackerMessage::GetMetadata)
2107 .await
2108 .unwrap()
2109 else {
2110 panic!("Invalid response")
2111 };
2112
2113 let subject_data = get_subject_state(&db, &subject_id, 1).await;
2114 let event = get_event_sn(&db, &subject_id, 1).await;
2115
2116 let RequestEventDB::Transfer {
2117 evaluation_error,
2118 new_owner: new_owner_transfer,
2119 } = event.event
2120 else {
2121 panic!()
2122 };
2123
2124 assert_eq!(
2125 "runner error: invalid event: [execute_transfer_not_gov] invalid event: 'new owner EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbA' is not a member of governance",
2126 evaluation_error.unwrap()
2127 );
2128
2129 assert_eq!(metadata.name, subject_data.name);
2130 assert_eq!(metadata.name.unwrap(), "Subject Name");
2131
2132 assert_eq!(metadata.description, subject_data.description);
2133 assert_eq!(metadata.description.unwrap(), "Subject Description");
2134
2135 assert_eq!(metadata.subject_id.to_string(), event.subject_id);
2136 assert_eq!(metadata.subject_id.to_string(), subject_data.subject_id);
2137 assert_eq!(metadata.subject_id, subject_id);
2138
2139 assert_eq!(
2140 metadata.governance_id.to_string(),
2141 subject_data.governance_id
2142 );
2143 assert_eq!(metadata.governance_id, gov_id);
2144
2145 assert_eq!(
2146 metadata.genesis_gov_version,
2147 subject_data.genesis_gov_version
2148 );
2149 assert_eq!(metadata.genesis_gov_version, 1);
2150
2151 assert_eq!(
2152 metadata.schema_id.to_string(),
2153 subject_data.schema_id.to_string()
2154 );
2155 assert_eq!(metadata.schema_id, SchemaType::Type("Example".to_string()));
2156
2157 assert_eq!(
2158 metadata.namespace.to_string(),
2159 subject_data.namespace.to_string()
2160 );
2161 assert_eq!(metadata.namespace, Namespace::new());
2162
2163 assert_eq!(
2164 new_owner_transfer,
2165 "EUrVnqpwo9EKBvMru4wWLMpJgOTKM5gZnxApRmjrRbbA"
2166 );
2167 assert!(subject_data.new_owner.is_none(),);
2168 assert!(metadata.new_owner.is_none());
2169
2170 assert_eq!(metadata.sn, event.sn);
2171 assert_eq!(metadata.sn, subject_data.sn);
2172 assert_eq!(metadata.sn, 1);
2173
2174 assert!(subject_data.active);
2175 assert!(metadata.active);
2176
2177 assert_eq!(metadata.properties.0, subject_data.properties);
2178 assert!(metadata.properties.0["one"].as_u64().unwrap() == 0);
2179 assert!(metadata.properties.0["two"].as_u64().unwrap() == 0);
2180 assert!(metadata.properties.0["three"].as_u64().unwrap() == 0);
2181 }
2182}