276 lines
9 KiB
Python
276 lines
9 KiB
Python
"""
|
|
Tests for resource limits module.
|
|
|
|
Following TDD approach - these tests are written before implementation.
|
|
Tests cover all parsing and validation requirements from todo.md section 1.2.1.
|
|
"""
|
|
|
|
import pytest
|
|
|
|
|
|
def test_parse_memory_string_megabytes():
|
|
"""Test parsing memory string with megabytes suffix."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
result = parse_memory_string("512m")
|
|
assert result == 536870912 # 512 * 1024 * 1024
|
|
|
|
|
|
def test_parse_memory_string_gigabytes():
|
|
"""Test parsing memory string with gigabytes suffix."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
result = parse_memory_string("2g")
|
|
assert result == 2147483648 # 2 * 1024 * 1024 * 1024
|
|
|
|
|
|
def test_parse_memory_string_kilobytes():
|
|
"""Test parsing memory string with kilobytes suffix."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
result = parse_memory_string("1024k")
|
|
assert result == 1048576 # 1024 * 1024
|
|
|
|
|
|
def test_parse_memory_string_case_insensitive():
|
|
"""Test that memory string parsing is case-insensitive."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
assert parse_memory_string("512M") == 536870912
|
|
assert parse_memory_string("2G") == 2147483648
|
|
assert parse_memory_string("1024K") == 1048576
|
|
|
|
|
|
def test_parse_memory_string_invalid_format_raises_value_error():
|
|
"""Test that invalid format raises ValueError."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
with pytest.raises(ValueError) as exc_info:
|
|
parse_memory_string("invalid")
|
|
assert "invalid" in str(exc_info.value).lower() or "format" in str(exc_info.value).lower()
|
|
|
|
with pytest.raises(ValueError):
|
|
parse_memory_string("512x") # Invalid suffix
|
|
|
|
with pytest.raises(ValueError):
|
|
parse_memory_string("abc") # Not a number
|
|
|
|
|
|
def test_parse_memory_string_negative_value_raises_value_error():
|
|
"""Test that negative values raise ValueError."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
with pytest.raises(ValueError) as exc_info:
|
|
parse_memory_string("-512m")
|
|
assert "positive" in str(exc_info.value).lower() or "negative" in str(exc_info.value).lower()
|
|
|
|
|
|
def test_parse_memory_string_zero_value_raises_value_error():
|
|
"""Test that zero value raises ValueError."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
with pytest.raises(ValueError) as exc_info:
|
|
parse_memory_string("0m")
|
|
assert "positive" in str(exc_info.value).lower() or "zero" in str(exc_info.value).lower()
|
|
|
|
|
|
def test_parse_cpu_quota_valid_value():
|
|
"""Test that valid CPU quota values are accepted."""
|
|
from pod_executor.security.resource_limits import parse_cpu_quota
|
|
|
|
result = parse_cpu_quota(50000)
|
|
assert result == 50000
|
|
|
|
result = parse_cpu_quota(100000) # 100% of one core
|
|
assert result == 100000
|
|
|
|
|
|
def test_parse_cpu_quota_max_limit():
|
|
"""Test that CPU quota has a reasonable maximum (10 cores)."""
|
|
from pod_executor.security.resource_limits import parse_cpu_quota
|
|
|
|
# Should accept up to 1000000 (10 cores)
|
|
result = parse_cpu_quota(1000000)
|
|
assert result == 1000000
|
|
|
|
# Should reject more than 10 cores
|
|
with pytest.raises(ValueError) as exc_info:
|
|
parse_cpu_quota(1000001)
|
|
assert "1000000" in str(exc_info.value) or "maximum" in str(exc_info.value).lower()
|
|
|
|
|
|
def test_parse_cpu_quota_negative_raises_value_error():
|
|
"""Test that negative CPU quota raises ValueError."""
|
|
from pod_executor.security.resource_limits import parse_cpu_quota
|
|
|
|
with pytest.raises(ValueError) as exc_info:
|
|
parse_cpu_quota(-1)
|
|
assert "positive" in str(exc_info.value).lower() or "negative" in str(exc_info.value).lower()
|
|
|
|
|
|
def test_parse_cpu_quota_zero_raises_value_error():
|
|
"""Test that zero CPU quota raises ValueError."""
|
|
from pod_executor.security.resource_limits import parse_cpu_quota
|
|
|
|
with pytest.raises(ValueError) as exc_info:
|
|
parse_cpu_quota(0)
|
|
assert "positive" in str(exc_info.value).lower() or "zero" in str(exc_info.value).lower()
|
|
|
|
|
|
def test_parse_storage_string_same_as_memory():
|
|
"""Test that storage parsing works the same as memory parsing."""
|
|
from pod_executor.security.resource_limits import parse_storage_string
|
|
|
|
assert parse_storage_string("1g") == 1073741824
|
|
assert parse_storage_string("512m") == 536870912
|
|
assert parse_storage_string("2048k") == 2097152
|
|
|
|
|
|
def test_resource_limits_class_initialization():
|
|
"""Test ResourceLimits class initializes correctly."""
|
|
from pod_executor.security.resource_limits import ResourceLimits
|
|
|
|
limits = ResourceLimits(
|
|
memory="512m",
|
|
storage="1g",
|
|
cpu_quota=50000,
|
|
timeout=300
|
|
)
|
|
|
|
assert limits.memory_bytes == 536870912
|
|
assert limits.storage_bytes == 1073741824
|
|
assert limits.cpu_quota == 50000
|
|
assert limits.timeout == 300
|
|
|
|
|
|
def test_resource_limits_validates_memory():
|
|
"""Test that ResourceLimits validates memory string."""
|
|
from pod_executor.security.resource_limits import ResourceLimits
|
|
|
|
with pytest.raises(ValueError):
|
|
ResourceLimits(
|
|
memory="invalid",
|
|
storage="1g",
|
|
cpu_quota=50000,
|
|
timeout=300
|
|
)
|
|
|
|
|
|
def test_resource_limits_validates_storage():
|
|
"""Test that ResourceLimits validates storage string."""
|
|
from pod_executor.security.resource_limits import ResourceLimits
|
|
|
|
with pytest.raises(ValueError):
|
|
ResourceLimits(
|
|
memory="512m",
|
|
storage="invalid",
|
|
cpu_quota=50000,
|
|
timeout=300
|
|
)
|
|
|
|
|
|
def test_resource_limits_validates_cpu_quota():
|
|
"""Test that ResourceLimits validates CPU quota."""
|
|
from pod_executor.security.resource_limits import ResourceLimits
|
|
|
|
with pytest.raises(ValueError):
|
|
ResourceLimits(
|
|
memory="512m",
|
|
storage="1g",
|
|
cpu_quota=-1,
|
|
timeout=300
|
|
)
|
|
|
|
|
|
def test_resource_limits_to_podman_params():
|
|
"""Test conversion to Podman container parameters."""
|
|
from pod_executor.security.resource_limits import ResourceLimits
|
|
|
|
limits = ResourceLimits(
|
|
memory="512m",
|
|
storage="1g",
|
|
cpu_quota=50000,
|
|
timeout=300
|
|
)
|
|
|
|
params = limits.to_podman_params()
|
|
|
|
assert isinstance(params, dict)
|
|
assert "mem_limit" in params
|
|
assert params["mem_limit"] == "536870912" # Should be string for Podman
|
|
# CPU quota is set via cpu_quota parameter
|
|
assert "cpu_quota" in params
|
|
assert params["cpu_quota"] == 50000
|
|
|
|
|
|
def test_resource_limits_default_timeout():
|
|
"""Test that ResourceLimits has a default timeout."""
|
|
from pod_executor.security.resource_limits import ResourceLimits
|
|
|
|
limits = ResourceLimits(
|
|
memory="512m",
|
|
storage="1g",
|
|
cpu_quota=50000
|
|
)
|
|
|
|
assert limits.timeout == 300 # Default from signature
|
|
|
|
|
|
def test_parse_memory_string_with_spaces():
|
|
"""Test parsing memory strings that have spaces."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
# Should handle spaces gracefully (strip them)
|
|
result = parse_memory_string(" 512m ")
|
|
assert result == 536870912
|
|
|
|
|
|
def test_parse_memory_string_bytes_suffix():
|
|
"""Test parsing memory string with bytes suffix (no multiplier)."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
# Just a number (bytes) - should this be supported?
|
|
# Based on architecture, we support k, m, g suffixes
|
|
# Plain numbers should probably raise an error for safety
|
|
with pytest.raises(ValueError):
|
|
parse_memory_string("1024")
|
|
|
|
|
|
def test_resource_limits_storage_quota_in_podman_params():
|
|
"""Test that storage limits are included in Podman params."""
|
|
from pod_executor.security.resource_limits import ResourceLimits
|
|
|
|
limits = ResourceLimits(
|
|
memory="512m",
|
|
storage="1g",
|
|
cpu_quota=50000,
|
|
timeout=300
|
|
)
|
|
|
|
params = limits.to_podman_params()
|
|
|
|
# Storage limit might be set via storage_opt or similar
|
|
# The exact parameter depends on Podman API
|
|
assert "storage_bytes" in params or "storage_opt" in params
|
|
|
|
|
|
def test_cpu_quota_explanation():
|
|
"""Test that CPU quota values have clear meaning."""
|
|
from pod_executor.security.resource_limits import parse_cpu_quota
|
|
|
|
# 100000 = 100% of one CPU core
|
|
# 50000 = 50% of one CPU core
|
|
# 200000 = 200% = 2 CPU cores
|
|
|
|
assert parse_cpu_quota(50000) == 50000 # 0.5 cores
|
|
assert parse_cpu_quota(100000) == 100000 # 1 core
|
|
assert parse_cpu_quota(200000) == 200000 # 2 cores
|
|
|
|
|
|
def test_parse_memory_with_decimal():
|
|
"""Test parsing memory strings with decimal values."""
|
|
from pod_executor.security.resource_limits import parse_memory_string
|
|
|
|
# Should handle decimals
|
|
result = parse_memory_string("1.5g")
|
|
assert result == 1610612736 # 1.5 * 1024 * 1024 * 1024
|