def test_basic_local():
    ns = local.Local()
    ns.foo = 0
    values = []

    def value_setter(idx):
        time.sleep(0.01 * idx)
        ns.foo = idx
        time.sleep(0.02)
        values.append(ns.foo)

    threads = [Thread(target=value_setter, args=(x,)) for x in [1, 2, 3]]
    for thread in threads:
        thread.start()
    time.sleep(0.2)
    assert sorted(values) == [1, 2, 3]

    def delfoo():
        del ns.foo

    delfoo()
    pytest.raises(AttributeError, lambda: ns.foo)
    pytest.raises(AttributeError, delfoo)

    local.release_local(ns)

def destroy():
	"""closes connection and releases werkzeug local"""
	if conn:
		conn.close()
	
	from werkzeug.local import release_local
	release_local(local)

def test_basic_local():
    """Basic local object support"""
    l = Local()
    l.foo = 0
    values = []

    def value_setter(idx):
        time.sleep(0.01 * idx)
        l.foo = idx
        time.sleep(0.02)
        values.append(l.foo)

    threads = [Thread(target=value_setter, args=(x,)) for x in [1, 2, 3]]
    for thread in threads:
        thread.start()
    time.sleep(0.2)
    assert sorted(values) == [1, 2, 3]

    def delfoo():
        del l.foo

    delfoo()
    assert_raises(AttributeError, lambda: l.foo)
    assert_raises(AttributeError, delfoo)

    release_local(l)

def end_fake_request():
    """
    Start lizard_history machinery to log changes and remove the
    fake_request from the thread.
    """
    ops_done.send(None)
    release_local(_local)

 def manage(cls):
     """ Context manager for a set of environments. """
     if hasattr(cls._local, 'environments'):
         yield
     else:
         try:
             cls._local.environments = Environments()
             yield
         finally:
             release_local(cls._local)

def test_local_release():
    ns = local.Local()
    ns.foo = 42
    local.release_local(ns)
    assert not hasattr(ns, "foo")

    ls = local.LocalStack()
    ls.push(42)
    local.release_local(ls)
    assert ls.top is None

    def test_local_release(self):
        loc = local.Local()
        loc.foo = 42
        local.release_local(loc)
        assert not hasattr(loc, 'foo')

        ls = local.LocalStack()
        ls.push(42)
        local.release_local(ls)
        assert ls.top is None

def test_local_release():
    l = local.Local()
    l.foo = 42
    local.release_local(l)
    assert not hasattr(l, 'foo')

    ls = local.LocalStack()
    ls.push(42)
    local.release_local(ls)
    assert ls.top is None

def test_local_release():
    """Locals work without manager"""
    loc = Local()
    loc.foo = 42
    release_local(loc)
    assert not hasattr(loc, "foo")

    ls = LocalStack()
    ls.push(42)
    release_local(ls)
    assert ls.top is None

    def __call__(self, environ, start_response):
        """Process a request"""
        # Set up the request and do our pre-processing
        request = Request(environ)
        self.before(request)

        # Defer  to the wrapped app, then do our cleanup n stuff
        response = Response.from_app(self.app, environ)
        self.after(request, response)
        release_local(self.local)

        # finally, blah
        return response(environ, start_response)

def test_metric_hook_user_name(context, get_breadcrumbs):
    r = mock_response(view='view')

    talisker.requests._local.metric_api_name = 'api'
    talisker.requests._local.metric_host_name = 'service'
    talisker.requests.metrics_response_hook(r)
    release_local(talisker.requests._local)

    assert context.statsd[0] == 'requests.count.service.api:1|c'
    assert context.statsd[1] == (
        'requests.latency.service.api.200:1000.000000|ms'
    )
    breadcrumbs = get_breadcrumbs()
    if breadcrumbs is not None:
        assert breadcrumbs[0]['type'] == 'http'
        assert breadcrumbs[0]['category'] == 'requests'
        assert breadcrumbs[0]['data']['url'] == 'http://example.com/'
        assert breadcrumbs[0]['data']['host'] == 'example.com'
        assert breadcrumbs[0]['data']['view'] == 'view'
        assert breadcrumbs[0]['data']['method'] == 'GET'
        assert breadcrumbs[0]['data']['status_code'] == 200
        assert breadcrumbs[0]['data']['duration_ms'] == 1000.0

 def process_exception(self, request, exception):
     release_local(_local)

def destroy():
	"""closes connection and releases werkzeug local"""
	if conn:
		conn.close()
	
	release_local(local)

def main():
    logging.getLogger().setLevel(logging.DEBUG)
    from kay.utils import local
    from werkzeug.local import release_local
    release_local(local)
    run_wsgi_app(application)

def clear():
    release_local(CONTEXT)

def destroy():
	"""Closes connection and releases werkzeug local."""
	if db:
		db.close()

	release_local(local)

 def process_response(self, request, response):
     release_local(_local)
     return response