huaweicloud-encryption-sdk-python 1.2.1__py3-none-any.whl

tests/test_factories.py

@@ -0,0 +1,71 @@
+import pytest
+from huaweicloud_encryptionsdk.keyrings.kms_keyring_factory import KmsKeyringFactory
+from huaweicloud_encryptionsdk.keyrings.raw_keyring_factory import RawKeyringFactory
+from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_aes_keyring import RawAesKeyring
+from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_sm4_keyring import RawSM4Keyring
+from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_sm4_cbc_keyring import RawSM4CBCKeyring
+from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_rsa_keyring import RawRSAKeyring
+from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_sm2_keyring import RawSM2Keyring
+from huaweicloud_encryptionsdk.keyrings.kmskeyring.kms_multi_region_keyring import KMSMultiRegionKeyring
+from huaweicloud_encryptionsdk.keyrings.kmskeyring.kms_discovery_keyring import KMSDiscoveryKeyring
+from huaweicloud_encryptionsdk.keyrings.kmskeyring.kms_key_capsule_keyring import KMSKeyCapsuleKeyring
+from huaweicloud_encryptionsdk.meterialmanager.data_key_generate_factory import DataKeyGenerateFactory
+from huaweicloud_encryptionsdk.meterialmanager.local_data_key_generate import LocalDataKeyGenerate
+from huaweicloud_encryptionsdk.meterialmanager.kms_data_key_generate import KmsDataKeyGenerate
+from huaweicloud_encryptionsdk.meterialmanager.key_capsule_data_key_generate import KeyCapsuleDataKeyGenerate
+from huaweicloud_encryptionsdk.proof.proof_collector_factory import ProofCollectorFactory
+from huaweicloud_encryptionsdk.proof.proof_collector import ProofCollector
+from huaweicloud_encryptionsdk.proof.proof_info import ProofInfo
+from huaweicloud_encryptionsdk.proof.attestation_document import AttestationDocument
+from huaweicloud_encryptionsdk.model.enums.keyring_type_enum import KeyringTypeEnum
+from huaweicloud_encryptionsdk.model.enums.data_key_generate_type import DataKeyGenerateType
+
+
+class TestRawKeyringFactory:
+    def test_aes(self):
+        kr = RawKeyringFactory().get_keyring("AES")
+        assert isinstance(kr, RawAesKeyring)
+
+    def test_sm4(self):
+        kr = RawKeyringFactory().get_keyring("SM4_GCM")
+        assert isinstance(kr, RawSM4Keyring)
+
+    def test_sm4_cbc(self):
+        kr = RawKeyringFactory().get_keyring("SM4_CBC")
+        assert isinstance(kr, RawSM4CBCKeyring)
+
+    def test_rsa(self):
+        kr = RawKeyringFactory().get_keyring("RSA")
+        assert isinstance(kr, RawRSAKeyring)
+
+    def test_sm2(self):
+        kr = RawKeyringFactory().get_keyring("SM2")
+        assert isinstance(kr, RawSM2Keyring)
+
+
+class TestKmsKeyringFactory:
+    def test_multi_region(self):
+        kr = KmsKeyringFactory().get_keyring("multi")
+        assert isinstance(kr, KMSMultiRegionKeyring)
+
+    def test_discovery(self):
+        kr = KmsKeyringFactory().get_keyring("discovery")
+        assert isinstance(kr, KMSDiscoveryKeyring)
+
+    def test_key_capsule(self):
+        kr = KmsKeyringFactory().get_keyring("key_capsule")
+        assert isinstance(kr, KMSKeyCapsuleKeyring)
+
+
+class TestDataKeyGenerateFactory:
+    def test_local(self):
+        gen = DataKeyGenerateFactory.get_data_key_generate(DataKeyGenerateType.LOCAL_GENERATE)
+        assert isinstance(gen, LocalDataKeyGenerate)
+
+    def test_kms(self):
+        gen = DataKeyGenerateFactory.get_data_key_generate(DataKeyGenerateType.KMS_GENERATE)
+        assert isinstance(gen, KmsDataKeyGenerate)
+
+    def test_key_capsule(self):
+        gen = DataKeyGenerateFactory.get_data_key_generate(DataKeyGenerateType.KEY_CAPSULE_GENERATE)
+        assert isinstance(gen, KeyCapsuleDataKeyGenerate)

