repo_id stringclasses 409
values | prefix large_stringlengths 34 36.3k | target large_stringlengths 1 498 | assertion_type stringclasses 31
values | difficulty stringclasses 8
values | test_file stringlengths 10 121 | test_function stringlengths 1 104 | test_class stringlengths 0 51 | lineno int32 2 11.3k | commit_idx int32 |
|---|---|---|---|---|---|---|---|---|---|
Delgan/loguru | import sys
from logging import FileHandler, Filter, Formatter, Handler, NullHandler, StreamHandler
import pytest
from loguru import logger
def test_stream_handler(capsys):
logger.add(StreamHandler(sys.stderr), format="{level} {message}")
logger.info("test")
logger.remove()
logger.warning("nope")
... | "" | assert | string_literal | tests/test_standard_handler.py | test_stream_handler | 21 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_file_mode_w(tmp_path):
file = tmp_path / "test.log"
file.write_text("base\n")
logger.add(file, format="{message}", mode="w")
logger.debug("msg")
assert file.read_text() == | "msg\n" | assert | string_literal | tests/test_add_option_kwargs.py | test_file_mode_w | 19 | null | |
Delgan/loguru | import sys
import pytest
from loguru import logger
def test_returned_ids(capsys):
ids = logger.configure(
handlers=[
{"sink": sys.stdout, "format": "{message}"},
{"sink": sys.stderr, "format": "{message}"},
]
)
assert len(ids) == | 2 | assert | numeric_literal | tests/test_configure.py | test_returned_ids | 93 | null | |
Delgan/loguru | import asyncio
import logging
import os
import pathlib
import sys
import pytest
from loguru import logger
message = "test message"
expected = message + "\n"
repetitions = pytest.mark.parametrize("rep", [0, 1, 2])
def log(sink, rep=1):
logger.debug("This shouldn't be printed.")
i = logger.add(sink, format="... | "" | assert | string_literal | tests/test_add_sinks.py | test_stdout_sink | 41 | null | |
Delgan/loguru | import os
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
@pytest.mark.skipif(os.name == "nt", reason="Windows can't delete file in use")
def test_file_deleted_before_write_without_delay(tmp_path):
file = tmp_path / "test.log"
logger.add(file, format="{... | "Test\n" | assert | string_literal | tests/test_filesink_watch.py | test_file_deleted_before_write_without_delay | 17 | null | |
Delgan/loguru | import gc
import pickle
import sys
import threading
import time
import pytest
from loguru import logger
def _remove_cyclic_references():
"""Prevent cyclic isolate finalizers bleeding into other tests."""
try:
yield
finally:
gc.collect()
def test_no_deadlock_if_logger_used_inside_sink_wit... | "" | assert | string_literal | tests/test_locks.py | test_no_deadlock_if_logger_used_inside_sink_with_catch | 80 | null | |
Delgan/loguru | import os
import sys
import threading
import time
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
@pytest.mark.parametrize("delay", [True, False])
def test_exception_during_compression_at_rotation_not_caught(freeze_time, tmp_path, capsys, delay):
with freez... | err | assert | variable | tests/test_filesink_compression.py | test_exception_during_compression_at_rotation_not_caught | 238 | null | |
Delgan/loguru | import multiprocessing
import os
from unittest.mock import patch
import pytest
from loguru import logger
def test_invalid_context_name():
with pytest.raises( | ValueError, match=r"cannot find context for") | pytest.raises | complex_expr | tests/test_add_option_context.py | test_invalid_context_name | 57 | null | |
Delgan/loguru | import sys
import pytest
from loguru import logger
def test_activation(writer):
activation = [("tests", False), ("tests.test_configure", True)]
logger.add(writer, format="{message}")
logger.configure(activation=activation)
logger.debug("Logging")
assert writer.read() == | "Logging\n" | assert | string_literal | tests/test_configure.py | test_activation | 66 | null | |
Delgan/loguru | import io
import pathlib
import re
from datetime import datetime
import pytest
from loguru import logger
TEXT = "This\nIs\nRandom\nText\n123456789\nABC!DEF\nThis Is The End\n"
def fileobj():
with io.StringIO(TEXT) as file:
yield file
def test_parse_bytes():
with io.BytesIO(b"Testing bytes!") as fil... | dict(ponct=b"!") | assert | func_call | tests/test_parse.py | test_parse_bytes | 65 | null | |
Delgan/loguru | import datetime
import os
import sys
from time import strftime
from unittest.mock import Mock
import freezegun
import pytest
import loguru
from loguru import logger
def _expected_fallback_time_zone():
# For some reason, Python versions and interepreters return different time zones here.
return strftime("%Z")... | dt.strftime("%B %b %A %a\n") | assert | func_call | tests/test_datetime.py | test_locale_formatting | 163 | null | |
Delgan/loguru | import sys
from logging import FileHandler, Filter, Formatter, Handler, NullHandler, StreamHandler
import pytest
from loguru import logger
def test_standard_handler_with_configured_filter(capsys):
handler = StreamHandler(sys.stdout)
filter_ = RejectAllFilter()
logger.add(handler, format="{message}")
... | "a\nc\n" | assert | string_literal | tests/test_standard_handler.py | test_standard_handler_with_configured_filter | 236 | null | |
Delgan/loguru | import asyncio
import sys
import threading
from unittest.mock import MagicMock
import pytest
from loguru import logger
from loguru._contextvars import load_contextvar_class
def test_contextualize_thread(writer):
logger.add(writer, format="{message} {extra[i]}")
def task():
logger.info("Processing")
... | ["Processing %d" % i for i in range(5)] | assert | collection | tests/test_contextualize.py | test_contextualize_thread | 117 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_unknown_level(writer):
with pytest.raises( | ValueError, match="^Level 'foo' does not exist$") | pytest.raises | complex_expr | tests/test_add_option_level.py | test_unknown_level | 34 | null | |
Delgan/loguru | import os
import platform
import re
import subprocess
import sys
import traceback
from unittest.mock import MagicMock
import pytest
from loguru import logger
def normalize(exception):
"""Normalize exception output for reproducible test cases."""
if os.name == "nt":
exception = re.sub(
r'F... | "" | assert | string_literal | tests/test_exceptions_formatting.py | compare_exception | 115 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_incomplete_frame_context_with_others(writer, incomplete_frame_context):
logger.add(writer, format="{message}")
logger.info("1")
logger.enable(None)
logger.disable("foobar")
logger.enable("foo.bar")
logger.disable(None)
logger.info("2")
l... | "1\n3\n" | assert | string_literal | tests/test_activation.py | test_incomplete_frame_context_with_others | 141 | null | |
Delgan/loguru | import json
import re
import sys
from loguru import logger
def test_serialize_non_ascii_characters():
sink = JsonSink()
logger.add(sink, format="{level.icon} {message}", serialize=True)
logger.debug("天")
assert re.search(r'"message": "([^\"]+)"', sink.message).group(1) == "天"
assert re.search(r'"t... | "🐞" | assert | string_literal | tests/test_add_option_serialize.py | test_serialize_non_ascii_characters | 35 | null | |
Delgan/loguru | import asyncio
import site
import sys
import sysconfig
import threading
import types
import pytest
from loguru import logger
def test_decorate_generator_with_error():
@logger.catch
def foo():
yield 0
yield 1
raise ValueError
assert list(foo()) == | [0, 1] | assert | collection | tests/test_exceptions_catch.py | test_decorate_generator_with_error | 414 | null | |
Delgan/loguru | import asyncio
import site
import sys
import sysconfig
import threading
import types
import pytest
from loguru import logger
def test_decorate_function(writer):
logger.add(writer, format="{message}", diagnose=False, backtrace=False, colorize=False)
@logger.catch
def a(x):
return 100 / x
as... | 2 | assert | numeric_literal | tests/test_exceptions_catch.py | test_decorate_function | 375 | null | |
Delgan/loguru | import logging
import sys
from logging import StreamHandler
import pytest
from loguru import logger
from .conftest import make_logging_logger
@pytest.mark.parametrize("use_opt", [False, True])
def test_exception(capsys, use_opt):
with make_logging_logger("tests", StreamHandler(sys.stderr)):
logger.add(P... | "Oops..." | assert | string_literal | tests/test_propagation.py | test_exception | 101 | null | |
Delgan/loguru | import io
import pathlib
import re
from datetime import datetime
import pytest
from loguru import logger
TEXT = "This\nIs\nRandom\nText\n123456789\nABC!DEF\nThis Is The End\n"
def fileobj():
with io.StringIO(TEXT) as file:
yield file
def test_greedy_pattern():
text = ("\n" + "a" * 100) * 1000
p... | [dict(a="a" * 100)] * 1000 | assert | collection | tests/test_parse.py | test_greedy_pattern | 87 | null | |
Delgan/loguru | import datetime
import os
import pathlib
import tempfile
import time
from unittest.mock import Mock
import pytest
import loguru
from loguru import logger
from loguru._ctime_functions import load_ctime_functions
from .conftest import check_dir
def tmp_path_local(reset_logger):
# Pytest 'tmp_path' creates directo... | "4\n5\n" | assert | string_literal | tests/test_filesink_rotation.py | test_time_rotation_reopening_native | 739 | null | |
Delgan/loguru | import sys
import pytest
from loguru import logger
def test_dont_reset_previous_levels(writer):
logger.level("abc", no=30)
logger.configure(levels=[])
logger.add(writer, format="{level} {message}")
logger.log("abc", "Test")
assert writer.read() == | "abc Test\n" | assert | string_literal | tests/test_configure.py | test_dont_reset_previous_levels | 164 | null | |
Delgan/loguru | import pickle
import re
import sys
import time
import pytest
from loguru import logger
from .conftest import default_threading_excepthook
def test_caught_exception_queue_put(writer, capsys):
logger.add(writer, enqueue=True, catch=True, format="{message}")
logger.info("It's fine")
logger.bind(broken=Not... | err | assert | variable | tests/test_add_option_enqueue.py | test_caught_exception_queue_put | 104 | null | |
Delgan/loguru | import copy
import multiprocessing
import os
import platform
import sys
import threading
import time
import pytest
from loguru import logger
from .conftest import new_event_loop_context
def fork_context():
return multiprocessing.get_context("fork")
def spawn_context():
return multiprocessing.get_context("s... | "" | assert | string_literal | tests/test_multiprocessing.py | test_await_complete_spawn | 394 | null | |
Delgan/loguru | import logging
import sys
from logging import StreamHandler
import pytest
from loguru import logger
from .conftest import make_logging_logger
def test_propagate(capsys):
with make_logging_logger("tests", StreamHandler(sys.stderr)) as logging_logger:
logging_logger.debug("1")
logger.debug("2")
... | "1\n3\n" | assert | string_literal | tests/test_propagation.py | test_propagate | 49 | null | |
Delgan/loguru | import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from .conftest import parse
@pytest.mark.parametrize("colorize", [True, False])
def test_colors_without_formatting_args(writer, colorize):
string = "{} This { should } not } raise {"
logger.add(writer, colorize=colorize, ... | string + "\n" | assert | complex_expr | tests/test_opt.py | test_colors_without_formatting_args | 401 | null | |
Delgan/loguru | import os
import re
import pytest
from loguru import logger
def test_formatting_missing_lineno_frame_context(writer, missing_frame_lineno_value):
logger.add(writer, format="{line} {message}", colorize=False)
logger.info("Foobar")
assert writer.read() == | "0 Foobar\n" | assert | string_literal | tests/test_formatting.py | test_formatting_missing_lineno_frame_context | 119 | null | |
Delgan/loguru | import datetime
import os
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
@pytest.mark.parametrize("delay", [True, False])
def test_exception_during_retention_at_rotation(freeze_time, tmp_path, capsys, delay):
with freeze_time("2022-02-22") as frozen:
... | "" | assert | string_literal | tests/test_filesink_retention.py | test_exception_during_retention_at_rotation | 290 | null | |
Delgan/loguru | import re
import sys
import time
import pytest
from loguru import logger
from .conftest import default_threading_excepthook
def broken_sink(m):
raise ValueError("Error!")
def test_unprintable_record(writer, capsys):
class Unprintable:
def __repr__(self):
raise ValueError("Failed")
... | "a 1\nc 2\n" | assert | string_literal | tests/test_add_option_catch.py | test_unprintable_record | 86 | null | |
Delgan/loguru | import copy
from loguru import logger
def print_(message):
print(message, end="")
def test_add_sink_after_deepcopy(capsys):
logger_ = copy.deepcopy(logger)
logger_.add(print_, format="{message}", catch=False)
logger_.info("A")
logger.info("B")
out, err = capsys.readouterr()
assert out ... | "" | assert | string_literal | tests/test_deepcopy.py | test_add_sink_after_deepcopy | 20 | null | |
Delgan/loguru | import multiprocessing
import os
from unittest.mock import patch
import pytest
from loguru import logger
def test_using_multiprocessing_directly_if_context_is_none():
logger.add(lambda _: None, enqueue=True, context=None)
assert multiprocessing.get_start_method(allow_none=True) is not | None | assert | none_literal | tests/test_add_option_context.py | test_using_multiprocessing_directly_if_context_is_none | 12 | null | |
Delgan/loguru | import itertools
import time
from threading import Barrier, Thread
from loguru import logger
def test_safe_removing_while_logging(capsys):
barrier = Barrier(2)
counter = itertools.count()
sink = NonSafeSink(1)
i = logger.add(sink, format="{message}", catch=False)
def thread_1():
barrier.... | "" | assert | string_literal | tests/test_threading.py | test_safe_removing_while_logging | 111 | null | |
Delgan/loguru | import re
import pytest
from loguru import logger
@pytest.mark.parametrize(
"filter",
[
"test",
"testss",
"tests.",
"tests.test_add_option_filter.",
".",
(lambda r: False),
(lambda r: r["level"].no != 10),
{"": False},
{"": True, "tests"... | "" | assert | string_literal | tests/test_add_option_filter.py | test_filtered_out | 55 | null | |
Delgan/loguru | import pytest
from loguru._defaults import env
@pytest.mark.parametrize("value", ["y", "1", "TRUE"])
def test_bool_positive(value, monkeypatch):
with monkeypatch.context() as context:
key = "VALID_BOOL_POS"
context.setenv(key, value)
assert env(key, bool) is | True | assert | bool_literal | tests/test_defaults.py | test_bool_positive | 19 | null | |
Delgan/loguru | import io
import pathlib
import re
from datetime import datetime
import pytest
from loguru import logger
TEXT = "This\nIs\nRandom\nText\n123456789\nABC!DEF\nThis Is The End\n"
def fileobj():
with io.StringIO(TEXT) as file:
yield file
def test_parse_pathlib(tmp_path):
file = tmp_path / "test.log"
... | dict(r="Random") | assert | func_call | tests/test_parse.py | test_parse_pathlib | 38 | null | |
Delgan/loguru | import datetime
import os
import sys
from time import strftime
from unittest.mock import Mock
import freezegun
import pytest
import loguru
from loguru import logger
def _expected_fallback_time_zone():
# For some reason, Python versions and interepreters return different time zones here.
return strftime("%Z")... | expected_result + "\n" | assert | complex_expr | tests/test_datetime.py | test_update_with_zone_info | 244 | null | |
Delgan/loguru | import json
import re
import sys
from loguru import logger
def test_serialize():
sink = JsonSink()
logger.add(sink, format="{level} {message}", serialize=True)
logger.debug("Test")
assert sink.json["text"] == "DEBUG Test\n"
assert sink.dict["message"] == sink.json["record"]["message"] == "Test"
... | set(sink.json["record"].keys()) | assert | func_call | tests/test_add_option_serialize.py | test_serialize | 26 | null | |
Delgan/loguru | import sys
import time
import pytest
from loguru import logger
def test_exception_in_stop_during_remove_one(capsys):
i = logger.add(StopSinkError(), catch=False, format="{message}")
logger.info("A")
with pytest.raises( | OSError, match=r"Stop error") | pytest.raises | complex_expr | tests/test_remove.py | test_exception_in_stop_during_remove_one | 72 | null | |
Delgan/loguru | import datetime
import os
import pathlib
import tempfile
import time
from unittest.mock import Mock
import pytest
import loguru
from loguru import logger
from loguru._ctime_functions import load_ctime_functions
from .conftest import check_dir
def tmp_path_local(reset_logger):
# Pytest 'tmp_path' creates directo... | "1\n2\n3\n" | assert | string_literal | tests/test_filesink_rotation.py | test_time_rotation_reopening_native | 725 | null | |
Delgan/loguru | import json
import re
import sys
from loguru import logger
def test_serialize():
sink = JsonSink()
logger.add(sink, format="{level} {message}", serialize=True)
logger.debug("Test")
assert sink.json["text"] == "DEBUG Test\n"
assert sink.dict["message"] == | sink.json["record"]["message"] | assert | complex_expr | tests/test_add_option_serialize.py | test_serialize | 25 | null | |
Delgan/loguru | import gc
import pickle
import sys
import threading
import time
import pytest
from loguru import logger
def _remove_cyclic_references():
"""Prevent cyclic isolate finalizers bleeding into other tests."""
try:
yield
finally:
gc.collect()
def test_no_deadlock_if_logger_used_inside_sink_wit... | RuntimeError, match=r".*deadlock avoided.*") | pytest.raises | complex_expr | tests/test_locks.py | test_no_deadlock_if_logger_used_inside_sink_without_catch | 90 | null | |
Delgan/loguru | import asyncio
import logging
import multiprocessing
import re
import sys
import threading
import pytest
from loguru import logger
from .conftest import new_event_loop_context, set_event_loop_context
async def async_writer(msg):
await asyncio.sleep(0.01)
print(msg, end="")
def test_coroutine_function(capsy... | "" | assert | string_literal | tests/test_coroutine_sink.py | test_coroutine_function | 36 | null | |
Delgan/loguru | import asyncio
import contextlib
import datetime
import logging
import pickle
import pytest
from loguru import logger
from .conftest import parse
def print_(message):
print(message, end="")
async def async_print(msg):
print_(msg)
def copied_logger_though_pickle(logger):
pickled = pickle.dumps(logger)
... | "bar\n" | assert | string_literal | tests/test_pickling.py | test_pickling_bound_logger | 288 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_function_format_without_exception(writer):
logger.add(writer, format=lambda _: "{message}\n")
try:
1 / 0 # noqa: B018
except ZeroDivisionError:
logger.exception("Error!")
assert writer.read() == | "Error!\n" | assert | string_literal | tests/test_add_option_format.py | test_function_format_without_exception | 45 | null | |
Delgan/loguru | import inspect
import logging
from loguru import logger
from .conftest import make_logging_logger
def test_formatting(writer):
fmt = (
"{name} - {file.name} - {function} - {level.name} - "
"{level.no} - {line} - {module} - {message}"
)
expected = (
"tests.test_interception - test... | expected | assert | variable | tests/test_interception.py | test_formatting | 47 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_multiple_activations():
def n():
return len(logger._core.activation_list)
assert n() == 0
logger.enable("")
assert n() == 0
logger.disable("")
assert n() == 1
logger.enable("foo")
assert n() == | 2 | assert | numeric_literal | tests/test_activation.py | test_multiple_activations | 89 | null | |
Delgan/loguru | import re
import pytest
from loguru import logger
def test_filter_dict_with_custom_level(writer):
logger.level("MY_LEVEL", 6, color="", icon="")
logger.add(writer, level=0, filter={"tests": "MY_LEVEL"}, format="{message}")
logger.log(3, "No")
logger.log(9, "Yes")
assert writer.read() == | "Yes\n" | assert | string_literal | tests/test_add_option_filter.py | test_filter_dict_with_custom_level | 140 | null | |
Delgan/loguru | import asyncio
import logging
import multiprocessing
import re
import sys
import threading
import pytest
from loguru import logger
from .conftest import new_event_loop_context, set_event_loop_context
async def async_writer(msg):
await asyncio.sleep(0.01)
print(msg, end="")
def test_exception_in_coroutine_n... | 1 | assert | numeric_literal | tests/test_coroutine_sink.py | test_exception_in_coroutine_not_caught | 357 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_not_override_parent_logger(writer):
logger_1 = logger.bind(a="a")
logger_2 = logger_1.bind(a="A")
logger.add(writer, format="{extra[a]} {message}")
logger_1.debug("1")
logger_2.debug("2")
assert writer.read() == | "a 1\nA 2\n" | assert | string_literal | tests/test_bind.py | test_not_override_parent_logger | 40 | null | |
Delgan/loguru | import functools
import pytest
from loguru import logger
from .conftest import parse
@pytest.mark.parametrize("level", ["foo", "debug"])
def test_log_unknown_level(writer, level):
logger.add(writer)
with pytest.raises( | ValueError, match="^Level '[^']+' does not exist$") | pytest.raises | complex_expr | tests/test_levels.py | test_log_unknown_level | 219 | null | |
Delgan/loguru | import os
import re
import pytest
from loguru import logger
@pytest.mark.parametrize("colors", [True, False])
def test_non_string_message_is_str_in_record(writer, colors):
output = ""
def sink(message):
nonlocal output
assert isinstance(message.record["message"], str)
output += messa... | "[123]\n" | assert | string_literal | tests/test_formatting.py | test_non_string_message_is_str_in_record | 201 | null | |
Delgan/loguru | import os
from stat import S_IMODE
import pytest
from loguru import logger
def set_umask():
default = os.umask(0)
yield
os.umask(default)
@pytest.mark.parametrize("permissions", [0o777, 0o766, 0o744, 0o700, 0o611])
def test_log_file_permissions(tmp_path, permissions):
def file_permission_opener(file... | expected | assert | variable | tests/test_filesink_permissions.py | test_log_file_permissions | 27 | null | |
Delgan/loguru | from loguru import logger
def test_patch_after_add(writer):
logger.add(writer, format="{extra[a]} {message}")
logger_patched = logger.patch(lambda r: r["extra"].update(a=0))
logger_patched.debug("A")
assert writer.read() == | "0 A\n" | assert | string_literal | tests/test_patch.py | test_patch_after_add | 9 | null | |
Delgan/loguru | import sys
from logging import FileHandler, Filter, Formatter, Handler, NullHandler, StreamHandler
import pytest
from loguru import logger
def test_no_conflict_with_extra_dict(capsys):
handler = StreamHandler(sys.stdout)
logger.add(handler, format="{message}", catch=False)
logger.bind(args=True, name="fo... | "OK!\n" | assert | string_literal | tests/test_standard_handler.py | test_no_conflict_with_extra_dict | 61 | null | |
Delgan/loguru | import os
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
@pytest.mark.skipif(os.name == "nt", reason="Windows can't delete file in use")
def test_file_reopened_with_arguments(tmp_path):
file = tmp_path / "test.log"
logger.add(file, format="{message}", ... | "?\n" | assert | string_literal | tests/test_filesink_watch.py | test_file_reopened_with_arguments | 47 | null | |
Delgan/loguru | import sys
import pytest
from loguru import logger
def test_configure_filter_using_new_level(writer):
logger.configure(
levels=[{"name": "CONF_LVL_2", "no": 33, "icon": "", "color": ""}],
handlers=[
{"sink": writer, "level": 0, "filter": {"tests": "CONF_LVL_2"}, "format": "{message}"}... | "Custom\n" | assert | string_literal | tests/test_configure.py | test_configure_filter_using_new_level | 188 | null | |
Delgan/loguru | import io
import pathlib
import re
from datetime import datetime
import pytest
from loguru import logger
TEXT = "This\nIs\nRandom\nText\n123456789\nABC!DEF\nThis Is The End\n"
def fileobj():
with io.StringIO(TEXT) as file:
yield file
@pytest.mark.parametrize("chunk", [-1, 1, 2**16])
def test_chunk(file... | dict(a="ABC") | assert | func_call | tests/test_parse.py | test_chunk | 71 | null | |
Delgan/loguru | import asyncio
import site
import sys
import sysconfig
import threading
import types
import pytest
from loguru import logger
@pytest.mark.parametrize("diagnose", [False, True])
def test_caret_not_masked(writer, diagnose):
logger.add(writer, backtrace=True, diagnose=diagnose, colorize=False, format="")
@logg... | 1 | assert | numeric_literal | tests/test_exceptions_catch.py | test_caret_not_masked | 24 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_file_auto_buffering(tmp_path):
# There doesn't seem to be a reliable way to known buffer size for text files.
# We perform a preliminary test to ensure empirically that 128 <= buffer size <= 65536.
dummy_filepath = tmp_path / "dummy.txt"
with open(str(d... | "" | assert | string_literal | tests/test_add_option_kwargs.py | test_file_auto_buffering | 37 | null | |
Delgan/loguru | import os
import platform
import re
import subprocess
import sys
import traceback
from unittest.mock import MagicMock
import pytest
from loguru import logger
def normalize(exception):
"""Normalize exception output for reproducible test cases."""
if os.name == "nt":
exception = re.sub(
r'F... | "\n" | assert | string_literal | tests/test_exceptions_formatting.py | test_invalid_format_exception_only_no_output | 300 | null | |
Delgan/loguru | import sys
import time
import pytest
from loguru import logger
def test_remove_simple(writer):
i = logger.add(writer, format="{message}")
logger.debug("1")
logger.remove(i)
logger.debug("2")
assert writer.read() == | "1\n" | assert | string_literal | tests/test_remove.py | test_remove_simple | 49 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_invalid_file_kwargs():
with pytest.raises( | TypeError, match=r".*keyword argument;*") | pytest.raises | complex_expr | tests/test_add_option_kwargs.py | test_invalid_file_kwargs | 74 | null | |
Delgan/loguru | import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from .conftest import parse
@pytest.mark.parametrize("colors", [True, False])
def test_message_update_not_overridden_by_raw(writer, colors):
logger.add(writer, colorize=True)
logger.patch(lambda r: r.update(message="Updat... | "Updated!" | assert | string_literal | tests/test_opt.py | test_message_update_not_overridden_by_raw | 627 | null | |
Delgan/loguru | import functools
import pytest
from loguru import logger
from .conftest import parse
def test_blank_color(writer):
logger.level("INFO", color=" ")
logger.add(writer, level="DEBUG", format="<level>{message}</level>", colorize=True)
logger.info("Test")
assert writer.read() == | parse("Test" "\x1b[0m" "\n") | assert | func_call | tests/test_levels.py | test_blank_color | 93 | null | |
Delgan/loguru | import pytest
from loguru import logger
def test_override_configured(writer):
logger.configure(extra={"a": 1})
logger2 = logger.bind(a=2)
logger2.add(writer, format="{extra[a]} {message}")
logger2.debug("?")
assert writer.read() == | "2 ?\n" | assert | string_literal | tests/test_bind.py | test_override_configured | 86 | null | |
Delgan/loguru | import re
import sys
import time
import pytest
from loguru import logger
from .conftest import default_threading_excepthook
def broken_sink(m):
raise ValueError("Error!")
def test_catch_is_false(capsys):
logger.add(broken_sink, catch=False)
with pytest.raises( | ValueError, match="Error!") | pytest.raises | complex_expr | tests/test_add_option_catch.py | test_catch_is_false | 26 | null | |
Delgan/loguru | import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from .conftest import parse
def test_args_with_colors_not_formatted_twice(capsys):
logger.add(sys.stdout, format="{message}", colorize=True)
logger.add(sys.stderr, format="{message}", colorize=False)
a = MagicMock(__f... | "a b\n" | assert | string_literal | tests/test_opt.py | test_args_with_colors_not_formatted_twice | 475 | null | |
Delgan/loguru | from loguru import logger
def test_override_previous_patched(writer):
logger.add(writer, format="{extra[x]} {message}")
logger2 = logger.patch(lambda r: r["extra"].update(x=3))
logger2.patch(lambda r: r["extra"].update(x=2)).debug("4")
assert writer.read() == | "2 4\n" | assert | string_literal | tests/test_patch.py | test_override_previous_patched | 45 | null | |
Delgan/loguru | import logging
import sys
from logging import StreamHandler
import pytest
from loguru import logger
from .conftest import make_logging_logger
@pytest.mark.parametrize("use_opt", [False, True])
def test_exception(capsys, use_opt):
with make_logging_logger("tests", StreamHandler(sys.stderr)):
logger.add(P... | error | assert | variable | tests/test_propagation.py | test_exception | 102 | null | |
Delgan/loguru | import inspect
import logging
from loguru import logger
from .conftest import make_logging_logger
def test_exception(writer):
with make_logging_logger("tests.test_interception", InterceptHandler()) as logging_logger:
logger.add(writer, format="{message}")
try:
1 / 0 # noqa: B018
... | "Oops..." | assert | string_literal | tests/test_interception.py | test_exception | 114 | null | |
Delgan/loguru | import os
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
def test_file_correctly_reused_after_rotation(tmp_path):
filepath = tmp_path / "test.log"
logger.add(
filepath,
format="{message}",
mode="w",
watch=True,
r... | "Test 1\n" | assert | string_literal | tests/test_filesink_watch.py | test_file_correctly_reused_after_rotation | 132 | null | |
Delgan/loguru | import datetime
import os
import sys
from time import strftime
from unittest.mock import Mock
import freezegun
import pytest
import loguru
from loguru import logger
def _expected_fallback_time_zone():
# For some reason, Python versions and interepreters return different time zones here.
return strftime("%Z")... | expected + "\n" | assert | complex_expr | tests/test_datetime.py | test_formatting | 135 | null | |
Delgan/loguru | import datetime
import os
import pathlib
import tempfile
import time
from unittest.mock import Mock
import pytest
import loguru
from loguru import logger
from loguru._ctime_functions import load_ctime_functions
from .conftest import check_dir
def tmp_path_local(reset_logger):
# Pytest 'tmp_path' creates directo... | ["a\n", "b\nc\n", "d\n", "e\n"] | assert | collection | tests/test_filesink_rotation.py | test_time_rotation | 164 | null | |
Delgan/loguru | import asyncio
import site
import sys
import sysconfig
import threading
import types
import pytest
from loguru import logger
def test_exception_is_tuple():
exception = None
def writer(msg):
nonlocal exception
exception = msg.record["exception"]
logger.add(writer, catch=False)
try:
... | 3 | assert | numeric_literal | tests/test_exceptions_catch.py | test_exception_is_tuple | 250 | null | |
Delgan/loguru | import datetime
import os
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
def test_not_managed_files(tmp_path):
others = {
"test_.log",
"_test.log",
"tes.log",
"te.st.log",
"testlog",
"test",
"test.tar... | others | assert | variable | tests/test_filesink_retention.py | test_not_managed_files | 118 | null | |
Delgan/loguru | import sys
from logging import FileHandler, Filter, Formatter, Handler, NullHandler, StreamHandler
import pytest
from loguru import logger
def test_exception(capsys):
result = None
class ExceptionHandler(Handler):
def emit(self, record):
nonlocal result
result = bool(record.e... | True | assert | bool_literal | tests/test_standard_handler.py | test_exception | 98 | null | |
Delgan/loguru | import os
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
@pytest.mark.skipif(os.name == "nt", reason="Windows can't delete file in use")
def test_file_deleted_before_rotation(tmp_path):
exists = None
file = tmp_path / "test.log"
def rotate(_, __):... | True | assert | bool_literal | tests/test_filesink_watch.py | test_file_deleted_before_rotation | 83 | null | |
Delgan/loguru | import logging
import sys
from logging import StreamHandler
import pytest
from loguru import logger
from .conftest import make_logging_logger
def test_propagate_too_high(capsys):
with make_logging_logger(
"tests.test_propagation.deep", StreamHandler(sys.stderr)
) as logging_logger:
logger.ad... | "2\n" | assert | string_literal | tests/test_propagation.py | test_propagate_too_high | 79 | null | |
Delgan/loguru | import asyncio
import builtins
import contextlib
import datetime
import io
import logging
import multiprocessing
import os
import pathlib
import re
import sys
import threading
import time
import traceback
import warnings
from typing import NamedTuple
import freezegun
import pytest
import loguru
def new_event_loop_co... | size | assert | variable | tests/conftest.py | check_dir | 134 | null | |
Delgan/loguru | import pickle
import re
import sys
import time
import pytest
from loguru import logger
from .conftest import default_threading_excepthook
def test_enqueue():
x = []
def sink(message):
time.sleep(0.1)
x.append(message)
logger.add(sink, format="{message}", enqueue=True)
logger.debug(... | 1 | assert | numeric_literal | tests/test_add_option_enqueue.py | test_enqueue | 63 | null | |
Delgan/loguru | import sys
import time
import pytest
from loguru import logger
def test_exception_in_stop_during_remove_one(capsys):
i = logger.add(StopSinkError(), catch=False, format="{message}")
logger.info("A")
with pytest.raises(OSError, match=r"Stop error"):
logger.remove(i)
logger.info("Nope")
ou... | "A\n" | assert | string_literal | tests/test_remove.py | test_exception_in_stop_during_remove_one | 78 | null | |
Delgan/loguru | import builtins
import os
import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from loguru._colorama import should_colorize, should_wrap
from .conftest import (
StreamFilenoException,
StreamIsattyException,
StreamIsattyFalse,
StreamIsattyTrue,
)
def clear_environmen... | expected | assert | variable | tests/test_colorama.py | test_pycharm_fixed | 97 | null | |
Delgan/loguru | import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from .conftest import parse
def test_colors_doesnt_raise_unrelated_colorize(writer):
logger.add(writer, format="{message} {extra[trap]}", colorize=True, catch=False)
logger.bind(trap="</red>").opt(colors=True).debug("A")
... | "A </red>\n" | assert | string_literal | tests/test_opt.py | test_colors_doesnt_raise_unrelated_colorize | 249 | null | |
Delgan/loguru | import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from .conftest import parse
def test_record_not_in_extra():
extra = None
def sink(message):
nonlocal extra
extra = message.record["extra"]
logger.add(sink, catch=False)
logger.opt(record=True).i... | {} | assert | collection | tests/test_opt.py | test_record_not_in_extra | 45 | null | |
Delgan/loguru | import os
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
@pytest.mark.skipif(os.name == "nt", reason="Windows can't delete file in use")
def test_file_deleted_before_write_with_delay(tmp_path):
file = tmp_path / "test.log"
logger.add(file, format="{mes... | "Test 2\n" | assert | string_literal | tests/test_filesink_watch.py | test_file_deleted_before_write_with_delay | 27 | null | |
Delgan/loguru | import os
import pytest
from loguru import logger
from .conftest import StreamIsattyException, StreamIsattyFalse, StreamIsattyTrue, parse
@pytest.mark.parametrize(
("format", "message", "expected"),
[
("<red>{message}</red>", "Foo", parse("<red>Foo</red>\n")),
(lambda _: "<red>{message}</red... | expected | assert | variable | tests/test_add_option_colorize.py | test_colorized_format | 22 | null | |
Delgan/loguru | import os
import platform
import re
import subprocess
import sys
import traceback
from unittest.mock import MagicMock
import pytest
from loguru import logger
def normalize(exception):
"""Normalize exception output for reproducible test cases."""
if os.name == "nt":
exception = re.sub(
r'F... | 0 | assert | numeric_literal | tests/test_exceptions_formatting.py | compare_exception | 114 | null | |
Delgan/loguru | import re
import sys
import time
import pytest
from loguru import logger
from .conftest import default_threading_excepthook
def broken_sink(m):
raise ValueError("Error!")
def test_broken_sink_not_caught_enqueue():
called = 0
def broken_sink(m):
nonlocal called
called += 1
raise... | 2 | assert | numeric_literal | tests/test_add_option_catch.py | test_broken_sink_not_caught_enqueue | 144 | null | |
Delgan/loguru | import io
import pathlib
import re
from datetime import datetime
import pytest
from loguru import logger
TEXT = "This\nIs\nRandom\nText\n123456789\nABC!DEF\nThis Is The End\n"
def fileobj():
with io.StringIO(TEXT) as file:
yield file
def test_parse_without_group(fileobj):
result, *_ = list(logger.p... | {} | assert | collection | tests/test_parse.py | test_parse_without_group | 59 | null | |
Delgan/loguru | import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from .conftest import parse
def test_exception_log_function(writer):
logger.add(writer, format="{level.no} {message}")
try:
1 / 0 # noqa: B018
except Exception:
logger.opt(exception=True).log(50, "Er... | "50 Error" | assert | string_literal | tests/test_opt.py | test_exception_log_function | 119 | null | |
Delgan/loguru | import sys
import pytest
from loguru import logger
def test_returned_ids(capsys):
ids = logger.configure(
handlers=[
{"sink": sys.stdout, "format": "{message}"},
{"sink": sys.stderr, "format": "{message}"},
]
)
assert len(ids) == 2
logger.debug("Test")
o... | "Test\n" | assert | string_literal | tests/test_configure.py | test_returned_ids | 99 | null | |
Delgan/loguru | import pytest
from loguru import logger
@pytest.mark.parametrize(
("message", "format", "expected"),
[
("a", "Message: {message}", "Message: a\n"),
("b", "Nope", "Nope\n"),
("c", "{level} {message} {level}", "DEBUG c DEBUG\n"),
("d", "{message} {level} {level.no} {level.name}",... | expected | assert | variable | tests/test_add_option_format.py | test_format | 20 | null | |
Delgan/loguru | import sys
from unittest.mock import MagicMock
import pytest
from loguru import logger
from .conftest import parse
def test_keep_extra(writer):
logger.configure(extra=dict(test=123))
logger.add(writer, format="{extra[test]}")
logger.opt().debug("")
logger.opt().log(50, "")
assert writer.read()... | "123\n123\n" | assert | string_literal | tests/test_opt.py | test_keep_extra | 572 | null | |
Delgan/loguru | import logging
import pathlib
import re
import sys
from loguru import logger
def test_multiple_handlers():
logger.add(sys.__stdout__)
logger.add(sys.__stderr__)
r = (
"<loguru.logger handlers=["
"(id=0, level=10, sink=<stdout>), "
"(id=1, level=10, sink=<stderr>)"
"]>"
... | r | assert | variable | tests/test_repr.py | test_multiple_handlers | 174 | null | |
Delgan/loguru | import sys
import loguru
from loguru._get_frame import load_get_frame_function
def test_with_sys_getframe(monkeypatch):
def patched():
return
with monkeypatch.context() as context:
context.setattr(sys, "_getframe", patched())
assert load_get_frame_function() == | patched() | assert | func_call | tests/test_get_frame.py | test_with_sys_getframe | 13 | null | |
Delgan/loguru | import functools
import pytest
from loguru import logger
from .conftest import parse
def test_add_level(writer):
name = "L3V3L"
icon = "[o]"
level = 10
logger.level(name, level, color="<red>", icon=icon)
fmt = "{level.icon} <level>{level.name}</level> -> {level.no} -> {message}"
logger.add(... | expected + "\n" | assert | complex_expr | tests/test_levels.py | test_add_level | 35 | null | |
Delgan/loguru | import json
import re
import sys
from loguru import logger
def test_serialize_exception_instance():
sink = JsonSink()
logger.add(sink, format="{message}", serialize=True, catch=False)
logger.opt(exception=ZeroDivisionError("Oops")).error("Failure")
lines = sink.json["text"].splitlines()
assert ... | "Failure" | assert | string_literal | tests/test_add_option_serialize.py | test_serialize_exception_instance | 101 | null | |
Delgan/loguru | import os
import sys
import threading
import time
from unittest.mock import Mock
import pytest
from loguru import logger
from .conftest import check_dir
@pytest.mark.parametrize("delay", [True, False])
def test_exception_during_compression_at_rotation(freeze_time, tmp_path, capsys, delay):
with freeze_time("201... | "" | assert | string_literal | tests/test_filesink_compression.py | test_exception_during_compression_at_rotation | 206 | null | |
Delgan/loguru | import asyncio
import logging
import os
import pathlib
import sys
import pytest
from loguru import logger
message = "test message"
expected = message + "\n"
repetitions = pytest.mark.parametrize("rep", [0, 1, 2])
def log(sink, rep=1):
logger.debug("This shouldn't be printed.")
i = logger.add(sink, format="... | expected * rep | assert | complex_expr | tests/test_add_sinks.py | test_stdout_sink | 40 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.