Use hardcoded schema

Author: ben-edna

tests/test_fuzzing.py

@@ -3,33 +3,14 @@
 from __future__ import annotations
 
 import os
-import re
 import tempfile
 from contextlib import suppress
-from typing import Any, Dict, Mapping, Tuple
+from typing import Any
 
 import yaml
 from hypothesis import given, settings
 from hypothesis import strategies as st
-
-# StrictYAML is a runtime dependency:
-# pip install strictyaml hypothesis
-from strictyaml import Any as SyAny
-from strictyaml import (
-    Bool,
-    EmptyList,
-    EmptyNone,
-    Enum,
-    Float,
-    Int,
-    Map,
-    MapPattern,
-    Regex,
-    Seq,
-    Str,
-    as_document,
-    load,
-)
+from strictyaml import as_document, load
 
 from dfetch.__main__ import DfetchFatalException, run
 from dfetch.manifest.manifest import Manifest
@@ -57,231 +38,94 @@
 else:
     settings.load_profile("dev")
 
+# Avoid control chars and NUL to prevent OS/path/subprocess issues in tests
+SAFE_TEXT = st.text(
+    alphabet=st.characters(
+        min_codepoint=32, blacklist_categories=("Cs",)
+    ),  # no controls/surrogates
+    min_size=0,
+    max_size=64,
+)
 
-def _classname(obj: Any) -> str:
-    return obj.__class__.__name__
+# NUMBER = Int() | Float()  with finite floats
+SAFE_NUMBER = st.one_of(
+    st.integers(),
+    st.floats(allow_nan=False, allow_infinity=False),
+)
 
 
-def _get_map_items(m: Map) -> Mapping[Any, Any]:
-    """
-    StrictYAML's Map stores the key->validator mapping internally.
-    It has varied attribute names across versions; try common ones.
-    """
-    for attr in ("_validator", "_map", "map", "mapping"):
-        val = getattr(m, attr, None)
-        if isinstance(val, Mapping):
-            return val
-    raise TypeError("Unsupported StrictYAML Map internals; cannot find mapping dict.")
+def opt_str():
+    """Small helper for optional text fields."""
+    return st.none() | SAFE_TEXT
+
+
+remote_entry = st.builds(
+    lambda name, url_base, default: {
+        k: v
+        for k, v in {
+            "name": name,
+            "url-base": url_base,
+            "default": default,
+        }.items()
+        if v is not None
+    },
+    name=SAFE_TEXT.filter(lambda s: len(s) > 0),
+    url_base=SAFE_TEXT.filter(lambda s: len(s) > 0),
+    default=st.none() | st.booleans(),
+)
 
+vcs_enum = st.sampled_from(["git", "svn"])
+
+ignore_list = st.lists(SAFE_TEXT, min_size=1, max_size=5)
+
+project_entry = st.builds(
+    lambda name, dst, branch, tag, revision, url, repo_path, remote, patch, vcs, src, ignore: {
+        k: v
+        for k, v in {
+            "name": name,
+            "dst": dst,
+            "branch": branch,
+            "tag": tag,
+            "revision": revision,
+            "url": url,
+            "repo-path": repo_path,
+            "remote": remote,
+            "patch": patch,
+            "vcs": vcs,
+            "src": src,
+            "ignore": ignore,
+        }.items()
+        if v is not None
+    },
+    name=SAFE_TEXT.filter(lambda s: len(s) > 0),
+    dst=opt_str(),
+    branch=opt_str(),
+    tag=opt_str(),
+    revision=opt_str(),
+    url=opt_str(),
+    repo_path=opt_str(),
+    remote=opt_str(),
+    patch=opt_str(),
+    vcs=st.none() | vcs_enum,
+    src=opt_str(),
+    ignore=st.one_of(ignore_list, st.just([])),
+)
 