tests/test_huawei_crypto.py

@@ -0,0 +1,67 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from huaweicloud_encryptionsdk import HuaweiCrypto, HuaweiConfig
+from huaweicloud_encryptionsdk.exception.errors import KeyringNotFoundException
+from huaweicloud_encryptionsdk.model.enums.crypto_algorithm import CryptoAlgorithm
+
+
+class TestHuaweiCryptoNoKeyring:
+    def test_encrypt_without_keyring_raises(self):
+        config = HuaweiConfig(ak="ak", sk="sk", crypto_algorithm=CryptoAlgorithm.AES_256_GCM_NOPADDING)
+        crypto = HuaweiCrypto(config)
+        with pytest.raises(KeyringNotFoundException):
+            crypto.encrypt(b"test")
+
+    def test_decrypt_without_keyring_raises(self):
+        config = HuaweiConfig(ak="ak", sk="sk")
+        crypto = HuaweiCrypto(config)
+        with pytest.raises(KeyringNotFoundException):
+            crypto.decrypt(b"test")
+
+    def test_encrypt_stream_without_keyring_raises(self):
+        config = HuaweiConfig(ak="ak", sk="sk", crypto_algorithm=CryptoAlgorithm.AES_256_GCM_NOPADDING)
+        crypto = HuaweiCrypto(config)
+        with pytest.raises(KeyringNotFoundException):
+            crypto.encrypt_stream(MagicMock(), MagicMock())
+
+    def test_decrypt_stream_without_keyring_raises(self):
+        config = HuaweiConfig(ak="ak", sk="sk")
+        crypto = HuaweiCrypto(config)
+        with pytest.raises(KeyringNotFoundException):
+            crypto.decrypt_stream(MagicMock(), MagicMock())
+
+    def test_encrypt_file_without_keyring_raises(self):
+        config = HuaweiConfig(ak="ak", sk="sk", crypto_algorithm=CryptoAlgorithm.AES_256_GCM_NOPADDING)
+        crypto = HuaweiCrypto(config)
+        with pytest.raises(KeyringNotFoundException):
+            crypto.encrypt_file("src.txt", "dst.txt")
+
+    def test_decrypt_file_without_keyring_raises(self):
+        config = HuaweiConfig(ak="ak", sk="sk")
+        crypto = HuaweiCrypto(config)
+        with pytest.raises(KeyringNotFoundException):
+            crypto.decrypt_file("src.txt", "dst.txt")
+
+
+class TestHuaweiCryptoBuilder:
+    def test_with_keyring(self):
+        config = HuaweiConfig(ak="ak", sk="sk")
+        crypto = HuaweiCrypto(config)
+        mock_keyring = MagicMock()
+        result = crypto.with_keyring(mock_keyring)
+        assert result is crypto
+
+    def test_with_crypto_material_manager(self):
+        config = HuaweiConfig(ak="ak", sk="sk")
+        crypto = HuaweiCrypto(config)
+        mock_manager = MagicMock()
+        result = crypto.with_crypto_material_manager(mock_manager)
+        assert result is crypto
+
+
+class TestHuaweiConfigLocalLogOnly:
+    def test_local_log_only_does_not_init_lts(self):
+        config = HuaweiConfig(ak="ak", sk="sk", local_log_only=True)
+        crypto = HuaweiCrypto(config)
+        from huaweicloud_encryptionsdk.log.log_reporter_manager import LogReporterManager
+        assert LogReporterManager.get_instance().is_initialized

tests/test_imports.py

