Clean up logic for making fields nullable in v1, also clean up how tests are run against different versions

Author: phillipdupuis

pydantic2ts/cli/script.py

@@ -177,17 +177,13 @@ def _clean_json_schema(schema: Dict[str, Any], model: Any = None) -> None:
 
     if _is_v1_model(model):
         fields: List["ModelField"] = list(model.__fields__.values())
-        for field in fields:
+        fields_that_should_be_nullable = [f for f in fields if f.allow_none]
+        for field in fields_that_should_be_nullable:
             try:
-                if not field.allow_none:
-                    continue
                 name = field.alias
-                prop = properties.get(name)
-                if prop is None:
-                    continue
-                if _is_nullable(prop):
-                    continue
-                properties[name] = {"anyOf": [prop, {"type": "null"}]}
+                prop = properties.get(field.alias)
+                if prop and not _is_nullable(prop):
+                    properties[name] = {"anyOf": [prop, {"type": "null"}]}
             except Exception:
                 LOG.error(
                     f"Failed to ensure nullability for field {field.alias}.",

tests/test_script.py

@@ -10,24 +10,24 @@
 from pydantic2ts.cli.script import parse_cli_args
 from pydantic2ts.pydantic_v2 import enabled as v2_enabled
 
-_PYDANTIC_VERSIONS = ("v1", "v2") if v2_enabled else ("v1",)
+_PYDANTIC_VERSIONS = (1, 2) if v2_enabled else (1,)
 _RESULTS_DIRECTORY = Path(
     os.path.join(os.path.dirname(os.path.realpath(__file__)), "expected_results")
 )
 
 
-def _get_input_module(test_name: str, pydantic_version: str) -> str:
-    return str(_RESULTS_DIRECTORY / test_name / pydantic_version / "input.py")
+def _get_input_module(test_name: str, pydantic_version: int) -> str:
+    return str(_RESULTS_DIRECTORY / test_name / f"v{pydantic_version}" / "input.py")
 
 
-def _get_expected_output(test_name: str, pydantic_version: str) -> str:
-    return (_RESULTS_DIRECTORY / test_name / pydantic_version / "output.ts").read_text()
+def _get_expected_output(test_name: str, pydantic_version: int) -> str:
+    return (_RESULTS_DIRECTORY / test_name / f"v{pydantic_version}" / "output.ts").read_text()
 
 
 def _run_test(
     tmp_path: Path,
     test_name: str,
-    pydantic_version: str,
+    pydantic_version: int,
     *,
     module_path: Optional[str] = None,
     call_from_python: bool = False,
@@ -38,7 +38,7 @@ def _run_test(
     Compare the output with the expected output, verifying it is identical.
     """
     module_path = module_path or _get_input_module(test_name, pydantic_version)
-    output_path = str(tmp_path / f"{test_name}_{pydantic_version}.ts")
+    output_path = str(tmp_path / f"{test_name}_v{pydantic_version}.ts")
 
     if call_from_python:
         generate_typescript_defs(module_path, output_path, exclude)
@@ -55,31 +55,31 @@ def _run_test(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_single_module(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+def test_single_module(tmp_path: Path, pydantic_version: int, call_from_python: bool):
     _run_test(tmp_path, "single_module", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_submodules(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+def test_submodules(tmp_path: Path, pydantic_version: int, call_from_python: bool):
     _run_test(tmp_path, "submodules", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_generics(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+def test_generics(tmp_path: Path, pydantic_version: int, call_from_python: bool):
     _run_test(tmp_path, "generics", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_excluding_models(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+def test_excluding_models(tmp_path: Path, pydantic_version: int, call_from_python: bool):
     _run_test(
         tmp_path,
         "excluding_models",
@@ -91,25 +91,25 @@ def test_excluding_models(tmp_path: Path, pydantic_version: str, call_from_pytho
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
-    product([v for v in _PYDANTIC_VERSIONS if v != "v1"], [False, True]),
+    product([v for v in _PYDANTIC_VERSIONS if v > 1], [False, True]),
 )
-def test_computed_fields(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+def test_computed_fields(tmp_path: Path, pydantic_version: int, call_from_python: bool):
     _run_test(tmp_path, "computed_fields", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_extra_fields(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+def test_extra_fields(tmp_path: Path, pydantic_version: int, call_from_python: bool):
     _run_test(tmp_path, "extra_fields", pydantic_version, call_from_python=call_from_python)
 
 
 def test_relative_filepath(tmp_path: Path):
     test_name = "single_module"
     pydantic_version = _PYDANTIC_VERSIONS[0]
     relative_path = (
-        Path(".") / "tests" / "expected_results" / test_name / pydantic_version / "input.py"
+        Path(".") / "tests" / "expected_results" / test_name / f"v{pydantic_version}" / "input.py"
     )
     _run_test(
         tmp_path,