sfq 0.0.42__tar.gz → 0.0.43__tar.gz

{sfq-0.0.42 → sfq-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sfq
-Version: 0.0.42
+Version: 0.0.43
 Summary: Python wrapper for the Salesforce's Query API.
 Author-email: David Moruzzi <sfq.pypi@dmoruzi.com>
 Keywords: salesforce,salesforce query

{sfq-0.0.42 → sfq-0.0.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sfq"
-version = "0.0.42"
+version = "0.0.43"
 description = "Python wrapper for the Salesforce's Query API."
 readme = "README.md"
 authors = [{ name = "David Moruzzi", email = "sfq.pypi@dmoruzi.com" }]

{sfq-0.0.42 → sfq-0.0.43}/src/sfq/__init__.py

@@ -52,7 +52,7 @@ __all__ = [
     "PlatformEventsClient",
 ]
 
-__version__ = "0.0.42"
+__version__ = "0.0.43"
 """
 ### `__version__`
 
@@ -70,7 +70,7 @@ class _SFTokenAuth:
         access_token: str,
         api_version: str = "v64.0",
         token_endpoint: str = "/services/oauth2/token",
-        user_agent: str = "sfq/0.0.42",
+        user_agent: str = "sfq/0.0.43",
         sforce_client: str = "_auto",
         proxy: str = "_auto",
     ) -> None:
@@ -114,7 +114,7 @@ class SFAuth:
         access_token: Optional[str] = None,
         token_expiration_time: Optional[float] = None,
         token_lifetime: int = 15 * 60,
-        user_agent: str = "sfq/0.0.42",
+        user_agent: str = "sfq/0.0.43",
         sforce_client: str = "_auto",
         proxy: str = "_auto",
     ) -> None:
@@ -185,7 +185,7 @@ class SFAuth:
         )
 
         # Store version information
-        self.__version__ = "0.0.42"
+        self.__version__ = "0.0.43"
         """
         ### `__version__`
         

{sfq-0.0.42 → sfq-0.0.43}/src/sfq/http_client.py

@@ -29,7 +29,7 @@ class HTTPClient:
     def __init__(
         self,
         auth_manager: AuthManager,
-        user_agent: str = "sfq/0.0.42",
+        user_agent: str = "sfq/0.0.43",
         sforce_client: str = "_auto",
         high_api_usage_threshold: int = 80,
     ) -> None:

{sfq-0.0.42 → sfq-0.0.43}/src/sfq/utils.py

@@ -6,6 +6,8 @@ used throughout the SFQ library, including the custom TRACE logging level and
 sensitive data redaction functionality.
 """
 
+import base64
+import hashlib
 import json
 import logging
 import re
@@ -374,3 +376,69 @@ def records_to_html_table(
         normalized_data.append(normalized_row)
 
     return dicts_to_html_table(normalized_data, styled=styled)
+
+
+def fuzz(text: str, key: str, prefix_len: int = 4, suffix_len: int = 4) -> str:
+    """Lightweight XOR-based obfuscation with variable hash prefix/suffix (no separators).
+    
+    Args:
+        text: The text to obfuscate
+        key: The key for XOR operation
+        prefix_len: Length of the MD5 hash prefix (default: 4)
+        suffix_len: Length of the SHA1 hash suffix (default: 4)
+        
+    Returns:
+        Base64 encoded obfuscated string
+    """
+
+    prefix = hashlib.md5(text.encode()).hexdigest()[:prefix_len]
+    suffix = hashlib.sha1(text.encode()).hexdigest()[-suffix_len:] if suffix_len > 0 else ""
+
+    if not key:
+        combined = prefix + text + suffix
+    else:
+        fuzzed_chars = [
+            chr(ord(char) ^ ord(key[i % len(key)])) for i, char in enumerate(text)
+        ]
+        combined = prefix + ''.join(fuzzed_chars) + suffix
+
+    encoded = base64.b64encode(combined.encode("utf-8")).decode("utf-8")
+    return encoded
+
+
+def defuzz(encoded_text: str, key: str, prefix_len: int = 4, suffix_len: int = 4) -> str:
+    """Reverse the fuzz transformation (no separators).
+    
+    Args:
+        encoded_text: The base64 encoded obfuscated text
+        key: The key used for original XOR operation
+        prefix_len: Length of the MD5 hash prefix (must match encoding)
+        suffix_len: Length of the SHA1 hash suffix (must match encoding)
+        
+    Returns:
+        The original decoded text
+        
+    Raises:
+        ValueError: If encoded text format is invalid or corrupted
+    """
+
+    decoded = base64.b64decode(encoded_text.encode("utf-8")).decode("utf-8")
+
+    if len(decoded) < prefix_len + suffix_len:
+        raise ValueError("Invalid encoded text format or corrupted data.")
+
+    prefix = decoded[:prefix_len]
+    suffix = decoded[-suffix_len:] if suffix_len > 0 else ""
+    body = decoded[prefix_len:-suffix_len] if suffix_len > 0 else decoded[prefix_len:]
+
+    if len(prefix) != prefix_len or len(suffix) != suffix_len:
+        raise ValueError("Prefix/suffix length mismatch or corrupted data.")
+
+    if not key:
+        return body
+
+    defuzzed_chars = [
+        chr(ord(char) ^ ord(key[i % len(key)])) for i, char in enumerate(body)
+    ]
+
+    return ''.join(defuzzed_chars)

sfq-0.0.43/tests/test_SFTokenAuth_e2e.py

@@ -0,0 +1,116 @@
+"""
+End-to-end tests for the SFTokenAuth module.
+
+These tests run against a real Salesforce instance using environment variables
+to ensure the SFTokenAuth functionality works correctly in practice.
+"""
+
+import os
+from typing import Dict, Any
+
+import pytest
+
+from sfq import SFAuth, _SFTokenAuth
+
+
+# Environment variable names for Salesforce authentication
+SF_ENV_VARS = {
+    "INSTANCE_URL": "SF_INSTANCE_URL",
+    "CLIENT_ID": "SF_CLIENT_ID",
+    "CLIENT_SECRET": "SF_CLIENT_SECRET",
+    "REFRESH_TOKEN": "SF_REFRESH_TOKEN"
+}
+
+
+def _validate_required_env_vars() -> None:
+    """Validate that all required environment variables are present."""
+    missing_vars = [
+        env_var for env_var in SF_ENV_VARS.values()
+        if not os.getenv(env_var)
+    ]
+    
+    if missing_vars:
+        pytest.fail(f"Missing required environment variables: {', '.join(missing_vars)}")
+
+
+def _get_auth_credentials() -> Dict[str, str]:
+    """Get authentication credentials from environment variables."""
+    _validate_required_env_vars()
+    
+    return {
+        "instance_url": os.getenv(SF_ENV_VARS["INSTANCE_URL"], ""),
+        "client_id": os.getenv(SF_ENV_VARS["CLIENT_ID"], ""),
+        "client_secret": os.getenv(SF_ENV_VARS["CLIENT_SECRET"], "").strip(),
+        "refresh_token": os.getenv(SF_ENV_VARS["REFRESH_TOKEN"], ""),
+    }
+
+
+@pytest.fixture(scope="module")
+def sf_auth_instance() -> SFAuth:
+    """Create an SFAuth instance for E2E testing."""
+    credentials = _get_auth_credentials()
+    return SFAuth(**credentials)
+
+
+@pytest.fixture(scope="module")
+def token_auth_instance(sf_auth_instance: SFAuth) -> _SFTokenAuth:
+    """Create an _SFTokenAuth instance using access token from SFAuth."""
+    # Ensure we have a valid access token
+    sf_auth_instance._refresh_token_if_needed()
+    
+    return _SFTokenAuth(
+        instance_url=sf_auth_instance.instance_url,
+        access_token=sf_auth_instance.access_token,
+    )
+
+
+def _validate_query_response(response: Dict[str, Any], expected_record_count: int = 1) -> None:
+    """Validate that a query response contains the expected structure and data."""
+    # Basic response validation
+    assert response is not None, "Query response should not be None"
+    assert isinstance(response, dict), f"Query should return a dict, got: {type(response)}"
+    
+    # Validate response structure
+    required_fields = ["records", "done", "totalSize"]
+    for field in required_fields:
+        assert field in response, f"Response missing required field '{field}': {response}"
+    
+    # Validate records
+    records = response["records"]
+    assert len(records) == expected_record_count, (
+        f"Expected {expected_record_count} record(s), got {len(records)}: {response}"
+    )
+    
+    # Validate record structure (for expected record count > 0)
+    if expected_record_count > 0:
+        record = records[0]
+        assert "Id" in record, f"Record missing 'Id' field: {record}"
+        assert record["Id"], f"Record 'Id' should not be empty: {record}"
+    
+    # Validate query completion status
+    assert response["done"] is True, f"Query should be marked as done: {response}"
+    
+    # Validate total size
+    assert response["totalSize"] == expected_record_count, (
+        f"Expected totalSize {expected_record_count}, got {response['totalSize']}: {response}"
+    )
+
+
+def test_basic_query_execution(token_auth_instance: _SFTokenAuth) -> None:
+    """Test that a basic SOQL query executes successfully and returns expected results."""
+    # Define a simple query that should return at least one record
+    query = "SELECT Id FROM FeedComment LIMIT 1"
+    
+    # Execute the query
+    response = token_auth_instance.query(query)
+    
+    # Validate the response
+    _validate_query_response(response, expected_record_count=1)
+
+
+def test_query_with_multiple_records(token_auth_instance: _SFTokenAuth) -> None:
+    """Test query execution that returns multiple records."""
+    query = "SELECT Id FROM FeedComment LIMIT 5"
+    response = token_auth_instance.query(query)
+    
+    _validate_query_response(response, expected_record_count=5)

sfq-0.0.43/tests/test_fuzzing.py

@@ -0,0 +1,659 @@
+import base64
+import pytest
+from sfq.utils import fuzz, defuzz
+
+# ============================================================================
+# BASIC FUNCTIONALITY TESTS
+# ============================================================================
+
+
+@pytest.mark.parametrize("prefix_len,suffix_len", [(2, 2), (4, 6), (8, 8)])
+def test_fuzz_defuzz_roundtrip(prefix_len: int, suffix_len: int) -> None:
+    """Test that fuzz/defuzz roundtrip works with various prefix/suffix lengths."""
+    text = "SensitiveData123!"
+    key = "mySecretKey"
+
+    encoded = fuzz(text, key, prefix_len=prefix_len, suffix_len=suffix_len)
+    decoded = defuzz(encoded, key, prefix_len=prefix_len, suffix_len=suffix_len)
+
+    assert decoded == text, (
+        f"Roundtrip failed for prefix={prefix_len}, suffix={suffix_len}"
+    )
+
+
+def test_different_keys_produce_different_output() -> None:
+    """Test that different keys produce different encoded results."""
+    text = "hello world"
+    key1 = "keyA"
+    key2 = "keyB"
+
+    enc1 = fuzz(text, key1)
+    enc2 = fuzz(text, key2)
+
+    assert enc1 != enc2, "Different keys should produce different results"
+
+
+def test_same_input_same_key_produces_same_output() -> None:
+    """Test that same input and key always produce identical output."""
+    text = "repeatable"
+    key = "staticKey"
+
+    enc1 = fuzz(text, key)
+    enc2 = fuzz(text, key)
+
+    assert enc1 == enc2, "Same input and key should always produce same output"
+
+
+# ============================================================================
+# ERROR HANDLING TESTS
+# ============================================================================
+
+
+def test_invalid_encoded_text_format() -> None:
+    """Test that invalid encoded text format raises appropriate exception."""
+    key = "abc"
+    bad_data = "not_base64|format"
+    with pytest.raises(Exception):
+        defuzz(bad_data, key)
+
+
+def test_invalid_base64_format() -> None:
+    """Test that invalid base64 format raises appropriate exception."""
+    key = "abc"
+    bad_data = "invalid_base64_string!"
+    with pytest.raises(Exception):
+        defuzz(bad_data, key)
+
+
+def test_prefix_suffix_length_mismatch() -> None:
+    """Test that mismatched prefix/suffix lengths raise ValueError."""
+    text = "TestData"
+    key = "abc123"
+    prefix_length = 4
+    suffix_length = 4
+
+    encoded = fuzz(text, key, prefix_len=prefix_length, suffix_len=suffix_length)
+    decoded = defuzz(encoded, key, prefix_len=prefix_length, suffix_len=suffix_length)
+    decoded_mismatch = defuzz(
+        encoded_text=encoded,
+        key=key,
+        prefix_len=prefix_length * 2,
+        suffix_len=suffix_length * 2,
+    )
+
+    assert decoded == text, "The decoded result should equal the original text"
+    assert decoded_mismatch != text, (
+        "The mismatched keys should not be equal to the original text"
+    )
+
+
+def test_missing_separators() -> None:
+    """Test that encoded text missing separators is handled correctly."""
+    key = "abc"
+    # Create valid format without separators (this should work fine)
+    text = "noseparators"
+    encoded = fuzz(text, key)
+    # This should not raise an exception
+    decoded = defuzz(encoded, key)
+    assert decoded == text, "Text without separators should work fine"
+
+
+def test_too_many_separators() -> None:
+    """Test that encoded text with too many separators raises ValueError."""
+    key = "abc"
+    # Create invalid format with too many separators
+    invalid_data = base64.b64encode("a|b|c|d".encode()).decode()
+    with pytest.raises(ValueError, match="Invalid encoded text format"):
+        defuzz(invalid_data, key)
+
+
+# ============================================================================
+# EDGE CASE TESTS
+# ============================================================================
+
+
+def test_empty_string() -> None:
+    """Test fuzzing/defuzzing of empty string."""
+    text = ""
+    key = "someKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Empty string should survive roundtrip"
+
+
+def test_single_character() -> None:
+    """Test fuzzing/defuzzing of single character."""
+    text = "a"
+    key = "someKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Single character should survive roundtrip"
+
+
+def test_unicode_support() -> None:
+    """Test that Unicode text survives roundtrip."""
+    text = "秘密情報🔒"
+    key = "unicodeKey"
+
+    encoded = fuzz(text, key, prefix_len=5, suffix_len=5)
+    decoded = defuzz(encoded, key, prefix_len=5, suffix_len=5)
+
+    assert decoded == text, "Unicode text should survive roundtrip"
+
+
+def test_special_characters() -> None:
+    """Test fuzzing/defuzzing of special characters."""
+    text = "!@#$%^&*()_+-=[]{}|;':\",./<>?"
+    key = "specialKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Special characters should survive roundtrip"
+
+
+def test_newlines_and_whitespace() -> None:
+    """Test fuzzing/defuzzing of strings with newlines and whitespace."""
+    text = "Line 1\nLine 2\tTabbed\r\nCarriage Return"
+    key = "whitespaceKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Newlines and whitespace should survive roundtrip"
+
+
+def test_long_strings() -> None:
+    """Test fuzzing/defuzzing of very long strings."""
+    text = "A" * 10000  # 10KB string
+    key = "longKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Long strings should survive roundtrip"
+
+
+def test_binary_data() -> None:
+    """Test fuzzing/defuzzing of binary-like data."""
+    text = "\x00\x01\x02\x03\xff\xfe\xfd"
+    key = "binaryKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Binary data should survive roundtrip"
+
+
+# ============================================================================
+# PARAMETER VARIATION TESTS
+# ============================================================================
+
+
+@pytest.mark.parametrize("prefix_len", [0, 1, 2, 4, 8, 16])
+@pytest.mark.parametrize("suffix_len", [0, 1, 2, 4, 8, 16])
+def test_various_prefix_suffix_lengths(prefix_len: int, suffix_len: int) -> None:
+    """Test fuzzing/defuzzing with various prefix/suffix length combinations."""
+    text = "Test data with varying lengths"
+    key = "testKey"
+
+    encoded = fuzz(text, key, prefix_len=prefix_len, suffix_len=suffix_len)
+    decoded = defuzz(encoded, key, prefix_len=prefix_len, suffix_len=suffix_len)
+
+    assert decoded == text, (
+        f"Roundtrip failed for prefix={prefix_len}, suffix={suffix_len}"
+    )
+
+
+def test_zero_prefix_suffix_length() -> None:
+    """Test fuzzing/defuzzing with zero prefix/suffix lengths."""
+    text = "Test data"
+    key = "testKey"
+
+    encoded = fuzz(text, key, prefix_len=0, suffix_len=0)
+    decoded = defuzz(encoded, key, prefix_len=0, suffix_len=0)
+
+    assert decoded == text, "Zero prefix/suffix lengths should work"
+
+
+def test_maximum_prefix_suffix_length() -> None:
+    """Test fuzzing/defuzzing with maximum reasonable prefix/suffix lengths."""
+    text = "Test data"
+    key = "testKey"
+
+    encoded = fuzz(text, key, prefix_len=32, suffix_len=32)
+    decoded = defuzz(encoded, key, prefix_len=32, suffix_len=32)
+
+    assert decoded == text, "Maximum prefix/suffix lengths should work"
+
+
+# ============================================================================
+# KEY VARIATION TESTS
+# ============================================================================
+
+
+@pytest.mark.parametrize("key", ["", "a", "ab", "abc", "very_long_key_string"])
+def test_various_key_lengths(key: str) -> None:
+    """Test fuzzing/defuzzing with various key lengths."""
+    text = "Test data"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, f"Roundtrip failed for key length {len(key)}"
+
+
+def test_empty_key() -> None:
+    """Test fuzzing/defuzzing with empty key."""
+    text = "Test data"
+    key = ""
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Empty key should work"
+
+
+def test_special_characters_in_key() -> None:
+    """Test fuzzing/defuzzing with special characters in key."""
+    text = "Test data"
+    key = "!@#$%^&*()"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Special characters in key should work"
+
+
+# ============================================================================
+# SECURITY AND COLLISION TESTS
+# ============================================================================
+
+
+def test_different_inputs_same_key() -> None:
+    """Test that different inputs produce different outputs with same key."""
+    key = "sameKey"
+    text1 = "hello world"
+    text2 = "goodbye world"
+
+    enc1 = fuzz(text1, key)
+    enc2 = fuzz(text2, key)
+
+    assert enc1 != enc2, "Different inputs should produce different outputs"
+
+
+def test_similar_inputs_different_output() -> None:
+    """Test that similar inputs produce different outputs."""
+    key = "testKey"
+    text1 = "hello world"
+    text2 = "hello worlD"  # Only one character difference
+
+    enc1 = fuzz(text1, key)
+    enc2 = fuzz(text2, key)
+
+    assert enc1 != enc2, "Similar inputs should produce different outputs"
+
+
+def test_hash_collision_resistance() -> None:
+    """Test that hash collisions are handled properly."""
+    # Test with inputs that might produce similar hash prefixes
+    key = "testKey"
+    text1 = "test"
+    text2 = "test "  # Slightly different
+
+    enc1 = fuzz(text1, key, prefix_len=8, suffix_len=8)
+    enc2 = fuzz(text2, key, prefix_len=8, suffix_len=8)
+
+    # Even if hashes are similar, the XOR should make them different
+    assert enc1 != enc2, "Hash collisions should not produce identical outputs"
+
+
+# ============================================================================
+# PERFORMANCE TESTS
+# ============================================================================
+
+
+def test_performance_multiple_calls() -> None:
+    """Test that multiple calls to fuzz/defuzz are consistent."""
+    text = "Performance test data"
+    key = "perfKey"
+
+    # Test multiple calls to ensure consistency
+    results = []
+    for _ in range(10):
+        encoded = fuzz(text, key)
+        decoded = defuzz(encoded, key)
+        results.append(decoded)
+
+    # All results should be identical to original
+    for result in results:
+        assert result == text, "All roundtrips should produce identical results"
+
+
+def test_large_data_performance() -> None:
+    """Test performance with large data sets."""
+    text = "Large data " * 1000  # ~15KB string
+    key = "largeKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Large data should survive roundtrip"
+
+
+# ============================================================================
+# BACKWARD COMPATIBILITY TESTS
+# ============================================================================
+
+
+def test_default_parameters() -> None:
+    """Test that default parameters work correctly."""
+    text = "Test data"
+    key = "testKey"
+
+    # Test with default parameters (should be prefix_len=4, suffix_len=4)
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Default parameters should work"
+
+
+def test_backward_compatibility() -> None:
+    """Test that existing code patterns still work."""
+    # Simulate old usage patterns
+    text = "Legacy data"
+    key = "legacyKey"
+
+    # Old style without explicit parameters
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Backward compatibility should be maintained"
+
+
+# ============================================================================
+# ENCODING SCENARIOS TESTS
+# ============================================================================
+
+
+def test_base64_encoding_robustness() -> None:
+    """Test that base64 encoding/decoding is robust."""
+    text = "Test data with various characters: áéíóú 中文 🚀"
+    key = "encodingKey"
+
+    encoded = fuzz(text, key)
+
+    # Verify the encoded result is valid base64
+    try:
+        decoded_base64 = base64.b64decode(encoded.encode()).decode()
+        # The implementation doesn't use separators, so we don't expect "|"
+        assert len(decoded_base64) > 0, "Decoded base64 should not be empty"
+    except Exception:
+        pytest.fail("Encoded result should be valid base64")
+
+    # Test roundtrip
+    decoded = defuzz(encoded, key)
+    assert decoded == text, "Base64 encoding should be robust"
+
+
+def test_hash_algorithm_consistency() -> None:
+    """Test that hash algorithms produce consistent results."""
+    text = "Consistency test"
+    key = "hashKey"
+
+    # Multiple calls should produce identical hash prefixes/suffixes
+    encoded1 = fuzz(text, key, prefix_len=8, suffix_len=8)
+    encoded2 = fuzz(text, key, prefix_len=8, suffix_len=8)
+
+    # Extract the hash parts to verify consistency
+    decoded1 = base64.b64decode(encoded1.encode()).decode()
+    decoded2 = base64.b64decode(encoded2.encode()).decode()
+
+    # Extract prefix and suffix directly (no separators in implementation)
+    prefix1 = decoded1[:8]
+    suffix1 = decoded1[-8:]
+    prefix2 = decoded2[:8]
+    suffix2 = decoded2[-8:]
+
+    assert prefix1 == prefix2, "MD5 hash prefix should be consistent"
+    assert suffix1 == suffix2, "SHA1 hash suffix should be consistent"
+
+
+def test_xor_operation_properties() -> None:
+    """Test XOR operation mathematical properties."""
+    text = "XOR test"
+    key = "xorKey"
+
+    # Test that XOR is reversible: (a ^ b) ^ b = a
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "XOR operation should be mathematically reversible"
+
+    # Test that same key produces same transformation
+    encoded2 = fuzz(text, key)
+    assert encoded == encoded2, "Same key should produce identical XOR transformation"
+
+
+# ============================================================================
+# ADDITIONAL EDGE CASES
+# ============================================================================
+
+
+def test_repeated_characters() -> None:
+    """Test fuzzing/defuzzing of strings with repeated characters."""
+    text = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"  # 32 'a's
+    key = "repeatKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Repeated characters should survive roundtrip"
+
+
+def test_mixed_case_sensitivity() -> None:
+    """Test case sensitivity of the fuzzing algorithm."""
+    text1 = "Hello World"
+    text2 = "hello world"
+    key = "caseKey"
+
+    enc1 = fuzz(text1, key)
+    enc2 = fuzz(text2, key)
+
+    assert enc1 != enc2, "Case sensitivity should be preserved"
+
+
+def test_numeric_data() -> None:
+    """Test fuzzing/defuzzing of numeric strings."""
+    text = "1234567890"
+    key = "numericKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Numeric data should survive roundtrip"
+
+
+def test_alphanumeric_data() -> None:
+    """Test fuzzing/defuzzing of alphanumeric strings."""
+    text = "Alphanumeric123!@#"
+    key = "alphanumericKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Alphanumeric data should survive roundtrip"
+
+
+def test_unicode_combining_characters() -> None:
+    """Test fuzzing/defuzzing of Unicode combining characters."""
+    text = "c\u0327"  # c + combining tilde = ç
+    key = "unicodeCombineKey"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Unicode combining characters should survive roundtrip"
+
+
+# ============================================================================
+# STRESS TESTS
+# ============================================================================
+
+
+def test_stress_multiple_variations() -> None:
+    """Stress test with multiple parameter variations."""
+    test_cases = [
+        ("short", "k"),
+        ("medium length text", "mediumKey"),
+        ("very long text " * 50, "veryLongKey"),
+        ("", ""),
+        ("special!@#$%^&*()", "special!@#$%^&*()"),
+        ("áéíóú 中文 🚀", "unicodeKey"),
+    ]
+
+    for text, key in test_cases:
+        encoded = fuzz(text, key)
+        decoded = defuzz(encoded, key)
+        assert decoded == text, (
+            f"Stress test failed for: text='{text[:50]}...', key='{key}'"
+        )
+
+
+def test_stress_hash_collisions() -> None:
+    """Stress test to check for hash collisions with many inputs."""
+    key = "stressKey"
+    results = set()
+
+    # Test many different inputs
+    for i in range(1000):
+        text = f"test_input_{i}"
+        encoded = fuzz(text, key, prefix_len=4, suffix_len=4)
+        results.add(encoded)
+
+    # Should have mostly unique results (allowing for some collisions due to short prefix/suffix)
+    assert len(results) >= 900, (
+        f"Too many hash collisions: {1000 - len(results)} collisions out of 1000"
+    )
+
+
+# ============================================================================
+# PROPERTY-BASED TESTS (using hypothesis-like testing)
+# ============================================================================
+
+
+def test_property_reversibility() -> None:
+    """Test that fuzz/defuzz is always reversible (property-based test)."""
+    # Test with a variety of inputs
+    test_inputs = [
+        "",
+        "a",
+        "ab",
+        "abc",
+        "hello",
+        "hello world",
+        "hello world!",
+        "123",
+        "123abc",
+        "abc123",
+        "123abc!@#",
+        "line1\nline2\tline3",
+        "áéíóú",
+        "中文",
+        "🚀",
+        "a" * 100,
+        "a" * 1000,
+    ]
+
+    key = "propertyKey"
+
+    for text in test_inputs:
+        encoded = fuzz(text, key)
+        decoded = defuzz(encoded, key)
+        assert decoded == text, f"Reversibility property failed for: {repr(text)}"
+
+
+def test_property_deterministic() -> None:
+    """Test that fuzz/defuzz is deterministic (property-based test)."""
+    test_inputs = ["hello", "", "special!@#", "unicode🚀"]
+    key = "deterministicKey"
+
+    for text in test_inputs:
+        # Multiple calls should produce identical results
+        encoded1 = fuzz(text, key)
+        encoded2 = fuzz(text, key)
+        encoded3 = fuzz(text, key)
+
+        assert encoded1 == encoded2 == encoded3, (
+            f"Deterministic property failed for: {repr(text)}"
+        )
+
+        decoded1 = defuzz(encoded1, key)
+        decoded2 = defuzz(encoded2, key)
+        decoded3 = defuzz(encoded3, key)
+
+        assert decoded1 == decoded2 == decoded3, (
+            f"Deterministic defuzz failed for: {repr(text)}"
+        )
+
+
+# ============================================================================
+# DOCUMENTATION AND EXAMPLE TESTS
+# ============================================================================
+
+
+def test_examples_from_documentation():
+    """Test examples that would be suitable for documentation."""
+    # Example 1: Basic usage
+    text = "sensitive_password_123"
+    key = "my_secret_key"
+
+    encoded = fuzz(text, key)
+    decoded = defuzz(encoded, key)
+
+    assert decoded == text, "Basic usage example should work"
+
+    # Example 2: Custom prefix/suffix lengths
+    encoded_custom = fuzz(text, key, prefix_len=8, suffix_len=8)
+    decoded_custom = defuzz(encoded_custom, key, prefix_len=8, suffix_len=8)
+
+    assert decoded_custom == text, "Custom prefix/suffix example should work"
+
+    # Example 3: Verify encoded format
+    decoded_format = base64.b64decode(encoded.encode()).decode()
+    # The implementation doesn't use separators, so we check the structure differently
+    assert len(decoded_format) > 0, "Encoded format should not be empty"
+    # Verify it has prefix + body + suffix structure
+    assert len(decoded_format) >= 8, (
+        "Encoded format should have at least prefix and suffix"
+    )
+
+
+def test_real_world_scenarios():
+    """Test real-world usage scenarios."""
+    scenarios = [
+        # API tokens
+        ("sk-1234567890abcdef", "api_key"),
+        # Passwords
+        ("P@ssw0rd!2023", "auth_key"),
+        # Session IDs
+        ("sess_abc123def456", "session_key"),
+        # JWT tokens
+        (
+            "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+            "jwt_key",
+        ),
+        # SQL queries (sanitized)
+        ("SELECT * FROM users WHERE id = 123", "query_key"),
+        # JSON data
+        ('{"user": "john", "pass": "secret"}', "json_key"),
+    ]
+
+    for text, key in scenarios:
+        encoded = fuzz(text, key)
+        decoded = defuzz(encoded, key)
+        assert decoded == text, f"Real-world scenario failed for: {text[:50]}..."

{sfq-0.0.42 → sfq-0.0.43}/uv.lock

@@ -3,5 +3,5 @@ requires-python = ">=3.9"
 
 [[package]]
 name = "sfq"
-version = "0.0.42"
+version = "0.0.43"
 source = { editable = "." }

sfq-0.0.42/tests/test_SFTokenAuth_e2e.py

@@ -1,58 +0,0 @@
-"""
-End-to-end tests for the SFTokenAuth module.
-
-These tests run against a real Salesforce instance using environment variables
-to ensure the SFTokenAuth functionality works correctly in practice.
-"""
-
-import os
-
-import pytest
-
-from sfq import _SFTokenAuth
-
-
-@pytest.fixture(scope="module")
-def sf_instance():
-    """Create an AuthManager instance for E2E testing."""
-    required_env_vars = [
-        "SF_INSTANCE_URL",
-        "SF_ACCESS_TOKEN",
-    ]
-
-    missing_vars = [var for var in required_env_vars if not os.getenv(var)]
-    if missing_vars:
-        pytest.fail(f"Missing required env vars: {', '.join(missing_vars)}")
-
-    sf = _SFTokenAuth(
-        instance_url=os.getenv("SF_INSTANCE_URL"),
-        access_token=os.getenv("SF_ACCESS_TOKEN"),
-    )
-    return sf
-
-
-def test_query(sf_instance):
-    """Ensure that a simple query returns the expected results."""
-    query = "SELECT Id FROM FeedComment LIMIT 1"
-    response = sf_instance.query(query)
-
-    assert response and isinstance(response, dict), (
-        f"Query did not return a dict: {response}"
-    )
-
-    assert "records" in response, f"No records in response: {response}"
-    assert len(response["records"]) == 1, (
-        f"Expected 1 record, got {len(response['records'])}: {response}"
-    )
-    assert "Id" in response["records"][0], (
-        f"No Id in record: {response['records'][0]}"
-    )
-    assert response["records"][0]["Id"], (
-        f"Id is empty in record: {response['records'][0]}"
-    )
-    assert response["done"] is True, f"Query not marked as done: {response}"
-    assert "totalSize" in response, f"No totalSize in response: {response}"
-    assert response["totalSize"] == 1, (
-        f"Expected totalSize 1, got {response['totalSize']}: {response}"
-    )
-