@@ -0,0 +1,46 @@
+def test_import_main():
+    from huaweicloud_encryptionsdk import HuaweiCrypto, HuaweiConfig
+
+
+def test_import_models():
+    from huaweicloud_encryptionsdk.model.crypto_result import CryptoResult
+    from huaweicloud_encryptionsdk.model.data_key_materials import DataKeyMaterials
+    from huaweicloud_encryptionsdk.model.cipher_header import CipherHeader
+    from huaweicloud_encryptionsdk.model.cipher_body import CipherBody
+    from huaweicloud_encryptionsdk.model.ciphertext_data_key import CiphertextDataKey
+    from huaweicloud_encryptionsdk.model.kms_config import KMSConfig
+    from huaweicloud_encryptionsdk.model.key_capsule import KeyCapsule
+    from huaweicloud_encryptionsdk.model.key_capsule_config import KeyCapsuleConfig
+    from huaweicloud_encryptionsdk.model.access_point_config import AccessPointConfig
+
+
+def test_import_enums():
+    from huaweicloud_encryptionsdk.model.enums.crypto_algorithm import CryptoAlgorithm
+    from huaweicloud_encryptionsdk.model.enums.keyring_type_enum import KeyringTypeEnum
+    from huaweicloud_encryptionsdk.model.enums.data_key_generate_type import DataKeyGenerateType
+    from huaweicloud_encryptionsdk.model.enums.key_provider_enum import KeyProviderEnum
+    from huaweicloud_encryptionsdk.model.enums.access_point_type import AccessPointType
+
+
+def test_import_exceptions():
+    from huaweicloud_encryptionsdk.exception.errors import (
+        HuaweicloudException,
+        KeyringNotFoundException,
+        KeyringNotMatchException,
+        KeyParseException,
+        EncryptException,
+        CipherTamperedException,
+        CipherDataException,
+        ErrorMessage,
+    )
+
+
+def test_import_keyrings():
+    from huaweicloud_encryptionsdk.keyrings.keyring import Keyring
+    from huaweicloud_encryptionsdk.keyrings.raw_keyring_factory import RawKeyringFactory
+    from huaweicloud_encryptionsdk.keyrings.kms_keyring_factory import KmsKeyringFactory
+    from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_aes_keyring import RawAesKeyring
+    from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_rsa_keyring import RawRSAKeyring
+    from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_sm2_keyring import RawSM2Keyring
+    from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_sm4_keyring import RawSM4Keyring
+    from huaweicloud_encryptionsdk.keyrings.rawkeyring.raw_sm4_cbc_keyring import RawSM4CBCKeyring

tests/test_kms_models.py

@@ -0,0 +1,95 @@
+import pytest
+from huaweicloud_encryptionsdk.kms.create_key_capsule_request import CreateKeyCapsuleRequest
+from huaweicloud_encryptionsdk.kms.create_key_capsule_response import CreateKeyCapsuleResponse
+from huaweicloud_encryptionsdk.kms.decrypt_key_capsule_request import DecryptKeyCapsuleRequest
+from huaweicloud_encryptionsdk.kms.decrypt_key_capsule_response import DecryptKeyCapsuleResponse
+
+
+class TestCreateKeyCapsuleRequest:
+    def test_defaults(self):
+        r = CreateKeyCapsuleRequest()
+        assert r.key_id is None
+        assert r.datakey_length == 0
+        assert r.public_key is None
+        assert r.policy_id is None
+        assert r.key_policy is None
+
+    def test_to_dict(self):
+        r = CreateKeyCapsuleRequest(key_id="kid", datakey_length=256, public_key="pk", policy_id="pid")
+        d = r.to_dict()
+        assert d["key_id"] == "kid"
+        assert d["datakey_length"] == 256
+        assert d["public_key"] == "pk"
+        assert d["policy_id"] == "pid"
+
+    def test_from_dict(self):
+        d = {"key_id": "kid", "datakey_length": 128, "public_key": "pk", "policy_id": "pid", "key_policy": "kp"}
+        r = CreateKeyCapsuleRequest.from_dict(d)
+        assert r.key_id == "kid"
+        assert r.datakey_length == 128
+        assert r.key_policy == "kp"
+
+    def test_roundtrip(self):
+        r = CreateKeyCapsuleRequest(key_id="kid", datakey_length=256, public_key="pk")
+        d = r.to_dict()
+        r2 = CreateKeyCapsuleRequest.from_dict(d)
+        assert r2.key_id == r.key_id
+        assert r2.datakey_length == r.datakey_length
+
+
+class TestCreateKeyCapsuleResponse:
+    def test_defaults(self):
+        r = CreateKeyCapsuleResponse()
+        assert r.key_id is None
+        assert r.datakey_cipher is None
+        assert r.datakey is None
+        assert r.datakey_capsule is None
+
+    def test_from_dict(self):
+        d = {"key_id": "kid", "datakey_cipher": "cipher", "datakey": "dk", "datakey_capsule": "capsule"}
+        r = CreateKeyCapsuleResponse.from_dict(d)
+        assert r.key_id == "kid"
+        assert r.datakey_cipher == "cipher"
+        assert r.datakey == "dk"
+        assert r.datakey_capsule == "capsule"
+
+
+class TestDecryptKeyCapsuleRequest:
+    def test_defaults(self):
+        r = DecryptKeyCapsuleRequest()
+        assert r.key_id is None
+        assert r.datakey_capsule is None
+        assert r.attestation_document is None
+
+    def test_to_dict(self):
+        r = DecryptKeyCapsuleRequest(key_id="kid", datakey_capsule="capsule")
+        d = r.to_dict()
+        assert d["key_id"] == "kid"
+        assert d["datakey_capsule"] == "capsule"
+
+    def test_from_dict(self):
+        d = {"key_id": "kid", "datakey_capsule": "capsule"}
+        r = DecryptKeyCapsuleRequest.from_dict(d)
+        assert r.key_id == "kid"
+        assert r.datakey_capsule == "capsule"
+
+
+class TestDecryptKeyCapsuleResponse:
+    def test_defaults(self):
+        r = DecryptKeyCapsuleResponse()
+        assert r.key_id is None
+        assert r.datakey is None
+        assert r.datakey_cipher is None
+        assert r.instance_id is None
+
+    def test_from_dict(self):
+        d = {"key_id": "kid", "datakey": "dk", "datakey_cipher": "cipher", "instanceId": "inst-123"}
+        r = DecryptKeyCapsuleResponse.from_dict(d)
+        assert r.key_id == "kid"
+        assert r.datakey == "dk"
+        assert r.instance_id == "inst-123"
+
+    def test_from_dict_without_instance_id(self):
+        d = {"key_id": "kid", "datakey": "dk"}
+        r = DecryptKeyCapsuleResponse.from_dict(d)
+        assert r.instance_id is None

