Skip to content

Commit 58a2c44

Browse files
committed
test: cover the logging setup and its capture in parallelize
- 23 offline tests over enable/disable, level parsing and OSW_LOG_LEVEL - handler_chain walking past a non-propagating logger - worker records buffered, replayed in input order, dropped without flush_at_end, and the logger restored even when the batch raises
1 parent db51192 commit 58a2c44

1 file changed

Lines changed: 238 additions & 0 deletions

File tree

‎tests/test_logging_setup.py‎

Lines changed: 238 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,238 @@
1+
"""Offline tests for the osw logging setup and its capture in parallelize.
2+
3+
Covers #130: prints replaced by logging, on by default, and routed per worker
4+
thread so a parallel batch does not garble its own progress bar.
5+
"""
6+
7+
import logging
8+
9+
import pytest
10+
11+
import osw
12+
from osw.utils.util import ThreadRoutedLogHandler, handler_chain, parallelize
13+
14+
15+
class ListHandler(logging.Handler):
16+
"""Collects records so a test can assert on them"""
17+
18+
def __init__(self):
19+
super().__init__()
20+
self.records = []
21+
22+
def emit(self, record: logging.LogRecord):
23+
self.records.append(record)
24+
25+
def messages(self, name: str = None):
26+
return [r.getMessage() for r in self.records if name is None or r.name == name]
27+
28+
29+
@pytest.fixture
30+
def osw_logger():
31+
"""Hands out the osw logger and puts its global state back afterwards"""
32+
logger = logging.getLogger("osw")
33+
saved = (logger.handlers[:], logger.level, logger.propagate)
34+
yield logger
35+
logger.handlers, logger.level, logger.propagate = saved
36+
37+
38+
@pytest.fixture
39+
def collected(osw_logger):
40+
"""The osw logger with a single collecting handler on it"""
41+
handler = ListHandler()
42+
osw_logger.handlers = [handler]
43+
osw_logger.propagate = False
44+
osw_logger.setLevel(logging.DEBUG)
45+
return handler
46+
47+
48+
def test_the_package_attaches_its_own_handler_on_import():
49+
"""Logging is on by default, so a caller who configures nothing still sees
50+
what osw is doing."""
51+
names = [h.get_name() for h in logging.getLogger("osw").handlers]
52+
53+
assert "osw-default" in names
54+
55+
56+
@pytest.mark.parametrize(
57+
"value, expected",
58+
[
59+
("DEBUG", logging.DEBUG),
60+
("debug", logging.DEBUG),
61+
(" warning ", logging.WARNING),
62+
("10", 10),
63+
("OFF", osw.OFF),
64+
("NONE", osw.OFF),
65+
("SILENT", osw.OFF),
66+
("nonsense", osw.DEFAULT_LOG_LEVEL),
67+
("", osw.DEFAULT_LOG_LEVEL),
68+
],
69+
)
70+
def test_the_environment_variable_is_parsed_leniently(value, expected):
71+
"""An unusable value falls back rather than raising at import time."""
72+
assert osw._parse_level(value) == expected
73+
74+
75+
def test_enable_logging_reads_the_environment_variable(osw_logger, monkeypatch):
76+
monkeypatch.setenv(osw.LOG_LEVEL_ENV_VAR, "WARNING")
77+
78+
osw.enable_logging()
79+
80+
assert osw_logger.level == logging.WARNING
81+
82+
83+
def test_enable_logging_does_not_stack_handlers(osw_logger):
84+
"""Calling it again replaces the handler instead of adding a second one,
85+
so messages are not emitted twice."""
86+
osw.enable_logging()
87+
osw.enable_logging()
88+
89+
assert len(osw_default_handlers(osw_logger)) == 1
90+
91+
92+
def osw_default_handlers(logger):
93+
"""The handlers osw attached itself
94+
95+
Membership rather than list equality, because pytest's logging plugin
96+
attaches its own capture handlers to any logger that does not propagate,
97+
which the osw logger does not while the default handler is on it.
98+
"""
99+
return [h for h in logger.handlers if h.get_name() == "osw-default"]
100+
101+
102+
def test_disable_logging_leaves_a_foreign_handler_alone(osw_logger):
103+
"""Only the handler osw attached itself is removed. A handler the calling
104+
application added keeps receiving records."""
105+
foreign = ListHandler()
106+
osw.enable_logging()
107+
osw_logger.addHandler(foreign)
108+
109+
osw.disable_logging()
110+
111+
assert foreign in osw_logger.handlers
112+
assert osw_default_handlers(osw_logger) == []
113+
114+
115+
def test_disable_logging_restores_propagation(osw_logger):
116+
"""Handing control back to the root logger is what lets an application take
117+
over with basicConfig()."""
118+
osw.enable_logging()
119+
assert osw_logger.propagate is False
120+
121+
osw.disable_logging()
122+
123+
assert osw_logger.propagate is True
124+
125+
126+
def test_set_log_level_filters_what_is_emitted(collected, osw_logger):
127+
osw.set_log_level(logging.WARNING)
128+
log = logging.getLogger("osw.somewhere")
129+
130+
log.info("routine progress")
131+
log.warning("something worth saying")
132+
133+
assert collected.messages() == ["something worth saying"]
134+
135+
136+
def test_handler_chain_stops_where_propagation_stops(osw_logger):
137+
own = ListHandler()
138+
osw_logger.handlers = [own]
139+
osw_logger.propagate = False
140+
141+
assert handler_chain(osw_logger) == [own]
142+
143+
144+
def test_handler_chain_includes_ancestors_while_propagating(osw_logger):
145+
"""After disable_logging() the records land on the root logger, so the
146+
chain has to keep walking to find where they actually go."""
147+
own = ListHandler()
148+
inherited = ListHandler()
149+
osw_logger.handlers = [own]
150+
osw_logger.propagate = True
151+
root = logging.getLogger()
152+
root.addHandler(inherited)
153+
try:
154+
chain = handler_chain(osw_logger)
155+
finally:
156+
root.removeHandler(inherited)
157+
158+
assert own in chain
159+
assert inherited in chain
160+
161+
162+
def test_an_unregistered_thread_is_forwarded(osw_logger):
163+
"""The calling thread and tqdm keep writing straight through."""
164+
wrapped = ListHandler()
165+
handler = ThreadRoutedLogHandler([wrapped])
166+
osw_logger.handlers = [handler]
167+
osw_logger.setLevel(logging.DEBUG)
168+
169+
logging.getLogger("osw.caller").info("straight through")
170+
171+
assert wrapped.messages() == ["straight through"]
172+
173+
174+
def test_a_registered_thread_is_buffered(osw_logger):
175+
wrapped = ListHandler()
176+
handler = ThreadRoutedLogHandler([wrapped])
177+
osw_logger.handlers = [handler]
178+
osw_logger.setLevel(logging.DEBUG)
179+
buffer = handler.register()
180+
try:
181+
logging.getLogger("osw.worker").info("held back")
182+
finally:
183+
handler.unregister()
184+
185+
assert wrapped.messages() == []
186+
assert [r.getMessage() for r in buffer] == ["held back"]
187+
188+
189+
WORKER = "osw.worker"
190+
191+
192+
def _log_item(item):
193+
logging.getLogger(WORKER).info(f"handled {item}")
194+
return item
195+
196+
197+
def test_worker_records_are_replayed_in_input_order(collected):
198+
"""The tasks finish in whatever order they finish, so the replay is what
199+
puts the messages back in the order of the iterable."""
200+
parallelize(_log_item, [1, 2, 3, 4], flush_at_end=True, progress_bar=False)
201+
202+
assert collected.messages(WORKER) == [
203+
"handled 1",
204+
"handled 2",
205+
"handled 3",
206+
"handled 4",
207+
]
208+
209+
210+
def test_worker_records_are_dropped_without_flush_at_end(collected):
211+
"""flush_at_end=False means quiet, which is what debug=False asks for."""
212+
parallelize(_log_item, [1, 2, 3], flush_at_end=False, progress_bar=False)
213+
214+
assert collected.messages(WORKER) == []
215+
216+
217+
def test_the_logger_is_restored_afterwards(collected, osw_logger):
218+
parallelize(_log_item, [1], flush_at_end=True, progress_bar=False)
219+
220+
assert collected in osw_logger.handlers
221+
assert not [h for h in osw_logger.handlers if isinstance(h, ThreadRoutedLogHandler)]
222+
assert osw_logger.propagate is False
223+
224+
225+
def _fail_on_item(item):
226+
logging.getLogger(WORKER).info(f"about to fail on {item}")
227+
raise ValueError(item)
228+
229+
230+
def test_a_failed_batch_still_replays_and_restores(collected, osw_logger):
231+
"""The replay sits in a finally block, so a batch that raised still reports
232+
what its tasks had to say."""
233+
with pytest.raises(ValueError):
234+
parallelize(_fail_on_item, [7], flush_at_end=True, progress_bar=False)
235+
236+
assert collected.messages(WORKER) == ["about to fail on 7"]
237+
assert collected in osw_logger.handlers
238+
assert not [h for h in osw_logger.handlers if isinstance(h, ThreadRoutedLogHandler)]

0 commit comments

Comments
 (0)