def test_args(self):
auth = auth_lib.AuthContext({}, {"REQUEST_METHOD": "GET"})
ctx = context.RequestContext(auth=auth,
remote_ip=REMOTE_IP,
x_forwarded_for=X_FORWARDED_FOR_IPS)
self.assertEqual(ctx.auth, auth)
self.assertEqual(ctx.remote_ip, REMOTE_IP)
self.assertEqual(ctx.x_forwarded_for, X_FORWARDED_FOR_IPS)
def test_environ(self):
environ = {"one": "two", "three": "four"}
auth = auth_lib.AuthContext({}, environ)
self.assertNotEqual(context.from_environ(environ).auth, auth)
context.set_in_environ(
environ, context.from_environ(environ).replace(auth=auth)
)
self.assertEqual(environ["one"], "two")
self.assertEqual(environ["three"], "four")
self.assertEqual(context.from_environ(environ).auth, auth)
def test_cache_success(self):
call_count_box = [0]
class UsernameProvider(auth.AuthProvider):
def authenticate(self, environ):
call_count_box[0] += 1
return environ["username"]
providers = {UsernameProvider: UsernameProvider()}
auth_ctx = auth.AuthContext(providers, {"username": "******"})
self.assertEqual(auth_ctx.get(UsernameProvider), "whoami")
self.assertEqual(auth_ctx.get(UsernameProvider), "whoami")
self.assertEqual(call_count_box[0], 1)
def test_cache_failure(self):
call_count_box = [0]
class FailureProvider(auth.AuthProvider):
def authenticate(self, environ):
call_count_box[0] += 1
raise RuntimeError()
providers = {FailureProvider: FailureProvider()}
auth_ctx = auth.AuthContext(providers, {})
with self.assertRaises(RuntimeError):
auth_ctx.get(FailureProvider)
with self.assertRaises(RuntimeError):
auth_ctx.get(FailureProvider)
self.assertEqual(call_count_box[0], 2)
def test_replace(self):
environ1 = {"one": "two", "three": "four"}
auth1 = auth_lib.AuthContext({}, environ1)
environ2 = {"one": "two"}
auth2 = auth_lib.AuthContext({}, environ2)
remote_ip1 = ipaddress.ip_address("192.168.0.1")
remote_ip2 = ipaddress.ip_address("192.168.0.2")
x_forwarded_for_ips1 = (remote_ip1, REMOTE_IP)
x_forwarded_for_ips2 = (remote_ip2, REMOTE_IP)
req_context = context.RequestContext(
auth=auth1,
remote_ip=remote_ip1,
x_forwarded_for=x_forwarded_for_ips1,
)
self.assertEqual(req_context.auth, auth1)
self.assertEqual(req_context.remote_ip, remote_ip1)
self.assertEqual(req_context.x_forwarded_for, x_forwarded_for_ips1)
req_context_new = req_context.replace(auth=auth2)
self.assertEqual(req_context_new.auth, auth2)
self.assertEqual(req_context_new.remote_ip, req_context.remote_ip)
self.assertEqual(req_context_new.x_forwarded_for,
req_context.x_forwarded_for)
req_context_new = req_context.replace(remote_ip=remote_ip2)
self.assertEqual(req_context_new.auth, req_context.auth)
self.assertEqual(req_context_new.remote_ip, remote_ip2)
self.assertEqual(req_context_new.x_forwarded_for,
req_context.x_forwarded_for)
req_context_new = req_context.replace(
x_forwarded_for=x_forwarded_for_ips2)
self.assertEqual(req_context_new.auth, req_context.auth)
self.assertEqual(req_context_new.remote_ip, req_context.remote_ip)
self.assertEqual(req_context_new.x_forwarded_for, x_forwarded_for_ips2)
def test_environ(self):
environ = {"one": "two", "three": "four"}
auth = auth_lib.AuthContext({}, environ)
req_context = context.from_environ(environ)
self.assertNotEqual(req_context.auth, auth)
self.assertNotEqual(req_context.remote_ip, REMOTE_IP)
self.assertNotEqual(req_context.x_forwarded_for, X_FORWARDED_FOR_IPS)
context.set_in_environ(
environ,
context.from_environ(environ).replace(
auth=auth,
remote_ip=REMOTE_IP,
x_forwarded_for=X_FORWARDED_FOR_IPS,
),
)
self.assertEqual(environ["one"], "two")
self.assertEqual(environ["three"], "four")
req_context = context.from_environ(environ)
self.assertEqual(req_context.auth, auth)
self.assertEqual(req_context.remote_ip, REMOTE_IP)
self.assertEqual(req_context.x_forwarded_for, X_FORWARDED_FOR_IPS)
def wrapper(environ, start_response):
environ = dict(environ)
auth_ctx = auth.AuthContext(auth_providers, environ)
ctx = context.from_environ(environ).replace(auth=auth_ctx)
context.set_in_environ(environ, ctx)
return wsgi_app(environ, start_response)
def test_args(self):
auth = auth_lib.AuthContext({}, {"REQUEST_METHOD": "GET"})
ctx = context.RequestContext(auth=auth)
self.assertEqual(ctx.auth, auth)