tests/test_log_file_backup.py

@@ -0,0 +1,45 @@
+import os
+import json
+import time
+import pytest
+from huaweicloud_encryptionsdk.log.log_file_backup import LogFileBackup
+
+
+class TestLogFileBackup:
+    def test_save_and_recover(self, tmp_path):
+        backup = LogFileBackup(backup_dir_path=str(tmp_path))
+        logs = [{"operation": "encrypt", "keyId": "kid-123"}]
+        filepath = backup.save_failed_logs(logs, int(time.time() * 1000))
+        assert filepath is not None
+        assert os.path.exists(filepath)
+
+        recovered = backup.recover_failed_logs()
+        assert len(recovered) == 1
+        assert recovered[0]["operation"] == "encrypt"
+        assert recovered[0]["keyId"] == "kid-123"
+
+    def test_save_multiple_batches(self, tmp_path):
+        backup = LogFileBackup(backup_dir_path=str(tmp_path))
+        backup.save_failed_logs([{"op": "a"}], int(time.time() * 1000))
+        time.sleep(0.01)
+        backup.save_failed_logs([{"op": "b"}], int(time.time() * 1000))
+
+        recovered = backup.recover_failed_logs()
+        assert len(recovered) == 2
+
+    def test_clear_all(self, tmp_path):
+        backup = LogFileBackup(backup_dir_path=str(tmp_path))
+        backup.save_failed_logs([{"op": "a"}], int(time.time() * 1000))
+        backup.clear_all_backup_files()
+
+        recovered = backup.recover_failed_logs()
+        assert len(recovered) == 0
+
+    def test_recover_from_empty_dir(self, tmp_path):
+        backup = LogFileBackup(backup_dir_path=str(tmp_path))
+        recovered = backup.recover_failed_logs()
+        assert recovered == []
+
+    def test_backup_dir_property(self, tmp_path):
+        backup = LogFileBackup(backup_dir_path=str(tmp_path))
+        assert backup.backup_dir_path == str(tmp_path)

tests/test_lts_struct_log_builder.py

