def tearDown(self):
     
     wsgi_intercept.remove_wsgi_intercept('test', 80)
     del self.app
     del self.server
     del self.db
     del self.config

    def tearDown(self):
        # remove wsgi intercept mechanism
        for server in self.servers:
            remove_wsgi_intercept(server['HOST'], int(server['PORT']))
        urllib2_intercept.uninstall_opener()

        self.rm.set_db(settings.DB_CONNECTIONS[0])

def test_cookie_session_middleware():
    user = user_module.User()
    user._update_data(FAKE_USER_DATA)
    user_module.thread_locals.current_user = user

    app = CookieSessionMiddleware(application, b'wtf!', expires=3600, max_age=3600)
    add_wsgi_intercept(HOST, PORT, lambda: app)

    response = requests.get(URL)
    assert response.cookies['leancloud:session']

    del user_module.thread_locals.current_user
    requests.get(URL, cookies=response.cookies)
    current = user_module.User.get_current()
    assert current.id == user.id
    assert current.get_session_token() == user.get_session_token()
    assert not current._attributes

    del user_module.thread_locals.current_user
    response = requests.get(URL + '/logout', cookies=response.cookies)
    assert 'leancloud:session' not in response.cookies

    # TODO: try not using for..in to get cookie
    for cookie in response.cookies:
        if cookie.name == "leancloud:session":
            assert cookie.expires
            assert cookie.max_age
            break

    remove_wsgi_intercept()

def test_app(environ, start_response):
    """Simplest possible application object"""
    url =  urlunparse((
                       environ['wsgi.url_scheme'],
                       environ['HTTP_HOST'],
                       environ['PATH_INFO'],
                       '',
                       environ['QUERY_STRING'],
                       ''
                       ))
    key = md5hash(url)
    status = '200 OK'
    response_headers = [('Content-type','text/xml')]
    start_response(status, response_headers)

    global _app_was_hit
    _app_was_hit = True
    
    data_file = os.path.join(os.path.dirname(__file__), 'data', "%s.xml" % key)
    
    try:
        filedata = open(data_file).read()
    except IOError:
        #print "\nintercepted: %s" % url
        #print "key:", key 
        import wsgi_intercept
        wsgi_intercept.remove_wsgi_intercept('ws.audioscrobbler.com', 80)
        import urllib.request, urllib.error, urllib.parse
        filedata = urllib.request.urlopen(url).read()
        wsgi_intercept.add_wsgi_intercept('ws.audioscrobbler.com', 80, create_wsgi_app)
        open(data_file, "w").write(filedata)
    return [filedata]

def fakeConnection(domain, port, call, page=None):
	"""Sets up a wsgi_intercept, calls your code inside the with statement, then removes said intercept"""
	wsgi_intercept.add_wsgi_intercept(domain, port, call, page)
	try:
		yield
		wsgi_intercept.remove_wsgi_intercept(domain, port)  # remove our intercept!
	except:
		wsgi_intercept.remove_wsgi_intercept(domain, port)  # remove our intercept!
		raise # and reraise the exception

def test_https_redirect_middleware():
    https_redirect_middleware.is_prod = True
    app = https_redirect_middleware.HttpsRedirectMiddleware(application)
    add_wsgi_intercept(HOST, PORT, lambda: app)

    response = requests.get(url=URL, allow_redirects=False)

    assert response.is_redirect == True
    assert response.next.url[:5] == "https"

    remove_wsgi_intercept()

    def teardown_intercept(self):
        """Remove the installed WSGI intercepts."""
        for host, port in self.intercepted:
            remove_wsgi_intercept(host, port)

        if self.intercept_api:
            uninstall()

        uninstall_opener()

        self.unpatch_wsgi_intercept()

def response_for():
    """Register two intercepts, and return responses for them."""
    urllib_intercept.install_opener()
    add_wsgi_intercept(LOCAL_HOST, PORT, lambda: handleRequest)
    add_wsgi_intercept(REMOTE_HOST, 443, lambda: intercept_fn)

    def response_for(data):
        url = 'http://{}:{}'.format(LOCAL_HOST, PORT)
        response = urlopen(url, urlencode(data))
        return response.code, response.read()

    yield response_for
    remove_wsgi_intercept()

def response_for(form_handler):
    host, port = 'test.local', 80
    urllib_intercept.install_opener()
    add_wsgi_intercept(host, port, lambda: form_handler)
    url = 'http://{}:{}'.format(host, port)

    def response_for(data):
        if data is None:
            response = urlopen(url)
        else:
            response = urlopen(url, urlencode(data))
        return response.code, response.read()

    yield response_for
    remove_wsgi_intercept()

