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_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_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_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_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_honors_wrapper_class(self):
     p = BoundLoggerLazyProxy(None, wrapper_class=Wrapper)
     b = p.bind()
     assert isinstance(b, Wrapper)

 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