@@ -0,0 +1,97 @@
+import json
+import pytest
+from huaweicloud_encryptionsdk.log.lts_struct_log_builder import LtsStructLogBuilder
+
+
+class TestBuildEncryptStructLog:
+    def test_basic_fields(self):
+        log = LtsStructLogBuilder.build_encrypt_struct_log(
+            encrypt_file_name=None,
+            encrypt_data_bytes=100,
+            encrypt_output_file_name=None,
+            encrypt_output_bytes=200,
+            key_id="kid-123",
+            access_point_type="ECS",
+            instance_id="inst-456",
+        )
+        assert log["operation"] == "encrypt"
+        assert "timestamp" in log
+        assert "utcTime" in log
+        assert log["encryptDataBytes"] == "100"
+        assert log["encryptOutputBytes"] == "200"
+        assert log["keyId"] == "kid-123"
+        assert log["accessPointType"] == "ECS"
+        assert log["instanceId"] == "inst-456"
+
+    def test_optional_fields_omitted(self):
+        log = LtsStructLogBuilder.build_encrypt_struct_log(
+            encrypt_file_name=None,
+            encrypt_data_bytes=0,
+            encrypt_output_file_name=None,
+            encrypt_output_bytes=0,
+            key_id=None,
+            access_point_type=None,
+            instance_id=None,
+        )
+        assert "encryptDataBytes" not in log
+        assert "encryptOutputBytes" not in log
+        assert "keyId" not in log
+        assert "accessPointType" not in log
+        assert "instanceId" not in log
+
+    def test_with_file_names(self):
+        log = LtsStructLogBuilder.build_encrypt_struct_log(
+            encrypt_file_name="test.txt",
+            encrypt_data_bytes=100,
+            encrypt_output_file_name="test.enc",
+            encrypt_output_bytes=200,
+            key_id="kid",
+            access_point_type="Custom",
+            instance_id=None,
+        )
+        assert log["encryptFileName"] == "test.txt"
+        assert log["encryptOutputFileName"] == "test.enc"
+        assert "instanceId" not in log
+
+    def test_utc_time_format(self):
+        log = LtsStructLogBuilder.build_encrypt_struct_log(
+            encrypt_file_name=None, encrypt_data_bytes=None,
+            encrypt_output_file_name=None, encrypt_output_bytes=None,
+            key_id=None, access_point_type=None, instance_id=None,
+        )
+        assert log["utcTime"].endswith("Z")
+        assert "T" in log["utcTime"]
+
+
+class TestBuildDecryptStructLog:
+    def test_basic_fields(self):
+        log = LtsStructLogBuilder.build_decrypt_struct_log(
+            decrypt_file_name=None,
+            decrypt_data_bytes=200,
+            decrypt_output_file_name=None,
+            decrypt_output_bytes=100,
+            key_id="kid-123",
+            access_point_type="CCE",
+            instance_id="inst-789",
+        )
+        assert log["operation"] == "decrypt"
+        assert log["decryptDataBytes"] == "200"
+        assert log["decryptOutputBytes"] == "100"
+        assert log["keyId"] == "kid-123"
+        assert log["accessPointType"] == "CCE"
+        assert log["instanceId"] == "inst-789"
+
+    def test_instance_id_from_decrypt_response(self):
+        log = LtsStructLogBuilder.build_decrypt_struct_log(
+            decrypt_file_name=None, decrypt_data_bytes=None,
+            decrypt_output_file_name=None, decrypt_output_bytes=None,
+            key_id="kid", access_point_type="Custom",
+            instance_id="from-kms-response",
+        )
+        assert log["instanceId"] == "from-kms-response"
+
+
+class TestGetLocalIp:
+    def test_returns_string_or_none(self):
+        ip = LtsStructLogBuilder.get_local_ip()
+        assert ip is None or isinstance(ip, str)

tests/test_models.py