-def _unwrap_optional_key(k: Any) -> Tuple[str, bool]:
-    """
-    Returns (key_name, is_optional).
-    Optional('b', default=...) is used *as a key* inside Map({...}).
-    """
-    if _classname(k) == "Optional":
-        for attr in ("_key", "key"):
-            name = getattr(k, attr, None)
-            if isinstance(name, str):
-                return name, True
-        return str(k), True
-    if isinstance(k, str):
-        return k, False
-    return str(k), False
-
-
-def _enum_values(e: Enum) -> Any:
-    vals = getattr(e, "_restricted_to", None)
-    if vals:
-        return list(vals)
-    raise TypeError("Unsupported StrictYAML Enum internals; cannot read choices.")
-
-
-def _regex_pattern(r: Regex) -> re.Pattern:
-    for attr in ("_regex", "regex", "pattern"):
-        pat = getattr(r, attr, None)
-        if isinstance(pat, (str, re.Pattern)):
-            return re.compile(pat) if isinstance(pat, str) else pat
-    raise TypeError("Unsupported StrictYAML Regex internals; cannot read pattern.")
-
-
-def _mappattern_parts(mp: MapPattern) -> Tuple[Any, Any, int | None, int | None]:
-    key_v = None
-    val_v = None
-    min_k = getattr(mp, "minimum_keys", None)
-    max_k = getattr(mp, "maximum_keys", None)
-    for attr in ("_key_validator", "key_validator"):
-        key_v = getattr(mp, attr, None) or key_v
-    for attr in ("_value_validator", "value_validator"):
-        val_v = getattr(mp, attr, None) or val_v
-    if key_v is None or val_v is None:
-        raise TypeError("Unsupported StrictYAML MapPattern internals.")
-    return key_v, val_v, min_k, max_k
-
-
-def strictyaml_to_strategy(
-    validator: Any, *, default_text_alphabet=st.characters(), default_max_list=5
-):
-    """
-    Convert a StrictYAML validator into a Hypothesis strategy that yields
-    *Python data structures* which conform to the schema.
-    """
-    name = _classname(validator)
-
-    if isinstance(validator, Str):
-        return st.text(alphabet=default_text_alphabet)
-
-    if isinstance(validator, Int):
-        return st.integers()
-
-    if isinstance(validator, Float):
-        return st.floats(allow_nan=False, allow_infinity=False)
-
-    if isinstance(validator, Bool):
-        return st.booleans()
-
-    if isinstance(validator, Enum):
-        values = _enum_values(validator)
-        return st.sampled_from(values)
-
-    if isinstance(validator, Regex):
-        pattern = _regex_pattern(validator)
-        return st.from_regex(pattern, fullmatch=True)
-
-    if isinstance(validator, Seq):
-        item_v = None
-        for attr in ("_validator", "validator", "_item_validator", "item_validator"):
-            item_v = getattr(validator, attr, None) or item_v
-        if item_v is None:
-            raise TypeError(
-                "Unsupported StrictYAML Seq internals; cannot find item validator."
-            )
-        return st.lists(
-            strictyaml_to_strategy(
-                item_v,
-                default_text_alphabet=default_text_alphabet,
-                default_max_list=default_max_list,
-            ),
-            min_size=1,
-            max_size=default_max_list,
-        )
-
-    if isinstance(validator, EmptyList):
-        return st.just([])
-
-    if isinstance(validator, Map):
-        items = _get_map_items(validator)
-        required: Dict[str, Any] = {}
-        optional: Dict[str, Any] = {}
-
-        for raw_key, val_validator in items.items():
-            key_name, is_opt = _unwrap_optional_key(raw_key)
-            if is_opt:
-                optional[key_name] = strictyaml_to_strategy(
-                    val_validator,
-                    default_text_alphabet=default_text_alphabet,
-                    default_max_list=default_max_list,
-                )
-            else:
-                required[key_name] = strictyaml_to_strategy(
-                    val_validator,
-                    default_text_alphabet=default_text_alphabet,
-                    default_max_list=default_max_list,
-                )
-
-        base = st.fixed_dictionaries(required)
-
-        def with_optional(base_dict: Dict[str, Any]):
-            if not optional:
-                return st.just(base_dict)
-            opt_kv_strats = [st.tuples(st.just(k), s) for k, s in optional.items()]
-
-            chosen = st.lists(st.one_of(*opt_kv_strats), unique_by=lambda kv: kv[0])
-            return chosen.map(lambda kvs: {**base_dict, **dict(kvs)})
-
-        return base.flatmap(with_optional)
-
-    if isinstance(validator, MapPattern):
-        key_v, val_v, min_k, max_k = _mappattern_parts(validator)
-        key_strat = strictyaml_to_strategy(
-            key_v,
-            default_text_alphabet=default_text_alphabet,
-            default_max_list=default_max_list,
-        )
-        val_strat = strictyaml_to_strategy(
-            val_v,
-            default_text_alphabet=default_text_alphabet,
-            default_max_list=default_max_list,
-        )
-
-        return st.dictionaries(
-            keys=key_strat,
-            values=val_strat,
-            min_size=min_k or 0,
-            max_size=max_k or default_max_list,
-        )
-
-    if _classname(validator) in ("OrValidator", "Or"):
-        children = None
-
-        for attr in ("validators", "_validators", "choices", "_choices"):
-            vs = getattr(validator, attr, None)
-            if isinstance(vs, (list, tuple)) and len(vs) > 0:
-                children = list(vs)
-                break
-
-        if children is None:
-            left = None
-            right = None
-            for la in ("_a", "a", "_left", "left", "_lhs", "lhs", "_validator_a"):
-                if getattr(validator, la, None) is not None:
-                    left = getattr(validator, la)
-                    break
-            for ra in ("_b", "b", "_right", "right", "_rhs", "rhs", "_validator_b"):
-                if getattr(validator, ra, None) is not None:
-                    right = getattr(validator, ra)
-                    break
-            if left is not None and right is not None:
-                children = [left, right]
-
-        if not children:
-            raise TypeError(
-                "Unsupported StrictYAML OrValidator internals; no children found."
-            )
-
-        branch_strats = [
-            strictyaml_to_strategy(
-                c,
-                default_text_alphabet=default_text_alphabet,
-                default_max_list=default_max_list,
-            )
-            for c in children
-        ]
-        return st.one_of(branch_strats)
-
-    if isinstance(validator, SyAny):
-        leaf = st.one_of(
-            st.booleans(),
-            st.integers(),
-            st.floats(allow_nan=False, allow_infinity=False),
-            st.text(),
-        )
-        return st.recursive(
-            leaf,
-            lambda inner: st.one_of(
-                st.lists(inner, max_size=3),
-                st.dictionaries(st.text(), inner, max_size=3),
-            ),
-            max_leaves=10,
-        )
-
-    if isinstance(validator, EmptyNone):
-        return st.none()
-
-    # If we reach here, add more mappings (e.g., Decimal, Datetime, Email, etc.) as needed.
-    raise NotImplementedError(
-        f"No strategy mapping implemented for StrictYAML validator: {name}"
-    )
+remotes_seq = st.none() | st.lists(remote_entry, min_size=1, max_size=4)
+projects_seq = st.lists(project_entry, min_size=1, max_size=6)
+
+manifest_strategy = st.builds(
+    lambda version, remotes, projects: {
+        "manifest": {
+            "version": version,
+            **({"remotes": remotes} if remotes is not None else {}),
+            "projects": projects,
+        }
+    },
+    version=SAFE_NUMBER,
+    remotes=remotes_seq,
+    projects=projects_seq,
+)
 
 
 def validate_with_strictyaml(data: Any, yaml_schema: Any) -> None:
