265 lines
7.7 KiB
Python
265 lines
7.7 KiB
Python
"""Tests for Fuzzer."""
|
|
|
|
import pytest
|
|
from src.core.fuzzer import Fuzzer
|
|
|
|
|
|
class TestFuzzer:
|
|
"""Tests for Fuzzer class."""
|
|
|
|
def test_fuzz_string_returns_invalid_string(self):
|
|
"""Test that fuzzing string returns edge case values."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "string", "minLength": 5}
|
|
result = fuzzer.fuzz_string(schema)
|
|
|
|
assert isinstance(result, str)
|
|
|
|
def test_fuzz_integer_returns_boundary_values(self):
|
|
"""Test that fuzzing integer returns boundary values."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "integer", "minimum": 0, "maximum": 100}
|
|
result = fuzzer.fuzz_integer(schema)
|
|
|
|
assert isinstance(result, int)
|
|
|
|
def test_fuzz_number_returns_special_values(self):
|
|
"""Test that fuzzing number returns special values."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "number"}
|
|
result = fuzzer.fuzz_number(schema)
|
|
|
|
assert isinstance(result, (int, float))
|
|
|
|
def test_fuzz_boolean_returns_invalid_values(self):
|
|
"""Test that fuzzing boolean may return non-boolean values."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "boolean"}
|
|
result = fuzzer.fuzz_boolean(schema)
|
|
|
|
assert isinstance(result, (bool, int, str))
|
|
|
|
def test_fuzz_array_returns_edge_cases(self):
|
|
"""Test that fuzzing array returns edge case arrays."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "array", "items": {"type": "string"}}
|
|
result = fuzzer.fuzz_array(schema)
|
|
|
|
assert isinstance(result, list)
|
|
|
|
def test_fuzz_object_returns_edge_cases(self):
|
|
"""Test that fuzzing object returns edge case objects."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "integer"},
|
|
"name": {"type": "string"}
|
|
},
|
|
"required": ["id"]
|
|
}
|
|
result = fuzzer.fuzz_object(schema)
|
|
|
|
assert isinstance(result, dict)
|
|
|
|
def test_fuzz_null_returns_null(self):
|
|
"""Test that fuzzing null returns null values."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "null"}
|
|
result = fuzzer.fuzz_null(schema)
|
|
|
|
assert result is None or result in Fuzzer.NULL_VALUES
|
|
|
|
def test_fuzz_schema_with_type_string(self):
|
|
"""Test fuzzing schema with string type."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "string", "format": "email"}
|
|
result = fuzzer.fuzz_schema(schema)
|
|
|
|
assert isinstance(result, str)
|
|
|
|
def test_fuzz_schema_with_type_integer(self):
|
|
"""Test fuzzing schema with integer type."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "integer"}
|
|
result = fuzzer.fuzz_schema(schema)
|
|
|
|
assert isinstance(result, int)
|
|
|
|
def test_fuzz_schema_with_type_object(self):
|
|
"""Test fuzzing schema with object type."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {
|
|
"type": "object",
|
|
"properties": {
|
|
"user": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "integer"},
|
|
"name": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
result = fuzzer.fuzz_schema(schema)
|
|
|
|
assert isinstance(result, dict)
|
|
|
|
def test_fuzz_schema_with_empty_schema(self):
|
|
"""Test fuzzing with empty schema returns None."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
result = fuzzer.fuzz_schema({})
|
|
|
|
assert result is None
|
|
|
|
def test_fuzz_schema_with_none_schema(self):
|
|
"""Test fuzzing with None schema returns None."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
result = fuzzer.fuzz_schema(None)
|
|
|
|
assert result is None
|
|
|
|
def test_fuzz_request_body(self):
|
|
"""Test fuzzing request body."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {
|
|
"type": "object",
|
|
"properties": {
|
|
"name": {"type": "string"},
|
|
"age": {"type": "integer"}
|
|
}
|
|
}
|
|
result = fuzzer.fuzz_request_body(schema)
|
|
|
|
assert isinstance(result, (dict, type(None)))
|
|
|
|
def test_fuzz_request_body_with_none(self):
|
|
"""Test fuzzing None request body."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
result = fuzzer.fuzz_request_body(None)
|
|
|
|
assert result is None
|
|
|
|
def test_fuzz_response(self):
|
|
"""Test generating fuzzed response."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "object", "properties": {"id": {"type": "integer"}}}
|
|
result = fuzzer.fuzz_response(schema, status_code=200)
|
|
|
|
assert result["status_code"] == 200
|
|
assert "body" in result
|
|
|
|
def test_inject_null_values_into_object(self):
|
|
"""Test injecting null values into object."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
data = {"name": "test", "email": "test@example.com", "age": 25}
|
|
result = fuzzer.inject_null_values(data, max_depth=2)
|
|
|
|
assert isinstance(result, dict)
|
|
|
|
def test_inject_null_values_into_array(self):
|
|
"""Test injecting null values into array."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
data = [{"name": "test1"}, {"name": "test2"}]
|
|
result = fuzzer.inject_null_values(data, max_depth=2)
|
|
|
|
assert isinstance(result, list)
|
|
assert len(result) == 2
|
|
|
|
def test_create_edge_case_response(self):
|
|
"""Test creating edge case response."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {"type": "object", "properties": {"message": {"type": "string"}}}
|
|
result = fuzzer.create_edge_case_response(schema)
|
|
|
|
assert "status_code" in result
|
|
assert "body" in result
|
|
|
|
def test_null_values_constant(self):
|
|
"""Test that NULL_VALUES is defined correctly."""
|
|
assert None in Fuzzer.NULL_VALUES
|
|
assert "" in Fuzzer.NULL_VALUES
|
|
|
|
def test_invalid_strings_constant(self):
|
|
"""Test that INVALID_STRINGS contains common edge cases."""
|
|
assert "" in Fuzzer.INVALID_STRINGS
|
|
assert "undefined" in Fuzzer.INVALID_STRINGS
|
|
|
|
def test_boundary_values_constant(self):
|
|
"""Test that BOUNDARY_VALUES contains boundary integers."""
|
|
assert -1 in Fuzzer.BOUNDARY_VALUES
|
|
assert 0 in Fuzzer.BOUNDARY_VALUES
|
|
assert 1 in Fuzzer.BOUNDARY_VALUES
|
|
|
|
|
|
class TestFuzzerEdgeCases:
|
|
"""Tests for fuzzer edge case handling."""
|
|
|
|
def test_fuzz_with_nested_schema(self):
|
|
"""Test fuzzing deeply nested schema."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {
|
|
"type": "object",
|
|
"properties": {
|
|
"level1": {
|
|
"type": "object",
|
|
"properties": {
|
|
"level2": {
|
|
"type": "object",
|
|
"properties": {
|
|
"level3": {
|
|
"type": "string"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
result = fuzzer.fuzz_schema(schema)
|
|
|
|
assert isinstance(result, dict)
|
|
|
|
def test_fuzz_array_with_complex_items(self):
|
|
"""Test fuzzing array with complex item schemas."""
|
|
fuzzer = Fuzzer(seed=42)
|
|
|
|
schema = {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "integer"},
|
|
"name": {"type": "string"},
|
|
"tags": {
|
|
"type": "array",
|
|
"items": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
result = fuzzer.fuzz_array(schema)
|
|
|
|
assert isinstance(result, list)
|