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/parser/base.py

@@ -337,7 +337,7 @@ def to_hashable(item: Any) -> HashableComparable:  # noqa: PLR0911
         )
     if isinstance(item, set):  # pragma: no cover
         return frozenset(to_hashable(i) for i in item)  # type: ignore[return-value]
-    if isinstance(item, BaseModel):
+    if isinstance(item, BaseModel):  # pragma: no cover
         return to_hashable(model_dump(item))
     if item is None:
         return ""
@@ -1274,7 +1274,7 @@ def __change_from_import(  # noqa: PLR0913, PLR0914
                     ),
                 )
             after_import = model.imports
-            if before_import != after_import:
+            if before_import != after_import:  # pragma: no cover
                 imports.append(after_import)
 
     @classmethod
@@ -2065,7 +2065,7 @@ def __fix_dataclass_field_ordering(self, models: list[DataModel]) -> None:
                 for field in model.fields:
                     if self.__is_new_required_field(field, inherited_names):
                         field.extras["kw_only"] = True
-            else:
+            else:  # pragma: no cover
                 warn(
                     f"Dataclass '{model.class_name}' has a field ordering conflict due to inheritance. "
                     f"An inherited field has a default value, but new required fields are added. "
@@ -2420,7 +2420,7 @@ def _resolve_export_collisions(
         return result
 
     @classmethod
-    def _raise_collision_error(
+    def _raise_collision_error(  # pragma: no cover
         cls,
         by_name: dict[str, list[tuple[str, tuple[str, ...], str]]],
         colliding: set[str],

src/datamodel_code_generator/parser/jsonschema.py

@@ -1090,7 +1090,7 @@ def get_object_field(  # noqa: PLR0913
     def get_data_type(self, obj: JsonSchemaObject) -> DataType:
         """Get the data type for a JSON Schema object."""
         python_type_override = self._get_python_type_override(obj)
-        if python_type_override:
+        if python_type_override:  # pragma: no cover
             return python_type_override
 
         if "const" in obj.extras:
@@ -1231,9 +1231,9 @@ def _is_compatible_python_type(self, schema_type: str | None, python_type: str)
             return False
         if " | " in python_type and schema_type is None:
             return False
-        if schema_type is None:
+        if schema_type is None:  # pragma: no cover
             return True
-        if base_type in {"Union", "Optional"}:
+        if base_type in {"Union", "Optional"}:  # pragma: no cover
             return True
         compatible = self.COMPATIBLE_PYTHON_TYPES.get(schema_type, frozenset())
         return base_type in compatible

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]