@@ -0,0 +1,142 @@
+import pytest
+from huaweicloud_encryptionsdk.model.key_capsule import KeyCapsule
+from huaweicloud_encryptionsdk.model.kms_config import KMSConfig
+from huaweicloud_encryptionsdk.model.access_point_config import AccessPointConfig
+from huaweicloud_encryptionsdk.model.key_capsule_config import KeyCapsuleConfig
+from huaweicloud_encryptionsdk.model.data_key_materials import DataKeyMaterials
+from huaweicloud_encryptionsdk.model.crypto_result import CryptoResult
+from huaweicloud_encryptionsdk.model.request.encrypt_request import EncryptRequest
+from huaweicloud_encryptionsdk.huawei_config import HuaweiConfig
+from huaweicloud_encryptionsdk.model.enums.crypto_algorithm import CryptoAlgorithm
+
+
+class TestKeyCapsule:
+    def test_defaults(self):
+        kc = KeyCapsule()
+        assert kc.key_id is None
+        assert kc.datakey_capsule is None
+        assert kc.access_point_type == 0
+        assert kc.instance_id is None
+
+    def test_with_values(self):
+        kc = KeyCapsule(key_id="kid", datakey_capsule="capsule", access_point_type=1, instance_id="inst-123")
+        assert kc.key_id == "kid"
+        assert kc.datakey_capsule == "capsule"
+        assert kc.access_point_type == 1
+        assert kc.instance_id == "inst-123"
+
+
+class TestKMSConfig:
+    def test_defaults(self):
+        c = KMSConfig()
+        assert c.region == ""
+        assert c.key_id == ""
+        assert c.project_id == ""
+        assert c.end_point is None
+
+    def test_with_values(self):
+        c = KMSConfig(region="cn-north-7", key_id="kid", project_id="pid", end_point="https://kms.example.com")
+        assert c.region == "cn-north-7"
+        assert c.key_id == "kid"
+        assert c.project_id == "pid"
+        assert c.end_point == "https://kms.example.com"
+
+
+class TestAccessPointConfig:
+    def test_defaults(self):
+        ap = AccessPointConfig()
+        assert ap.type == 0
+        assert ap.encrypted_private_key is None
+        assert ap.private_key_decrypt_callback is None
+        assert ap.service_account is None
+
+    def test_with_callback(self):
+        cb = lambda x: x
+        ap = AccessPointConfig(type=2, encrypted_private_key="enc", private_key_decrypt_callback=cb)
+        assert ap.type == 2
+        assert ap.private_key_decrypt_callback("test") == "test"
+
+
+class TestKeyCapsuleConfig:
+    def test_defaults(self):
+        kcc = KeyCapsuleConfig()
+        assert kcc.region == ""
+        assert kcc.default_policy_id is None
+        assert kcc.default_key_policy is None
+        assert kcc.access_point_config is None
+
+    def test_with_access_point(self):
+        ap = AccessPointConfig(type=1)
+        kcc = KeyCapsuleConfig(region="cn-north-7", access_point_config=ap)
+        assert kcc.region == "cn-north-7"
+        assert kcc.access_point_config.type == 1
+
+
+class TestEncryptRequest:
+    def test_defaults(self):
+        r = EncryptRequest()
+        assert r.encryption_context == {}
+        assert r.plain_text == b""
+        assert r.policy_id is None
+        assert r.key_policy is None
+
+    def test_with_values(self):
+        r = EncryptRequest(plain_text=b"hello", policy_id="pid")
+        assert r.plain_text == b"hello"
+        assert r.policy_id == "pid"
+
+
+class TestDataKeyMaterials:
+    def test_defaults(self):
+        dkm = DataKeyMaterials()
+        assert dkm.plaintext_data_key == b""
+        assert dkm.ciphertext_data_keys == []
+        assert dkm.encryption_contexts == {}
+        assert dkm.crypto_algorithm is None
+        assert dkm.key_capsule is None
+
+    def test_with_values(self):
+        kc = KeyCapsule(key_id="kid", instance_id="inst-1")
+        dkm = DataKeyMaterials(plaintext_data_key=b"\x01\x02", key_capsule=kc)
+        assert dkm.plaintext_data_key == b"\x01\x02"
+        assert dkm.key_capsule.key_id == "kid"
+        assert dkm.key_capsule.instance_id == "inst-1"
+
+
+class TestCryptoResult:
+    def test_defaults(self):
+        r = CryptoResult()
+        assert r.result is None
+        assert r.headers is None
+        assert r.data_length == 0
+
+    def test_with_values(self):
+        r = CryptoResult(result=b"decrypted", data_length=10)
+        assert r.result == b"decrypted"
+        assert r.data_length == 10
+
+
+class TestHuaweiConfig:
+    def test_defaults(self):
+        c = HuaweiConfig()
+        assert c.ak == ""
+        assert c.sk == ""
+        assert c.is_discovery is False
+        assert c.kms_config_list is None
+        assert c.crypto_algorithm is None
+        assert c.key_capsule_config is None
+        assert c.log_config is None
+        assert c.local_log_only is False
+
+    def test_set_ak_sk(self):
+        c = HuaweiConfig()
+        c.set_ak("myak")
+        c.set_sk("mysk")
+        assert c.get_ak() == "myak"
+        assert c.get_sk() == "mysk"
+
+    def test_with_key_capsule(self):
+        kcc = KeyCapsuleConfig(region="cn-north-7")
+        c = HuaweiConfig(ak="ak", sk="sk", key_capsule_config=kcc, crypto_algorithm=CryptoAlgorithm.AES_256_GCM_NOPADDING)
+        assert c.key_capsule_config.region == "cn-north-7"
+        assert c.crypto_algorithm == CryptoAlgorithm.AES_256_GCM_NOPADDING

