More tests for full coverage

Author: mauvilsa

DOCUMENTATION.rst

@@ -2335,9 +2335,9 @@ in ``subclasses_disabled``; in this case, the effect is to unregister it. By
 default, the following disable functions are registered: ``is_pure_dataclass``,
 ``is_pydantic_model``, ``is_attrs_class``, and ``is_final_class``.
 
-Since ``subclasses_enabled`` takes precedence, it is possible to keep subclass
-support disabled for dataclasses, but enable enable it for a specific dataclass
-as follows:
+Some examples. Since ``subclasses_enabled`` takes precedence, it is possible to
+keep subclass support disabled for dataclasses, but enable enable it for a
+specific dataclass as follows:
 
 .. testsetup:: enable_disable_subclasses
 
@@ -2358,12 +2358,21 @@ as follows:
 
     set_parsing_settings(subclasses_enabled=[DataClassBaseType])
 
-To enable subclass support for all dataclasses and pydantic models, the
-following can be done:
+To enable subclass support for all pydantic models, the following can be done:
 
 .. testcode:: enable_disable_subclasses
 
-    set_parsing_settings(subclasses_enabled=["is_pure_dataclass", "is_pydantic_model"])
+    set_parsing_settings(subclasses_enabled=["is_pydantic_model"])
+
+To enable subclass support for all dataclasses, but have it disabled for a
+specific dataclass, the following can be done:
+
+.. testcode:: enable_disable_subclasses
+
+    set_parsing_settings(
+        subclasses_enabled=["is_pure_dataclass"],
+        subclasses_disabled=[DataClassBaseType],
+    )
 
 
 .. _argument-linking:

jsonargparse/_common.py

@@ -319,9 +319,9 @@ def is_subclasses_disabled(cls) -> bool:
         return False
     subclass_disabled = any(selector(cls) for selector in subclasses_disabled_selectors.values())
     if not subclass_disabled:
-        subclass_disabled = any(issubclass(cls, disabled_type) for disabled_type in subclasses_disabled_types)
+        subclass_disabled = any(issubclass(cls, disable_type) for disable_type in subclasses_disabled_types)
     if subclass_disabled:
-        subclass_disabled = not any(issubclass(cls, enabled_type) for enabled_type in subclasses_enabled_types)
+        subclass_disabled = not any(issubclass(cls, enable_type) for enable_type in subclasses_enabled_types)
     return subclass_disabled
 
 
@@ -349,7 +349,7 @@ def subclass_type_behavior(
             subclasses_disabled_selectors[disable_item.__name__] = disable_item
         else:
             raise ValueError(
-                f"Expected 'subclasses_disabled' list items to be types or callables, but got {disable_item!r}"
+                f"Expected 'subclasses_disabled' list items to be types or functions, but got {disable_item!r}"
             )
 
 

jsonargparse_tests/conftest.py

@@ -146,6 +146,14 @@ def example_parser() -> ArgumentParser:
     return parser
 
 
+@pytest.fixture
+def subclass_behavior(monkeypatch) -> Iterator[None]:
+    monkeypatch.setattr("jsonargparse._common.subclasses_enabled_types", set())
+    monkeypatch.setattr("jsonargparse._common.subclasses_disabled_types", set())
+    with patch.dict("jsonargparse._common.subclasses_disabled_selectors"):
+        yield
+
+
 @pytest.fixture
 def tmp_cwd(tmpdir) -> Iterator[Path]:
     with tmpdir.as_cwd():

jsonargparse_tests/test_dataclasses.py

@@ -14,6 +14,7 @@
     Namespace,
     set_parsing_settings,
 )
