add test for search contract creation restriction

Author: pauldelucia

packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs

@@ -7,6 +7,8 @@ mod creation_tests {
     use dapi_grpc::platform::v0::get_contested_resource_vote_state_request::GetContestedResourceVoteStateRequestV0;
     use dapi_grpc::platform::v0::get_contested_resource_vote_state_response::{get_contested_resource_vote_state_response_v0, GetContestedResourceVoteStateResponseV0};
     use assert_matches::assert_matches;
+    use dpp::platform_value::string_encoding::Encoding;
+    use dpp::prelude::Identifier;
     use rand::distributions::Standard;
     use dpp::consensus::basic::document::DocumentFieldMaxSizeExceededError;
     use dpp::consensus::ConsensusError;
@@ -2468,6 +2470,141 @@ mod creation_tests {
         assert_eq!(consensus_error.to_string(), "Document Creation on 86LHvdC1Tqx5P97LQUSibGFqf2vnKFpB6VkqQ7oso86e:card is not allowed because of the document type's creation restriction mode Owner Only");
     }
 
+    #[test]
+    fn test_document_creation_on_search_system_contract_fails_due_to_restriction() {
+        // Build test platform
+        let mut platform = TestPlatformBuilder::new()
+            .with_latest_protocol_version()
+            .build_with_mock_rpc()
+            .set_initial_state_structure();
+
+        // Create an identity that will attempt to create the document
+        let (identity, signer, key) = setup_identity(&mut platform, 999, dash_to_credits!(0.1));
+
+        // Obtain the current platform state and version
+        let platform_state = platform.state.load();
+        let platform_version = platform_state
+            .current_platform_version()
+            .expect("expected to get current platform version");
+
+        // Load the system Search contract
+        let search_contract = platform.drive.cache.system_data_contracts.load_search();
+
+        platform
+            .drive
+            .apply_contract(
+                &search_contract,
+                BlockInfo::default(),
+                true,
+                StorageFlags::optional_default_as_cow(),
+                None,
+                platform_version,
+            )
+            .expect("expected to apply contract successfully");
+
+        // Get the document type from the search contract.
+        let doc_type = search_contract
+            .document_type_for_name("contract")
+            .expect("expected to find 'contract' in Search contract");
+
+        // Verify that the document type has the restrictive creation mode
+        assert_eq!(
+            doc_type.creation_restriction_mode(),
+            CreationRestrictionMode::NoCreationAllowed,
+            "Expected creation restriction mode to be NoCreationAllowed (2)."
+        );
+
+        // Create a random document
+        let mut rng = StdRng::seed_from_u64(123456);
+        let entropy = Bytes32::random_with_rng(&mut rng);
+
+        let mut document = doc_type
+            .random_document_with_identifier_and_entropy(
+                &mut rng,
+                identity.id(),
+                entropy,
+                DocumentFieldFillType::DoNotFillIfNotRequired,
+                DocumentFieldFillSize::AnyDocumentFillSize,
+                platform_version,
+            )
+            .expect("expected to create a random document");
+
+        // Set fields in the document
+        document.set("keyword", "meme".into());
+        document.set("contractId", Identifier::random().into());
+
+        // Create the transition
+        let documents_batch_create_transition =
+            BatchTransition::new_document_creation_transition_from_document(
+                document.clone(),
+                doc_type,
+                entropy.0,
+                &key,
+                1,
+                0,
+                None,
+                &signer,
+                platform_version,
+                None,
+                None,
+                None,
+            )
+            .expect("expect to create documents batch transition");
+
+        let documents_batch_create_serialized_transition = documents_batch_create_transition
+            .serialize_to_bytes()
+            .expect("expected documents batch serialized state transition");
+
+        // Start transaction and submit the transition
+        let transaction = platform.drive.grove.start_transaction();
+
+        let processing_result = platform
+            .platform
+            .process_raw_state_transitions(
+                &vec![documents_batch_create_serialized_transition],
+                &platform_state,
+                &BlockInfo::default(),
+                &transaction,
+                platform_version,
+                false,
+                None,
+            )
+            .expect("expected to process state transition");
+
+        println!("Processing result: {:?}", processing_result);
+
+        // Since the creationRestrictionMode is 2 (NoCreationAllowed), this should fail
+        assert_eq!(
+            processing_result.invalid_paid_count(),
+            1,
+            "Expected exactly 1 invalid paid transition"
+        );
+
+        platform
+            .drive
+            .grove
+            .commit_transaction(transaction)
+            .unwrap()
+            .expect("expected to commit transaction");
+
+        // Check the returned consensus error
+        let result = processing_result.into_execution_results().remove(0);
+        let PaidConsensusError(consensus_error, _) = result else {
+            panic!("expected a paid consensus error");
+        };
+
+        // Compare message to whatever your code sets for this error
+        assert_eq!(
+            consensus_error.to_string(),
+            format!(
+                "Document Creation on {}:{} is not allowed because of the document type's creation restriction mode No Creation Allowed",
+                search_contract.id().to_string(Encoding::Base58),
+                "contract"
+            ),
+            "Mismatch in error message"
+        );
+    }
+
     #[test]
     fn test_document_creation_paid_with_a_token_burn() {
         let platform_version = PlatformVersion::latest();