def test_extract_redirect_errors_out_helpfully_if_not_a_redirect(self):
content = factory.getRandomString(10)
other_response = HttpResponse(status=httplib.OK, content=content)
try:
extract_redirect(other_response)
except ValueError as e:
pass
self.assertIn(unicode(httplib.OK), unicode(e))
self.assertIn(content, unicode(e))
def test_extract_redirect_errors_out_helpfully_if_not_a_redirect(self):
content = factory.getRandomString(10)
other_response = HttpResponse(status=httplib.OK, content=content)
try:
extract_redirect(other_response)
except ValueError as e:
pass
self.assertIn(unicode(httplib.OK), unicode(e))
self.assertIn(content, unicode(e))
def test_extract_redirect_errors_out_helpfully_if_not_a_redirect(self):
content = factory.make_string(10).encode("ascii")
other_response = HttpResponse(content=content)
try:
extract_redirect(other_response)
except ValueError as e:
self.assertThat(
str(e),
Equals("Not a redirect: http status %d. Content: %s" %
(http.client.OK.value, content)))
def test_can_update_license_key(self):
self.client.login(user=factory.make_admin())
key = factory.make_LicenseKey(
distro_series=random.choice(REQUIRE_LICENSE_KEY))
make_osystem_requiring_license_key(self, key.osystem,
key.distro_series)
self.patch(forms, "validate_license_key").return_value = True
new_key = factory.make_name("key")
edit_link = reverse("license-key-edit",
args=[key.osystem, key.distro_series])
definition = {
"osystem": key.osystem,
"distro_series": "%s/%s" % (key.osystem, key.distro_series),
"license_key": new_key,
}
response = self.client.post(edit_link, definition)
self.assertEqual(
(http.client.FOUND, reverse("settings_license_keys")),
(response.status_code, extract_redirect(response)),
)
expected_result = {
"osystem": key.osystem,
"distro_series": key.distro_series,
"license_key": new_key,
}
self.assertAttributes(reload_object(key), expected_result)
def test_extract_redirect_only_returns_target_path(self):
url_path = factory.make_string()
self.assertEqual(
"/%s" % url_path,
extract_redirect(
HttpResponseRedirect("http://example.com/%s" % url_path)),
)
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_maas_load_image(self):
img_path = 'img/bg_dots.png'
url = '%s?%s' % (reverse('combo-maas'), img_path)
response = self.client.get(url)
self.assertEqual(
'%s%s' % (settings.STATIC_URL, img_path),
extract_redirect(response))
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_get_skips_confirmation_for_missing_objects(self):
next_url = factory.make_string()
request = RequestFactory().get("/foo")
view = FakeDeleteView(next_url=next_url, request=request)
response = view.get(request)
self.assertEqual(next_url, extract_redirect(response))
self.assertEqual([view.compose_feedback_nonexistent()], view.notices)
def test_get_skips_confirmation_for_missing_objects(self):
next_url = factory.getRandomString()
request = RequestFactory().get('/foo')
view = FakeDeleteView(next_url=next_url, request=request)
response = view.get(request)
self.assertEqual(next_url, extract_redirect(response))
self.assertEqual([view.compose_feedback_nonexistent()], view.notices)
def test_login_redirects_when_authenticated(self):
password = factory.make_string()
user = factory.make_User(password=password)
self.client.handler.enforce_csrf_checks = True
self.client.login(username=user.username, password=password)
response = self.client.get(reverse("login"))
self.assertEqual(reverse("index"), extract_redirect(response))
def test_can_create_license_key(self):
self.client.login(user=factory.make_admin())
osystem = make_osystem_requiring_license_key(self)
self.patch(forms, "validate_license_key").return_value = True
series = osystem["default_release"]
key = factory.make_name("key")
add_link = reverse("license-key-add")
definition = {
"osystem": osystem["name"],
"distro_series": "%s/%s" % (osystem["name"], series),
"license_key": key,
}
response = self.client.post(add_link, definition)
self.assertEqual(
(http.client.FOUND, reverse("settings_license_keys")),
(response.status_code, extract_redirect(response)),
)
new_license_key = LicenseKey.objects.get(osystem=osystem["name"],
distro_series=series)
expected_result = {
"osystem": osystem["name"],
"distro_series": series,
"license_key": key,
}
self.assertAttributes(new_license_key, expected_result)
def test_delete_key_POST_ignores_nonexistent_key(self):
# Deleting a key that's already been deleted? Basically that's
# success.
key = factory.make_sshkey(self.logged_in_user)
del_link = reverse('prefs-delete-sshkey', args=[key.id])
key.delete()
response = self.client.post(del_link, {'post': 'yes'})
self.assertEqual('/account/prefs/', extract_redirect(response))
def test_delete_key_POST(self):
# A POST request deletes the key, and redirects to the prefs.
key = factory.make_sshkey(self.logged_in_user)
del_link = reverse('prefs-delete-sshkey', args=[key.id])
response = self.client.post(del_link, {'post': 'yes'})
self.assertEqual('/account/prefs/', extract_redirect(response))
self.assertFalse(SSHKey.objects.filter(id=key.id).exists())
def test_delete_key_GET_nonexistent_key_redirects_to_prefs(self):
# Deleting a nonexistent key requires no confirmation. It just
# "succeeds" instantaneously.
key = factory.make_sshkey(self.logged_in_user)
del_link = reverse('prefs-delete-sshkey', args=[key.id])
key.delete()
response = self.client.get(del_link)
self.assertEqual('/account/prefs/', extract_redirect(response))
def test_login_redirects_GET(self):
password = factory.make_string()
user = factory.make_User(password=password)
response = self.client.post(
reverse("login") + '?%s=%s' % (
REDIRECT_FIELD_NAME, reverse('prefs')),
{'username': user.username, 'password': password})
self.assertEqual(reverse('prefs'), extract_redirect(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_delete_key_POST_ignores_nonexistent_key(self):
# Deleting a key that's already been deleted? Basically that's
# success.
key = factory.make_sshkey(self.logged_in_user)
del_link = reverse('prefs-delete-sshkey', args=[key.id])
key.delete()
response = self.client.post(del_link, {'post': 'yes'})
self.assertEqual('/account/prefs/', extract_redirect(response))
def test_delete_key_POST(self):
# A POST request deletes the key, and redirects to the prefs.
key = factory.make_sshkey(self.logged_in_user)
del_link = reverse('prefs-delete-sshkey', args=[key.id])
response = self.client.post(del_link, {'post': 'yes'})
self.assertEqual('/account/prefs/', extract_redirect(response))
self.assertFalse(SSHKey.objects.filter(id=key.id).exists())
def test_can_delete_commissioning_script(self):
self.client_log_in(as_admin=True)
script = factory.make_Script()
delete_link = reverse('commissioning-script-delete', args=[script.id])
response = self.client.post(delete_link, {'post': 'yes'})
self.assertEqual((http.client.FOUND, reverse('settings')),
(response.status_code, extract_redirect(response)))
self.assertFalse(Script.objects.filter(id=script.id).exists())
def test_delete_key_GET_nonexistent_key_redirects_to_prefs(self):
# Deleting a nonexistent key requires no confirmation. It just
# "succeeds" instantaneously.
key = factory.make_sshkey(self.logged_in_user)
del_link = reverse('prefs-delete-sshkey', args=[key.id])
key.delete()
response = self.client.get(del_link)
self.assertEqual('/account/prefs/', extract_redirect(response))
def test_can_delete_cluster(self):
nodegroup = factory.make_node_group()
delete_link = reverse('cluster-delete', args=[nodegroup.uuid])
response = self.client.post(delete_link, {'post': 'yes'})
self.assertEqual(
(httplib.FOUND, reverse('settings')),
(response.status_code, extract_redirect(response)))
self.assertFalse(
NodeGroup.objects.filter(uuid=nodegroup.uuid).exists())
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_node_delete_mac_POST_deletes_mac(self):
node = factory.make_node(owner=self.logged_in_user)
mac = factory.make_mac_address(node=node)
mac_delete_link = reverse('mac-delete', args=[node.system_id, mac])
response = self.client.post(mac_delete_link, {'post': 'yes'})
self.assertEqual(
reverse('node-edit', args=[node.system_id]),
extract_redirect(response))
self.assertFalse(MACAddress.objects.filter(id=mac.id).exists())
def perform_action_and_get_node_page(self, node, action_name):
"""POST to perform a node action, then load the resulting page."""
node_link = reverse('node-view', args=[node.system_id])
response = self.client.post(
node_link, data={NodeActionForm.input_name: action_name})
redirect = extract_redirect(response)
if redirect != node_link:
self.fail("Odd: %s redirected to %s." % (node_link, redirect))
return self.client.get(redirect)
def test_can_delete_commissioning_script(self):
script = factory.make_commissioning_script()
delete_link = reverse('commissioning-script-delete', args=[script.id])
response = self.client.post(delete_link, {'post': 'yes'})
self.assertEqual(
(httplib.FOUND, reverse('settings')),
(response.status_code, extract_redirect(response)))
self.assertFalse(
CommissioningScript.objects.filter(id=script.id).exists())
def test_cannot_add_zone(self):
self.client_log_in()
name = factory.make_name('zone')
response = self.client.post(reverse('zone-add'), {'name': name})
# This returns an inappropriate response (302 FOUND, redirect to the
# login page; should be 403 FORBIDDEN) but does not actually create the
# zone, and that's the main thing.
self.assertEqual(reverse('login'), extract_redirect(response))
self.assertEqual([], list(Zone.objects.filter(name=name)))
def test_can_delete_commissioning_script(self):
self.client.login(user=factory.make_admin())
script = factory.make_Script()
delete_link = reverse("commissioning-script-delete", args=[script.id])
response = self.client.post(delete_link, {"post": "yes"})
self.assertEqual(
(http.client.FOUND, reverse("settings_scripts")),
(response.status_code, extract_redirect(response)),
)
self.assertFalse(Script.objects.filter(id=script.id).exists())
def test_node_delete_mac_POST_displays_message(self):
node = factory.make_node(owner=self.logged_in_user)
mac = factory.make_mac_address(node=node)
mac_delete_link = reverse('mac-delete', args=[node.system_id, mac])
response = self.client.post(mac_delete_link, {'post': 'yes'})
redirect = extract_redirect(response)
response = self.client.get(redirect)
self.assertEqual(
["Mac address %s deleted." % mac.mac_address],
[message.message for message in response.context['messages']])
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_node_add_mac_POST_adds_mac(self):
node = factory.make_node(owner=self.logged_in_user)
mac_add_link = reverse('mac-add', args=[node.system_id])
mac = factory.getRandomMACAddress()
response = self.client.post(mac_add_link, {'mac_address': mac})
self.assertEqual(
reverse('node-edit', args=[node.system_id]),
extract_redirect(response))
self.assertTrue(
MACAddress.objects.filter(node=node, mac_address=mac).exists())
def test_node_add_mac_POST_displays_message(self):
node = factory.make_node(owner=self.logged_in_user)
mac_add_link = reverse('mac-add', args=[node.system_id])
mac = factory.getRandomMACAddress()
response = self.client.post(mac_add_link, {'mac_address': mac})
redirect = extract_redirect(response)
response = self.client.get(redirect)
self.assertEqual(
["MAC address added."],
[message.message for message in response.context['messages']])
def test_login_redirects_POST(self):
password = factory.make_string()
user = factory.make_User(password=password)
response = self.client.post(
'/accounts/login/', {
'username': user.username,
'password': password,
REDIRECT_FIELD_NAME: reverse('prefs'),
})
self.assertEqual(reverse('prefs'), extract_redirect(response))
def test_login_doesnt_redirect_to_logout_GET(self):
password = factory.make_string()
user = factory.make_User(password=password)
response = self.client.post(
'/accounts/login/?%s=%s' %
(REDIRECT_FIELD_NAME, reverse('logout')), {
'username': user.username,
'password': password
})
self.assertEqual('/', extract_redirect(response))
def test_login_doesnt_redirect_to_logout_POST(self):
password = factory.make_string()
user = factory.make_User(password=password)
response = self.client.post(
reverse("login"), {
'username': user.username,
'password': password,
REDIRECT_FIELD_NAME: reverse('logout'),
})
self.assertEqual(reverse("index"), extract_redirect(response))
def test_node_delete_redirects_if_mac_does_not_exist(self):
# If the MAC address does not exist, the user is redirected
# to the node edit page.
node = factory.make_node(owner=self.logged_in_user)
mac = factory.getRandomMACAddress()
mac_delete_link = reverse('mac-delete', args=[node.system_id, mac])
response = self.client.get(mac_delete_link)
self.assertEqual(
reverse('node-edit', args=[node.system_id]),
extract_redirect(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))
# An error message has been published.
self.assertEqual([(constants.ERROR, "Error: " + error_message, '')],
request._messages.messages)
def test_can_delete_license_key(self):
self.client.login(user=factory.make_admin())
key = factory.make_LicenseKey()
delete_link = reverse('license-key-delete',
args=[key.osystem, key.distro_series])
response = self.client.post(delete_link, {'post': 'yes'})
self.assertEqual((http.client.FOUND, reverse('settings_license_keys')),
(response.status_code, extract_redirect(response)))
self.assertFalse(
LicenseKey.objects.filter(
osystem=key.osystem, distro_series=key.distro_series).exists())
def test_adds_zone(self):
self.client_log_in(as_admin=True)
definition = {
'name': factory.make_name('zone'),
'description': factory.make_string(),
}
response = self.client.post(reverse('zone-add'), definition)
self.assertEqual(http.client.FOUND, response.status_code)
zone = Zone.objects.get(name=definition['name'])
self.assertEqual(definition['description'], zone.description)
self.assertEqual(reverse('zone-list'), extract_redirect(response))
def test_error_middleware_handles_ExternalComponentException(self):
url = factory.getRandomString()
request = fake_request(url, 'POST')
error_message = factory.getRandomString()
exception = ExternalComponentException(error_message)
middleware = ErrorsMiddleware()
response = middleware.process_exception(request, exception)
# The response is a redirect.
self.assertEqual(url, extract_redirect(response))
# An error message has been published.
self.assertEqual(
[(constants.ERROR, error_message, '')], request._messages.messages)
def test_raised_MAASException_redirects(self):
# When a ExternalComponentException is raised in a POST request, the
# response is a redirect to the same page.
# Patch NodeEdit to error on post.
def post(self, request, *args, **kwargs):
raise ExternalComponentException()
self.patch(NodeEdit, 'post', post)
node = factory.make_node(owner=self.logged_in_user)
node_edit_link = reverse('node-edit', args=[node.system_id])
response = self.client.post(node_edit_link, {})
self.assertEqual(node_edit_link, extract_redirect(response))
def test_error_middleware_handles_ExternalComponentException(self):
url = factory.getRandomString()
request = fake_request(url, 'POST')
error_message = factory.getRandomString()
exception = ExternalComponentException(error_message)
error_middleware = ErrorsMiddleware()
response = error_middleware.process_exception(request, exception)
# The response is a redirect.
self.assertEqual(request.path, extract_redirect(response))
# An error message has been published.
self.assertEqual(
[(constants.ERROR, error_message, '')], request._messages.messages)
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))
# An error message has been published.
self.assertEqual([(constants.ERROR, "Error: " + error_message, '')],
request._messages.messages)
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))
# An error message has been published.
self.assertEqual([(constants.ERROR, "Error: %s" % error_message, '')],
request._messages.messages)
def test_login_doesnt_redirect_to_logout_GET(self):
password = factory.make_string()
user = factory.make_User(password=password)
self.client.handler.enforce_csrf_checks = True
response = self.client.post(
reverse("login") + "?%s=%s" %
(REDIRECT_FIELD_NAME, reverse("logout")),
{
"username": user.username,
"password": password
},
)
self.assertEqual(reverse("index"), extract_redirect(response))
def test_login_redirects_POST(self):
password = factory.make_string()
user = factory.make_User(password=password)
self.client.handler.enforce_csrf_checks = True
response = self.client.post(
reverse("login"),
{
"username": user.username,
"password": password,
REDIRECT_FIELD_NAME: reverse("prefs"),
},
)
self.assertEqual(reverse("prefs"), extract_redirect(response))
def test_can_delete_cluster_interface(self):
nodegroup = factory.make_node_group()
interface = factory.make_node_group_interface(
nodegroup=nodegroup,
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
delete_link = reverse(
'cluster-interface-delete',
args=[nodegroup.uuid, interface.interface])
response = self.client.post(delete_link, {'post': 'yes'})
self.assertEqual(
(httplib.FOUND, reverse('cluster-edit', args=[nodegroup.uuid])),
(response.status_code, extract_redirect(response)))
self.assertFalse(
NodeGroupInterface.objects.filter(id=interface.id).exists())
def test_can_create_cluster_interface(self):
nodegroup = factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
create_link = reverse(
'cluster-interface-create', args=[nodegroup.uuid])
data = factory.get_interface_fields()
response = self.client.post(create_link, data)
self.assertEqual(
(httplib.FOUND, reverse('cluster-edit', args=[nodegroup.uuid])),
(response.status_code, extract_redirect(response)))
interface = NodeGroupInterface.objects.get(
nodegroup__uuid=nodegroup.uuid, interface=data['interface'])
self.assertThat(
reload_object(interface),
MatchesStructure.byEquality(**data))
def test_can_create_commissioning_script(self):
content = factory.getRandomString()
name = factory.make_name('filename')
create_link = reverse('commissioning-script-add')
filepath = self.make_file(name=name, contents=content)
with open(filepath) as fp:
response = self.client.post(
create_link, {'name': name, 'content': fp})
self.assertEqual(
(httplib.FOUND, reverse('settings')),
(response.status_code, extract_redirect(response)))
new_script = CommissioningScript.objects.get(name=name)
self.assertThat(
new_script,
MatchesStructure.byEquality(name=name, content=content))
def test_get_combo_redirects_if_unknown_type(self):
# The optional parameter 'default_redirect' allows to configure
# a default address where requests for files of unknown types will be
# redirected.
# Create a test file with an unknown extension.
test_file_name = "%s.%s" % (
factory.getRandomString(), factory.getRandomString())
redirect_root = factory.getRandomString()
view = get_combo_view(
factory.getRandomString(), default_redirect=redirect_root)
rf = RequestFactory()
request = rf.get("/test/?%s" % test_file_name)
response = view(request)
self.assertEqual(
'%s%s' % (redirect_root, test_file_name),
extract_redirect(response))
def test_settings_import_boot_images_reserved_to_admin(self):
response = self.client.post(
reverse('settings'), {'import_all_boot_images': 1})
self.assertEqual(reverse('login'), extract_redirect(response))
def test_Redirect_produces_redirect_to_given_URL(self):
target = factory.getRandomString()
exception = Redirect(target)
response = exception.make_http_response()
self.assertEqual(target, extract_redirect(response))
def test_extract_redirect_extracts_redirect_location(self):
url = factory.getRandomString()
self.assertEqual(
url, extract_redirect(HttpResponseRedirect(url)))
def test_extract_redirect_only_returns_target_path(self):
url_path = factory.getRandomString()
self.assertEqual(
"/%s" % url_path,
extract_redirect(
HttpResponseRedirect("http://example.com/%s" % url_path)))
def test_login_redirects_when_authenticated(self):
password = factory.getRandomString()
user = factory.make_user(password=password)
self.client.login(username=user.username, password=password)
response = self.client.get('/accounts/login/')
self.assertEqual('/', extract_redirect(response))