+from jsonargparse._common import subclasses_disabled_selectors
 from jsonargparse._namespace import NSKeyError
 from jsonargparse._optionals import (
     docstring_parser_support,
@@ -31,6 +32,13 @@
 
 annotated = typing_extensions_import("Annotated")
 
+
+@pytest.fixture
+def enable_subclasses(subclass_behavior):
+    set_parsing_settings(subclasses_enabled=["is_pure_dataclass"])
+    yield
+
+
 BetweenThreeAndNine = restricted_number_type("BetweenThreeAndNine", float, [(">=", 3), ("<=", 9)])
 ListPositiveInt = List[PositiveInt]
 
@@ -768,13 +776,6 @@ def test_add_subclass_dataclass_subclasses_disabled(parser):
         parser.add_subclass_arguments(DataMain, "data")
 
 
-@pytest.fixture
-def enable_subclasses():
-    with patch.dict("jsonargparse._common.subclasses_disabled_selectors"):
-        set_parsing_settings(subclasses_enabled=["is_pure_dataclass"])
-        yield
-
-
 @pytest.mark.parametrize("default", [None, DataMain()])
 def test_add_subclass_dataclass_subclasses_enabled(parser, default, enable_subclasses):
     parser.add_subclass_arguments(DataMain, "data", default=default)
@@ -849,6 +850,46 @@ def test_add_argument_dataclass_subclasses_enabled(parser, subtests, enable_subc
         assert dataclasses.asdict(init.data) == {"p1": 2, "p2": "-"}
 
 
+def test_add_argument_dataclass_single_type_subclasses_enabled(parser, subclass_behavior):
+    set_parsing_settings(subclasses_enabled=[DataMain])
+    assert "is_pure_dataclass" in subclasses_disabled_selectors
+
+    parser.add_argument("--data", type=DataMain, default=DataMain(p1=2))
+
+    config = {"class_path": f"{__name__}.DataSub", "init_args": {"p2": "y"}}
+    cfg = parser.parse_args([f"--data={json.dumps(config)}"])
+    init = parser.instantiate_classes(cfg)
+    assert isinstance(init.data, DataSub)
+    assert dataclasses.asdict(init.data) == {"p1": 2, "p2": "y"}
+    dump = json_or_yaml_load(parser.dump(cfg))["data"]
+    assert dump == {"class_path": f"{__name__}.DataSub", "init_args": {"p1": 2, "p2": "y"}}
+
+
+def test_add_argument_dataclass_single_type_subclasses_disabled(parser, enable_subclasses):
+    set_parsing_settings(subclasses_disabled=[DataMain])
+    assert "is_pure_dataclass" not in subclasses_disabled_selectors
+
+    parser.add_argument("--data", type=DataMain, default=DataMain(p1=2))
+
+    config = {"class_path": f"{__name__}.DataSub", "init_args": {"p2": "y"}}
+    with pytest.raises(ArgumentError, match="Group 'data' does not accept option 'init_args.p2'"):
+        parser.parse_args([f"--data={json.dumps(config)}"])
+
+
+def test_add_argument_dataclass_subclasses_disabled_function(parser, enable_subclasses):
+    def is_data_main(obj):
+        return obj is DataMain
+
+    set_parsing_settings(subclasses_disabled=[is_data_main])
+    assert "is_pure_dataclass" not in subclasses_disabled_selectors
+
+    parser.add_argument("--data", type=DataMain, default=DataMain(p1=2))
+
+    config = {"class_path": f"{__name__}.DataSub", "init_args": {"p2": "y"}}
+    with pytest.raises(ArgumentError, match="Group 'data' does not accept option 'init_args.p2'"):
+        parser.parse_args([f"--data={json.dumps(config)}"])
+
+
 class ParentData:
     def __init__(self, data: DataMain = DataMain(p1=2)):
         self.data = data

jsonargparse_tests/test_parsing_settings.py

@@ -208,13 +208,25 @@ def test_set_omegaconf_absolute_to_relative_paths_failure():
 # enable/disable-subclasses
 
 
-def test_default_subclass_disable_functions():
+def test_default_subclass_disable_functions(subclass_behavior):
     from jsonargparse._common import subclasses_disabled_selectors
 
-    for name in [
-        "is_pure_dataclass",
-        "is_pydantic_model",
-        "is_attrs_class",
-        "is_final_class",
-    ]:
-        assert name in subclasses_disabled_selectors
+    set_parsing_settings(
+        subclasses_enabled=["is_pure_dataclass", "is_pydantic_model", "is_attrs_class", "is_final_class"]
+    )
+    assert not subclasses_disabled_selectors
+
+
+def test_unknown_subclass_disable_function():
+    with pytest.raises(ValueError, match="no function 'unknown_selector'"):
+        set_parsing_settings(subclasses_enabled=["unknown_selector"])
+
+
+def test_invalid_item_type_subclass_enable():
+    with pytest.raises(ValueError, match="Expected 'subclasses_enabled' list items to be types or strings"):
+        set_parsing_settings(subclasses_enabled=[123])
+
+
+def test_invalid_item_type_subclass_disable():
+    with pytest.raises(ValueError, match="Expected 'subclasses_disabled' list items to be types or functions"):
+        set_parsing_settings(subclasses_disabled=[123])

jsonargparse_tests/test_pydantic.py

@@ -4,7 +4,6 @@
 import json
 from copy import deepcopy
 from typing import Dict, List, Literal, Optional, Union
-from unittest.mock import patch
 
 import pytest
 
@@ -40,10 +39,9 @@ def missing_pydantic():
 
 
 @pytest.fixture
-def enable_subclasses():
-    with patch.dict("jsonargparse._common.subclasses_disabled_selectors"):
-        set_parsing_settings(subclasses_enabled=["is_pydantic_model"])
-        yield
+def enable_subclasses(subclass_behavior):
+    set_parsing_settings(subclasses_enabled=["is_pydantic_model"])
+    yield
 
 
 @skip_if_pydantic_v1_on_v2