src/emuvim/test/unittests/test_emulator.py

   1 """
   2 Test suite to automatically test emulator functionalities.
   3 Directly interacts with the emulator through the Mininet-like
   4 Python API.
   5
   6 Does not test API endpoints. This is done in separated test suites.
   7 """
   8
   9 import time
  10 import unittest
  11 from emuvim.dcemulator.node import EmulatorCompute
  12 from emuvim.test.base import SimpleTestTopology
  13
  14
  15 #@unittest.skip("disabled topology tests for development")
  16 class testEmulatorTopology( SimpleTestTopology ):
  17     """
  18     Tests to check the topology API of the emulator.
  19     """
  20
  21     def testSingleDatacenter(self):
  22         """
  23         Create a single data center and add check if its switch is up
  24         by using manually added hosts. Tests especially the
  25         data center specific addLink method.
  26         """
  27         # create network
  28         self.createNet(nswitches=0, ndatacenter=1, nhosts=2, ndockers=0)
  29         # setup links
  30         self.net.addLink(self.dc[0], self.h[0])
  31         self.net.addLink(self.h[1], self.dc[0])
  32         # start Mininet network
  33         self.startNet()
  34         # check number of running nodes
  35         self.assertTrue(len(self.getContainernetContainers()) == 0)
  36         self.assertTrue(len(self.net.hosts) == 2)
  37         self.assertTrue(len(self.net.switches) == 1)
  38         # check connectivity by using ping
  39         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
  40         # stop Mininet network
  41         self.stopNet()
  42
  43     #@unittest.skip("disabled to test if CI fails because this is the first test.")
  44     def testMultipleDatacenterDirect(self):
  45         """
  46         Create a two data centers and interconnect them.
  47         """
  48         # create network
  49         self.createNet(nswitches=0, ndatacenter=2, nhosts=2, ndockers=0)
  50         # setup links
  51         self.net.addLink(self.dc[0], self.h[0])
  52         self.net.addLink(self.h[1], self.dc[1])
  53         self.net.addLink(self.dc[0], self.dc[1])
  54         # start Mininet network
  55         self.startNet()
  56         # check number of running nodes
  57         self.assertTrue(len(self.getContainernetContainers()) == 0)
  58         self.assertTrue(len(self.net.hosts) == 2)
  59         self.assertTrue(len(self.net.switches) == 2)
  60         # check connectivity by using ping
  61         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
  62         # stop Mininet network
  63         self.stopNet()
  64
  65     def testMultipleDatacenterWithIntermediateSwitches(self):
  66         """
  67         Create a two data centers and interconnect them with additional
  68         switches between them.
  69         """
  70         # create network
  71         self.createNet(
  72             nswitches=3, ndatacenter=2, nhosts=2, ndockers=0,
  73             autolinkswitches=True)
  74         # setup links
  75         self.net.addLink(self.dc[0], self.h[0])
  76         self.net.addLink(self.h[1], self.dc[1])
  77         self.net.addLink(self.dc[0], self.s[0])
  78         self.net.addLink(self.s[2], self.dc[1])
  79         # start Mininet network
  80         self.startNet()
  81         # check number of running nodes
  82         self.assertTrue(len(self.getContainernetContainers()) == 0)
  83         self.assertTrue(len(self.net.hosts) == 2)
  84         self.assertTrue(len(self.net.switches) == 5)
  85         # check connectivity by using ping
  86         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
  87         # stop Mininet network
  88         self.stopNet()
  89
  90
  91 #@unittest.skip("disabled compute tests for development")
  92 class testEmulatorCompute( SimpleTestTopology ):
  93     """
  94     Tests to check the emulator's API to add and remove
  95     compute resources at runtime.
  96     """
  97
  98     def testAddSingleComputeSingleDC(self):
  99         """
 100         Adds a single compute instance to
 101         a single DC and checks its connectivity with a
 102         manually added host.
 103         """
 104         # create network
 105         self.createNet(nswitches=0, ndatacenter=1, nhosts=1, ndockers=0)
 106         # setup links
 107         self.net.addLink(self.dc[0], self.h[0])
 108         # start Mininet network
 109         self.startNet()
 110         # add compute resources
 111         vnf1 = self.dc[0].startCompute("vnf1")
 112         # check number of running nodes
 113         self.assertTrue(len(self.getContainernetContainers()) == 1)
 114         self.assertTrue(len(self.net.hosts) == 2)
 115         self.assertTrue(len(self.net.switches) == 1)
 116         # check compute list result
 117         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 118         self.assertTrue(isinstance(self.dc[0].listCompute()[0], EmulatorCompute))
 119         self.assertTrue(self.dc[0].listCompute()[0].name == "vnf1")
 120         # check connectivity by using ping
 121         self.assertTrue(self.net.ping([self.h[0], vnf1]) <= 0.0)
 122         # stop Mininet network
 123         self.stopNet()
 124
 125     def testRemoveSingleComputeSingleDC(self):
 126         """
 127         Test stop method for compute instances.
 128         Check that the instance is really removed.
 129         """
 130         # create network
 131         self.createNet(nswitches=0, ndatacenter=1, nhosts=1, ndockers=0)
 132         # setup links
 133         self.net.addLink(self.dc[0], self.h[0])
 134         # start Mininet network
 135         self.startNet()
 136         # add compute resources
 137         vnf1 = self.dc[0].startCompute("vnf1")
 138         # check number of running nodes
 139         self.assertTrue(len(self.getContainernetContainers()) == 1)
 140         self.assertTrue(len(self.net.hosts) == 2)
 141         self.assertTrue(len(self.net.switches) == 1)
 142         # check compute list result
 143         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 144         # check connectivity by using ping
 145         self.assertTrue(self.net.ping([self.h[0], vnf1]) <= 0.0)
 146         # remove compute resources
 147         self.dc[0].stopCompute("vnf1")
 148         # check number of running nodes
 149         self.assertTrue(len(self.getContainernetContainers()) == 0)
 150         self.assertTrue(len(self.net.hosts) == 1)
 151         self.assertTrue(len(self.net.switches) == 1)
 152         # check compute list result
 153         self.assertTrue(len(self.dc[0].listCompute()) == 0)
 154         # stop Mininet network
 155         self.stopNet()
 156
 157     def testGetStatusSingleComputeSingleDC(self):
 158         """
 159         Check if the getStatus functionality of EmulatorCompute
 160         objects works well.
 161         """
 162         # create network
 163         self.createNet(nswitches=0, ndatacenter=1, nhosts=1, ndockers=0)
 164         # setup links
 165         self.net.addLink(self.dc[0], self.h[0])
 166         # start Mininet network
 167         self.startNet()
 168         # add compute resources
 169         vnf1 = self.dc[0].startCompute("vnf1")
 170         # check number of running nodes
 171         self.assertTrue(len(self.getContainernetContainers()) == 1)
 172         self.assertTrue(len(self.net.hosts) == 2)
 173         self.assertTrue(len(self.net.switches) == 1)
 174         # check compute list result
 175         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 176         self.assertTrue(isinstance(self.dc[0].listCompute()[0], EmulatorCompute))
 177         self.assertTrue(self.dc[0].listCompute()[0].name == "vnf1")
 178         # check connectivity by using ping
 179         self.assertTrue(self.net.ping([self.h[0], vnf1]) <= 0.0)
 180         # check get status
 181         s = self.dc[0].containers.get("vnf1").getStatus()
 182         self.assertTrue(s["name"] == "vnf1")
 183         self.assertTrue(s["state"]["Running"])
 184         # stop Mininet network
 185         self.stopNet()
 186
 187     def testConnectivityMultiDC(self):
 188         """
 189         Test if compute instances started in different data centers
 190         are able to talk to each other.
 191         """
 192         # create network
 193         self.createNet(
 194             nswitches=3, ndatacenter=2, nhosts=0, ndockers=0,
 195             autolinkswitches=True)
 196         # setup links
 197         self.net.addLink(self.dc[0], self.s[0])
 198         self.net.addLink(self.dc[1], self.s[2])
 199         # start Mininet network
 200         self.startNet()
 201         # add compute resources
 202         vnf1 = self.dc[0].startCompute("vnf1")
 203         vnf2 = self.dc[1].startCompute("vnf2")
 204         # check number of running nodes
 205         self.assertTrue(len(self.getContainernetContainers()) == 2)
 206         self.assertTrue(len(self.net.hosts) == 2)
 207         self.assertTrue(len(self.net.switches) == 5)
 208         # check compute list result
 209         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 210         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 211         # check connectivity by using ping
 212         self.assertTrue(self.net.ping([vnf1, vnf2]) <= 0.0)
 213         # stop Mininet network
 214         self.stopNet()
 215
 216     def testInterleavedAddRemoveMultiDC(self):
 217         """
 218         Test multiple, interleaved add and remove operations and ensure
 219         that always all expected compute instances are reachable.
 220         """
 221                 # create network
 222         self.createNet(
 223             nswitches=3, ndatacenter=2, nhosts=0, ndockers=0,
 224             autolinkswitches=True)
 225         # setup links
 226         self.net.addLink(self.dc[0], self.s[0])
 227         self.net.addLink(self.dc[1], self.s[2])
 228         # start Mininet network
 229         self.startNet()
 230         # add compute resources
 231         vnf1 = self.dc[0].startCompute("vnf1")
 232         vnf2 = self.dc[1].startCompute("vnf2")
 233         # check number of running nodes
 234         self.assertTrue(len(self.getContainernetContainers()) == 2)
 235         self.assertTrue(len(self.net.hosts) == 2)
 236         self.assertTrue(len(self.net.switches) == 5)
 237         # check compute list result
 238         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 239         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 240         # check connectivity by using ping
 241         self.assertTrue(self.net.ping([vnf1, vnf2]) <= 0.0)
 242         # remove compute resources
 243         self.dc[0].stopCompute("vnf1")
 244         # check number of running nodes
 245         self.assertTrue(len(self.getContainernetContainers()) == 1)
 246         self.assertTrue(len(self.net.hosts) == 1)
 247         self.assertTrue(len(self.net.switches) == 5)
 248         # check compute list result
 249         self.assertTrue(len(self.dc[0].listCompute()) == 0)
 250         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 251         # add compute resources
 252         vnf3 = self.dc[0].startCompute("vnf3")
 253         vnf4 = self.dc[0].startCompute("vnf4")
 254         # check compute list result
 255         self.assertTrue(len(self.dc[0].listCompute()) == 2)
 256         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 257         self.assertTrue(self.net.ping([vnf3, vnf2]) <= 0.0)
 258         self.assertTrue(self.net.ping([vnf4, vnf2]) <= 0.0)
 259         # remove compute resources
 260         self.dc[0].stopCompute("vnf3")
 261         self.dc[0].stopCompute("vnf4")
 262         self.dc[1].stopCompute("vnf2")
 263         # check compute list result
 264         self.assertTrue(len(self.dc[0].listCompute()) == 0)
 265         self.assertTrue(len(self.dc[1].listCompute()) == 0)
 266         # stop Mininet network
 267         self.stopNet()
 268
 269 if __name__ == '__main__':
 270     unittest.main()