[2] - AddedTests for network score

packages/statement/src/statement_chain.py

@@ -121,7 +121,7 @@ async def prepare_extrinsic_to_register(
 
         if exists:
             raise Errors.DuplicateStatementError(
-                f"The statement is already anchored in the chain\nIdentifier: {stmt_entry['elementUri']}"
+                f"The statement is already anchored in the chain\nIdentifier: {stmt_entry['element_uri']}"
             )
 
         tx = api.compose_call(

tests/test_asset.py

@@ -0,0 +1,134 @@
+import unittest
+from unittest.mock import MagicMock, patch
+import asyncio
+from packages.utils.src.SDKErrors import Errors
+from packages.utils.src.prefix import ASSET_PREFIX
+import packages.sdk.src as Cord
+
+# Global test constants
+TEST_ASSET_ENTRY = {
+    "creator": "did:cord:creator",
+    "issuer": "did:cord:issuer",
+    "owner": "did:cord:owner",
+    "entry": {"asset_id": "123", "asset_instance_id": "456"},
+    "digest": "dummy_digest",
+    "uri": "asset:cord:123:456"
+}
+TEST_AUTHOR_ACCOUNT = MagicMock()
+TEST_AUTHORIZATION_URI = "auth:cord:a3fraTJoz9yDKpvMyAJJ971F3p7Ts1bfBz2WyMojvYqQNjf6S"
+TEST_SIGNATURE_CALLBACK = MagicMock()
+
+class TestCordAssetFunctions(unittest.TestCase):
+
+    @patch('packages.sdk.src.ConfigService.get')
+    @patch('packages.sdk.src.Did.authorize_tx')
+    def test_dispatch_create_to_chain_success(self, mock_authorize_tx, mock_get):
+        mock_api = MagicMock()
+        mock_get.return_value = mock_api
+        mock_authorize_tx.return_value = "signed_tx"
+
+        mock_api.compose_call.return_value = "tx_call"
+        mock_api.create_signed_extrinsic.return_value = "signed_extrinsic"
+        mock_api.submit_extrinsic.return_value = None
+
+        result = asyncio.run(
+            Cord.Asset.asset_chain.dispatch_create_to_chain(
+                TEST_ASSET_ENTRY,
+                TEST_AUTHOR_ACCOUNT,
+                TEST_AUTHORIZATION_URI,
+                TEST_SIGNATURE_CALLBACK
+            )
+        )
+
+        self.assertEqual(result, TEST_ASSET_ENTRY["uri"])
+
+    @patch('packages.sdk.src.ConfigService.get')
+    @patch('packages.sdk.src.Did.authorize_tx')
+    def test_dispatch_create_to_chain_failure(self, mock_authorize_tx, mock_get):
+        mock_get.return_value = MagicMock()
+        mock_authorize_tx.side_effect = Exception("Authorization failed")
+
+        with self.assertRaises(Errors.CordDispatchError):
+            asyncio.run(
+                Cord.Asset.asset_chain.dispatch_create_to_chain(
+                    TEST_ASSET_ENTRY,
+                    TEST_AUTHOR_ACCOUNT,
+                    TEST_AUTHORIZATION_URI,
+                    TEST_SIGNATURE_CALLBACK
+                )
+            )
+
+    @patch('packages.sdk.src.ConfigService.get')
+    @patch('packages.sdk.src.Did.authorize_tx')
+    def test_dispatch_issue_to_chain_success(self, mock_authorize_tx, mock_get):
+        mock_api = MagicMock()
+        mock_get.return_value = mock_api
+        mock_authorize_tx.return_value = "signed_tx"
+
+        mock_api.create_signed_extrinsic.return_value = "signed_extrinsic"
+        mock_api.submit_extrinsic.return_value = None
+
+        result = asyncio.run(
+            Cord.Asset.asset_chain.dispatch_issue_to_chain(
+                TEST_ASSET_ENTRY,
+                TEST_AUTHOR_ACCOUNT,
+                TEST_AUTHORIZATION_URI,
+                TEST_SIGNATURE_CALLBACK
+            )
+        )
+
+        self.assertEqual(result, TEST_ASSET_ENTRY["uri"])
+
+    @patch('packages.sdk.src.ConfigService.get')
+    @patch('packages.sdk.src.Did.authorize_tx')
+    def test_dispatch_issue_to_chain_failure(self, mock_authorize_tx, mock_get):
+        mock_get.return_value = MagicMock()
+        mock_authorize_tx.side_effect = Exception("Authorization failed")
+
+        with self.assertRaises(Errors.CordDispatchError):
+            asyncio.run(
+                Cord.Asset.asset_chain.dispatch_issue_to_chain(
+                    TEST_ASSET_ENTRY,
+                    TEST_AUTHOR_ACCOUNT,
+                    TEST_AUTHORIZATION_URI,
+                    TEST_SIGNATURE_CALLBACK
+                )
+            )
+
+    @patch('packages.sdk.src.ConfigService.get')
+    @patch('packages.sdk.src.Did.authorize_tx')
+    def test_dispatch_transfer_to_chain_success(self, mock_authorize_tx, mock_get):
+        mock_api = MagicMock()
+        mock_get.return_value = mock_api
+        mock_authorize_tx.return_value = "signed_tx"
+
+        mock_api.create_signed_extrinsic.return_value = "signed_extrinsic"
+        mock_api.submit_extrinsic.return_value = None
+
+        result = asyncio.run(
+            Cord.Asset.asset_chain.dispatch_transfer_to_chain(
+                TEST_ASSET_ENTRY,
+                TEST_AUTHOR_ACCOUNT,
+                TEST_SIGNATURE_CALLBACK
+            )
+        )
+
+        self.assertEqual(result, f"{ASSET_PREFIX}{TEST_ASSET_ENTRY['entry']['asset_id']}:{TEST_ASSET_ENTRY['entry']['asset_instance_id']}")
+
+    @patch('packages.sdk.src.ConfigService.get')
+    @patch('packages.sdk.src.Did.authorize_tx')
+    def test_dispatch_transfer_to_chain_failure(self, mock_authorize_tx, mock_get):
+        mock_get.return_value = MagicMock()
+        mock_authorize_tx.side_effect = Exception("Authorization failed")
+
+        with self.assertRaises(Errors.CordDispatchError):
+            asyncio.run(
+                Cord.Asset.asset_chain.dispatch_transfer_to_chain(
+                    TEST_ASSET_ENTRY,
+                    TEST_AUTHOR_ACCOUNT,
+                    TEST_SIGNATURE_CALLBACK
+                )
+            )
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_did.py

@@ -153,6 +153,137 @@ def test_create_did(self, mock_config_service_get, mock_get_store_tx, mock_gener
             self.assertEqual(result["mnemonic"], mnemonic)
             self.assertEqual(result["document"], "mocked_document")
 
+    @patch('packages.sdk.src.Did.generate_mnemonic')
+    @patch('packages.sdk.src.Did.generate_keypairs')
+    @patch('packages.sdk.src.Did.get_store_tx')
+    @patch('packages.sdk.src.ConfigService.get')
+    def test_create_did_failure(self, mock_config_service_get, mock_get_store_tx, mock_generate_keypairs, mock_generate_mnemonic):
+        # Mock the return values of the functions and methods
+        mock_api = MagicMock()
+        mock_config_service_get.return_value = mock_api
+
+        mnemonic = "use stereo ostrich special broccoli hurdle share subway jewel truck almost noodle loud goat more enhance brisk hope attend girl city catch mistake differ"
+        mock_generate_mnemonic.return_value = mnemonic
+        mock_keypairs = {
+            "authentication": MagicMock(),
+            "key_agreement": MagicMock(),
+            "assertion_method": MagicMock(),
+            "capability_delegation": MagicMock()
+        }
+        mock_generate_keypairs.return_value = mock_keypairs
+
+        mock_get_store_tx.return_value = "mocked_tx"
+
+        mock_api.create_signed_extrinsic = MagicMock()
+        mock_api.submit_extrinsic = MagicMock()
+        mock_api.runtime_call = MagicMock(return_value="mocked_encoded_did")
+
+        # Simulate failure by returning None or an empty dictionary from linked_info_from_chain
+        with patch('packages.sdk.src.Did.get_did_uri_from_key', return_value="did:cord:3vRsRQmgpuuyzkfMYwnAMuT9LKwxZMedbBGmAicrXk7EhsEr") as mock_get_did_uri_from_key, \
+            patch('packages.sdk.src.Did.linked_info_from_chain', return_value=None) as mock_linked_info_from_chain:
+
+            submitter_account = MagicMock()
+            submitter_account.ss58_address = "mocked_address"
+
+            # Call the function and expect it to raise an exception
+            with self.assertRaises(Exception) as context:
+                asyncio.run(Cord.Did.create_did(submitter_account))
+
+            # Assertions
+            mock_generate_mnemonic.assert_called_once_with(24)
+            mock_generate_keypairs.assert_called_once_with(mnemonic, "sr25519")
+            mock_get_store_tx.assert_called_once()
+            mock_api.create_signed_extrinsic.assert_called_once_with("mocked_tx", submitter_account)
+            mock_api.submit_extrinsic.assert_called_once()
+            mock_get_did_uri_from_key.assert_called_once()
+            mock_api.runtime_call.assert_called_once_with("DidApi", "query", ["3vRsRQmgpuuyzkfMYwnAMuT9LKwxZMedbBGmAicrXk7EhsEr"])
+            mock_linked_info_from_chain.assert_called_once_with("mocked_encoded_did")
+
+            # Check that the correct exception message is raised
+            self.assertEqual(str(context.exception), "DID was not successfully created.")
+
+
+    @patch('packages.sdk.src.Did.generate_mnemonic')
+    @patch('packages.sdk.src.Did.generate_keypairs')
+    @patch('packages.sdk.src.Did.get_store_tx')
+    @patch('packages.sdk.src.ConfigService.get')
+    def test_create_did_failure_in_tx_creation(self, mock_config_service_get, mock_get_store_tx, mock_generate_keypairs, mock_generate_mnemonic):
+        # Mock the return values of the functions and methods
+        mock_api = MagicMock()
+        mock_config_service_get.return_value = mock_api
+
+        mnemonic = "use stereo ostrich special broccoli hurdle share subway jewel truck almost noodle loud goat more enhance brisk hope attend girl city catch mistake differ"
+        mock_generate_mnemonic.return_value = mnemonic
+        mock_keypairs = {
+            "authentication": MagicMock(),
+            "key_agreement": MagicMock(),
+            "assertion_method": MagicMock(),
+            "capability_delegation": MagicMock()
+        }
+        mock_generate_keypairs.return_value = mock_keypairs
+
+        # Simulate failure in transaction creation
+        mock_get_store_tx.side_effect = Exception("Failed to create transaction")
+
+        submitter_account = MagicMock()
+        submitter_account.ss58_address = "mocked_address"
+
+        # Call the function and expect it to raise an exception
+        with self.assertRaises(Exception) as context:
+            asyncio.run(Cord.Did.create_did(submitter_account))
+
+        # Assertions
+        mock_generate_mnemonic.assert_called_once_with(24)
+        mock_generate_keypairs.assert_called_once_with(mnemonic, "sr25519")
+        mock_get_store_tx.assert_called_once()
+
+        # Check that the correct exception message is raised
+        self.assertEqual(str(context.exception), "Failed to create transaction")
+
+    @patch('packages.sdk.src.Did.generate_mnemonic')
+    @patch('packages.sdk.src.Did.generate_keypairs')
+    @patch('packages.sdk.src.Did.get_store_tx')
+    @patch('packages.sdk.src.ConfigService.get')
+    def test_create_did_failure_in_submission(self, mock_config_service_get, mock_get_store_tx, mock_generate_keypairs, mock_generate_mnemonic):
+        # Mock the return values of the functions and methods
+        mock_api = MagicMock()
+        mock_config_service_get.return_value = mock_api
+
+        mnemonic = "use stereo ostrich special broccoli hurdle share subway jewel truck almost noodle loud goat more enhance brisk hope attend girl city catch mistake differ"
+        mock_generate_mnemonic.return_value = mnemonic
+        mock_keypairs = {
+            "authentication": MagicMock(),
+            "key_agreement": MagicMock(),
+            "assertion_method": MagicMock(),
+            "capability_delegation": MagicMock()
+        }
+        mock_generate_keypairs.return_value = mock_keypairs
+
+        mock_get_store_tx.return_value = "mocked_tx"
+
+        mock_api.create_signed_extrinsic = MagicMock()
+
+        # Simulate failure in submitting the transaction
+        mock_api.submit_extrinsic.side_effect = Exception("Failed to submit transaction")
+
+        submitter_account = MagicMock()
+        submitter_account.ss58_address = "mocked_address"
+
+        # Call the function and expect it to raise an exception
+        with self.assertRaises(Exception) as context:
+            asyncio.run(Cord.Did.create_did(submitter_account))
+
+        # Assertions
+        mock_generate_mnemonic.assert_called_once_with(24)
+        mock_generate_keypairs.assert_called_once_with(mnemonic, "sr25519")
+        mock_get_store_tx.assert_called_once()
+        mock_api.create_signed_extrinsic.assert_called_once_with("mocked_tx", submitter_account)
+        mock_api.submit_extrinsic.assert_called_once()
+
+        # Check that the correct exception message is raised
+        self.assertEqual(str(context.exception), "Failed to submit transaction")
+
+
     @patch('packages.sdk.src.ConfigService.get')
     @patch('packages.sdk.src.Did.get_address_by_key')
     @patch('packages.sdk.src.Did.public_key_to_chain_for_keypair')