Remove dead code

Author: b-long

tests/test_validate_otdf_python.py

@@ -15,7 +15,6 @@
 # Add the local otdf_python source directory to sys.path
 # sys.path.insert(0, str(Path(__file__).parent / "src"))
 
-from otdf_python.config import TDFConfig
 from otdf_python.kas_info import KASInfo
 from otdf_python.sdk_builder import SDKBuilder
 from otdf_python.sdk import SDK
@@ -24,31 +23,7 @@
 from tests.config_pydantic import CONFIG_TDF
 
 
-def get_fallback_kas_public_key() -> str:
-    """
-    Get the KAS public key from environment variables or use a fallback.
-
-    Returns:
-        str: The KAS public key
-    """
-    # Try to get from environment
-    kas_public_key = os.environ.get("OPENTDF_KAS_PUBLIC_KEY")
-    if kas_public_key:
-        return kas_public_key
-
-    # Fallback to default test key
-    return """-----BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvxW+N0O+ZdYG9JDAXhCP
-0bc9OHCIa9IHrP0O6I1a1/gYnZXUVkL/5VX1HCTwg8lYYGjFpDXCYl7kzr42RW9K
-nzpgmH3A7erLp0X87Jzi7CgANu38/drJ5EnjWYQ7jkGY9vF/lJFG13RlM3HjhzGV
-eIocJaQM3U4r1WMzUwYUoZ9/QfGUdwxbGKxkaY/Z2KjaS6A35RCiQyy2K8unmY9T
-HPQHcm0OCZZkp4mXTWF8VoGIpPACCtSBR1t6tt3nZGH+pmIYYnV+gulYbJEvcaj/
-n1UDtivFEh1ZSWKdVLzvwBGS6+pVaXLQH+tPRUSQ7/oBL5GQEMxYnTsQcmGPJxrL
-pQIDAQAB
------END PUBLIC KEY-----"""
-
-
-def _get_configuration() -> SDK:
+def _get_sdk() -> SDK:
     return (
         SDKBuilder()
         .set_platform_endpoint(
@@ -69,92 +44,37 @@ def _get_configuration() -> SDK:
     )
 
 
-# Helper to build TDFConfig safely, using environment variables for defaults
-def build_tdf_config() -> TDFConfig:
-    config = {}
-
-    # Helper to build a KASInfo from dict or env
-    def build_kasinfo_from_env_or_dict(kas):
-        if isinstance(kas, KASInfo):
-            return kas
-        if isinstance(kas, dict):
-            return KASInfo(**kas)
-        # Use environment variables for defaults
-        return KASInfo(
-            url=os.environ.get("OPENTDF_KAS_URL", "https://default.kas.example.com"),
-            public_key=get_fallback_kas_public_key(),
-            kid=os.environ.get("OPENTDF_KAS_KID", None),
-            default=None,
-            algorithm=None,
-        )
-
-    kas_info = config.get("kas_info")
-    if not kas_info:
-        kas_info = build_kasinfo_from_env_or_dict(None)
-    elif isinstance(kas_info, list):
-        kas_info = [build_kasinfo_from_env_or_dict(k) for k in kas_info]
-    else:
-        kas_info = build_kasinfo_from_env_or_dict(kas_info)
-
-    # Only pass valid fields for TDFConfig
-    valid_keys = {
-        "kas_info",
-        "kas_private_key",
-        "policy_object",
-        "attributes",
-        "segment_size",
-    }
-    filtered = {k: v for k, v in config.items() if k in valid_keys}
-    filtered["kas_info"] = kas_info
-
-    # Optionally, set kas_private_key from env if not provided
-    if "kas_private_key" not in filtered or not filtered["kas_private_key"]:
-        filtered["kas_private_key"] = os.environ.get("OPENTDF_KAS_PRIVATE_KEY", None)
+def _get_sdk_and_tdf_config() -> tuple:
+    sdk = _get_sdk()
 
-    # Use the new builder pattern if available
+    # Create KASInfo without public key - let the SDK fetch it
+    kas_info = KASInfo(
+        url=CONFIG_TDF.OPENTDF_PLATFORM_URL,
+        default=True,
+    )
 
-    sdk = _get_configuration()
-    return sdk.new_tdf_config(**filtered)
+    tdf_config = sdk.new_tdf_config(
+        attributes=["attr1", "attr2"],
+        kas_info_list=[kas_info],  # KAS info without explicit public key
+    )
+    return sdk, tdf_config
 
 
-def encrypt_file(input_path: Path, sdk=None) -> Path:
+def encrypt_file(input_path: Path) -> Path:
     """Encrypt a file and return the path to the encrypted file."""
-    if sdk is None:
-        kas_url = os.environ.get("OPENTDF_KAS_URL", "https://default.kas.example.com")
 
-        # Build the SDK
-        sdk = _get_configuration()
-
-        # Create KASInfo without public key - let the SDK fetch it
-        kas_info = KASInfo(url=kas_url)
-
-        # Create config with the KASInfo
-        config = sdk.new_tdf_config(
-            attributes=["attr1", "attr2"], kas_info_list=[kas_info]
-        )
-    else:
-        # If SDK is provided, we need to create a config with attributes and KASInfo
-        # Get the platform URL from the SDK
-        kas_url = sdk.get_platform_url() or "https://default.kas.example.com"
-
-        # Create KASInfo without public key - let the SDK fetch it
-        kas_info = KASInfo(url=kas_url)
-
-        # Create config with attributes and KASInfo
-        config = sdk.new_tdf_config(
-            attributes=["attr1", "attr2"], kas_info_list=[kas_info]
-        )
+    # Build the SDK
+    sdk, tdf_config = _get_sdk_and_tdf_config()
 
     output_path = input_path.with_suffix(input_path.suffix + ".tdf")
     with open(input_path, "rb") as infile, open(output_path, "wb") as outfile:
-        sdk.create_tdf(infile.read(), config, output_stream=outfile)
+        sdk.create_tdf(infile.read(), tdf_config, output_stream=outfile)
     return output_path
 
 
-def decrypt_file(encrypted_path: Path, sdk=None) -> Path:
+def decrypt_file(encrypted_path: Path) -> Path:
     """Decrypt a file and return the path to the decrypted file."""
-    if sdk is None:
-        sdk = _get_configuration()
+    sdk = _get_sdk()
 
     output_path = encrypted_path.with_suffix(".decrypted")
     with open(encrypted_path, "rb") as infile, open(output_path, "wb") as outfile:
@@ -179,7 +99,7 @@ def decrypt_file(encrypted_path: Path, sdk=None) -> Path:
 def verify_encrypt_str() -> None:
     print("Validating string encryption (local TDF)")
     try:
-        sdk = _get_configuration()
+        sdk = _get_sdk()
 
         payload = b"Hello from Python"
 
@@ -189,7 +109,7 @@ def verify_encrypt_str() -> None:
             default=True,
         )
 
