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 from mininet.node import RemoteController
  14
  15
  16 #@unittest.skip("disabled topology tests for development")
  17 class testEmulatorTopology( SimpleTestTopology ):
  18     """
  19     Tests to check the topology API of the emulator.
  20     """
  21
  22     def testSingleDatacenter(self):
  23         """
  24         Create a single data center and add check if its switch is up
  25         by using manually added hosts. Tests especially the
  26         data center specific addLink method.
  27         """
  28         # create network
  29         self.createNet(nswitches=0, ndatacenter=1, nhosts=2, ndockers=0)
  30         # setup links
  31         self.net.addLink(self.dc[0], self.h[0])
  32         self.net.addLink(self.h[1], self.dc[0])
  33         # start Mininet network
  34         self.startNet()
  35         # check number of running nodes
  36         self.assertTrue(len(self.getContainernetContainers()) == 0)
  37         self.assertTrue(len(self.net.hosts) == 2)
  38         self.assertTrue(len(self.net.switches) == 1)
  39         # check connectivity by using ping
  40         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
  41         # stop Mininet network
  42         self.stopNet()
  43
  44     #@unittest.skip("disabled to test if CI fails because this is the first test.")
  45     def testMultipleDatacenterDirect(self):
  46         """
  47         Create a two data centers and interconnect them.
  48         """
  49         # create network
  50         self.createNet(nswitches=0, ndatacenter=2, nhosts=2, ndockers=0)
  51         # setup links
  52         self.net.addLink(self.dc[0], self.h[0])
  53         self.net.addLink(self.h[1], self.dc[1])
  54         self.net.addLink(self.dc[0], self.dc[1])
  55         # start Mininet network
  56         self.startNet()
  57         # check number of running nodes
  58         self.assertTrue(len(self.getContainernetContainers()) == 0)
  59         self.assertTrue(len(self.net.hosts) == 2)
  60         self.assertTrue(len(self.net.switches) == 2)
  61         # check connectivity by using ping
  62         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
  63         # stop Mininet network
  64         self.stopNet()
  65
  66     def testMultipleDatacenterWithIntermediateSwitches(self):
  67         """
  68         Create a two data centers and interconnect them with additional
  69         switches between them.
  70         """
  71         # create network
  72         self.createNet(
  73             nswitches=3, ndatacenter=2, nhosts=2, ndockers=0,
  74             autolinkswitches=True)
  75         # setup links
  76         self.net.addLink(self.dc[0], self.h[0])
  77         self.net.addLink(self.h[1], self.dc[1])
  78         self.net.addLink(self.dc[0], self.s[0])
  79         self.net.addLink(self.s[2], self.dc[1])
  80         # start Mininet network
  81         self.startNet()
  82         # check number of running nodes
  83         self.assertTrue(len(self.getContainernetContainers()) == 0)
  84         self.assertTrue(len(self.net.hosts) == 2)
  85         self.assertTrue(len(self.net.switches) == 5)
  86         # check connectivity by using ping
  87         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
  88         # stop Mininet network
  89         self.stopNet()
  90
  91 class testEmulatorNetworking( SimpleTestTopology ):
  92
  93     def testSDNChaining(self):
  94         """
  95         Create a two data centers and interconnect them with additional
  96         switches between them.
  97         Uses Ryu SDN controller.
  98         Connect the Docker hosts to different datacenters and setup the links between.
  99         """
 100         # create network
 101         self.createNet(
 102             nswitches=3, ndatacenter=2, nhosts=0, ndockers=0,
 103             autolinkswitches=True,
 104             controller=RemoteController,
 105             enable_learning=False)
 106         # setup links
 107         self.net.addLink(self.dc[0], self.s[0])
 108         self.net.addLink(self.s[2], self.dc[1])
 109         # start Mininet network
 110         self.startNet()
 111
 112         # add compute resources
 113         vnf1 = self.dc[0].startCompute("vnf1", network=[{'id':'intf1', 'ip':'10.0.10.1/24'}])
 114         vnf2 = self.dc[1].startCompute("vnf2", network=[{'id':'intf2', 'ip':'10.0.10.2/24'}])
 115         # check number of running nodes
 116         self.assertTrue(len(self.getDockernetContainers()) == 2)
 117         self.assertTrue(len(self.net.hosts) == 2)
 118         self.assertTrue(len(self.net.switches) == 5)
 119         # check status
 120         # check get status
 121         s1 = self.dc[0].containers.get("vnf1").getStatus()
 122         self.assertTrue(s1["name"] == "vnf1")
 123         self.assertTrue(s1["state"]["Running"])
 124         self.assertTrue(s1["network"][0]['intf_name'] == 'intf1')
 125         self.assertTrue(s1["network"][0]['ip'] == '10.0.10.1')
 126
 127         s2 = self.dc[1].containers.get("vnf2").getStatus()
 128         self.assertTrue(s2["name"] == "vnf2")
 129         self.assertTrue(s2["state"]["Running"])
 130         self.assertTrue(s2["network"][0]['intf_name'] == 'intf2')
 131         self.assertTrue(s2["network"][0]['ip'] == '10.0.10.2')
 132
 133         # setup links
 134         self.net.setChain('vnf1', 'vnf2', 'intf1', 'intf2', bidirectional=True, cmd='add-flow')
 135         # check connectivity by using ping
 136         self.assertTrue(self.net.ping([vnf1, vnf2]) <= 0.0)
 137         # stop Mininet network
 138         self.stopNet()
 139
 140 #@unittest.skip("disabled compute tests for development")
 141 class testEmulatorCompute( SimpleTestTopology ):
 142     """
 143     Tests to check the emulator's API to add and remove
 144     compute resources at runtime.
 145     """
 146
 147     def testAddSingleComputeSingleDC(self):
 148         """
 149         Adds a single compute instance to
 150         a single DC and checks its connectivity with a
 151         manually added host.
 152         """
 153         # create network
 154         self.createNet(nswitches=0, ndatacenter=1, nhosts=1, ndockers=0)
 155         # setup links
 156         self.net.addLink(self.dc[0], self.h[0])
 157         # start Mininet network
 158         self.startNet()
 159         # add compute resources
 160         vnf1 = self.dc[0].startCompute("vnf1")
 161         # check number of running nodes
 162         self.assertTrue(len(self.getContainernetContainers()) == 1)
 163         self.assertTrue(len(self.net.hosts) == 2)
 164         self.assertTrue(len(self.net.switches) == 1)
 165         # check compute list result
 166         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 167         self.assertTrue(isinstance(self.dc[0].listCompute()[0], EmulatorCompute))
 168         self.assertTrue(self.dc[0].listCompute()[0].name == "vnf1")
 169         # check connectivity by using ping
 170         self.assertTrue(self.net.ping([self.h[0], vnf1]) <= 0.0)
 171         # stop Mininet network
 172         self.stopNet()
 173
 174     def testRemoveSingleComputeSingleDC(self):
 175         """
 176         Test stop method for compute instances.
 177         Check that the instance is really removed.
 178         """
 179         # create network
 180         self.createNet(nswitches=0, ndatacenter=1, nhosts=1, ndockers=0)
 181         # setup links
 182         self.net.addLink(self.dc[0], self.h[0])
 183         # start Mininet network
 184         self.startNet()
 185         # add compute resources
 186         vnf1 = self.dc[0].startCompute("vnf1")
 187         # check number of running nodes
 188         self.assertTrue(len(self.getContainernetContainers()) == 1)
 189         self.assertTrue(len(self.net.hosts) == 2)
 190         self.assertTrue(len(self.net.switches) == 1)
 191         # check compute list result
 192         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 193         # check connectivity by using ping
 194         self.assertTrue(self.net.ping([self.h[0], vnf1]) <= 0.0)
 195         # remove compute resources
 196         self.dc[0].stopCompute("vnf1")
 197         # check number of running nodes
 198         self.assertTrue(len(self.getContainernetContainers()) == 0)
 199         self.assertTrue(len(self.net.hosts) == 1)
 200         self.assertTrue(len(self.net.switches) == 1)
 201         # check compute list result
 202         self.assertTrue(len(self.dc[0].listCompute()) == 0)
 203         # stop Mininet network
 204         self.stopNet()
 205
 206     def testGetStatusSingleComputeSingleDC(self):
 207         """
 208         Check if the getStatus functionality of EmulatorCompute
 209         objects works well.
 210         """
 211         # create network
 212         self.createNet(nswitches=0, ndatacenter=1, nhosts=1, ndockers=0)
 213         # setup links
 214         self.net.addLink(self.dc[0], self.h[0])
 215         # start Mininet network
 216         self.startNet()
 217         # add compute resources
 218         vnf1 = self.dc[0].startCompute("vnf1")
 219         # check number of running nodes
 220         self.assertTrue(len(self.getContainernetContainers()) == 1)
 221         self.assertTrue(len(self.net.hosts) == 2)
 222         self.assertTrue(len(self.net.switches) == 1)
 223         # check compute list result
 224         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 225         self.assertTrue(isinstance(self.dc[0].listCompute()[0], EmulatorCompute))
 226         self.assertTrue(self.dc[0].listCompute()[0].name == "vnf1")
 227         # check connectivity by using ping
 228         self.assertTrue(self.net.ping([self.h[0], vnf1]) <= 0.0)
 229         # check get status
 230         s = self.dc[0].containers.get("vnf1").getStatus()
 231         self.assertTrue(s["name"] == "vnf1")
 232         self.assertTrue(s["state"]["Running"])
 233         # stop Mininet network
 234         self.stopNet()
 235
 236     def testConnectivityMultiDC(self):
 237         """
 238         Test if compute instances started in different data centers
 239         are able to talk to each other.
 240         """
 241         # create network
 242         self.createNet(
 243             nswitches=3, ndatacenter=2, nhosts=0, ndockers=0,
 244             autolinkswitches=True)
 245         # setup links
 246         self.net.addLink(self.dc[0], self.s[0])
 247         self.net.addLink(self.dc[1], self.s[2])
 248         # start Mininet network
 249         self.startNet()
 250         # add compute resources
 251         vnf1 = self.dc[0].startCompute("vnf1")
 252         vnf2 = self.dc[1].startCompute("vnf2")
 253         # check number of running nodes
 254         self.assertTrue(len(self.getContainernetContainers()) == 2)
 255         self.assertTrue(len(self.net.hosts) == 2)
 256         self.assertTrue(len(self.net.switches) == 5)
 257         # check compute list result
 258         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 259         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 260         # check connectivity by using ping
 261         self.assertTrue(self.net.ping([vnf1, vnf2]) <= 0.0)
 262         # stop Mininet network
 263         self.stopNet()
 264
 265     def testInterleavedAddRemoveMultiDC(self):
 266         """
 267         Test multiple, interleaved add and remove operations and ensure
 268         that always all expected compute instances are reachable.
 269         """
 270                 # create network
 271         self.createNet(
 272             nswitches=3, ndatacenter=2, nhosts=0, ndockers=0,
 273             autolinkswitches=True)
 274         # setup links
 275         self.net.addLink(self.dc[0], self.s[0])
 276         self.net.addLink(self.dc[1], self.s[2])
 277         # start Mininet network
 278         self.startNet()
 279         # add compute resources
 280         vnf1 = self.dc[0].startCompute("vnf1")
 281         vnf2 = self.dc[1].startCompute("vnf2")
 282         # check number of running nodes
 283         self.assertTrue(len(self.getContainernetContainers()) == 2)
 284         self.assertTrue(len(self.net.hosts) == 2)
 285         self.assertTrue(len(self.net.switches) == 5)
 286         # check compute list result
 287         self.assertTrue(len(self.dc[0].listCompute()) == 1)
 288         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 289         # check connectivity by using ping
 290         self.assertTrue(self.net.ping([vnf1, vnf2]) <= 0.0)
 291         # remove compute resources
 292         self.dc[0].stopCompute("vnf1")
 293         # check number of running nodes
 294         self.assertTrue(len(self.getContainernetContainers()) == 1)
 295         self.assertTrue(len(self.net.hosts) == 1)
 296         self.assertTrue(len(self.net.switches) == 5)
 297         # check compute list result
 298         self.assertTrue(len(self.dc[0].listCompute()) == 0)
 299         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 300         # add compute resources
 301         vnf3 = self.dc[0].startCompute("vnf3")
 302         vnf4 = self.dc[0].startCompute("vnf4")
 303         # check compute list result
 304         self.assertTrue(len(self.dc[0].listCompute()) == 2)
 305         self.assertTrue(len(self.dc[1].listCompute()) == 1)
 306         self.assertTrue(self.net.ping([vnf3, vnf2]) <= 0.0)
 307         self.assertTrue(self.net.ping([vnf4, vnf2]) <= 0.0)
 308         # remove compute resources
 309         self.dc[0].stopCompute("vnf3")
 310         self.dc[0].stopCompute("vnf4")
 311         self.dc[1].stopCompute("vnf2")
 312         # check compute list result
 313         self.assertTrue(len(self.dc[0].listCompute()) == 0)
 314         self.assertTrue(len(self.dc[1].listCompute()) == 0)
 315         # stop Mininet network
 316         self.stopNet()
 317
 318 if __name__ == '__main__':
 319     unittest.main()