Add tests for valid sink types and kwargs

loguru/__init__.py

@@ -174,7 +174,7 @@ def log_to(self, sink, *, level=DEBUG, format=VERBOSE_FORMAT, filter=None, color
                     colored = False
         else:
             type_name = type(sink).__name__
-            raise TypeError("Cannot log to objects of type '{}'.".format(type_name))
+            raise ValueError("Cannot log to objects of type '{}'.".format(type_name))
 
         if isinstance(filter, str):
             parent = filter + '.' * bool(filter)

tests/test_log_to_options.py

@@ -10,7 +10,7 @@ def logger():
     return loguru.Logger()
 
 @pytest.fixture
-def writter():
+def writer():
 
     def w(message):
         w.written.append(message)
@@ -28,11 +28,11 @@ def w(message):
     (loguru.WARNING, lambda x: x.success,  False),
     (float('inf'),   lambda x: x.critical, False),
 ])
-def test_level_option(level, function, should_output, logger, writter):
+def test_level_option(level, function, should_output, logger, writer):
     message = "Test Level"
-    logger.log_to(writter, level=level, format='{message}')
+    logger.log_to(writer, level=level, format='{message}')
     function(logger)(message)
-    assert writter.read() == (message + '\n') * should_output
+    assert writer.read() == (message + '\n') * should_output
 
 
 @pytest.mark.parametrize('message, format, expected', [
@@ -41,10 +41,10 @@ def test_level_option(level, function, should_output, logger, writter):
     ('c', '{level} {message} {level}', 'DEBUG c DEBUG'),
     ('d', '{message} {level} {level.no} {level.name}', 'd DEBUG %d DEBUG' % loguru.DEBUG)
 ])
-def test_format_option(message, format, expected, logger, writter):
-    logger.log_to(writter, format=format)
+def test_format_option(message, format, expected, logger, writer):
+    logger.log_to(writer, format=format)
     logger.debug(message)
-    assert writter.read() == expected + '\n'
+    assert writer.read() == expected + '\n'
 
 @pytest.mark.parametrize('filter, should_output', [
     (None, True),
@@ -57,29 +57,105 @@ def test_format_option(message, format, expected, logger, writter):
     (lambda r: r['level'] == "DEBUG", True),
     (lambda r: r['level'].no != loguru.DEBUG, False),
 ])
-def test_filter_option(filter, should_output, logger, writter):
+def test_filter_option(filter, should_output, logger, writer):
     message = "Test Filter"
-    logger.log_to(writter, filter=filter, format='{message}')
+    logger.log_to(writer, filter=filter, format='{message}')
     logger.debug(message)
-    assert writter.read() == (message + '\n') * should_output
+    assert writer.read() == (message + '\n') * should_output
 
 @pytest.mark.parametrize('message, format, expected, colored', [
     ('a', '<red>{message}</red>', 'a', False),
     ('b', '<red>{message}</red>', '\x1b[31mb\x1b[0m', True),
 ])
-def test_colored_option(message, format, expected, colored, logger, writter):
-    logger.log_to(writter, format=format, colored=colored)
+def test_colored_option(message, format, expected, colored, logger, writer):
+    logger.log_to(writer, format=format, colored=colored)
     logger.debug(message)
-    assert writter.read() == expected + '\n'
+    assert writer.read() == expected + '\n'
 
 @pytest.mark.parametrize('better_exceptions, startswith', [
     (False, 'Traceback (most recent call last):\n  File'),
     (True, 'Traceback (most recent call last):\n\n  File'),
 ])
-def test_better_exceptions_option(better_exceptions, startswith, logger, writter):
-    logger.log_to(writter, format='{message}', better_exceptions=better_exceptions)
+def test_better_exceptions_option(better_exceptions, startswith, logger, writer):
+    logger.log_to(writer, format='{message}', better_exceptions=better_exceptions)
     try:
         1 / 0
     except:
         logger.exception('')