-        config = sdk.new_tdf_config(
+        tdf_config = sdk.new_tdf_config(
             attributes=["attr1", "attr2"],
             kas_info_list=[kas_info],  # KAS info without explicit public key
         )
@@ -198,7 +118,7 @@ def verify_encrypt_str() -> None:
         from io import BytesIO
 
         output = BytesIO()
-        sdk.create_tdf(payload, config, output_stream=output)
+        sdk.create_tdf(payload, tdf_config, output_stream=output)
         manifest_bytes = output.getvalue()
         print(f"Manifest returned: {manifest_bytes[:60]}... (truncated)")
         assert manifest_bytes and len(manifest_bytes) > 0
@@ -233,6 +153,11 @@ def verify_encrypt_file() -> None:
         ) from e
 
 
+def test_verify_encrypt_file():
+    """Run the file encryption verification test."""
+    verify_encrypt_file()
+
+
 def verify_encrypt_decrypt_file() -> None:
     print("Validating encrypt/decrypt roundtrip (local TDF)")
     try:
@@ -241,17 +166,12 @@ def verify_encrypt_decrypt_file() -> None:
             input_file = tmpDir / "plain.txt"
             input_file.write_text("Secret message")
 
-            # Build the SDK
-            sdk = _get_configuration()
-
-            # Get public key from KAS
             try:
-                # Use the encrypt_file function which now gets the public key from KAS
-                encrypted_path = encrypt_file(input_file, sdk)
+                encrypted_path = encrypt_file(input_file)
                 print(f"Encrypted file at: {encrypted_path}")
 
                 # Decrypt the file using the same SDK
-                decrypted_path = decrypt_file(encrypted_path, sdk)
+                decrypted_path = decrypt_file(encrypted_path)
                 print(f"Decrypted file at: {decrypted_path}")
 
                 # Verify the result