tests/test_utils.py

@@ -0,0 +1,111 @@
+import pytest
+from huaweicloud_encryptionsdk.common.utils import (
+    is_empty, hex_to_bytes, bytes_to_hex, long_to_bytes, bytes_to_long,
+    bytes_to_int, add_prevent_overflow, serialize_context, deserialize_context,
+    get_capsule_kms_config,
+)
+from huaweicloud_encryptionsdk.model.kms_config import KMSConfig
+from huaweicloud_encryptionsdk.model.key_capsule_config import KeyCapsuleConfig
+
+
+class TestIsEmpty:
+    def test_none(self):
+        assert is_empty(None) is True
+
+    def test_empty_string(self):
+        assert is_empty("") is True
+
+    def test_empty_list(self):
+        assert is_empty([]) is True
+
+    def test_non_empty_string(self):
+        assert is_empty("abc") is False
+
+    def test_non_empty_list(self):
+        assert is_empty([1]) is False
+
+    def test_zero(self):
+        assert is_empty(0) is True
+
+
+class TestHexConversion:
+    def test_hex_to_bytes(self):
+        assert hex_to_bytes("48656c6c6f") == b"Hello"
+
+    def test_bytes_to_hex(self):
+        assert bytes_to_hex(b"Hello") == "48656c6c6f"
+
+    def test_roundtrip(self):
+        original = b"\x01\x02\xff\x00"
+        assert hex_to_bytes(bytes_to_hex(original)) == original
+
+    def test_empty(self):
+        with pytest.raises(ValueError):
+            hex_to_bytes("")
+        assert bytes_to_hex(b"") == ""
+
+
+class TestLongBytesConversion:
+    def test_long_to_bytes(self):
+        result = long_to_bytes(256)
+        assert len(result) == 8
+        assert result[-2:] == b"\x01\x00"
+
+    def test_bytes_to_long(self):
+        assert bytes_to_long(long_to_bytes(12345)) == 12345
+
+    def test_bytes_to_int(self):
+        b = b"\x00\x00\x00\x2a"
+        assert bytes_to_int(b) == 42
+
+    def test_roundtrip(self):
+        for val in [0, 1, 255, 256, 65535, 2**31 - 1]:
+            assert bytes_to_long(long_to_bytes(val)) == val
+
+
+class TestAddPreventOverflow:
+    def test_normal(self):
+        assert add_prevent_overflow(100, 200) == 300
+
+    def test_overflow(self):
+        result = add_prevent_overflow(2**63 - 1, 1)
+        assert result == 2**63
+
+    def test_zero(self):
+        assert add_prevent_overflow(0, 0) == 0
+
+
+class TestSerializeContext:
+    def test_roundtrip(self):
+        ctx = {"key1": "value1", "key2": "value2"}
+        serialized = serialize_context(ctx)
+        deserialized = deserialize_context(serialized)
+        assert deserialized == ctx
+
+    def test_empty_context(self):
+        ctx = {}
+        serialized = serialize_context(ctx)
+        deserialized = deserialize_context(serialized)
+        assert deserialized == ctx
+
+    def test_single_entry(self):
+        ctx = {"a": "b"}
+        serialized = serialize_context(ctx)
+        deserialized = deserialize_context(serialized)
+        assert deserialized == ctx
+
+
+class TestGetCapsuleKmsConfig:
+    def test_found(self):
+        kms1 = KMSConfig(region="cn-north-7", key_id="kid1", project_id="pid1")
+        kms2 = KMSConfig(region="cn-south-1", key_id="kid2", project_id="pid2")
+        kcc = KeyCapsuleConfig(region="cn-north-7")
+        result = get_capsule_kms_config([kms1, kms2], kcc)
+        assert result.region == "cn-north-7"
+        assert result.key_id == "kid1"
+
+    def test_not_found(self):
+        kms1 = KMSConfig(region="cn-north-7", key_id="kid1", project_id="pid1")
+        kcc = KeyCapsuleConfig(region="cn-south-1")
+        with pytest.raises(Exception):
+            get_capsule_kms_config([kms1], kcc)