def test_pickle(self, proto): """ Can be pickled and unpickled. """ bllp = BoundLoggerLazyProxy(None) assert repr(bllp) == repr(pickle.loads(pickle.dumps(bllp, proto)))
def test_honors_wrapper_class(self): """ Passed wrapper_class is used. """ p = BoundLoggerLazyProxy(None, wrapper_class=Wrapper) b = p.bind() assert isinstance(b, Wrapper)
def test_unbind_unbinds_from_initial_values(self): """ It's possible to unbind a value that came from initial_values. """ p = BoundLoggerLazyProxy(None, initial_values={"a": 1, "b": 2}) b = p.unbind("a") assert {"b": 2} == b._context
def test_new_binds_only_initial_values_explicit_ctx_class(self, proxy): proxy = BoundLoggerLazyProxy(None, initial_values={ "a": 1, "b": 2 }, context_class=dict) b = proxy.new(foo=42) assert {"a": 1, "b": 2, "foo": 42} == b._context
def test_new_binds_only_initial_values_implicit_ctx_class(self, proxy): """ new() doesn't clear initial_values if context_class comes from config. """ proxy = BoundLoggerLazyProxy(None, initial_values={"a": 1, "b": 2}) b = proxy.new(foo=42) assert {"a": 1, "b": 2, "foo": 42} == b._context
def test_bind_honors_initial_values(self): """ Passed initia_values are merged on binds. """ p = BoundLoggerLazyProxy(None, initial_values={"a": 1, "b": 2}) b = p.bind() assert {"a": 1, "b": 2} == b._context b = p.bind(c=3) assert {"a": 1, "b": 2, "c": 3} == b._context
def test_emphemeral(self): """ Calling an unknown method proxy creates a new wrapped bound logger first. """ class Foo(BoundLoggerBase): def foo(self): return 42 proxy = BoundLoggerLazyProxy(None, wrapper_class=Foo, cache_logger_on_first_use=False) assert 42 == proxy.foo()
def test_repr(self): p = BoundLoggerLazyProxy( None, processors=[1, 2, 3], context_class=dict, initial_values={'foo': 42}, logger_factory_args=(4, 5), ) assert ( "<BoundLoggerLazyProxy(logger=None, wrapper_class=None, " "processors=[1, 2, 3], " "context_class=<%s 'dict'>, " "initial_values={'foo': 42}, " "logger_factory_args=(4, 5))>" % ('class' if PY3 else 'type',) ) == repr(p)
def test_new_binds_only_initial_values_explicit_ctx_class(self, proxy): """ new() doesn't clear initial_values if context_class is passed explicitly.. """ proxy = BoundLoggerLazyProxy(None, initial_values={ "a": 1, "b": 2 }, context_class=dict) b = proxy.new(foo=42) assert {"a": 1, "b": 2, "foo": 42} == b._context
def test_argument_takes_precedence_over_configuration(self, cache): """ Passing cache_logger_on_first_use as an argument overrides config. """ configure(cache_logger_on_first_use=cache) proxy = BoundLoggerLazyProxy(None, cache_logger_on_first_use=not cache) bind = proxy.bind proxy.bind() if cache: assert bind == proxy.bind else: assert bind != proxy.bind
def test_bind_doesnt_cache_logger(self): """ Calling configure() changes BoundLoggerLazyProxys immediately. Previous uses of the BoundLoggerLazyProxy don't interfere. """ class F(object): "New logger factory with a new attribute" def a(self, *args): return 5 proxy = BoundLoggerLazyProxy(None) proxy.bind() configure(logger_factory=F) new_b = proxy.bind() assert new_b.a() == 5
def test_repr(self): """ repr reflects all attributes. """ p = BoundLoggerLazyProxy( None, processors=[1, 2, 3], context_class=dict, initial_values={"foo": 42}, logger_factory_args=(4, 5), ) assert ("<BoundLoggerLazyProxy(logger=None, wrapper_class=None, " "processors=[1, 2, 3], " "context_class=<class 'dict'>, " "initial_values={'foo': 42}, " "logger_factory_args=(4, 5))>") == repr(p)
def test_prefers_args_over_config(self): p = BoundLoggerLazyProxy(None, processors=[1, 2, 3], context_class=dict) b = p.bind() assert isinstance(b._context, dict) assert [1, 2, 3] == b._processors class Class(object): def __init__(self, *args, **kw): pass def update(self, *args, **kw): pass configure(processors=[4, 5, 6], context_class=Class) b = p.bind() assert not isinstance(b._context, Class) assert [1, 2, 3] == b._processors
def test_prefers_args_over_config(self): """ Configuration can be overridden by passing arguments. """ p = BoundLoggerLazyProxy(None, processors=[1, 2, 3], context_class=dict) b = p.bind() assert isinstance(b._context, dict) assert [1, 2, 3] == b._processors class Class: def __init__(self, *args, **kw): pass def update(self, *args, **kw): pass configure(processors=[4, 5, 6], context_class=Class) b = p.bind() assert not isinstance(b._context, Class) assert [1, 2, 3] == b._processors
def proxy(): """ Returns a BoundLoggerLazyProxy constructed w/o paramaters & None as logger. """ return BoundLoggerLazyProxy(None)
def test_argument_takes_precedence_over_configuration2(self): configure(cache_logger_on_first_use=False) proxy = BoundLoggerLazyProxy(None, cache_logger_on_first_use=True) bind = proxy.bind proxy.bind() assert bind != proxy.bind
def test_unbind_unbinds_from_initial_values(self): p = BoundLoggerLazyProxy(None, initial_values={"a": 1, "b": 2}) b = p.unbind("a") assert {"b": 2} == b._context
def test_bind_honors_initial_values(self): p = BoundLoggerLazyProxy(None, initial_values={"a": 1, "b": 2}) b = p.bind() assert {"a": 1, "b": 2} == b._context b = p.bind(c=3) assert {"a": 1, "b": 2, "c": 3} == b._context
def test_new_binds_only_initial_values_impolicit_ctx_class(self, proxy): proxy = BoundLoggerLazyProxy(None, initial_values={'a': 1, 'b': 2}) b = proxy.new(foo=42) assert {'a': 1, 'b': 2, 'foo': 42} == b._context
def test_unbind_unbinds_from_initial_values(self): p = BoundLoggerLazyProxy(None, initial_values={'a': 1, 'b': 2}) b = p.unbind('a') assert {'b': 2} == b._context
def test_bind_honors_initial_values(self): p = BoundLoggerLazyProxy(None, initial_values={'a': 1, 'b': 2}) b = p.bind() assert {'a': 1, 'b': 2} == b._context b = p.bind(c=3) assert {'a': 1, 'b': 2, 'c': 3} == b._context