Synnefo

            owner=choice(users),

            sourceimage=choice(images),

            hostid=str(i),

            flavor=choice(flavors))

def create_server_metadata(n=1):

            meta_value='Value %d' % (i + 1),

            vm = choice(servers))

class AssertInvariant(object):

    def __init__(self, callable, *args, **kwargs):

    SERVERS = 1

    SERVER_METADATA = 0

    IMAGE_METADATA = 0

    def setUp(self):

        self.client = AaiClient()

        create_image_metadata(self.IMAGE_METADATA)

        create_servers(self.SERVERS)

        create_server_metadata(self.SERVER_METADATA)

    def assertFault(self, response, status_code, name):

        self.assertEqual(response.status_code, status_code)

        return reply

    def get_network_details(self, network_id):

        response = self.client.get(path)

        self.assertEqual(response.status_code, 200)

        reply = json.loads(response.content)

        return reply['network']

    def update_network_name(self, network_id, new_name):

        data = json.dumps({'network': {'name': new_name}})

        response = self.client.put(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 204)

    def delete_network(self, network_id):

        response = self.client.delete(path)

        self.assertEqual(response.status_code, 204)

    def add_to_network(self, network_id, server_id):

        data = json.dumps({'add': {'serverRef': server_id}})

        response = self.client.post(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 202)

    def remove_from_network(self, network_id, server_id):

        data = json.dumps({'remove': {'serverRef': server_id}})

        response = self.client.post(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 202)

class ListNetworks(BaseTestCase):

    SERVERS = 5

    def setUp(self):

        BaseTestCase.setUp(self)

        machines = VirtualMachine.objects.all()

        for network in Network.objects.all():

            n = randint(0, self.SERVERS)

    def test_list_networks(self):

        networks = self.list_networks()

        for net in Network.objects.all():

            self.assertEqual(network['name'], net.name)

        self.assertEqual(networks, [])

    def test_list_networks_detail(self):

        networks = self.list_networks(detail=True)

        for net in Network.objects.all():

            self.assertEqual(network['name'], net.name)

            machines = set(vm.id for vm in net.machines.all())

            self.assertEqual(set(network['servers']['values']), machines)

class CreateNetwork(BaseTestCase):

    def test_create_network(self):

        self.create_network('net')

class GetNetworkDetails(BaseTestCase):

    SERVERS = 5

    def test_get_network_details(self):

        servers = VirtualMachine.objects.all()

        net = self.get_network_details(network.id)

        self.assertEqual(net['servers']['values'], [])

        server_id = choice(servers).id

        self.add_to_network(network.id, server_id)

        net = self.get_network_details(network.id)

        self.assertEqual(net['name'], network.name)

class UpdateNetworkName(BaseTestCase):

    def test_update_network_name(self):

        networks = self.list_networks(detail=True)

        network_id = network['id']

        new_name = network['name'] + '_2'

        self.update_network_name(network_id, new_name)

        network['name'] = new_name

class DeleteNetwork(BaseTestCase):

    def test_delete_network(self):

        networks = self.list_networks()

        network_id = network['id']

        self.delete_network(network_id)

class NetworkActions(BaseTestCase):

    SERVERS = 20

    def test_add_remove_server(self):

        server_ids = [vm.id for vm in VirtualMachine.objects.all()]

        network_id = network['id']

        to_add = set(sample(server_ids, 10))

        for server_id in to_add:

            self.add_to_network(network_id, server_id)

        to_remove = set(sample(to_add, 5))

        for server_id in to_remove:

            self.remove_from_network(network_id, server_id)