diff --git a/repo_logging.py b/repo_logging.py new file mode 100644 index 00000000..67db05fb --- /dev/null +++ b/repo_logging.py @@ -0,0 +1,74 @@ +# Copyright (C) 2023 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Logic for printing user-friendly logs in repo.""" + +import logging +import multiprocessing + +from color import Coloring + +SEPARATOR = "=" * 80 + + +class LogColoring(Coloring): + """Coloring outstream for logging.""" + + def __init__(self, config): + super().__init__(config, "logs") + self.error = self.colorer("error", fg="red") + self.warning = self.colorer("warn", fg="yellow") + + +class ConfigMock: + """Default coloring config to use when Logging.config is not set.""" + + def __init__(self): + self.default_values = {"color.ui": "auto"} + + def GetString(self, x): + return self.default_values.get(x, None) + + +class RepoLogger(logging.Logger): + """Repo Logging Module.""" + + # Aggregates error-level logs. This is used to generate an error summary + # section at the end of a command execution. + errors = multiprocessing.Manager().list() + + def __init__(self, name, config=None, **kwargs): + super().__init__(name, **kwargs) + self.config = config if config else ConfigMock() + self.colorer = LogColoring(self.config) + + def error(self, msg, *args, **kwargs): + """Print and aggregate error-level logs.""" + colored_error = self.colorer.error(msg, *args) + RepoLogger.errors.append(colored_error) + + super().error(colored_error, **kwargs) + + def warning(self, msg, *args, **kwargs): + """Print warning-level logs with coloring.""" + colored_warning = self.colorer.warning(msg, *args) + super().warning(colored_warning, **kwargs) + + def log_aggregated_errors(self): + """Print all aggregated logs.""" + super().error(self.colorer.error(SEPARATOR)) + super().error( + self.colorer.error("Repo command failed due to following errors:") + ) + super().error("\n".join(RepoLogger.errors)) diff --git a/tests/test_repo_logging.py b/tests/test_repo_logging.py new file mode 100644 index 00000000..ba8a9a9e --- /dev/null +++ b/tests/test_repo_logging.py @@ -0,0 +1,115 @@ +# Copyright (C) 2023 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Unit test for repo_logging module.""" +import unittest +from unittest.mock import MagicMock + +from repo_logging import RepoLogger + + +class TestRepoLogger(unittest.TestCase): + def test_error_logs_error(self): + """Test if error fn outputs logs.""" + logger = RepoLogger(__name__) + RepoLogger.errors[:] = [] + result = None + + def mock_handler(log): + nonlocal result + result = log.getMessage() + + mock_out = MagicMock() + mock_out.level = 0 + mock_out.handle = mock_handler + logger.addHandler(mock_out) + + logger.error("We're no strangers to love") + + self.assertEqual(result, "We're no strangers to love") + + def test_warning_logs_error(self): + """Test if warning fn outputs logs.""" + logger = RepoLogger(__name__) + RepoLogger.errors[:] = [] + result = None + + def mock_handler(log): + nonlocal result + result = log.getMessage() + + mock_out = MagicMock() + mock_out.level = 0 + mock_out.handle = mock_handler + logger.addHandler(mock_out) + + logger.warning("You know the rules and so do I (do I)") + + self.assertEqual(result, "You know the rules and so do I (do I)") + + def test_error_aggregates_error_msg(self): + """Test if error fn aggregates error logs.""" + logger = RepoLogger(__name__) + RepoLogger.errors[:] = [] + + logger.error("A full commitment's what I'm thinking of") + logger.error("You wouldn't get this from any other guy") + logger.error("I just wanna tell you how I'm feeling") + logger.error("Gotta make you understand") + + self.assertEqual( + RepoLogger.errors[:], + [ + "A full commitment's what I'm thinking of", + "You wouldn't get this from any other guy", + "I just wanna tell you how I'm feeling", + "Gotta make you understand", + ], + ) + + def test_log_aggregated_errors_logs_aggregated_errors(self): + """Test if log_aggregated_errors outputs aggregated errors.""" + logger = RepoLogger(__name__) + RepoLogger.errors[:] = [] + result = [] + + def mock_handler(log): + nonlocal result + result.append(log.getMessage()) + + mock_out = MagicMock() + mock_out.level = 0 + mock_out.handle = mock_handler + logger.addHandler(mock_out) + + logger.error("Never gonna give you up") + logger.error("Never gonna let you down") + logger.error("Never gonna run around and desert you") + logger.log_aggregated_errors() + + self.assertEqual( + result, + [ + "Never gonna give you up", + "Never gonna let you down", + "Never gonna run around and desert you", + "=" * 80, + "Repo command failed due to following errors:", + ( + "Never gonna give you up\n" + "Never gonna let you down\n" + "Never gonna run around and desert you" + ), + ], + )