def test_performs_action(self):
with transaction.atomic():
node1 = factory.make_Node()
node2 = factory.make_Node()
node3 = factory.make_Node()
admin = factory.make_admin()
request = factory.make_fake_request('/')
request.user = admin
system_id_to_delete = [node1.system_id, node2.system_id]
form = BulkNodeActionForm(
request=request,
user=admin,
data=dict(
action=Delete.name,
system_id=system_id_to_delete))
self.assertTrue(form.is_valid(), form._errors)
with transaction.atomic():
done, not_actionable, not_permitted = form.save()
self.assertEqual(
[2, 0, 0],
[done, not_actionable, not_permitted])
with transaction.atomic():
existing_nodes = list(Node.objects.filter(
system_id__in=system_id_to_delete))
node3_system_id = reload_object(node3).system_id
self.assertEqual(
[[], node3.system_id],
[existing_nodes, node3_system_id])
def test_sets_csrf_exception_if_no_session_cookie(self):
cookies = {}
request = factory.make_fake_request(factory.make_string(),
"GET",
cookies=cookies)
self.process_request(request)
self.assertTrue(getattr(request, "csrf_processing_done", None))
def test_ignores_non_rpc_errors(self):
request = factory.make_fake_request(factory.make_string(), "POST")
exception = ZeroDivisionError(
"You may think it's a long walk down the street to the chemist "
"but that's just peanuts to space!")
self.assertRaises(ZeroDivisionError, self.process_request, request,
exception)
def test_ignores_error_on_API(self):
non_api_request = factory.make_fake_request("/MAAS/api/2.0/ohai")
exception_class = random.choice(
(NoConnectionsAvailable, PowerActionAlreadyInProgress))
exception = exception_class(factory.make_string())
self.assertRaises(exception_class, self.process_request,
non_api_request, exception)
def test_return_redirect_login(self):
request = factory.make_fake_request("/MAAS/")
request.user = AnonymousUser()
self.assertEqual(
"/MAAS/accounts/login/",
extract_redirect(self.process_request(request)),
)
def test_doesnt_set_csrf_exception_if_session_cookie(self):
cookies = {settings.SESSION_COOKIE_NAME: factory.make_name("session")}
request = factory.make_fake_request(factory.make_string(),
"GET",
cookies=cookies)
self.process_request(request)
self.assertIsNone(getattr(request, "csrf_processing_done", None))
def test_return_redirect_to_index_on_user_not_completed_user_intro(self):
Config.objects.set_config("completed_intro", False)
request = factory.make_fake_request("/MAAS/account/prefs")
request.user = factory.make_admin()
request.user.userprofile.completed_intro = False
self.assertEqual("/MAAS/",
extract_redirect(self.process_request(request)))
def test_update_metrics(self):
prometheus_metrics = create_metrics()
middleware = PrometheusRequestMetricsMiddleware(
self.get_response, prometheus_metrics=prometheus_metrics)
middleware(factory.make_fake_request("/MAAS/accounts/login/"))
middleware(factory.make_fake_request("/MAAS/accounts/login/"))
middleware(factory.make_fake_request("/MAAS/other/path"))
metrics_text = prometheus_metrics.generate_latest().decode('ascii')
self.assertIn(
'http_request_latency_count{method="GET",'
'path="/MAAS/accounts/login/",status="200"} 2.0',
metrics_text)
self.assertIn(
'http_request_latency_count{method="GET",'
'path="/MAAS/other/path",status="404"} 1.0',
metrics_text)
def test_doesnt_set_csrf_exception_if_session_cookie(self):
middleware = CSRFHelperMiddleware()
cookies = {settings.SESSION_COOKIE_NAME: factory.make_name('session')}
request = factory.make_fake_request(factory.make_string(),
'GET',
cookies=cookies)
self.assertIsNone(middleware.process_request(request))
self.assertIsNone(getattr(request, 'csrf_processing_done', None))
def test_sets_csrf_exception_if_no_session_cookie(self):
middleware = CSRFHelperMiddleware()
cookies = {}
request = factory.make_fake_request(factory.make_string(),
'GET',
cookies=cookies)
self.assertIsNone(middleware.process_request(request))
self.assertTrue(getattr(request, 'csrf_processing_done', None))
def test__checks_connectivity_of_rack_controllers(self):
getAllClients = self.patch(middleware_module, 'getAllClients')
request = factory.make_fake_request(factory.make_string(), 'GET')
middleware = ExternalComponentsMiddleware()
middleware.process_request(request)
self.assertThat(getAllClients, MockCalledOnceWith())
def test_ignores_error_outside_API(self):
middleware = APIRPCErrorsMiddleware()
non_api_request = factory.make_fake_request("/middleware/api/hello")
exception_class = random.choice(
(NoConnectionsAvailable, PowerActionAlreadyInProgress))
exception = exception_class(factory.make_string())
self.assertIsNone(
middleware.process_exception(non_api_request, exception))
def test_is_authenticated_external_auth(self):
user = factory.make_User()
request = factory.make_fake_request('/')
request.external_auth_info = ExternalAuthInfo('macaroon',
'https://example.com')
request.user = user
auth = MAASAPIAuthentication()
self.assertTrue(auth.is_authenticated(request))
def test_debugging_logger_logs_binary_response(self):
self.patch(settings, "DEBUG_HTTP", True)
logger = self.useFixture(FakeLogger('maasserver', logging.DEBUG))
request = factory.make_fake_request("foo")
response = HttpResponse(content=sample_binary_data,
content_type=b"application/octet-stream")
self.process_request(request, response)
self.assertThat(logger.output, Contains("non-utf-8 (binary?) content"))
def test_debugging_logger_does_not_log_response_if_no_debug_http(self):
logger = self.useFixture(FakeLogger('maasserver', logging.DEBUG))
request = factory.make_fake_request("/MAAS/api/2.0/nodes/")
response = HttpResponse(content="test content",
content_type=b"text/plain; charset=utf-8")
self.process_request(request, response)
debug_output = DebuggingLoggerMiddleware._build_request_repr(request)
self.assertThat(logger.output, Not(Contains(debug_output)))
def test_ignores_non_rpc_errors(self):
middleware = RPCErrorsMiddleware()
request = factory.make_fake_request(factory.make_string(), 'POST')
exception = ZeroDivisionError(
"You may think it's a long walk down the street to the chemist "
"but that's just peanuts to space!")
response = middleware.process_exception(request, exception)
self.assertIsNone(response)
def test_handles_TimeoutError(self):
request = factory.make_fake_request(factory.make_string(), "POST")
error_message = "Here, have a picture of Queen Victoria!"
error = TimeoutError(error_message)
response = self.process_request(request, error)
# The response is a redirect.
self.assertEqual(request.path, extract_redirect(response))
def test_debugging_logger_logs_request(self):
self.patch(settings, "DEBUG_HTTP", True)
logger = self.useFixture(FakeLogger('maasserver', logging.DEBUG))
request = factory.make_fake_request("/MAAS/api/2.0/nodes/")
request.content = "test content"
self.process_request(request)
debug_output = DebuggingLoggerMiddleware._build_request_repr(request)
self.assertThat(logger.output, Contains(debug_output))
def test_with_external_auth_rbac(self):
Config.objects.set_config("rbac_url", "https://rbac.example.com/")
request = factory.make_fake_request("/")
self.process_request(request)
self.assertEqual(request.external_auth_info.type, "rbac")
self.assertEqual(request.external_auth_info.url,
"https://rbac.example.com/auth")
self.assertEqual(request.external_auth_info.domain, "")
self.assertEqual(request.external_auth_info.admin_group, "")
def test_with_external_auth_rbac(self):
Config.objects.set_config('rbac_url', 'https://rbac.example.com/')
request = factory.make_fake_request('/')
self.process_request(request)
self.assertEqual(request.external_auth_info.type, 'rbac')
self.assertEqual(request.external_auth_info.url,
'https://rbac.example.com/auth')
self.assertEqual(request.external_auth_info.domain, '')
self.assertEqual(request.external_auth_info.admin_group, '')
def test_handles_NoConnectionsAvailable(self):
request = factory.make_fake_request(factory.make_string(), "POST")
error_message = ("No connections available for cluster %s" %
factory.make_name("cluster"))
error = NoConnectionsAvailable(error_message)
response = self.process_request(request, error)
# The response is a redirect.
self.assertEqual(request.path, extract_redirect(response))
def test_debugging_logger_logs_response(self):
logger = self.useFixture(FakeLogger('maasserver', logging.DEBUG))
request = factory.make_fake_request("foo")
response = HttpResponse(content="test content",
content_type=b"text/plain; charset=utf-8")
self.process_request(request, response)
self.assertThat(
logger.output,
Contains(response.content.decode(settings.DEFAULT_CHARSET)))
def test_authenticate_external_user_denied(self):
password = factory.make_string()
user = factory.make_User(password=password, is_local=False)
backend = MAASAuthorizationBackend()
request = factory.make_fake_request('/')
self.assertIsNone(
backend.authenticate(request,
username=user.username,
password=password))
def test_with_external_auth_candid(self):
Config.objects.set_config('external_auth_url', 'https://example.com/')
Config.objects.set_config('external_auth_domain', 'ldap')
Config.objects.set_config('external_auth_admin_group', 'admins')
request = factory.make_fake_request('/')
self.process_request(request)
self.assertEqual(request.external_auth_info.type, 'candid')
self.assertEqual(request.external_auth_info.url, 'https://example.com')
self.assertEqual(request.external_auth_info.domain, 'ldap')
self.assertEqual(request.external_auth_info.admin_group, 'admins')
def test_handles_TimeoutError(self):
request = factory.make_fake_request(
"/MAAS/api/2.0/" + factory.make_string(), 'POST')
error_message = "No thanks, I'm trying to give them up."
error = TimeoutError(error_message)
response = self.process_request(request, error)
self.assertEqual((http.client.GATEWAY_TIMEOUT, error_message),
(response.status_code,
response.content.decode(settings.DEFAULT_CHARSET)))
def test_503_response_includes_retry_after_header_by_default(self):
request = factory.make_fake_request(
"/MAAS/api/2.0/" + factory.make_string(), 'POST')
error = NoConnectionsAvailable(factory.make_name())
response = self.process_request(request, error)
self.assertEqual((
http.client.SERVICE_UNAVAILABLE,
'%s' % middleware_module.RETRY_AFTER_SERVICE_UNAVAILABLE,
), (response.status_code, response['Retry-after']))
def test_handles_PowerActionAlreadyInProgress(self):
request = factory.make_fake_request(factory.make_string(), "POST")
error_message = ("Unable to execute power action: another action is "
"already in progress for node %s" %
factory.make_name("node"))
error = PowerActionAlreadyInProgress(error_message)
response = self.process_request(request, error)
# The response is a redirect.
self.assertEqual(request.path, extract_redirect(response))
def test_no_connections_available_has_usable_cluster_name_in_msg(self):
# If a NoConnectionsAvailable exception carries a reference to
# the cluster UUID, RPCErrorsMiddleware will look up the
# cluster's name and make the error message it displays more
# useful.
request = factory.make_fake_request(factory.make_string(), "POST")
rack_controller = factory.make_RackController()
error = NoConnectionsAvailable(factory.make_name("msg"),
uuid=rack_controller.system_id)
self.process_request(request, error)
def test_with_external_auth_candid(self):
Config.objects.set_config("external_auth_url", "https://example.com/")
Config.objects.set_config("external_auth_domain", "ldap")
Config.objects.set_config("external_auth_admin_group", "admins")
request = factory.make_fake_request("/")
self.process_request(request)
self.assertEqual(request.external_auth_info.type, "candid")
self.assertEqual(request.external_auth_info.url, "https://example.com")
self.assertEqual(request.external_auth_info.domain, "ldap")
self.assertEqual(request.external_auth_info.admin_group, "admins")
def test_authenticate_username_password(self):
password = factory.make_string()
user = factory.make_User(password=password)
backend = MAASAuthorizationBackend()
request = factory.make_fake_request('/')
ExternalAuthInfoMiddleware(lambda request: request)(request)
self.assertEqual(
backend.authenticate(request,
username=user.username,
password=password), user)
