Update tests for obliteration

src/process.rs

@@ -509,7 +509,7 @@ mod tests {
 
     use serde_json::json;
     use sp_client::{
-        bitcoin::{secp256k1::SecretKey, Network}, silentpayments::utils::SilentPaymentAddress, spclient::{SpClient, SpWallet, SpendKey}
+        bitcoin::{secp256k1::SecretKey, Network, Txid}, silentpayments::utils::SilentPaymentAddress, spclient::{SpClient, SpWallet, SpendKey}
     };
 
     use crate::pcd::{Member, ValidationRule};
@@ -588,10 +588,35 @@ mod tests {
         .unwrap()
     }
 
+    fn create_dave_wallet() -> SpWallet {
+        SpWallet::new(
+            SpClient::new(
+                "default".to_owned(),
+                SecretKey::from_str(
+                    "261d5f9ae4d2b0d8b17ed0c52bd2be7dbce14d9ac1f0f1d4904d3ca7df03766d",
+                )
+                .unwrap(),
+                SpendKey::Secret(
+                    SecretKey::from_str(
+                        "8441e2adbb39736f384617fafc61e0d894bf3a5c2b69801fd4476bdcce04fb59",
+                    )
+                    .unwrap(),
+                ),
+                None,
+                Network::Signet,
+            )
+            .unwrap(),
+            None,
+            vec![],
+        )
+        .unwrap()
+    }
+
     fn dummy_process_state() -> ProcessState {
         let alice_wallet = create_alice_wallet();
         let bob_wallet = create_bob_wallet();
         let carol_wallet = create_carol_wallet();
+        let dave_wallet = create_dave_wallet();
 
         let alice_address =
             SilentPaymentAddress::try_from(alice_wallet.get_client().get_receiving_address())
@@ -602,15 +627,20 @@ mod tests {
         let carol_address =
             SilentPaymentAddress::try_from(carol_wallet.get_client().get_receiving_address())
                 .unwrap();
+        let dave_address =
+            SilentPaymentAddress::try_from(dave_wallet.get_client().get_receiving_address())
+                .unwrap();
 
         let alice_bob = Member::new(vec![alice_address, bob_address]).unwrap();
         let carol = Member::new(vec![carol_address]).unwrap();
+        let dave = Member::new(vec![dave_address]).unwrap();
 
         let validation_rule1 =
             ValidationRule::new(1.0, vec!["field1".to_owned()], 0.5).unwrap();
         let validation_rule2 = ValidationRule::new(1.0, vec!["field2".to_owned()], 0.5).unwrap();
         let validation_rule3 = ValidationRule::new(1.0, vec!["roles".to_owned()], 0.5).unwrap();
         let validation_rule4 = ValidationRule::new(1.0, vec!["public1".to_owned(), "public2".to_owned()], 0.5).unwrap();
+        let apophis_rule = ValidationRule::new(1.0, vec!["".to_owned()], 1.0).unwrap();
 
         let role_def1 = RoleDefinition {
             members: vec![alice_bob.clone()],
@@ -635,11 +665,18 @@ mod tests {
             storages: vec![]
         };
 
+        let role_def_apophis = RoleDefinition {
+            members: vec![dave],
+            validation_rules: vec![apophis_rule],
+            storages: vec![]
+        };
+
         let roles: BTreeMap<String, RoleDefinition> = BTreeMap::from([
             ("role1".to_owned(), role_def1),
             ("role2".to_owned(), role_def2),
             ("role_roles".to_owned(), role_def_roles),
-            ("role_public_data".to_owned(), role_def_public_data)
+            ("role_public_data".to_owned(), role_def_public_data),
+            ("apophis".to_owned(), role_def_apophis)
         ]);
 
         let clear_pcd: BTreeMap<String, Value> = serde_json::from_value(json!({
@@ -766,6 +803,62 @@ mod tests {
         assert!(result.is_ok());
     }
 
+    #[test]
+    /// Carol tries to obliterate the process but she's not apophis
+    fn test_error_invalid_obliteration() {
+        let mut state = dummy_process_state();
+        let mut process = Process::new(state.commited_in);
+        process.insert_concurrent_state(state.clone()).unwrap();
+        // We simulate a first commitment
+        process.update_states_tip(
+            OutPoint::new(
+                Txid::from_str(
+                    "cbeb4455f8d11848809bacd59bfd570243dbe7c4e9a340fa949aae3020fdb127"
+                ).unwrap()
+                , 0
+            )
+        ).unwrap();
+        // Now we take the last empty state and try to invalidate it
+        let empty_state = process.get_state_for_id(&[0u8; 32]).unwrap();
+        let carol_key: SecretKey = create_carol_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash = empty_state.get_message_hash(true).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash, carol_key));
+        let result = state.is_valid(None);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    /// Dave signs to obliterate the process
+    fn test_valid_obliteration() {
+        let mut state = dummy_process_state();
+        let mut process = Process::new(state.commited_in);
+        process.insert_concurrent_state(state.clone()).unwrap();
+        // We simulate a first commitment
+        process.update_states_tip(
+            OutPoint::new(
+                Txid::from_str(
+                    "cbeb4455f8d11848809bacd59bfd570243dbe7c4e9a340fa949aae3020fdb127"
+                ).unwrap()
+                , 0
+            )
+        ).unwrap();
+        // Now we take the last empty state and try to invalidate it
+        let empty_state = process.get_state_for_id(&[0u8; 32]).unwrap();
+        let dave_key: SecretKey = create_dave_wallet()
+            .get_client()
+            .get_spend_key()
+            .try_into()
+            .unwrap();
+        let message_hash = empty_state.get_message_hash(true).unwrap();
+        state.validation_tokens.push(Proof::new(message_hash, dave_key));
+        let result = state.is_valid(None);
+        assert!(result.is_ok());
+    }
+
     #[test]
     /// Carol refuses change for her part
     fn test_error_carol_votes_no() {