def response_for():
    host, port = 'test.local', 80
    urllib_intercept.install_opener()
    add_wsgi_intercept(host, port, lambda: handleRequest)
    url = 'http://{}:{}'.format(host, port)

    def response_for(data):
        if data is None:
            response = urlopen(url)
        else:
            response = urlopen(url, urlencode(data))
        assert response.getcode() == 200
        return response.read()

    yield response_for
    remove_wsgi_intercept()

def test_app(environ, start_response):
    """Simplest possible application object"""
    url =  urlunparse((
                       environ['wsgi.url_scheme'],
                       environ['HTTP_HOST'],
                       environ['PATH_INFO'],
                       '',
                       environ['QUERY_STRING'],
                       ''
                       ))
    status = '200 OK'
    response_headers = [('Content-type','text/xml')]
    start_response(status, response_headers)

    global _app_was_hit
    _app_was_hit = True
    
#    old_key = md5hash(url)
    
    url_without_apikey = re.sub(r'(api_key=[^&]+.)','', url) 
    key = md5hash(url_without_apikey)
    data_file = os.path.join(CACHE_PATH, "%s.xml" % key)
    
#    old_file = os.path.join(CACHE_PATH, "%s.xml" % old_key)
#    if os.path.exists(old_file):
#        assert not os.path.exists(data_file)
##        print 'RENME'
#        os.rename(old_file, data_file)
    
#    print old_file
#    print data_file
#    print url
#    print url_without_apikey
    
#    assert False
    try:
        filedata = open(data_file).read()
    except IOError:
        #print "\nintercepted: %s" % url
        #print "old_key:", old_key 
        import wsgi_intercept
        wsgi_intercept.remove_wsgi_intercept('ws.audioscrobbler.com', 80)
        import urllib2
        filedata = urllib2.urlopen(url).read()
        wsgi_intercept.add_wsgi_intercept('ws.audioscrobbler.com', 80, create_wsgi_app)
        open(data_file, "w").write(filedata)
    return [filedata]

def response_for(form_handler):
    """ Registers two intercepts, returns responses for them based on bool """
    urllib_intercept.install_opener()
    add_wsgi_intercept(HOST, LOG_PORT, lambda: form_handler[0])
    add_wsgi_intercept(HOST, NO_LOG_PORT, lambda: form_handler[1])

    def response_for(data, log=False):
        if log:
            url = 'http://{}:{}'.format(HOST, LOG_PORT)
        else:
            url = 'http://{}:{}'.format(HOST, NO_LOG_PORT)
        if data is None:
            response = urlopen(url)
        else:
            response = urlopen(url, urlencode(data))
        return response.code, response.read()

    yield response_for
    remove_wsgi_intercept()

def test_sitekey_frame(mocker):
    mocker.patch(MODULE + '.get_template', FakeTemplate)
    mocker.patch(MODULE + '.M2Crypto', FakeM2Crypto)

    urllib_intercept.install_opener()
    add_wsgi_intercept(HOST, 80, lambda: sitekey_frame.sitekey_frame,
                       script_name=SCRIPT_NAME)
    try:
        response = urllib2.urlopen(urllib2.Request(
            'http://{}/{}'.format(HOST, SCRIPT_NAME),
            headers={'User-Agent': 'foobar'},
        ))
        assert response.code == 200
        data = eval(response.read())
        assert base64.b64decode(data['signature']) == TO_SIGN
        assert data['http_path'] == '/' + SCRIPT_NAME
        assert data['http_host'] == HOST
        assert data['http_ua'] == USER_AGENT
    finally:
        remove_wsgi_intercept()

def http_teardown(host, port):
    # Remove the WSGI interception layer.
    wsgi_intercept.remove_wsgi_intercept(host, port)

 def tearDown(self):
     uninstall_opener()
     for host, port in self.intercepted:
         wsgi_intercept.remove_wsgi_intercept(host, port)
     TestCase.tearDown(self)

def teardown_module(module):
    wsgi_intercept.remove_wsgi_intercept('wsgify.org', 80)

 def tearDown(self):
     wsgi_intercept.remove_wsgi_intercept('statictest', 80)
     http_client_intercept.uninstall()

def tearDownBrowser(*args):
    wsgi_intercept.remove_wsgi_intercept()
    wsgi_intercept.urllib2_intercept.uninstall_opener()

def remove_redirect(host):
    wsgi_intercept.remove_wsgi_intercept(host, 80)
    uninstall()

 def end_mock(self):
     requests_intercept.uninstall()
     wsgi_intercept.remove_wsgi_intercept()