Add tests for --no-use-union-operator and add pragma: no cover to environment-specific code

Author: koxudaxi

docs/cli-reference/model-customization.md

@@ -4945,6 +4945,21 @@ where optional fields have defaults but cannot accept `None` values.
                     - type: string
                     - type: number
                    nullable: true
+            maybeValue:
+              description: A value that can be string or integer, not nullable
+              oneOf:
+                - type: string
+                - type: integer
+            nullableUnion:
+              description: A nullable union of string or integer
+              oneOf:
+                - type: string
+                - type: integer
+              nullable: true
+            simpleUnion:
+              oneOf:
+                - type: string
+                - type: number
           required:
             - comments
             - oneOfComments
@@ -5034,6 +5049,13 @@ where optional fields have defaults but cannot accept `None` values.
     class Options(BaseModel):
         comments: list[str | None]
         oneOfComments: list[str | float | None]
+        maybeValue: str | int | None = Field(
+            None, description='A value that can be string or integer, not nullable'
+        )
+        nullableUnion: str | int | None = Field(
+            None, description='A nullable union of string or integer'
+        )
+        simpleUnion: str | float | None = None
     ```
 
 ---

src/datamodel_code_generator/config.py

@@ -59,7 +59,7 @@
     ExtraTemplateDataType = defaultdict[str, dict[str, Any]]
 elif is_pydantic_v2():
     ExtraTemplateDataType = defaultdict[str, Annotated[dict[str, Any], Field(default_factory=dict)]]
-else:
+else:  # pragma: no cover
     ExtraTemplateDataType = defaultdict[str, dict[str, Any]]
 
 

src/datamodel_code_generator/format.py

@@ -238,7 +238,7 @@ def __init__(  # noqa: PLR0912, PLR0913, PLR0915, PLR0917
             black_kwargs: dict[str, Any] = {}
             if wrap_string_literal is not None:
                 experimental_string_processing = wrap_string_literal
-            elif black.__version__ < "24.1.0":
+            elif black.__version__ < "24.1.0":  # pragma: no cover
                 experimental_string_processing = config.get("experimental-string-processing")
             else:
                 experimental_string_processing = config.get("preview", False) and (  # pragma: no cover

src/datamodel_code_generator/model/msgspec.py

@@ -238,12 +238,12 @@ def _add_unset_type(type_: str, use_union_operator: bool) -> str:  # noqa: FBT00
     """Add UnsetType to a type hint without removing None."""
     if use_union_operator:
         return f"{type_}{UNION_OPERATOR_DELIMITER}{UNSET_TYPE}"
-    if type_.startswith(UNION_PREFIX):
+    if type_.startswith(UNION_PREFIX):  # pragma: no cover
         return f"{type_[:-1]}{UNION_DELIMITER}{UNSET_TYPE}]"
     if type_.startswith(OPTIONAL_PREFIX):  # pragma: no cover
         inner_type = type_[len(OPTIONAL_PREFIX) : -1]
         return f"{UNION_PREFIX}{inner_type}{UNION_DELIMITER}{NONE}{UNION_DELIMITER}{UNSET_TYPE}]"
-    return f"{UNION_PREFIX}{type_}{UNION_DELIMITER}{UNSET_TYPE}]"
+    return f"{UNION_PREFIX}{type_}{UNION_DELIMITER}{UNSET_TYPE}]"  # pragma: no cover
 
 
 @import_extender
@@ -438,7 +438,7 @@ def needs_annotated_import(self) -> bool:
         """
         if not self.annotated:
             return False
-        if self.extras.get("is_classvar"):
+        if self.extras.get("is_classvar"):  # pragma: no cover
             return self.use_annotated and self._get_meta_string() is not None
         return True
 

src/datamodel_code_generator/model/pydantic/__init__.py

@@ -44,7 +44,7 @@ def dict(  # type: ignore[override]
 
         if is_pydantic_v2():
             return self.model_dump(**kwargs)
-        return super().dict(**kwargs)
+        return super().dict(**kwargs)  # pragma: no cover
 
 
 __all__ = [

src/datamodel_code_generator/model/pydantic_v2/__init__.py

@@ -52,7 +52,7 @@ def dict(self, **kwargs: Any) -> dict[str, Any]:  # type: ignore[override]
 
         if is_pydantic_v2():
             return self.model_dump(**kwargs)
-        return super().dict(**kwargs)
+        return super().dict(**kwargs)  # pragma: no cover
 
 
 __all__ = [

src/datamodel_code_generator/util.py

@@ -19,7 +19,7 @@
 
 try:
     from tomllib import load as load_tomllib  # type: ignore[ignoreMissingImports]
-except ImportError:
+except ImportError:  # pragma: no cover
     from tomli import load as load_tomllib  # type: ignore[ignoreMissingImports]
 
 
@@ -165,9 +165,9 @@ def inner(
             if mode == "before":
                 return model_validator_v2(mode=mode)(classmethod(method))  # type: ignore[reportReturnType]
             return model_validator_v2(mode=mode)(method)  # type: ignore[reportReturnType]
-        from pydantic import root_validator  # noqa: PLC0415
+        from pydantic import root_validator  # noqa: PLC0415  # pragma: no cover
 
-        return root_validator(method, pre=mode == "before")  # pyright: ignore[reportCallIssue]
+        return root_validator(method, pre=mode == "before")  # pyright: ignore[reportCallIssue]  # pragma: no cover
 
     return inner
 
@@ -184,9 +184,9 @@ def inner(method: Callable[[Model, Any], Any]) -> Callable[[Model, Any], Any]:
             from pydantic import field_validator as field_validator_v2  # noqa: PLC0415
 
             return field_validator_v2(field_name, *fields, mode=mode)(method)
-        from pydantic import validator  # noqa: PLC0415
+        from pydantic import validator  # noqa: PLC0415  # pragma: no cover
 
-        return validator(field_name, *fields, pre=mode == "before")(method)  # pyright: ignore[reportReturnType]
+        return validator(field_name, *fields, pre=mode == "before")(method)  # pyright: ignore[reportReturnType]  # pragma: no cover
 
     return inner
 
@@ -221,7 +221,7 @@ class _BaseModelV2(_PydanticBaseModel):
             model_config = _ConfigDict(strict=False)
 
         return _BaseModelV2
-    return _PydanticBaseModel
+    return _PydanticBaseModel  # pragma: no cover
 
 
 _BaseModel: type | None = None
@@ -286,25 +286,25 @@ def model_dump(obj: _BaseModel, **kwargs: Any) -> dict[str, Any]:  # pyright: ig
     """Version-compatible model serialization (dict/model_dump)."""
     if is_pydantic_v2():
         return obj.model_dump(**kwargs)
-    return obj.dict(**kwargs)  # type: ignore[reportDeprecated]
+    return obj.dict(**kwargs)  # type: ignore[reportDeprecated]  # pragma: no cover
 
 
 def model_validate(cls: type[Model], obj: Any) -> Model:
     """Version-compatible model validation (parse_obj/model_validate)."""
     if is_pydantic_v2():
         return cls.model_validate(obj)
-    return cls.parse_obj(obj)  # type: ignore[reportDeprecated]
+    return cls.parse_obj(obj)  # type: ignore[reportDeprecated]  # pragma: no cover
 
 
 def get_fields_set(obj: _BaseModel) -> set[str]:  # pyright: ignore[reportInvalidTypeForm]
     """Version-compatible access to fields set (__fields_set__/model_fields_set)."""
     if is_pydantic_v2():
         return obj.model_fields_set
-    return obj.__fields_set__  # type: ignore[reportDeprecated]
+    return obj.__fields_set__  # type: ignore[reportDeprecated]  # pragma: no cover
 
 
 def model_copy(obj: Model, **kwargs: Any) -> Model:
     """Version-compatible model copy (copy/model_copy)."""
     if is_pydantic_v2():
         return obj.model_copy(**kwargs)
-    return obj.copy(**kwargs)  # type: ignore[reportDeprecated]
+    return obj.copy(**kwargs)  # type: ignore[reportDeprecated]  # pragma: no cover

src/datamodel_code_generator/validators.py

@@ -46,6 +46,6 @@ class ModelValidators(BaseModel):
     class ValidatorsConfig(RootModel[dict[str, ModelValidators]]):
         """Root model for validators configuration."""
 
-else:
+else:  # pragma: no cover
     # Pydantic v1 doesn't support RootModel, but validators feature is v2-only anyway
     ValidatorsConfig = None  # type: ignore[assignment,misc]

tests/data/expected/main/openapi/msgspec_no_use_union_operator.py

@@ -79,3 +79,17 @@ class Notes(Struct):
 class Options(Struct):
     comments: list[str]
     oneOfComments: list[Union[str, float]]
+    maybeValue: Union[
+        Annotated[
+            Union[str, int],
+            Meta(description='A value that can be string or integer, not nullable'),
+        ],
+        UnsetType,
+    ] = UNSET
+    nullableUnion: Union[
+        Annotated[
+            Union[str, int], Meta(description='A nullable union of string or integer')
+        ],
+        UnsetType,
+    ] = UNSET
+    simpleUnion: Union[str, float, UnsetType] = UNSET

tests/data/expected/main/openapi/msgspec_nullable.py

@@ -79,3 +79,15 @@ class Notes(Struct):
 class Options(Struct):
     comments: list[str]
     oneOfComments: list[str | float]
+    maybeValue: (
+        Annotated[
+            str | int,
+            Meta(description='A value that can be string or integer, not nullable'),
+        ]
+        | UnsetType
+    ) = UNSET
+    nullableUnion: (
+        Annotated[str | int, Meta(description='A nullable union of string or integer')]
+        | UnsetType
+    ) = UNSET
+    simpleUnion: str | float | UnsetType = UNSET