-    assert writter.read().startswith('\n' + startswith)
+    assert writer.read().startswith('\n' + startswith)
+
+
+@pytest.mark.parametrize('sink_type', ['function', 'class', 'file_object', 'str_a', 'str_w'])
+@pytest.mark.parametrize('test_invalid', [False, True])
+def test_kwargs_option(sink_type, test_invalid, logger, tmpdir):
+    msg = 'msg'
+    kwargs = {'kw1': '1', 'kw2': '2'}
+
+    if sink_type == 'function':
+        out = []
+        def function(message, kw2, kw1):
+            out.append(message + kw1 + 'a' + kw2)
+
+        writer = function
+        validator = lambda: out == [msg + '\n1a2']
+
+        if test_invalid:
+            writer = lambda m: None
+    elif sink_type == 'class':
+        out = []
+        class Writer:
+            def __init__(self, kw2, kw1):
+                self.end = kw1 + 'b' + kw2
+            def write(self, m):
+                out.append(m + self.end)
+
+        writer = Writer
+        validator = lambda: out == [msg + '\n1b2']
+
+        if test_invalid:
+            writer.__init__ = lambda s: None
+    elif sink_type == 'file_object':
+        class Writer:
+            def __init__(self):
+                self.out = ''
+            def write(self, m, kw2, kw1):
+                self.out += m + kw1 + 'c' + kw2
+
+        writer = Writer()
+        validator = lambda: writer.out == msg + '\n1c2'
+
+        if test_invalid:
+            writer.write = lambda m: None
+    elif sink_type == 'str_a':
+        kwargs = {'mode': 'a', 'encoding': 'ascii'}
+        file = tmpdir.join('test.log')
+        with file.open(mode='w', encoding='ascii') as f:
+            f.write("This shouldn't be overwritten.")
+
+        writer = file.realpath()
+        validator = lambda: file.read() == "This shouldn't be overwritten." + msg + "\n"
+
+        if test_invalid:
+            kwargs = {"foo": 1, "bar": 2}
+    elif sink_type == 'str_w':
+        kwargs = {'mode': 'w', 'encoding': 'ascii'}
+        file = tmpdir.join('test.log')
+        with file.open(mode='w', encoding='ascii') as f:
+            f.write("This should be overwritten.")
+
+        writer = file.realpath()
+        validator = lambda: file.read() == msg + "\n"
+
+        if test_invalid:
+            kwargs = {"foo": 1, "bar": 2}
+
+    def test():
+        logger.log_to(writer, format='{message}', **kwargs)
+        logger.debug(msg)
+
+    if test_invalid:
+        with pytest.raises(TypeError):
+            test()
+    else:
+        test()
+        assert validator()

tests/test_log_to_sinks.py

@@ -7,7 +7,7 @@
 
 import pytest
 
-MESSAGES = ['ASCII test', '色 ᚠ ȝ î ರ 😄']
+MESSAGES = ['ASCII test']
 PARAMS = [(message, message + '\n') for message in MESSAGES]
 
 messages = pytest.mark.parametrize('message, expected', PARAMS)
@@ -40,9 +40,9 @@ def test_stderr_sink(message, expected, rep, capsys):
 @messages
 @repetitions
 @pytest.mark.parametrize("sink_from_path", [
-    lambda path: str(path),
+    str,
+    pathlib.Path,
     lambda path: open(path, 'a'),
-    lambda path: pathlib.Path(path),
     lambda path: pathlib.Path(path).open('a'),
 ])
 def test_file_sink(message, expected, rep, sink_from_path, tmpdir):
@@ -60,7 +60,26 @@ def test_function_sink(message, expected, rep):
     log(func, message, rep)
     assert a == [expected] * rep
 
-@pytest.mark.parametrize('sink', [123, object(), sys])
+@messages
+@repetitions
+def test_class_sink(message, expected, rep):
+    out = []
+    class A:
+        def write(self, m): out.append(m)
+    log(A, message, rep)
+    assert out == [expected] * rep
+
+@messages
+@repetitions
+def test_file_object_sink(message, expected, rep):
+    class A:
+        def __init__(self): self.out = ""
+        def write(self, m): self.out += m
+    a = A()
+    log(a, message, rep)
+    assert a.out == expected * rep
+
+@pytest.mark.parametrize('sink', [123, sys, object(), loguru.Logger(), loguru.Logger])
 def test_invalid_sink(sink):
-    with pytest.raises(TypeError):
+    with pytest.raises(ValueError):
         log(sink, "")