def test_configure_all(self, proxy):
        x = stub()
        configure(processors=[x], context_class=dict)
        b = proxy.bind()

        assert [x] == b._processors
        assert dict is b._context.__class__

 def test_just_processors(self, proxy):
     x = stub()
     configure(processors=[x])
     b = proxy.bind()
     assert [x] == b._processors
     assert _BUILTIN_DEFAULT_PROCESSORS != b._processors
     assert _BUILTIN_DEFAULT_CONTEXT_CLASS == b._context.__class__

 def test_get_logger_passes_positional_arguments_to_logger_factory(self):
     """
     Ensure `get_logger` passes optional positional arguments through to
     the logger factory.
     """
     factory = call_recorder(lambda *args: object())
     configure(logger_factory=factory)
     get_logger("test").bind(x=42)
     assert [call("test")] == factory.calls

 def test_rebinds_bind_method(self, proxy):
     """
     To save time, be rebind the bind method once the logger has been
     cached.
     """
     configure(cache_logger_on_first_use=True)
     bind = proxy.bind
     proxy.bind()
     assert bind != proxy.bind

 def test_reset(self, proxy):
     x = stub()
     configure(processors=[x], context_class=dict, wrapper_class=Wrapper)
     reset_defaults()
     b = proxy.bind()
     assert [x] != b._processors
     assert _BUILTIN_DEFAULT_PROCESSORS == b._processors
     assert isinstance(b, _BUILTIN_DEFAULT_WRAPPER_CLASS)
     assert _BUILTIN_DEFAULT_CONTEXT_CLASS == b._context.__class__
     assert _BUILTIN_DEFAULT_LOGGER_FACTORY is _CONFIG.logger_factory

    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_configures_logger_factory(self):
        def f():
            pass

        configure(logger_factory=f)
        assert f is _CONFIG.logger_factory

 def test_rest_resets_is_configured(self):
     configure()
     reset_defaults()
     assert False is _CONFIG.is_configured

 def test_configure_sets_is_configured(self):
     assert False is _CONFIG.is_configured
     configure()
     assert True is _CONFIG.is_configured

 def test_just_context_class(self, proxy):
     configure(context_class=dict)
     b = proxy.bind()
     assert dict is b._context.__class__
     assert _BUILTIN_DEFAULT_PROCESSORS == 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_honors_wrapper_from_config(self, proxy):
     configure(wrapper_class=Wrapper)
     b = proxy.bind()
     assert isinstance(b, Wrapper)