caplog un-disable logging, add missing test coverage

- Address review ad rebase to latest from main
- Make `force_enable_logging` private.

Issue: pytest-dev#8711
PR: pytest-dev#8758

src/_pytest/logging.py

@@ -458,22 +458,22 @@ def clear(self) -> None:
         """Reset the list of log records and the captured log text."""
         self.handler.clear()
 
-    def force_enable_logging(
+    def _force_enable_logging(
         self, level: Union[int, str], logger_obj: logging.Logger
     ) -> int:
-        """Enable the desired logging level if the level was disabled.
+        """Enable the desired logging level if the global level was disabled via ``logging.disabled``.
 
         Only enables logging levels greater than or equal to the requested ``level``.
 
         Does nothing if the desired ``level`` wasn't disabled.
 
-        :param Union[int, str] level:
+        :param level:
             The logger level caplog should capture.
             All logging is enabled if a non-standard logging level string is supplied.
             Valid level strings are in :data:`logging._nameToLevel`.
-        :param Logger logger_obj: The logger object to check.
+        :param logger_obj: The logger object to check.
 
-        :return int: The original disabled logging level.
+        :return: The original disabled logging level.
         """
         original_disable_level: int = logger_obj.manager.disable  # type: ignore[attr-defined]
 
@@ -511,7 +511,7 @@ def set_level(self, level: Union[int, str], logger: Optional[str] = None) -> Non
         if self._initial_handler_level is None:
             self._initial_handler_level = self.handler.level
         self.handler.setLevel(level)
-        initial_disabled_logging_level = self.force_enable_logging(level, logger_obj)
+        initial_disabled_logging_level = self._force_enable_logging(level, logger_obj)
         if self._initial_disabled_logging_level is None:
             self._initial_disabled_logging_level = initial_disabled_logging_level
 
@@ -533,7 +533,7 @@ def at_level(
         logger_obj.setLevel(level)
         handler_orig_level = self.handler.level
         self.handler.setLevel(level)
-        original_disable_level = self.force_enable_logging(level, logger_obj)
+        original_disable_level = self._force_enable_logging(level, logger_obj)
         try:
             yield
         finally:

testing/logging/test_fixture.py

@@ -1,4 +1,4 @@
-# type: ignore[attr-defined]
+# mypy: disable-error-code="attr-defined"
 import logging
 
 import pytest
@@ -88,7 +88,7 @@ def test2(caplog):
 def test_change_disabled_level_undo(
     pytester: Pytester, cleanup_disabled_logging
 ) -> None:
-    """Ensure that 'force_enable_logging' in 'set_level' is undone after the end of the test.
+    """Ensure that '_force_enable_logging' in 'set_level' is undone after the end of the test.
 
     Tests the logging output themselves (affected by disabled logging level).
     """
@@ -200,7 +200,7 @@ def test_with_statement_logging_disabled(caplog, cleanup_disabled_logging):
 def test_force_enable_logging_level_string(
     caplog, cleanup_disabled_logging, level_str, expected_disable_level
 ):
-    """Test force_enable_logging using a level string.
+    """Test _force_enable_logging using a level string.
 
     ``expected_disable_level`` is one level below ``level_str`` because the disabled log level
     always needs to be *at least* one level lower than the level that caplog is trying to capture.
@@ -211,7 +211,7 @@ def test_force_enable_logging_level_string(
     # Make sure all logging is disabled.
     assert not test_logger.isEnabledFor(logging.CRITICAL)
     # Un-disable logging for `level_str`.
-    caplog.force_enable_logging(level_str, test_logger)
+    caplog._force_enable_logging(level_str, test_logger)
     # Make sure that the disabled level is now one below the requested logging level.
     # We don't use `isEnabledFor` here because that also checks the level set by
     # `logging.setLevel()` which is irrelevant to `logging.disable()`.