diff options
| -rw-r--r-- | src/api/tests/test_models_unittest.py | 278 | ||||
| -rw-r--r-- | src/dashboard/testing_utils.py | 210 |
2 files changed, 478 insertions, 10 deletions
diff --git a/src/api/tests/test_models_unittest.py b/src/api/tests/test_models_unittest.py new file mode 100644 index 0000000..971f757 --- /dev/null +++ b/src/api/tests/test_models_unittest.py @@ -0,0 +1,278 @@ +############################################################################## +# Copyright (c) 2019 Sawyer Bergeron, Parker Berberian, and others. +# +# All rights reserved. This program and the accompanying materials +# are made available under the terms of the Apache License, Version 2.0 +# which accompanies this distribution, and is available at +# http://www.apache.org/licenses/LICENSE-2.0 +############################################################################## + + +from datetime import timedelta +from django.utils import timezone + +from booking.models import Booking +from api.models import ( + Job, + JobStatus, + JobFactory, + AccessRelation, + HostNetworkRelation, + HostHardwareRelation, + SoftwareRelation, +) + +from resource_inventory.models import ( + OPNFVRole, + HostProfile, +) + +from django.test import TestCase, Client + +from dashboard.testing_utils import ( + instantiate_host, + instantiate_user, + instantiate_userprofile, + instantiate_lab, + instantiate_installer, + instantiate_image, + instantiate_scenario, + instantiate_os, + make_hostprofile_set, + instantiate_opnfvrole, + instantiate_publicnet, + instantiate_booking, +) + + +class ValidBookingCreatesValidJob(TestCase): + @classmethod + def setUpTestData(cls): + cls.loginuser = instantiate_user(False, username="newtestuser", password="testpassword") + cls.userprofile = instantiate_userprofile(cls.loginuser) + + lab_user = instantiate_user(True) + cls.lab = instantiate_lab(lab_user) + + cls.host_profile = make_hostprofile_set(cls.lab) + cls.scenario = instantiate_scenario() + cls.installer = instantiate_installer([cls.scenario]) + os = instantiate_os([cls.installer]) + cls.image = instantiate_image(cls.lab, 1, cls.loginuser, os, cls.host_profile) + for i in range(30): + instantiate_host(cls.host_profile, cls.lab, name="host" + str(i), labid="host" + str(i)) + cls.role = instantiate_opnfvrole("Jumphost") + cls.computerole = instantiate_opnfvrole("Compute") + instantiate_publicnet(10, cls.lab) + instantiate_publicnet(12, cls.lab) + instantiate_publicnet(14, cls.lab) + + cls.lab_selected = 'lab_' + str(cls.lab.lab_user.id) + '_selected' + cls.host_selected = 'host_' + str(cls.host_profile.id) + '_selected' + + cls.post_data = cls.build_post_data() + + cls.client = Client() + + def setUp(self): + self.client.login( + username=self.loginuser.username, password="testpassword") + self.booking, self.compute_hostnames, self.jump_hostname = self.create_multinode_generic_booking() + + @classmethod + def build_post_data(cls): + post_data = {} + post_data['filter_field'] = '{"hosts":[{"host_' + str(cls.host_profile.id) + '":"true"}], "labs": [{"lab_' + str(cls.lab.lab_user.id) + '":"true"}]}' + post_data['purpose'] = 'purposefieldcontentstring' + post_data['project'] = 'projectfieldcontentstring' + post_data['length'] = '3' + post_data['ignore_this'] = 1 + post_data['users'] = '' + post_data['hostname'] = 'hostnamefieldcontentstring' + post_data['image'] = str(cls.image.id) + post_data['installer'] = str(cls.installer.id) + post_data['scenario'] = str(cls.scenario.id) + return post_data + + def post(self, changed_fields={}): + payload = self.post_data.copy() + payload.update(changed_fields) + response = self.client.post('/booking/quick/', payload) + return response + + def generate_booking(self): + self.post() + return Booking.objects.first() + + def test_valid_access_configs(self): + job = Job.objects.get(booking=self.booking) + self.assertIsNotNone(job) + + access_configs = [r.config for r in AccessRelation.objects.filter(job=job).all()] + + vpnconfigs = [] + sshconfigs = [] + + for config in access_configs: + if config.access_type == "vpn": + vpnconfigs.append(config) + elif config.access_type == "ssh": + sshconfigs.append(config) + else: + self.fail(msg="Undefined accessconfig: " + config.access_type + " found") + + user_set = [] + user_set.append(self.booking.owner) + user_set += self.booking.collaborators.all() + + for configs in [vpnconfigs, sshconfigs]: + for user in user_set: + configusers = [c.user for c in configs] + self.assertTrue(user in configusers) + + def test_valid_network_configs(self): + job = Job.objects.get(booking=self.booking) + self.assertIsNotNone(job) + + booking_hosts = self.booking.resource.hosts.all() + + netrelation_set = HostNetworkRelation.objects.filter(job=job) + netconfig_set = [r.config for r in netrelation_set] + + netrelation_hosts = [r.host for r in netrelation_set] + + for config in netconfig_set: + for interface in config.interfaces.all(): + self.assertTrue(interface.host in booking_hosts) + + # if no interfaces are referenced that shouldn't have vlans, + # and no vlans exist outside those accounted for in netconfigs, + # then the api is faithfully representing networks + # as netconfigs reference resource_inventory models directly + + # this test relies on the assumption that + # every interface is configured, whether it does or does not have vlans + # if this is not true, the test fails + + for host in booking_hosts: + self.assertTrue(host in netrelation_hosts) + relation = HostNetworkRelation.objects.filter(job=job).get(host=host) + + # do 2 direction matching that interfaces are one to one + config = relation.config + for interface in config.interfaces.all(): + self.assertTrue(interface in host.interfaces) + for interface in host.interfaces.all(): + self.assertTrue(interface in config.interfaces) + + for host in netrelation_hosts: + self.assertTrue(host in booking_hosts) + + def test_valid_hardware_configs(self): + job = Job.objects.get(booking=self.booking) + self.assertIsNotNone(job) + + hrelations = HostHardwareRelation.objects.filter(job=job).all() + + job_hosts = [r.host for r in hrelations] + + booking_hosts = self.booking.resource.hosts.all() + + self.assertEqual(len(booking_hosts), len(job_hosts)) + + for relation in hrelations: + self.assertTrue(relation.host in booking_hosts) + self.assertEqual(relation.status, JobStatus.NEW) + config = relation.config + host = relation.host + self.assertEqual(config.hostname, host.template.resource.name) + + def test_valid_software_configs(self): + job = Job.objects.get(booking=self.booking) + self.assertIsNotNone(job) + + srelation = SoftwareRelation.objects.filter(job=job).first() + self.assertIsNotNone(srelation) + + sconfig = srelation.config + self.assertIsNotNone(sconfig) + + oconfig = sconfig.opnfv + self.assertIsNotNone(oconfig) + + # not onetoone in models, but first() is safe here based on how ConfigBundle and a matching OPNFVConfig are created + # this should, however, be made explicit + self.assertEqual(oconfig.installer, self.booking.config_bundle.opnfv_config.first().installer.name) + self.assertEqual(oconfig.scenario, self.booking.config_bundle.opnfv_config.first().scenario.name) + + for host in oconfig.roles.all(): + role_name = host.config.opnfvRole.name + if str(role_name) == "Jumphost": + self.assertEqual(host.template.resource.name, self.jump_hostname) + elif str(role_name) == "Compute": + self.assertTrue(host.template.resource.name in self.compute_hostnames) + else: + self.fail(msg="Host with non-configured role name related to job: " + str(role_name)) + + def create_multinode_generic_booking(self): + topology = {} + + compute_hostnames = ["cmp01", "cmp02", "cmp03"] + + host_type = HostProfile.objects.first() + + universal_networks = [ + {"name": "public", "tagged": False, "public": True}, + {"name": "admin", "tagged": True, "public": False}] + just_compute_networks = [{"name": "private", "tagged": True, "public": False}] + just_jumphost_networks = [{"name": "external", "tagged": True, "public": True}] + + # generate a bunch of extra networks + for i in range(10): + net = {"tagged": False, "public": False} + net["name"] = "u_net" + str(i) + universal_networks.append(net) + + jhost_info = {} + jhost_info["type"] = host_type + jhost_info["role"] = OPNFVRole.objects.get(name="Jumphost") + jhost_info["nets"] = self.make_networks(host_type, list(just_jumphost_networks + universal_networks)) + jhost_info["image"] = self.image + topology["jump"] = jhost_info + + for hostname in compute_hostnames: + host_info = {} + host_info["type"] = host_type + host_info["role"] = OPNFVRole.objects.get(name="Compute") + host_info["nets"] = self.make_networks(host_type, list(just_compute_networks + universal_networks)) + host_info["image"] = self.image + topology[hostname] = host_info + + booking = instantiate_booking(self.loginuser, + timezone.now(), + timezone.now() + timedelta(days=1), + "demobooking", + self.lab, + topology=topology, + installer=self.installer, + scenario=self.scenario) + + if not booking.resource: + raise Exception("Booking does not have a resource when trying to pass to makeCompleteJob") + JobFactory.makeCompleteJob(booking) + + return booking, compute_hostnames, "jump" + + """ + evenly distributes networks given across a given profile's interfaces + """ + def make_networks(self, hostprofile, nets): + network_struct = [] + count = hostprofile.interfaceprofile.all().count() + for i in range(count): + network_struct.append([]) + while(nets): + index = len(nets) % count + network_struct[index].append(nets.pop()) + + return network_struct diff --git a/src/dashboard/testing_utils.py b/src/dashboard/testing_utils.py index e98b5e6..558031d 100644 --- a/src/dashboard/testing_utils.py +++ b/src/dashboard/testing_utils.py @@ -8,9 +8,15 @@ ############################################################################## from django.contrib.auth.models import User +from django.core.files.base import ContentFile import json +import re +from dashboard.exceptions import ( + InvalidHostnameException +) +from booking.models import Booking from account.models import UserProfile, Lab, LabStatus, VlanManager, PublicNetwork from resource_inventory.models import ( Host, @@ -24,13 +30,23 @@ from resource_inventory.models import ( Installer, OPNFVRole, RamProfile, + Network, + Vlan, + GenericResourceBundle, + GenericResource, + GenericHost, + ConfigBundle, + GenericInterface, + HostConfiguration, + OPNFVConfig, ) +from resource_inventory.resource_manager import ResourceManager class BookingContextData(object): def prepopulate(self, *args, **kwargs): self.loginuser = instantiate_user(False, username=kwargs.get("login_username", "newtestuser"), password="testpassword") - instantiate_userprofile(self.loginuser, True) + instantiate_userprofile(self.loginuser) lab_user = kwargs.get("lab_user", instantiate_user(True)) self.lab = instantiate_lab(lab_user) @@ -45,6 +61,179 @@ class BookingContextData(object): self.pubnet = instantiate_publicnet(10, self.lab) +""" +Info for instantiate_booking() function: +[topology] argument structure: + the [topology] argument should describe the structure of the pod + the top level should be a dictionary, with each key being a hostname + each value in the top level should be a dictionary with two keys: + "type" should map to a host profile instance + "nets" should map to a list of interfaces each with a list of + dictionaries each defining a network in the format + { "name": "netname", "tagged": True|False, "public": True|False } + each network is defined if a matching name is not found + + sample argument structure: + topology={ + "host1": { + "type": instanceOf HostProfile, + "role": instanceOf OPNFVRole + "image": instanceOf Image + "nets": [ + 0: [ + 0: { "name": "public", "tagged": True, "public": True }, + 1: { "name": "private", "tagged": False, "public": False }, + ] + 1: [] + ] + } + } +""" + + +def instantiate_booking(owner, + start, + end, + booking_identifier, + lab=Lab.objects.first(), + purpose="purposetext", + project="projecttext", + collaborators=[], + topology={}, + installer=None, + scenario=None): + (grb, host_set) = instantiate_grb(topology, owner, lab, booking_identifier) + cb = instantiate_cb(grb, owner, booking_identifier, topology, host_set, installer, scenario) + + resource = ResourceManager.getInstance().convertResourceBundle(grb, lab, cb) + + booking = Booking() + + booking.resource = resource + if not resource: + raise Exception("Resource not created") + booking.config_bundle = cb + booking.start = start + booking.end = end + booking.owner = owner + booking.purpose = purpose + booking.project = project + booking.lab = lab + booking.save() + + return booking + + +def instantiate_cb(grb, + owner, + booking_identifier, + topology={}, + host_set={}, + installer=None, + scenario=None): + cb = ConfigBundle() + cb.owner = owner + cb.name = str(booking_identifier) + "_cb" + cb.description = "cb generated by instantiate_cb() method" + cb.save() + + opnfvconfig = OPNFVConfig() + opnfvconfig.installer = installer + opnfvconfig.scenario = scenario + opnfvconfig.bundle = cb + opnfvconfig.save() + + # generate host configurations based on topology and host set + for hostname, host_info in topology.items(): + hconf = HostConfiguration() + hconf.bundle = cb + hconf.host = host_set[hostname] + hconf.image = host_info["image"] + hconf.opnfvRole = host_info["role"] + hconf.save() + return cb + + +def instantiate_grb(topology, + owner, + lab, + booking_identifier): + + grb = GenericResourceBundle(owner=owner, lab=lab) + grb.name = str(booking_identifier) + "_grb" + grb.description = "grb generated by instantiate_grb() method" + grb.save() + + networks = {} + host_set = {} + + for hostname in topology.keys(): + info = topology[hostname] + host_profile = info["type"] + + # need to construct host from hostname and type + ghost = instantiate_ghost(grb, host_profile, hostname) + host_set[hostname] = ghost + + ghost.save() + + # set up networks + nets = info["nets"] + for interface_index, interface_profile in enumerate(host_profile.interfaceprofile.all()): + generic_interface = GenericInterface() + generic_interface.host = ghost + generic_interface.profile = interface_profile + generic_interface.save() + + netconfig = nets[interface_index] + for network_index, network_info in enumerate(netconfig): + network_name = network_info["name"] + network = None + if network_name in networks: + network = networks[network_name] + else: + network = Network() + network.name = network_name + network.vlan_id = lab.vlan_manager.get_vlan() + network.save() + networks[network_name] = network + if network_info["public"]: + public_net = lab.vlan_manager.get_public_vlan() + if not public_net: + raise Exception("No more public networks available") + lab.vlan_manager.reserve_public_vlan(public_net.vlan) + network.vlan_id = public_net.vlan + else: + private_net = lab.vlan_manager.get_vlan() + if not private_net: + raise Exception("No more generic vlans are available") + lab.vlan_manager.reserve_vlans([private_net]) + network.vlan_id = private_net + + vlan = Vlan() + vlan.vlan_id = network.vlan_id + vlan.public = network_info["public"] + vlan.tagged = network_info["tagged"] + vlan.save() + generic_interface.vlans.add(vlan) + + return (grb, host_set) + + +def instantiate_ghost(grb, host_profile, hostname): + if not re.match(r"(?=^.{1,253}$)(^([A-Za-z0-9-_]{1,62}\.)*[A-Za-z0-9-_]{1,63})$", hostname): + raise InvalidHostnameException("Hostname must comply to RFC 952 and all extensions to it until this point") + gresource = GenericResource(bundle=grb, name=hostname) + gresource.save() + + ghost = GenericHost() + ghost.resource = gresource + ghost.profile = host_profile + ghost.save() + + return ghost + + def instantiate_user(is_superuser, username="testuser", password="testpassword", @@ -58,16 +247,17 @@ def instantiate_user(is_superuser, return user -def instantiate_userprofile(user=None, can_book_multiple=False): - if not user: - user = instantiate_user(True, 'test_user', 'test_pass', 'test_user@test_site.org') - userprofile = UserProfile() - userprofile.user = user - userprofile.booking_privledge = can_book_multiple +def instantiate_userprofile(user, email_addr="email@email.com", company="company", full_name="John Doe", booking_privledge=True, ssh_file=None): + up = UserProfile() + up.email_address = email_addr + up.company = company + up.full_name = full_name + up.booking_privledge = booking_privledge + up.user = user + up.save() + up.ssh_public_key.save("user_ssh_key", ssh_file if ssh_file else ContentFile("public key content string")) - userprofile.save() - - return user + return up def instantiate_vlanmanager(vlans=None, |