@@ -292,17 +136,14 @@ def validate_with_strictyaml(data: Any, yaml_schema: Any) -> None:
     as_document(data, yaml_schema)  # will raise YAMLSerializationError on mismatch
 
 
-data_strategy = strictyaml_to_strategy(schema)
-
-
-@given(data_strategy)
+@given(manifest_strategy)
 def test_data_conforms_to_schema(data):
     """Validate by attempting to serialize via StrictYAML."""
     # If data violates the schema, this raises and Hypothesis will shrink to a minimal counterexample.
     validate_with_strictyaml(data, schema)
 
 
-@given(data_strategy)
+@given(manifest_strategy)
 def test_manifest_can_be_created(data):
     """Validate by attempting to construct a Manifest."""
     try:
@@ -311,7 +152,7 @@ def test_manifest_can_be_created(data):
         pass
 
 
-@given(data_strategy)
+@given(manifest_strategy)
 def test_check(data):
     """Validate check comand."""
     with suppress(DfetchFatalException):
@@ -322,7 +163,7 @@ def test_check(data):
                 run(["check"])
 
 
-@given(data_strategy)
+@given(manifest_strategy)
 def test_update(data):
     """Validate update comand."""
     with suppress(DfetchFatalException):
@@ -337,7 +178,7 @@ def test_update(data):
 
     settings.load_profile("manual")
 
-    example = data_strategy.example()
+    example = manifest_strategy.example()
     print("One generated example:\n", example)
 
     # Show the YAML StrictYAML would emit for the example: