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))