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_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 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 tearDown(self):
wsgi_intercept.remove_wsgi_intercept('test', 80)
del self.app
del self.server
del self.db
del self.config
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_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 tearDown(self):
wsgi_intercept.remove_wsgi_intercept('test', 80)
del self.app
del self.server
del self.db
del self.config
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 assertResponse(self,
app,
method,
url,
status=None,
headers=None,
content=None):
host, port = 'localhost', 80
http_client_intercept.install()
add_wsgi_intercept(host, port, app)
client = http_lib.HTTPConnection(host, port)
client.request(method, url)
response = client.getresponse()
if status is not None:
self.assertEqual(response.status, status)
headers = headers or {}
for k, v in headers.items():
self.assertEqual(response.getheader(k), v)
if content is not None:
self.assertEqual(response.read(), content)
client.close()
remove_wsgi_intercept(host, port)
http_client_intercept.uninstall()
def make_intercept(scope='module'):
host = 'api.crowdin.com'
port = 443
urllib3_intercept.install()
add_wsgi_intercept(host, port, lambda: app.wsgi_app)
yield None
remove_wsgi_intercept()
def intercept_too_many_targets():
targets = ['de_DE', 'es_ES']
app = get_configured_app(target_langs=targets)
requests_intercept.install()
add_wsgi_intercept(_INTERCEPT_HOST, _INTERCEPT_PORT, lambda: app)
yield app
remove_wsgi_intercept()
def uninstall_intercept():
"""Uninstalls intercepts added by ``install_intercept``"""
authoring_settings = integration_test_settings()
# Grab the configured urls from the authoring config.
loc = _parse_url_from_settings(authoring_settings, 'archive.url')
remove_wsgi_intercept(*loc)
loc = _parse_url_from_settings(authoring_settings, 'publishing.url')
remove_wsgi_intercept(*loc)
def uninstall_intercept():
"""Uninstalls intercepts added by ``install_intercept``"""
authoring_settings = integration_test_settings()
# Grab the configured urls from the authoring config.
loc = _parse_url_from_settings(authoring_settings, 'archive.url')
remove_wsgi_intercept(*loc)
loc = _parse_url_from_settings(authoring_settings, 'publishing.url')
remove_wsgi_intercept(*loc)
def webservice(mock_detector):
"""Mock object detection web service."""
app = ws.make_app(mock_detector)
host, port = 'localhost', 8080
url = 'http://{0}:{1}/'.format(host, port)
requests_intercept.install()
icpt.add_wsgi_intercept(host, port, lambda: app)
yield {'app': app, 'url': url}
icpt.remove_wsgi_intercept()
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 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 is 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():
"""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 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 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_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 intercept_populated():
files = [
{
'name': 'file.json',
'data': json.dumps({
'foo': 'bar',
'faz': 'baz'
}),
},
{
'name': '___foo___file-utf8.json',
'data': json.dumps({'foo': '\u1234'}),
},
]
targets = ['de_DE']
app = get_configured_app(files=files, target_langs=targets)
requests_intercept.install()
add_wsgi_intercept(_INTERCEPT_HOST, _INTERCEPT_PORT, lambda: app)
yield app
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 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 remove_redirect(host):
wsgi_intercept.remove_wsgi_intercept(host, 80)
uninstall()
def stop_fixture(self):
wsgi_intercept.remove_wsgi_intercept(self.host, self.port)
def deinit_test_server():
# Remove the intercept.
remove_wsgi_intercept('localhost', 8080)
requests_intercept.uninstall()
def end_mock(self):
requests_intercept.uninstall()
wsgi_intercept.remove_wsgi_intercept()
def testTearDown(self):
for host in TEST_HOSTS:
wsgi_intercept.remove_wsgi_intercept(host, 80)
self._test_wsgi_application = None
super(ZopeBrowserLayer, self).testTearDown()
def stop(self):
remove_wsgi_intercept()
def tearDown(self):
wsgi_intercept.remove_wsgi_intercept('statictest', 80)
http_client_intercept.uninstall()
def remove_intercept():
wsgi_intercept.remove_wsgi_intercept('some_hopefully_nonexistant_domain', 80)
def uninstall_wsgi_intercept(self):
wsgi_intercept.remove_wsgi_intercept(self.host, self.port)
def remove_intercept():
wsgi_intercept.remove_wsgi_intercept()
def remove_intercept():
wsgi_intercept.remove_wsgi_intercept('some_hopefully_nonexistant_domain',
80)
def tearDown(self):
self.mock_db.stop()
self.validate_patch.stop()
wsgi_intercept.remove_wsgi_intercept('test', 80)
def uninstall_intercept(self):
remaining = wsgi_intercept.remove_wsgi_intercept(self.host, self.port)
# Only remove the module's class overrides if there are no intercepts
# left. Otherwise nested context managers cannot work.
if not remaining:
self.uninstall_module()
def teardown():
wsgi_intercept.remove_wsgi_intercept("127.0.0.1", 8000)
wsgi_intercept.requests_intercept.uninstall()
def tearDownBrowser(*args):
wsgi_intercept.remove_wsgi_intercept()
wsgi_intercept.urllib2_intercept.uninstall_opener()
def tearDown(self):
import wsgi_intercept
wsgi_intercept.remove_wsgi_intercept('test', 80)
gsm = getGlobalSiteManager()
gsm.unregisterUtility(self.mail_delivery, IMailDelivery, "Mail")
def tearDown(self):
wsgi_intercept.remove_wsgi_intercept('statictest', 80)
http_client_intercept.uninstall()
def remove_intercept():
wsgi_intercept.debuglevel = _saved_debuglevel
wsgi_intercept.remove_wsgi_intercept()
def tearDown(self):
uninstall_opener()
for host, port in self.intercepted:
wsgi_intercept.remove_wsgi_intercept(host, port)
TestCase.tearDown(self)
def test_intercept_removed(self):
from wsgi_intercept import remove_wsgi_intercept
remove_wsgi_intercept()
b = self.make_one()
with self.assertRaises(URLError):
b.open(self.url)
def teardown_module(module):
wsgi_intercept.remove_wsgi_intercept('wsgify.org', 80)
def remove_intercept():
wsgi_intercept.debuglevel = _saved_debuglevel
wsgi_intercept.remove_wsgi_intercept()
def http_teardown(host, port):
# Remove the WSGI interception layer.
wsgi_intercept.remove_wsgi_intercept(host, port)
def uninstall_intercept(self):
wsgi_intercept.remove_wsgi_intercept(self.host, self.port)
self._module.uninstall()
def stop_fake_magnetodb_api():
wsgi_intercept.remove_wsgi_intercept("localhost", 8080)
wsgi_intercept.http_client_intercept.uninstall()
def tearDown(self):
for host in TEST_HOSTS:
wsgi_intercept.remove_wsgi_intercept(host, 80)
self.cooperative_super('tearDown')
