src/emuvim/test/unittests/test_openstack.py

   1 """
   2 Copyright (c) 2015 SONATA-NFV
   3 ALL RIGHTS RESERVED.
   4
   5 Licensed under the Apache License, Version 2.0 (the "License");
   6 you may not use this file except in compliance with the License.
   7 You may obtain a copy of the License at
   8
   9     http://www.apache.org/licenses/LICENSE-2.0
  10
  11 Unless required by applicable law or agreed to in writing, software
  12 distributed under the License is distributed on an "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 See the License for the specific language governing permissions and
  15 limitations under the License.
  16
  17 Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION]
  18 nor the names of its contributors may be used to endorse or promote
  19 products derived from this software without specific prior written
  20 permission.
  21
  22 This work has been performed in the framework of the SONATA project,
  23 funded by the European Commission under Grant number 671517 through
  24 the Horizon 2020 and 5G-PPP programmes. The authors would like to
  25 acknowledge the contributions of their colleagues of the SONATA
  26 partner consortium (www.sonata-nfv.eu).
  27 """
  28
  29 """
  30 Test suite to automatically test emulator REST API endpoints.
  31 """
  32
  33 import os
  34 import unittest
  35 import requests
  36 import simplejson as json
  37 import time
  38
  39 from emuvim.test.api_base_openstack import ApiBaseOpenStack
  40
  41
  42 class testRestApi(ApiBaseOpenStack):
  43     """
  44     Tests to check the REST API endpoints of the emulator.
  45     """
  46
  47     def setUp(self):
  48         # create network
  49         self.createNet(nswitches=3, ndatacenter=2, nhosts=2, ndockers=0, autolinkswitches=True)
  50
  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
  56         # start api
  57         self.startApi()
  58
  59         # start Mininet network
  60         self.startNet()
  61
  62     @unittest.skip("temporarily disabled")
  63     def testChainingDummy(self):
  64         print('->>>>>>> test Chaining Class->>>>>>>>>>>>>>>')
  65         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  66         print(" ")
  67
  68         headers = {'Content-type': 'application/json'}
  69         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_chaining.json")).read()
  70         url = "http://0.0.0.0:8004/v1/tenantabc123/stacks"
  71         requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)), headers=headers)
  72
  73
  74         print('->>>>>>> test Chaining Versions ->>>>>>>>>>>>>>>')
  75         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  76         url = "http://0.0.0.0:4000/"
  77         listapiversionstackresponse = requests.get(url, headers=headers)
  78         self.assertEqual(listapiversionstackresponse.status_code, 200)
  79         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"][0]["id"], "v1")
  80         print(" ")
  81
  82         print('->>>>>>> test Chaining List ->>>>>>>>>>>>>>>')
  83         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  84         url = "http://0.0.0.0:4000/v1/chain/list"
  85         chainlistresponse = requests.get(url, headers=headers)
  86         self.assertEqual(chainlistresponse.status_code, 200)
  87         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
  88         print(" ")
  89
  90         print('->>>>>>> test Loadbalancing List ->>>>>>>>>>>>>>>')
  91         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  92         url = "http://0.0.0.0:4000/v1/lb/list"
  93         lblistresponse = requests.get(url, headers=headers)
  94         self.assertEqual(lblistresponse.status_code, 200)
  95         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"], [])
  96         print(" ")
  97
  98         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/iper-in-0"
  99         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 100         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 101         url = "http://0.0.0.0:4000/v1/chain/%s" %(testchain)
 102         chainvnfresponse = requests.put(url)
 103         self.assertEqual(chainvnfresponse.status_code, 200)
 104         self.assertGreaterEqual(json.loads(chainvnfresponse.content)["cookie"], 0)
 105         print(" ")
 106
 107         print('->>>>>>> test Chaining List ->>>>>>>>>>>>>>>')
 108         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 109         url = "http://0.0.0.0:4000/v1/chain/list"
 110         chainlistresponse = requests.get(url, headers=headers)
 111         self.assertEqual(chainlistresponse.status_code, 200)
 112         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_vnf"], "dc0_s1_firewall1")
 113         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_intf"], "fire-out-0")
 114         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_vnf"], "dc0_s1_iperf1")
 115         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_intf"], "iper-in-0")
 116         print(" ")
 117
 118         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 119         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 120         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 121         deletechainvnfresponse = requests.delete(url)
 122         self.assertEqual(deletechainvnfresponse.status_code, 200)
 123         self.assertEqual(deletechainvnfresponse.content, "true")
 124         print(" ")
 125
 126         print('->>>>>>> test Chaining List If Empty Again ->>>>>>>>>>>>>>>')
 127         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 128         url = "http://0.0.0.0:4000/v1/chain/list"
 129         chainlistresponse = requests.get(url, headers=headers)
 130         self.assertEqual(chainlistresponse.status_code, 200)
 131         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
 132         print(" ")
 133
 134         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/iper-in-0"
 135         print('->>>>>>> test Stack Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 136         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 137         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 138         stackchainvnfresponse = requests.post(url, data=json.dumps(json.loads('{"path":["dc1.s1", "s1","s2","s3","s1","dc1.s1"]}')), headers=headers)
 139         self.assertEqual(stackchainvnfresponse.status_code, 200)
 140         print (stackchainvnfresponse.content)
 141         self.assertGreaterEqual(json.loads(stackchainvnfresponse.content)["cookie"], 0)
 142         print(" ")
 143
 144
 145         print('->>>>>>> test Stack Chaining List ->>>>>>>>>>>>>>>')
 146         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 147         url = "http://0.0.0.0:4000/v1/chain/list"
 148         chainlistresponse = requests.get(url, headers=headers)
 149         self.assertEqual(chainlistresponse.status_code, 200)
 150         print (chainlistresponse.content)
 151         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_vnf"], "dc0_s1_firewall1")
 152         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_intf"], "fire-out-0")
 153         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_vnf"], "dc0_s1_iperf1")
 154         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_intf"], "iper-in-0")
 155         self.assertItemsEqual(json.loads(chainlistresponse.content)["chains"][0]["path"],['dc1.s1', 's1', 's2', 's3', 's1', 'dc1.s1'])
 156         print(" ")
 157
 158         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 159         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 160         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 161         deletechainvnfresponse = requests.delete(url)
 162         self.assertEqual(deletechainvnfresponse.status_code, 200)
 163         self.assertEqual(deletechainvnfresponse.content, "true")
 164         print(" ")
 165
 166         print('->>>>>>> test Chaining List If Empty Again ->>>>>>>>>>>>>>>')
 167         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 168         url = "http://0.0.0.0:4000/v1/chain/list"
 169         chainlistresponse = requests.get(url, headers=headers)
 170         self.assertEqual(chainlistresponse.status_code, 200)
 171         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
 172         print(" ")
 173
 174
 175         testchain = "dc0_s1_firewall1/non-existing-interface/dc0_s1_iperf1/iper-in-0"
 176         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 177         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 178         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 179         chainvnfresponse = requests.put(url)
 180         self.assertEqual(chainvnfresponse.status_code, 501)
 181         print(" ")
 182
 183         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/non-existing-interface"
 184         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 185         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 186         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 187         chainvnfresponse = requests.put(url)
 188         self.assertEqual(chainvnfresponse.status_code, 501)
 189         print(" ")
 190
 191         testchain = "dc0_s1_firewall1/non-existing-interface/dc0_s1_iperf1/iper-in-0"
 192         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 193         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 194         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 195         deletechainvnfresponse = requests.delete(url)
 196         self.assertEqual(deletechainvnfresponse.status_code, 501)
 197         print(" ")
 198
 199         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/non-existing-interface"
 200         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 201         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 202         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 203         deletechainvnfresponse = requests.delete(url)
 204         self.assertEqual(deletechainvnfresponse.status_code, 501)
 205         print(" ")
 206
 207         testchain = "non-existent-dc/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 208         print('->>>>>>> test Chain VNF Non-Existing DC ->>>>>>>>>>>>>>>')
 209         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 210         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 211         chainvnfresponse = requests.put(url)
 212         self.assertEqual(chainvnfresponse.status_code, 500)
 213         print(" ")
 214
 215
 216         testchain = "dc0/s1/firewall1/non-existent:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 217         print('->>>>>>> test Chain VNF Non-Existing Interfaces ->>>>>>>>>>>>>>>')
 218         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 219         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 220         chainvnfresponse = requests.put(url)
 221         self.assertEqual(chainvnfresponse.status_code, 500)
 222         print(" ")
 223
 224         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/non-existent:cp02:input"
 225         print('->>>>>>> test Chain VNF Non-Existing Interfaces ->>>>>>>>>>>>>>>')
 226         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 227         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 228         chainvnfresponse = requests.put(url)
 229         self.assertEqual(chainvnfresponse.status_code, 500)
 230         print(" ")
 231
 232         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 233         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 234         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 235         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 236         chainvnfresponse = requests.put(url)
 237         print (chainvnfresponse.content)
 238         self.assertEqual(chainvnfresponse.status_code, 200)
 239         self.assertGreaterEqual(json.loads(chainvnfresponse.content)["cookie"], 0)
 240         print(" ")
 241
 242         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 243         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 244         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 245         deletechainvnfresponse = requests.delete(url)
 246         self.assertEqual(deletechainvnfresponse.status_code, 200)
 247         self.assertEqual(deletechainvnfresponse.content, "true")
 248         print(" ")
 249
 250         print('->>>>>>> test Chaining List If Empty Again ->>>>>>>>>>>>>>>')
 251         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 252         url = "http://0.0.0.0:4000/v1/chain/list"
 253         chainlistresponse = requests.get(url, headers=headers)
 254         self.assertEqual(chainlistresponse.status_code, 200)
 255         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
 256         print(" ")
 257
 258         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 259         print('->>>>>>> test Stack Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 260         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 261         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 262         stackchainvnfresponse = requests.post(url, data=json.dumps(
 263             json.loads('{"path":["dc1.s1", "s1","s2","s3","s1","dc1.s1"]}')), headers=headers)
 264         self.assertEqual(stackchainvnfresponse.status_code, 200)
 265         print (stackchainvnfresponse.content)
 266         self.assertGreaterEqual(json.loads(stackchainvnfresponse.content)["cookie"], 0)
 267         print(" ")
 268
 269         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 270         print('->>>>>>> test Stack Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 271         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 272         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 273         stackchainvnfresponse = requests.delete(url, headers=headers)
 274         self.assertEqual(stackchainvnfresponse.status_code, 200)
 275         print(" ")
 276
 277
 278         print('->>>>>>> test Loadbalancing ->>>>>>>>>>>>>>>')
 279         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 280         url = "http://0.0.0.0:4000/v1/lb/dc0/s1/firewall1/firewall1:cp03:output"
 281         lblistresponse = requests.post(url, data=json.dumps(
 282             {"dst_vnf_interfaces":[{"pop":"dc0","stack":"s1","server":"iperf1","port":"iperf1:cp02:input"}]})
 283             , headers=headers)
 284         print (lblistresponse.content)
 285         self.assertEqual(lblistresponse.status_code, 200)
 286         self.assertIn("dc0_s1_firewall1:fire-out-0", lblistresponse.content)
 287         print(" ")
 288
 289         print('->>>>>>> test Loadbalancing List ->>>>>>>>>>>>>>>')
 290         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 291         url = "http://0.0.0.0:4000/v1/lb/list"
 292         lblistresponse = requests.get(url, headers=headers)
 293         self.assertEqual(lblistresponse.status_code, 200)
 294         print (lblistresponse.content )
 295         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_vnf"], "dc0_s1_iperf1")
 296         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_intf"], "iper-in-0")
 297         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_vnf"], "dc0_s1_firewall1")
 298         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_intf"],"fire-out-0")
 299         print(" ")
 300
 301         print('->>>>>>> test delete Loadbalancing ->>>>>>>>>>>>>>>')
 302         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 303         url = "http://0.0.0.0:4000/v1/lb/dc0/s1/firewall1/firewall1:cp03:output"
 304         lbdeleteresponse = requests.delete(url, headers=headers)
 305         print (lbdeleteresponse.content)
 306         self.assertEqual(lbdeleteresponse.status_code, 200)
 307         print(" ")
 308
 309         print('->>>>>>> testFloatingLoadbalancer ->>>>>>>>>>>>>>>')
 310         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 311         url = "http://0.0.0.0:4000/v1/lb/dc0/floating/bla/blubb"
 312         lblistresponse = requests.post(url, data=json.dumps(
 313             {"dst_vnf_interfaces":[{"pop":"dc0","stack":"s1","server":"iperf1","port":"iperf1:cp02:input"}]})
 314             , headers=headers)
 315         print (lblistresponse.content)
 316         self.assertEqual(lblistresponse.status_code, 200)
 317         resp = json.loads(lblistresponse.content)
 318         self.assertIsNotNone(resp.get('cookie'))
 319         self.assertIsNotNone(resp.get('floating_ip'))
 320         cookie = resp.get('cookie')
 321         print(" ")
 322
 323         print('->>>>>>> testDeleteFloatingLoadbalancer ->>>>>>>>>>>>>>>')
 324         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 325         url = "http://0.0.0.0:4000/v1/lb/dc0/floating/%s/blubb" % cookie
 326         lblistresponse = requests.delete(url, headers=headers)
 327         print (lblistresponse.content)
 328         self.assertEqual(lblistresponse.status_code, 200)
 329         print(" ")
 330
 331         print('->>>>>>> testLoadbalancingCustomPath ->>>>>>>>>>>>>>>')
 332         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 333         url = "http://0.0.0.0:4000/v1/lb/dc0_s1_firewall1/fire-out-0"
 334         lblistresponse = requests.post(url, data=json.dumps(
 335             {"dst_vnf_interfaces":{"dc0_s1_iperf1":"iper-in-0"},
 336              "path": {"dc0_s1_iperf1": {"iper-in-0": ["dc1.s1", "s1","s2","s3","s1","dc1.s1"]}}}), headers=headers)
 337         print (lblistresponse.content)
 338         self.assertEqual(lblistresponse.status_code, 200)
 339         self.assertIn("dc0_s1_firewall1:fire-out-0", lblistresponse.content)
 340         print(" ")
 341
 342         print('->>>>>>> testLoadbalancingListCustomPath ->>>>>>>>>>>>>>>')
 343         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 344         url = "http://0.0.0.0:4000/v1/lb/list"
 345         lblistresponse = requests.get(url, headers=headers)
 346         self.assertEqual(lblistresponse.status_code, 200)
 347         print (lblistresponse.content )
 348         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_vnf"], "dc0_s1_iperf1")
 349         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_intf"], "iper-in-0")
 350         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["path"],
 351                          ["dc1.s1", "s1","s2","s3","s1","dc1.s1"] )
 352         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_vnf"], "dc0_s1_firewall1")
 353         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_intf"],"fire-out-0")
 354         print(" ")
 355
 356
 357         print('->>>>>>> test Delete Loadbalancing ->>>>>>>>>>>>>>>')
 358         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 359         url = "http://0.0.0.0:4000/v1/lb/dc0_s1_firewall1/fire-out-0"
 360         lblistresponse = requests.delete(url, headers=headers)
 361         self.assertEqual(lblistresponse.status_code, 200)
 362         print(" ")
 363
 364         print('->>>>>>> test Query Topology ->>>>>>>>>>>>>>>')
 365         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 366         url = "http://0.0.0.0:4000/v1/topo"
 367         topolistresponse = requests.get(url, headers=headers)
 368         print(topolistresponse.content)
 369         self.assertEqual(topolistresponse.status_code, 200)
 370         print(" ")
 371
 372
 373     def testNovaDummy(self):
 374         print('->>>>>>> test Nova Dummy Class->>>>>>>>>>>>>>>')
 375         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 376         print(" ")
 377
 378         headers = {'Content-type': 'application/json'}
 379         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_create_stack.json")).read()
 380         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 381         requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)),
 382                       headers=headers)
 383
 384         print('->>>>>>> test Nova List Versions ->>>>>>>>>>>>>>>')
 385         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 386         url = "http://0.0.0.0:18774/"
 387         listapiversionnovaresponse = requests.get(url, headers=headers)
 388         self.assertEqual(listapiversionnovaresponse.status_code, 200)
 389         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["id"], "v2.1")
 390         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["status"], "CURRENT")
 391         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["version"], "2.38")
 392         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["min_version"], "2.1")
 393         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["updated"], "2013-07-23T11:33:21Z")
 394         print(" ")
 395
 396         print('->>>>>>> test Nova Version Show ->>>>>>>>>>>>>>>')
 397         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 398         url = "http://0.0.0.0:18774/v2.1/id_bla"
 399         listapiversion21novaresponse = requests.get(url, headers=headers)
 400         self.assertEqual(listapiversion21novaresponse.status_code, 200)
 401         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["id"], "v2.1")
 402         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["status"], "CURRENT")
 403         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["version"], "2.38")
 404         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["min_version"], "2.1")
 405         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["updated"], "2013-07-23T11:33:21Z")
 406         print(" ")
 407
 408         print('->>>>>>> test Nova Version List Server APIs ->>>>>>>>>>>>>>>')
 409         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 410         url = "http://0.0.0.0:18774/v2.1/id_bla/servers"
 411         listserverapisnovaresponse = requests.get(url, headers=headers)
 412         self.assertEqual(listserverapisnovaresponse.status_code, 200)
 413         self.assertNotEqual(json.loads(listserverapisnovaresponse.content)["servers"][0]["name"], "")
 414         print(" ")
 415
 416         print('->>>>>>> test Nova Delete Server APIs ->>>>>>>>>>>>>>>')
 417         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 418         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json.loads(listserverapisnovaresponse.content)["servers"][0]["id"])
 419         deleteserverapisnovaresponse = requests.delete(url, headers=headers)
 420         self.assertEqual(deleteserverapisnovaresponse.status_code, 204)
 421         print(" ")
 422
 423         print('->>>>>>> test Nova Delete Non-Existing Server APIs ->>>>>>>>>>>>>>>')
 424         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 425         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/non-existing-ix"
 426         deleteserverapisnovaresponse = requests.delete(url, headers=headers)
 427         self.assertEqual(deleteserverapisnovaresponse.status_code, 404)
 428         print(" ")
 429
 430
 431         print('->>>>>>> testNovaVersionListServerAPIs_withPortInformation ->>>>>>>>>>>>>>>')
 432         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 433         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/andPorts"
 434         listserverapisnovaresponse = requests.get(url, headers=headers)
 435         self.assertEqual(listserverapisnovaresponse.status_code, 200)
 436         self.assertNotEqual(json.loads(listserverapisnovaresponse.content)["servers"][0]["name"], "")
 437         print(" ")
 438
 439         print('->>>>>>> test Nova List Flavors ->>>>>>>>>>>>>>>')
 440         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 441         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors"
 442         listflavorsresponse = requests.get(url, headers=headers)
 443         self.assertEqual(listflavorsresponse.status_code, 200)
 444         self.assertIn(json.loads(listflavorsresponse.content)["flavors"][0]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 445         self.assertIn(json.loads(listflavorsresponse.content)["flavors"][1]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 446         self.assertIn(json.loads(listflavorsresponse.content)["flavors"][2]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 447         print(" ")
 448
 449         print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
 450         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 451         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors"
 452         addflavorsresponse = requests.post(url,
 453                                            data='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
 454                                            headers=headers)
 455         self.assertEqual(addflavorsresponse.status_code, 200)
 456         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["id"])
 457         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["links"][0]['href'])
 458         print(" ")
 459
 460         print('->>>>>>> test Nova List Flavors Detail ->>>>>>>>>>>>>>>')
 461         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 462         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
 463         listflavorsdetailresponse = requests.get(url, headers=headers)
 464         self.assertEqual(listflavorsdetailresponse.status_code, 200)
 465         self.assertIn(json.loads(listflavorsdetailresponse.content)["flavors"][0]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 466         self.assertIn(json.loads(listflavorsdetailresponse.content)["flavors"][1]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 467         self.assertIn(json.loads(listflavorsdetailresponse.content)["flavors"][2]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 468         print(" ")
 469
 470         print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
 471         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 472         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
 473         addflavorsresponse = requests.post(url,
 474                                            data='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
 475                                            headers=headers)
 476         self.assertEqual(addflavorsresponse.status_code, 200)
 477         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["id"])
 478         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["links"][0]['href'])
 479         print(" ")
 480
 481         print('->>>>>>> test Nova List Flavor By Id ->>>>>>>>>>>>>>>')
 482
 483         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 484         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors/%s" % (json.loads(listflavorsdetailresponse.content)["flavors"][0]["name"])
 485         listflavorsbyidresponse = requests.get(url, headers=headers)
 486         self.assertEqual(listflavorsbyidresponse.status_code, 200)
 487         self.assertEqual(json.loads(listflavorsbyidresponse.content)["flavor"]["id"], json.loads(listflavorsdetailresponse.content)["flavors"][0]["id"])
 488         print(" ")
 489
 490         print('->>>>>>> test Nova List Images ->>>>>>>>>>>>>>>')
 491         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 492         url = "http://0.0.0.0:18774/v2.1/id_bla/images"
 493         listimagesresponse = requests.get(url, headers=headers)
 494         self.assertEqual(listimagesresponse.status_code, 200)
 495         print(listimagesresponse.content)
 496         # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
 497         #self.assertIn(json.loads(listimagesresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 498         #self.assertIn(json.loads(listimagesresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 499         #self.assertIn(json.loads(listimagesresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 500         print(" ")
 501
 502         print('->>>>>>> test Nova List Images Details ->>>>>>>>>>>>>>>')
 503         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 504         url = "http://0.0.0.0:18774/v2.1/id_bla/images/detail"
 505         listimagesdetailsresponse = requests.get(url, headers=headers)
 506         self.assertEqual(listimagesdetailsresponse.status_code, 200)
 507         # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
 508         #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 509         #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 510         #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 511         self.assertEqual(json.loads(listimagesdetailsresponse.content)["images"][0]["metadata"]["architecture"],"x86_64")
 512         print(" ")
 513
 514         print('->>>>>>> test Nova List Image By Id ->>>>>>>>>>>>>>>')
 515         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 516         url = "http://0.0.0.0:18774/v2.1/id_bla/images/%s" % (json.loads(listimagesdetailsresponse.content)["images"][0]["id"])
 517         listimagebyidresponse = requests.get(url, headers=headers)
 518         self.assertEqual(listimagebyidresponse.status_code, 200)
 519         self.assertEqual(json.loads(listimagebyidresponse.content)["image"]["id"],json.loads(listimagesdetailsresponse.content)["images"][0]["id"])
 520         print(" ")
 521
 522         print('->>>>>>> test Nova List Image By Non-Existend Id ->>>>>>>>>>>>>>>')
 523         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 524         url = "http://0.0.0.0:18774/v2.1/id_bla/images/non_existing_id"
 525         listimagebynonexistingidresponse = requests.get(url, headers=headers)
 526         self.assertEqual(listimagebynonexistingidresponse.status_code, 404)
 527         print(" ")
 528
 529         #find ubuntu id
 530         for image in json.loads(listimagesresponse.content)["images"]:
 531             if image["name"] == "ubuntu:trusty":
 532                 ubuntu_image_id = image["id"]
 533
 534
 535
 536         print('->>>>>>> test Nova Create Server Instance ->>>>>>>>>>>>>>>')
 537         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 538         url = "http://0.0.0.0:18774/v2.1/id_bla/servers"
 539         data = '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json.loads(listflavorsresponse.content)["flavors"][0]["id"], ubuntu_image_id)
 540         createserverinstance = requests.post(url, data=data, headers=headers)
 541         self.assertEqual(createserverinstance.status_code, 200)
 542         self.assertEqual(json.loads(createserverinstance.content)["server"]["image"]["id"], ubuntu_image_id)
 543         print(" ")
 544
 545         print('->>>>>>> test Nova Create Server Instance With Already Existing Name ->>>>>>>>>>>>>>>')
 546         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 547         url = "http://0.0.0.0:18774/v2.1/id_bla/servers"
 548         data = '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json.loads(listflavorsresponse.content)["flavors"][0]["id"], ubuntu_image_id)
 549         createserverinstance = requests.post(url, data=data, headers=headers)
 550         self.assertEqual(createserverinstance.status_code, 409)
 551         print(" ")
 552
 553         print('->>>>>>> test Nova Version List Server APIs Detailed ->>>>>>>>>>>>>>>')
 554         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 555         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/detail"
 556         listserverapisdetailedresponse = requests.get(url, headers=headers)
 557         self.assertEqual(listserverapisdetailedresponse.status_code, 200)
 558         self.assertEqual(json.loads(listserverapisdetailedresponse.content)["servers"][0]["status"], "ACTIVE")
 559         print(" ")
 560
 561         print('->>>>>>> test Nova Show Server Details ->>>>>>>>>>>>>>>')
 562         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 563         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json.loads(listserverapisdetailedresponse.content)["servers"][0]["id"])
 564         listserverdetailsresponse = requests.get(url, headers=headers)
 565         self.assertEqual(listserverdetailsresponse.status_code, 200)
 566         self.assertEqual(json.loads(listserverdetailsresponse.content)["server"]["flavor"]["links"][0]["rel"], "bookmark")
 567         print(" ")
 568
 569         print('->>>>>>> test Nova Show Non-Existing Server Details ->>>>>>>>>>>>>>>')
 570         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 571         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/non_existing_server_id"
 572         listnonexistingserverdetailsresponse = requests.get(url, headers=headers)
 573         self.assertEqual(listnonexistingserverdetailsresponse.status_code, 404)
 574         print(" ")
 575
 576
 577
 578     def testNeutronDummy(self):
 579         print('->>>>>>> test Neutron Dummy Class->>>>>>>>>>>>>>>')
 580         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 581         print(" ")
 582
 583         headers = {'Content-type': 'application/json'}
 584         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_create_stack.json")).read()
 585         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 586         requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)), headers=headers)
 587         # test_heatapi_keystone_get_token = open("test_heatapi_keystone_get_token.json").read()
 588
 589         print('->>>>>>> test Neutron List Versions ->>>>>>>>>>>>>>>')
 590         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 591         url = "http://0.0.0.0:19696/"
 592         listapiversionstackresponse = requests.get(url, headers=headers)
 593         self.assertEqual(listapiversionstackresponse.status_code, 200)
 594         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"][0]["id"], "v2.0")
 595         print(" ")
 596
 597         print('->>>>>>> test Neutron Show API v2.0 ->>>>>>>>>>>>>>>')
 598         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 599         url = "http://0.0.0.0:19696/v2.0"
 600         listapiversionv20response = requests.get(url, headers=headers)
 601         self.assertEqual(listapiversionv20response.status_code, 200)
 602         self.assertEqual(json.loads(listapiversionv20response.content)["resources"][0]["name"], "subnet")
 603         self.assertEqual(json.loads(listapiversionv20response.content)["resources"][1]["name"], "network")
 604         self.assertEqual(json.loads(listapiversionv20response.content)["resources"][2]["name"], "ports")
 605         print(" ")
 606
 607         print('->>>>>>> test Neutron List Networks ->>>>>>>>>>>>>>>')
 608         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 609         url = "http://0.0.0.0:19696/v2.0/networks"
 610         listnetworksesponse1 = requests.get(url, headers=headers)
 611         self.assertEqual(listnetworksesponse1.status_code, 200)
 612         self.assertEqual(json.loads(listnetworksesponse1.content)["networks"][0]["status"], "ACTIVE")
 613         listNetworksId = json.loads(listnetworksesponse1.content)["networks"][0]["id"]
 614         listNetworksName = json.loads(listnetworksesponse1.content)["networks"][0]["name"]
 615         listNetworksId2 = json.loads(listnetworksesponse1.content)["networks"][1]["id"]
 616         print(" ")
 617
 618         print('->>>>>>> test Neutron List Non-Existing Networks ->>>>>>>>>>>>>>>')
 619         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 620         url = "http://0.0.0.0:19696/v2.0/networks?name=non_existent_network_name"
 621         listnetworksesponse2 = requests.get(url,headers=headers)
 622         self.assertEqual(listnetworksesponse2.status_code, 404)
 623         print(" ")
 624
 625         print('->>>>>>> test Neutron List Networks By Name ->>>>>>>>>>>>>>>')
 626         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 627         url = "http://0.0.0.0:19696/v2.0/networks?name=" + listNetworksName #tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
 628         listnetworksesponse3 = requests.get(url, headers=headers)
 629         self.assertEqual(listnetworksesponse3.status_code, 200)
 630         self.assertEqual(json.loads(listnetworksesponse3.content)["networks"][0]["name"], listNetworksName)
 631         print(" ")
 632
 633         print('->>>>>>> test Neutron List Networks By Id ->>>>>>>>>>>>>>>')
 634         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 635         url = "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId  # tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
 636         listnetworksesponse4 = requests.get(url, headers=headers)
 637         self.assertEqual(listnetworksesponse4.status_code, 200)
 638         self.assertEqual(json.loads(listnetworksesponse4.content)["networks"][0]["id"], listNetworksId)
 639         print(" ")
 640
 641         print('->>>>>>> test Neutron List Networks By Multiple Ids ->>>>>>>>>>>>>>>')
 642         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 643         url = "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId + "&id="+ listNetworksId2 # tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
 644         listnetworksesponse5 = requests.get(url, headers=headers)
 645         self.assertEqual(listnetworksesponse5.status_code, 200)
 646         self.assertEqual(json.loads(listnetworksesponse5.content)["networks"][0]["id"], listNetworksId)
 647         self.assertEqual(json.loads(listnetworksesponse5.content)["networks"][1]["id"], listNetworksId2)
 648         print(" ")
 649
 650         print('->>>>>>> test Neutron Show Network ->>>>>>>>>>>>>>>')
 651         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 652         url = "http://0.0.0.0:19696/v2.0/networks/"+listNetworksId
 653         shownetworksesponse = requests.get(url, headers=headers)
 654         self.assertEqual(shownetworksesponse.status_code, 200)
 655         self.assertEqual(json.loads(shownetworksesponse.content)["network"]["status"], "ACTIVE")
 656         print(" ")
 657
 658         print('->>>>>>> test Neutron Show Network Non-ExistendNetwork ->>>>>>>>>>>>>>>')
 659         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 660         url = "http://0.0.0.0:19696/v2.0/networks/non_existent_network_id"
 661         shownetworksesponse2 = requests.get(url, headers=headers)
 662         self.assertEqual(shownetworksesponse2.status_code, 404)
 663         print(" ")
 664
 665         print('->>>>>>> test Neutron Create Network ->>>>>>>>>>>>>>>')
 666         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 667         url = "http://0.0.0.0:19696/v2.0/networks"
 668         createnetworkresponse = requests.post(url, data='{"network": {"name": "sample_network","admin_state_up": true}}', headers=headers)
 669         self.assertEqual(createnetworkresponse.status_code, 201)
 670         self.assertEqual(json.loads(createnetworkresponse.content)["network"]["status"], "ACTIVE")
 671         print(" ")
 672
 673         print('->>>>>>> test Neutron Create Network With Existing Name ->>>>>>>>>>>>>>>')
 674         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 675         url = "http://0.0.0.0:19696/v2.0/networks"
 676         createnetworkresponsefailure = requests.post(url,data='{"network": {"name": "sample_network","admin_state_up": true}}',headers=headers)
 677         self.assertEqual(createnetworkresponsefailure.status_code, 400)
 678         print(" ")
 679
 680         print('->>>>>>> test Neutron Update Network ->>>>>>>>>>>>>>>')
 681         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 682         url = "http://0.0.0.0:19696/v2.0/networks/%s" % (json.loads(createnetworkresponse.content)["network"]["id"])
 683         updatenetworkresponse = requests.put(url, data='{"network": {"status": "ACTIVE", "admin_state_up":true, "tenant_id":"abcd123", "name": "sample_network_new_name", "shared":false}}' , headers=headers)
 684         self.assertEqual(updatenetworkresponse.status_code, 200)
 685         self.assertEqual(json.loads(updatenetworkresponse.content)["network"]["name"], "sample_network_new_name")
 686         self.assertEqual(json.loads(updatenetworkresponse.content)["network"]["tenant_id"], "abcd123")
 687         print(" ")
 688
 689         print('->>>>>>> test Neutron Update Non-Existing Network ->>>>>>>>>>>>>>>')
 690         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 691         url = "http://0.0.0.0:19696/v2.0/networks/non-existing-name123"
 692         updatenetworkresponse = requests.put(url, data='{"network": {"name": "sample_network_new_name"}}', headers=headers)
 693         self.assertEqual(updatenetworkresponse.status_code, 404)
 694         print(" ")
 695
 696         print('->>>>>>> test Neutron List Subnets ->>>>>>>>>>>>>>>')
 697         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 698         url = "http://0.0.0.0:19696/v2.0/subnets"
 699         listsubnetsresponse = requests.get(url, headers=headers)
 700         listSubnetName = json.loads(listsubnetsresponse.content)["subnets"][0]["name"]
 701         listSubnetId = json.loads(listsubnetsresponse.content)["subnets"][0]["id"]
 702         listSubnetId2 = json.loads(listsubnetsresponse.content)["subnets"][1]["id"]
 703         self.assertEqual(listsubnetsresponse.status_code, 200)
 704         self.assertNotIn('None', listSubnetName)
 705         print(" ")
 706
 707         print('->>>>>>> test Neutron List Subnets By Name ->>>>>>>>>>>>>>>')
 708         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 709         url = "http://0.0.0.0:19696/v2.0/subnets?name="+listSubnetName
 710         listsubnetByNameresponse = requests.get(url, headers=headers)
 711         self.assertEqual(listsubnetByNameresponse.status_code, 200)
 712         self.assertNotIn('None', json.loads(listsubnetByNameresponse.content)["subnets"][0]["name"])
 713         print(" ")
 714
 715         print('->>>>>>> test Neutron List Subnets By Id ->>>>>>>>>>>>>>>')
 716         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 717         url = "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId
 718         listsubnetsbyidresponse = requests.get(url, headers=headers)
 719         self.assertEqual(listsubnetsbyidresponse.status_code, 200)
 720         self.assertNotIn("None", json.loads(listsubnetsbyidresponse.content)["subnets"][0]["name"])
 721         print(" ")
 722
 723         print('->>>>>>> test Neutron List Subnets By Multiple Id ->>>>>>>>>>>>>>>')
 724         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 725         url = "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId +"&id="+listSubnetId2
 726         listsubnetsbymultipleidsresponse = requests.get(url, headers=headers)
 727         self.assertEqual(listsubnetsbymultipleidsresponse.status_code, 200)
 728         self.assertNotIn("None", json.loads(listsubnetsbymultipleidsresponse.content)["subnets"][0]["name"])
 729         print(" ")
 730
 731
 732
 733         print('->>>>>>> test Neutron Show Subnet->>>>>>>>>>>>>>>')
 734         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 735         url = "http://0.0.0.0:19696/v2.0/subnets/%s" % (json.loads(listsubnetsresponse.content)["subnets"][0]["id"])
 736         showsubnetsresponse = requests.get(url, headers=headers)
 737         self.assertEqual(showsubnetsresponse.status_code, 200)
 738         self.assertNotIn("None", json.loads(showsubnetsresponse.content)["subnet"]["name"])
 739         print(" ")
 740
 741         print('->>>>>>> test Neutron Show Non-Existing Subnet->>>>>>>>>>>>>>>')
 742         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 743         url = "http://0.0.0.0:19696/v2.0/subnets/non-existing-id123"
 744         showsubnetsresponse = requests.get(url, headers=headers)
 745         self.assertEqual(showsubnetsresponse.status_code, 404)
 746         print(" ")
 747
 748
 749         print('->>>>>>> test Neutron Create Subnet ->>>>>>>>>>>>>>>')
 750         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 751         url = "http://0.0.0.0:19696/v2.0/subnets"
 752         createsubnetdata = '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 753         createsubnetresponse = requests.post(url, data=createsubnetdata, headers=headers)
 754         self.assertEqual(createsubnetresponse.status_code, 201)
 755         self.assertEqual(json.loads(createsubnetresponse.content)["subnet"]["name"], "new_subnet")
 756         print(" ")
 757
 758         print('->>>>>>> test Neutron Create Second Subnet ->>>>>>>>>>>>>>>')
 759         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 760         url = "http://0.0.0.0:19696/v2.0/subnets"
 761         createsubnetdata = '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 762         createsubnetfailureresponse = requests.post(url, data=createsubnetdata, headers=headers)
 763         self.assertEqual(createsubnetfailureresponse.status_code, 409)
 764         print(" ")
 765
 766         print('->>>>>>> test Neutron Update Subnet ->>>>>>>>>>>>>>>')
 767         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 768         url = "http://0.0.0.0:19696/v2.0/subnets/%s" % (json.loads(createsubnetresponse.content)["subnet"]["id"])
 769         updatesubnetdata = '{"subnet": {"name": "new_subnet_new_name", "network_id":"some_id", "tenant_id":"new_tenant_id", "allocation_pools":"change_me", "gateway_ip":"192.168.1.120", "ip_version":4, "cidr":"10.0.0.1/24", "id":"some_new_id", "enable_dhcp":true} }'
 770         updatesubnetresponse = requests.put(url, data=updatesubnetdata, headers=headers)
 771         self.assertEqual(updatesubnetresponse.status_code, 200)
 772         self.assertEqual(json.loads(updatesubnetresponse.content)["subnet"]["name"], "new_subnet_new_name")
 773         print(" ")
 774
 775         print('->>>>>>> test Neutron Update Non-Existing Subnet ->>>>>>>>>>>>>>>')
 776         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 777         url = "http://0.0.0.0:19696/v2.0/subnets/non-existing-subnet-12345"
 778         updatenonexistingsubnetdata = '{"subnet": {"name": "new_subnet_new_name"} }'
 779         updatenonexistingsubnetresponse = requests.put(url, data=updatenonexistingsubnetdata, headers=headers)
 780         self.assertEqual(updatenonexistingsubnetresponse.status_code, 404)
 781         print(" ")
 782
 783
 784
 785         print('->>>>>>> test Neutron List Ports ->>>>>>>>>>>>>>>')
 786         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 787         url = "http://0.0.0.0:19696/v2.0/ports"
 788         listportsesponse = requests.get(url, headers=headers)
 789         self.assertEqual(listportsesponse.status_code, 200)
 790         self.assertEqual(json.loads(listportsesponse.content)["ports"][0]["status"], "ACTIVE")
 791         listPortsName = json.loads(listportsesponse.content)["ports"][0]["name"]
 792         listPortsId1 = json.loads(listportsesponse.content)["ports"][0]["id"]
 793         listPortsId2 = json.loads(listportsesponse.content)["ports"][1]["id"]
 794         print(" ")
 795
 796         print('->>>>>>> test Neutron List Ports By Name ->>>>>>>>>>>>>>>')
 797         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 798         url = "http://0.0.0.0:19696/v2.0/ports?name=" + listPortsName
 799         listportsbynameesponse = requests.get(url, headers=headers)
 800         self.assertEqual(listportsbynameesponse.status_code, 200)
 801         self.assertEqual(json.loads(listportsbynameesponse.content)["ports"][0]["name"], listPortsName)
 802         print(" ")
 803
 804         print('->>>>>>> test Neutron List Ports By Id ->>>>>>>>>>>>>>>')
 805         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 806         url = "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1
 807         listportsbyidesponse = requests.get(url, headers=headers)
 808         self.assertEqual(listportsbyidesponse.status_code, 200)
 809         self.assertEqual(json.loads(listportsbyidesponse.content)["ports"][0]["id"], listPortsId1)
 810         print(" ")
 811
 812         print('->>>>>>> test Neutron List Ports By Multiple Ids ->>>>>>>>>>>>>>>')
 813         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 814         url = "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1 +"&id="+listPortsId2
 815         listportsbymultipleidsesponse = requests.get(url, headers=headers)
 816         self.assertEqual(listportsbymultipleidsesponse.status_code, 200)
 817         self.assertEqual(json.loads(listportsbymultipleidsesponse.content)["ports"][0]["id"], listPortsId1)
 818         print(" ")
 819
 820         print('->>>>>>> test Neutron List Non-Existing Ports ->>>>>>>>>>>>>>>')
 821         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 822         url = "http://0.0.0.0:19696/v2.0/ports?id=non-existing-port-id"
 823         listportsbynonexistingidsesponse = requests.get(url, headers=headers)
 824         self.assertEqual(listportsbynonexistingidsesponse.status_code, 404)
 825         print(" ")
 826
 827         print('->>>>>>> test Neutron Show Port ->>>>>>>>>>>>>>>')
 828         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 829         url = "http://0.0.0.0:19696/v2.0/ports/%s" % (json.loads(listportsesponse.content)["ports"][0]["id"])
 830         showportresponse = requests.get(url, headers=headers)
 831         self.assertEqual(showportresponse.status_code, 200)
 832         self.assertEqual(json.loads(showportresponse.content)["port"]["status"], "ACTIVE")
 833         print(" ")
 834
 835         print('->>>>>>> test Neutron Show Non-Existing Port ->>>>>>>>>>>>>>>')
 836         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 837         url = "http://0.0.0.0:19696/v2.0/ports/non-existing-portid123"
 838         shownonexistingportresponse = requests.get(url, headers=headers)
 839         self.assertEqual(shownonexistingportresponse.status_code, 404)
 840         print(" ")
 841
 842         print('->>>>>>> test Neutron Create Port In Non-Existing Network ->>>>>>>>>>>>>>>')
 843         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 844         url = "http://0.0.0.0:19696/v2.0/ports"
 845         createnonexistingportdata = '{"port": {"name": "new_port", "network_id": "non-existing-id"} }'
 846         createnonexistingnetworkportresponse = requests.post(url, data=createnonexistingportdata, headers=headers)
 847         self.assertEqual(createnonexistingnetworkportresponse.status_code, 404)
 848         print(" ")
 849
 850         print('->>>>>>> test Neutron Create Port ->>>>>>>>>>>>>>>')
 851         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 852         url = "http://0.0.0.0:19696/v2.0/ports"
 853         createportdata = '{"port": {"name": "new_port", "network_id": "%s", "admin_state_up":true, "device_id":"device_id123", "device_owner":"device_owner123", "fixed_ips":"change_me","id":"new_id1234", "mac_address":"12:34:56:78:90", "status":"change_me", "tenant_id":"tenant_id123"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 854         createportresponse = requests.post(url, data=createportdata, headers=headers)
 855         self.assertEqual(createportresponse.status_code, 201)
 856         print (createportresponse.content)
 857         self.assertEqual(json.loads(createportresponse.content)["port"]["name"], "new_port")
 858         print(" ")
 859
 860         print('->>>>>>> test Neutron Create Port With Existing Name ->>>>>>>>>>>>>>>')
 861         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 862         url = "http://0.0.0.0:19696/v2.0/ports"
 863         createportwithexistingnamedata = '{"port": {"name": "new_port", "network_id": "%s"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 864         createportwithexistingnameresponse = requests.post(url, data=createportwithexistingnamedata, headers=headers)
 865         self.assertEqual(createportwithexistingnameresponse.status_code, 500)
 866         print(" ")
 867
 868         print('->>>>>>> test Neutron Create Port Without Name ->>>>>>>>>>>>>>>')
 869         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 870         url = "http://0.0.0.0:19696/v2.0/ports"
 871         createportdatawithoutname = '{"port": {"network_id": "%s"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 872         createportwithoutnameresponse = requests.post(url, data=createportdatawithoutname, headers=headers)
 873         self.assertEqual(createportwithoutnameresponse.status_code, 201)
 874         self.assertIn("port:cp", json.loads(createportwithoutnameresponse.content)["port"]["name"])
 875         print(" ")
 876
 877         print('->>>>>>> test Neutron Update Port ->>>>>>>>>>>>>>>')
 878         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 879         print(json.loads(createportresponse.content)["port"]["name"])
 880         url = "http://0.0.0.0:19696/v2.0/ports/%s" % (json.loads(createportresponse.content)["port"]["name"])
 881         updateportdata = '{"port": {"name": "new_port_new_name", "admin_state_up":true, "device_id":"device_id123", "device_owner":"device_owner123", "fixed_ips":"change_me","mac_address":"12:34:56:78:90", "status":"change_me", "tenant_id":"tenant_id123", "network_id":"network_id123"} }'
 882         updateportresponse = requests.put(url, data=updateportdata, headers=headers)
 883         self.assertEqual(updateportresponse.status_code, 200)
 884         self.assertEqual(json.loads(updateportresponse.content)["port"]["name"], "new_port_new_name")
 885         print(" ")
 886
 887         print('->>>>>>> test Neutron Update Non-Existing Port ->>>>>>>>>>>>>>>')
 888         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 889         url = "http://0.0.0.0:19696/v2.0/ports/non-existing-port-ip"
 890         updatenonexistingportdata = '{"port": {"name": "new_port_new_name"} }'
 891         updatenonexistingportresponse = requests.put(url, data=updatenonexistingportdata, headers=headers)
 892         self.assertEqual(updatenonexistingportresponse.status_code, 404)
 893         print(" ")
 894
 895         print('->>>>>>> test Neutron Delete Port ->>>>>>>>>>>>>>>')
 896         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 897         righturl = "http://0.0.0.0:19696/v2.0/ports/%s" % (json.loads(createportresponse.content)["port"]["id"])
 898         deleterightportresponse = requests.delete(righturl, headers=headers)
 899         self.assertEqual(deleterightportresponse.status_code, 204)
 900         print(" ")
 901
 902
 903         print('->>>>>>> test Neutron Delete Non-Existing Port ->>>>>>>>>>>>>>>')
 904         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 905         wrongurl = "http://0.0.0.0:19696/v2.0/ports/unknownid"
 906         deletewrongportresponse = requests.delete(wrongurl, headers=headers)
 907         self.assertEqual(deletewrongportresponse.status_code, 404)
 908         print(" ")
 909
 910         print('->>>>>>> test Neutron Delete Subnet ->>>>>>>>>>>>>>>')
 911         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 912         wrongurl = "http://0.0.0.0:19696/v2.0/subnets/unknownid"
 913         righturl = "http://0.0.0.0:19696/v2.0/subnets/%s" % (json.loads(updatesubnetresponse.content)["subnet"]["id"])
 914         deletewrongsubnetresponse = requests.delete(wrongurl, headers=headers)
 915         deleterightsubnetresponse = requests.delete(righturl, headers=headers)
 916         self.assertEqual(deletewrongsubnetresponse.status_code, 404)
 917         self.assertEqual(deleterightsubnetresponse.status_code, 204)
 918         print(" ")
 919
 920         print('->>>>>>> test Neutron Delete Network ->>>>>>>>>>>>>>>')
 921         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 922         righturl = "http://0.0.0.0:19696/v2.0/networks/%s" % (json.loads(createnetworkresponse.content)["network"]["id"])
 923         deleterightnetworkresponse = requests.delete(righturl, headers=headers)
 924         self.assertEqual(deleterightnetworkresponse.status_code, 204)
 925         print(" ")
 926
 927         print('->>>>>>> test Neutron Delete Non-Existing Network ->>>>>>>>>>>>>>>')
 928         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 929         wrongurl = "http://0.0.0.0:19696/v2.0/networks/unknownid"
 930         deletewrongnetworkresponse = requests.delete(wrongurl, headers=headers)
 931         self.assertEqual(deletewrongnetworkresponse.status_code, 404)
 932         print(" ")
 933
 934     def testKeystomeDummy(self):
 935         print('->>>>>>> test Keystone Dummy Class->>>>>>>>>>>>>>>')
 936         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 937         print(" ")
 938
 939         headers = {'Content-type': 'application/json'}
 940         test_heatapi_keystone_get_token = open(os.path.join(os.path.dirname(__file__), "test_heatapi_keystone_get_token.json")).read()
 941
 942         print('->>>>>>> test Keystone List Versions ->>>>>>>>>>>>>>>')
 943         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 944         url = "http://0.0.0.0:15000/"
 945         listapiversionstackresponse = requests.get(url, headers=headers)
 946         self.assertEqual(listapiversionstackresponse.status_code, 200)
 947         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"]["values"][0]["id"], "v2.0")
 948         print(" ")
 949
 950         print('->>>>>>> test Keystone Show ApiV2 ->>>>>>>>>>>>>>>')
 951         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 952         url = "http://0.0.0.0:15000/v2.0"
 953         showapiversionstackresponse = requests.get(url, headers=headers)
 954         self.assertEqual(showapiversionstackresponse.status_code, 200)
 955         self.assertEqual(json.loads(showapiversionstackresponse.content)["version"]["id"], "v2.0")
 956         print(" ")
 957
 958         print('->>>>>>> test Keystone Get Token ->>>>>>>>>>>>>>>')
 959         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 960         url = "http://0.0.0.0:15000/v2.0/tokens"
 961         gettokenstackresponse = requests.post(url, data=json.dumps(json.loads(test_heatapi_keystone_get_token)), headers=headers)
 962         self.assertEqual(gettokenstackresponse.status_code, 200)
 963         self.assertEqual(json.loads(gettokenstackresponse.content)["access"]["user"]["name"], "tenantName")
 964         print(" ")
 965
 966
 967     def testHeatDummy(self):
 968         print('->>>>>>> test Heat Dummy Class->>>>>>>>>>>>>>>')
 969         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 970         print(" ")
 971
 972         headers = {'Content-type': 'application/json'}
 973         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_create_stack.json")).read()
 974         test_heatapi_template_update_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_update_stack.json")).read()
 975
 976         print('->>>>>>> test Heat List API Versions Stack ->>>>>>>>>>>>>>>')
 977         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 978         url = "http://0.0.0.0:18004/"
 979         listapiversionstackresponse = requests.get(url, headers=headers)
 980         self.assertEqual(listapiversionstackresponse.status_code, 200)
 981         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"][0]["id"], "v1.0")
 982         print(" ")
 983
 984         print('->>>>>>> test Create Stack ->>>>>>>>>>>>>>>')
 985         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 986         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 987         createstackresponse = requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)), headers=headers)
 988         self.assertEqual(createstackresponse.status_code, 201)
 989         self.assertNotEqual(json.loads(createstackresponse.content)["stack"]["id"], "")
 990         print(" ")
 991
 992         print('->>>>>>> test Create Stack With Existing Name ->>>>>>>>>>>>>>>')
 993         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 994         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 995         createstackwithexistingnameresponse = requests.post(url, data='{"stack_name" : "s1"}', headers=headers)
 996         self.assertEqual(createstackwithexistingnameresponse.status_code, 409)
 997         print(" ")
 998
 999         print('->>>>>>> test Create Stack With Unsupported Version ->>>>>>>>>>>>>>>')
1000         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1001         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
1002         createstackwitheunsupportedversionresponse = requests.post(url, data='{"stack_name" : "stackname123", "template" : {"heat_template_version": "2015-04-29"}}', headers=headers)
1003         self.assertEqual(createstackwitheunsupportedversionresponse.status_code, 400)
1004         print(" ")
1005
1006
1007         print('->>>>>>> test List Stack ->>>>>>>>>>>>>>>')
1008         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1009         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
1010         liststackresponse = requests.get(url, headers=headers)
1011         self.assertEqual(liststackresponse.status_code, 200)
1012         self.assertEqual(json.loads(liststackresponse.content)["stacks"][0]["stack_status"], "CREATE_COMPLETE")
1013         print(" ")
1014
1015
1016         print('->>>>>>> test Show Stack ->>>>>>>>>>>>>>>')
1017         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1018         url = "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s"% json.loads(createstackresponse.content)['stack']['id']
1019         liststackdetailsresponse = requests.get(url, headers=headers)
1020         self.assertEqual(liststackdetailsresponse.status_code, 200)
1021         self.assertEqual(json.loads(liststackdetailsresponse.content)["stack"]["stack_status"], "CREATE_COMPLETE")
1022         print(" ")
1023
1024         print('->>>>>>> test Show Non-Exisitng Stack ->>>>>>>>>>>>>>>')
1025         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1026         url = "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/non_exisitng_id123"
1027         listnonexistingstackdetailsresponse = requests.get(url, headers=headers)
1028         self.assertEqual(listnonexistingstackdetailsresponse.status_code, 404)
1029         print(" ")
1030
1031         print('->>>>>>> test Update Stack ->>>>>>>>>>>>>>>')
1032         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1033         url = "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/%s"% json.loads(createstackresponse.content)['stack']['id']
1034         updatestackresponse = requests.put(url, data=json.dumps(json.loads(test_heatapi_template_update_stack)),
1035                                             headers=headers)
1036         self.assertEqual(updatestackresponse.status_code, 202)
1037         liststackdetailsresponse = requests.get(url, headers=headers)
1038         self.assertEqual(json.loads(liststackdetailsresponse.content)["stack"]["stack_status"], "UPDATE_COMPLETE")
1039         print(" ")
1040
1041         print('->>>>>>> test Update Non-Existing Stack ->>>>>>>>>>>>>>>')
1042         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1043         url = "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/non_existing_id_1234"
1044         updatenonexistingstackresponse = requests.put(url, data={"non": "sense"}, headers=headers)
1045         self.assertEqual(updatenonexistingstackresponse.status_code, 404)
1046         print(" ")
1047
1048         print('->>>>>>> test Delete Stack ->>>>>>>>>>>>>>>')
1049         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1050         url = "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s" % \
1051               json.loads(createstackresponse.content)['stack']['id']
1052         deletestackdetailsresponse = requests.delete(url, headers=headers)
1053         self.assertEqual(deletestackdetailsresponse.status_code, 204)
1054         print(" ")
1055
1056
1057     def test_CombinedTesting(self):
1058         print('->>>>>>> test Combinded tests->>>>>>>>>>>>>>>')
1059         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1060         print(" ")
1061
1062         headers = {'Content-type': 'application/json'}
1063         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__),
1064                                                                "test_heatapi_template_create_stack.json")).read()
1065         test_heatapi_template_update_stack = open(os.path.join(os.path.dirname(__file__),
1066                                                                "test_heatapi_template_update_stack.json")).read()
1067
1068         print('->>>>>>> test Combined Create Stack ->>>>>>>>>>>>>>>')
1069         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1070         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
1071         createstackresponse = requests.post(url,
1072                                             data=json.dumps(json.loads(test_heatapi_template_create_stack)),
1073                                             headers=headers)
1074         self.assertEqual(createstackresponse.status_code, 201)
1075         self.assertNotEqual(json.loads(createstackresponse.content)["stack"]["id"], "")
1076         print(" ")
1077
1078         print('->>>>>>> test Combined Neutron List Ports ->>>>>>>>>>>>>>>')
1079         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1080         url = "http://0.0.0.0:19696/v2.0/ports"
1081         listportsesponse = requests.get(url, headers=headers)
1082         self.assertEqual(listportsesponse.status_code, 200)
1083         self.assertEqual(len(json.loads(listportsesponse.content)["ports"]), 9)
1084         for port in json.loads(listportsesponse.content)["ports"]:
1085             self.assertEqual(len(str(port['fixed_ips'][0]['subnet_id'])), 36)
1086         print(" ")
1087
1088         print('->>>>>>> test Combined Neutron List Networks ->>>>>>>>>>>>>>>')
1089         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1090         url = "http://0.0.0.0:19696/v2.0/networks"
1091         listnetworksesponse = requests.get(url, headers=headers)
1092         self.assertEqual(listnetworksesponse.status_code, 200)
1093         self.assertEqual(len(json.loads(listnetworksesponse.content)["networks"]), 10)
1094         for net in json.loads(listnetworksesponse.content)["networks"]:
1095             self.assertEqual(len(str(net['subnets'][0])), 36)
1096         print(" ")
1097
1098         print('->>>>>>> test Combined Update Stack ->>>>>>>>>>>>>>>')
1099         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1100         url = "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/%s"% \
1101               json.loads(createstackresponse.content)['stack']['id']
1102         updatestackresponse = requests.put(url,
1103                                            data=json.dumps(json.loads(test_heatapi_template_update_stack)),
1104                                            headers=headers)
1105         self.assertEqual(updatestackresponse.status_code, 202)
1106         liststackdetailsresponse = requests.get(url, headers=headers)
1107         self.assertEqual(json.loads(liststackdetailsresponse.content)["stack"]["stack_status"], "UPDATE_COMPLETE")
1108         print(" ")
1109
1110         print('->>>>>>> test Combined Neutron List Ports ->>>>>>>>>>>>>>>')
1111         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1112         url = "http://0.0.0.0:19696/v2.0/ports"
1113         listportsesponse = requests.get(url, headers=headers)
1114         self.assertEqual(listportsesponse.status_code, 200)
1115         self.assertEqual(len(json.loads(listportsesponse.content)["ports"]), 9)
1116         for port in json.loads(listportsesponse.content)["ports"]:
1117             self.assertEqual(len(str(port['fixed_ips'][0]['subnet_id'])), 36)
1118         print(" ")
1119
1120         print('->>>>>>> test Combined Neutron List Networks ->>>>>>>>>>>>>>>')
1121         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1122         url = "http://0.0.0.0:19696/v2.0/networks"
1123         listnetworksesponse = requests.get(url, headers=headers)
1124         self.assertEqual(listnetworksesponse.status_code, 200)
1125         self.assertEqual(len(json.loads(listnetworksesponse.content)["networks"]), 14)
1126         for net in json.loads(listnetworksesponse.content)["networks"]:
1127             self.assertEqual(len(str(net['subnets'][0])), 36)
1128         print(" ")
1129
1130
1131         # workflow create floating ip and assign it to a server
1132
1133         print('->>>>>>> CombinedNeutronCreateFloatingIP ->>>>>>>>>>>>>>>')
1134         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1135         url = "http://0.0.0.0:19696/v2.0/floatingips"
1136         createflip = requests.post(url, headers=headers,
1137                                             data='{"floatingip":{"floating_network_id":"default"}}')
1138         self.assertEqual(createflip.status_code, 200)
1139         self.assertIsNotNone(json.loads(createflip.content)["floatingip"].get("port_id"))
1140         port_id = json.loads(createflip.content)["floatingip"].get("port_id")
1141         print(" ")
1142
1143         print('->>>>>>> CombinedNovaGetServer ->>>>>>>>>>>>>>>')
1144         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1145         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/detail"
1146         listserverapisdetailedresponse = requests.get(url, headers=headers)
1147         self.assertEqual(listserverapisdetailedresponse.status_code, 200)
1148         self.assertEqual(json.loads(listserverapisdetailedresponse.content)["servers"][0]["status"], "ACTIVE")
1149         server_id = json.loads(listserverapisdetailedresponse.content)["servers"][0]["id"]
1150         print(" ")
1151
1152         print('->>>>>>> CombinedNovaAssignInterface ->>>>>>>>>>>>>>>')
1153         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1154         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s/os-interface" % server_id
1155         assign = requests.post(url, headers=headers,
1156                                             data='{"interfaceAttachment":{"net_id": "default"}}')
1157         self.assertEqual(assign.status_code, 202)
1158         self.assertIsNotNone(json.loads(assign.content)["interfaceAttachment"].get("port_id"))
1159         port_id = json.loads(assign.content)["interfaceAttachment"].get("port_id")
1160         print(" ")
1161
1162         print('->>>>>>> CombinedNovaDeleteInterface ->>>>>>>>>>>>>>>')
1163         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1164         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s/os-interface/%s" % (server_id, port_id)
1165         getintfs = requests.delete(url, headers=headers)
1166         self.assertEqual(getintfs.status_code, 202)
1167         print(" ")
1168
1169     def testNeutronSFC(self):
1170         """
1171         Tests the Neutron Service Function Chaining implementation. As Some functions build up on others, a
1172         complete environment is created here:
1173
1174         Ports:              p1, p2, p3, p4
1175         Port Pairs:         pp1(p1, p2), pp2(p3, p4)
1176         Port Pair Groups:   ppg1(pp1, pp2)
1177         Flow Classifiers:   fc1
1178         Port Chain:         pc1(ppg1, fc1)
1179         """
1180
1181         headers = {'Content-type': 'application/json'}
1182
1183         print('->>>>>>> Create ports p1 - p4 ->>>>>>>>>>>>>>>')
1184         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1185         # Get network id
1186         network_resp = requests.get("http://0.0.0.0:19696/v2.0/networks?name=default", headers=headers)
1187         self.assertEqual(network_resp.status_code, 200)
1188         network_id = json.loads(network_resp.content)["networks"][0]["id"]
1189
1190         url = "http://0.0.0.0:19696/v2.0/ports"
1191         port_request = '{"port": {"name": "%s", "network_id": "%s"}}'
1192         p1_resp = requests.post(url, data=port_request % ("p1", network_id), headers=headers)
1193         self.assertEqual(p1_resp.status_code, 201)
1194         p2_resp = requests.post(url, data=port_request % ("p2", network_id), headers=headers)
1195         self.assertEqual(p2_resp.status_code, 201)
1196         p3_resp = requests.post(url, data=port_request % ("p3", network_id), headers=headers)
1197         self.assertEqual(p3_resp.status_code, 201)
1198         p4_resp = requests.post(url, data=port_request % ("p4", network_id), headers=headers)
1199         self.assertEqual(p4_resp.status_code, 201)
1200
1201         p1_id = json.loads(p1_resp.content)["port"]["id"]
1202         p2_id = json.loads(p2_resp.content)["port"]["id"]
1203         p3_id = json.loads(p3_resp.content)["port"]["id"]
1204         p4_id = json.loads(p4_resp.content)["port"]["id"]
1205
1206         print('->>>>>>> test Neutron SFC Port Pair Create ->>>>>>>>>>>>>>>')
1207         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1208         url = "http://0.0.0.0:19696/v2.0/sfc/port_pairs"
1209         pp1_resp = requests.post(url, data='{"port_pair": {"name": "pp1", "ingress": "%s", "egress": "%s"}}' % (p1_id, p2_id), headers=headers)
1210         self.assertEqual(pp1_resp.status_code, 201)
1211         pp2_resp = requests.post(url, data='{"port_pair": {"name": "pp2", "ingress": "%s", "egress": "%s"}}' % (p3_id, p4_id), headers=headers)
1212         self.assertEqual(pp2_resp.status_code, 201)
1213         pp3_resp = requests.post(url, data='{"port_pair": {"name": "pp3", "ingress": "%s", "egress": "%s"}}' % (p3_id, p4_id), headers=headers)
1214         self.assertEqual(pp3_resp.status_code, 201)
1215
1216         pp1_id = json.loads(pp1_resp.content)["port_pair"]["id"]
1217         pp2_id = json.loads(pp2_resp.content)["port_pair"]["id"]
1218         pp3_id = json.loads(pp3_resp.content)["port_pair"]["id"]
1219
1220         print('->>>>>>> test Neutron SFC Port Pair Update ->>>>>>>>>>>>>>>')
1221         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1222         url = "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp3_id
1223         pp3_update_resp = requests.put(url, data='{"port_pair": {"description": "port_pair_update"}}', headers=headers)
1224         self.assertEqual(pp3_update_resp.status_code, 200)
1225         self.assertEqual(json.loads(pp3_update_resp.content)["port_pair"]["description"], "port_pair_update")
1226
1227         print('->>>>>>> test Neutron SFC Port Pair Delete ->>>>>>>>>>>>>>>')
1228         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1229         url = "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp3_id
1230         pp3_delete_resp = requests.delete(url, headers=headers)
1231         self.assertEqual(pp3_delete_resp.status_code, 204)
1232
1233         print('->>>>>>> test Neutron SFC Port Pair List ->>>>>>>>>>>>>>>')
1234         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1235         url = "http://0.0.0.0:19696/v2.0/sfc/port_pairs"
1236         pp_list_resp = requests.get(url, headers=headers)
1237         self.assertEqual(pp_list_resp.status_code, 200)
1238         self.assertEqual(len(json.loads(pp_list_resp.content)["port_pairs"]), 2)  # only pp1 and pp2 should be left
1239
1240         print('->>>>>>> test Neutron SFC Port Pair Show ->>>>>>>>>>>>>>>')
1241         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1242         url = "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp2_id
1243         pp2_show_resp = requests.get(url, headers=headers)
1244         self.assertEqual(pp2_show_resp.status_code, 200)
1245         self.assertEqual(json.loads(pp2_show_resp.content)["port_pair"]["name"], "pp2")
1246
1247
1248         print('->>>>>>> test Neutron SFC Port Pair Group Create ->>>>>>>>>>>>>>>')
1249         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1250         url = "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups"
1251         ppg1_resp = requests.post(url, data='{"port_pair_group": {"name": "ppg1", "port_pairs": ["%s"]}}' % (pp1_id), headers=headers)
1252         self.assertEqual(ppg1_resp.status_code, 201)
1253         ppg2_resp = requests.post(url, data='{"port_pair_group": {"name": "ppg2", "port_pairs": ["%s"]}}' % (pp2_id), headers=headers)
1254         self.assertEqual(ppg2_resp.status_code, 201)
1255         ppg3_resp = requests.post(url, data='{"port_pair_group": {"name": "ppg3", "port_pairs": ["%s"]}}' % (pp2_id), headers=headers)
1256         self.assertEqual(ppg3_resp.status_code, 201)
1257
1258         ppg1_id = json.loads(ppg1_resp.content)["port_pair_group"]["id"]
1259         ppg2_id = json.loads(ppg2_resp.content)["port_pair_group"]["id"]
1260         ppg3_id = json.loads(ppg3_resp.content)["port_pair_group"]["id"]
1261
1262         print('->>>>>>> test Neutron SFC Port Pair Group Update ->>>>>>>>>>>>>>>')
1263         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1264         url = "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg3_id
1265         ppg3_update_resp = requests.put(url, data='{"port_pair_group": {"description": "port_pair_group_update"}}', headers=headers)
1266         self.assertEqual(ppg3_update_resp.status_code, 200)
1267         self.assertEqual(json.loads(ppg3_update_resp.content)["port_pair_group"]["description"], "port_pair_group_update")
1268
1269         print('->>>>>>> test Neutron SFC Port Pair Group Delete ->>>>>>>>>>>>>>>')
1270         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1271         url = "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg3_id
1272         ppg3_delete_resp = requests.delete(url, headers=headers)
1273         self.assertEqual(ppg3_delete_resp.status_code, 204)
1274
1275         print('->>>>>>> test Neutron SFC Port Pair Group List ->>>>>>>>>>>>>>>')
1276         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1277         url = "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups"
1278         ppg_list_resp = requests.get(url, headers=headers)
1279         self.assertEqual(ppg_list_resp.status_code, 200)
1280         self.assertEqual(len(json.loads(ppg_list_resp.content)["port_pair_groups"]), 2)  # only ppg1 and ppg2 should be left
1281
1282         print('->>>>>>> test Neutron SFC Port Pair Group Show ->>>>>>>>>>>>>>>')
1283         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1284         url = "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg2_id
1285         ppg2_show_resp = requests.get(url, headers=headers)
1286         self.assertEqual(ppg2_show_resp.status_code, 200)
1287         self.assertEqual(json.loads(ppg2_show_resp.content)["port_pair_group"]["name"], "ppg2")
1288
1289
1290         print('->>>>>>> test Neutron SFC Flow Classifier Create ->>>>>>>>>>>>>>>')
1291         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1292         url = "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers"
1293         fc1_resp = requests.post(url, data='{"flow_classifier": {"name": "fc1", "source_port_range_min": 22, "source_port_range_max": 4000}}', headers=headers)
1294         self.assertEqual(fc1_resp.status_code, 201)
1295         fc2_resp = requests.post(url, data='{"flow_classifier": {"name": "fc2", "source_port_range_min": 22, "source_port_range_max": 4000}}', headers=headers)
1296         self.assertEqual(fc2_resp.status_code, 201)
1297
1298         fc1_id = json.loads(fc1_resp.content)["flow_classifier"]["id"]
1299         fc2_id = json.loads(fc2_resp.content)["flow_classifier"]["id"]
1300
1301         print('->>>>>>> test Neutron SFC Flow Classifier Update ->>>>>>>>>>>>>>>')
1302         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1303         url = "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc2_id
1304         fc2_update_resp = requests.put(url, data='{"flow_classifier": {"description": "flow_classifier_update"}}', headers=headers)
1305         self.assertEqual(fc2_update_resp.status_code, 200)
1306         self.assertEqual(json.loads(fc2_update_resp.content)["flow_classifier"]["description"], "flow_classifier_update")
1307
1308         print('->>>>>>> test Neutron SFC Flow Classifier Delete ->>>>>>>>>>>>>>>')
1309         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1310         url = "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc2_id
1311         fc2_delete_resp = requests.delete(url, headers=headers)
1312         self.assertEqual(fc2_delete_resp.status_code, 204)
1313
1314         print('->>>>>>> test Neutron SFC Flow Classifier List ->>>>>>>>>>>>>>>')
1315         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1316         url = "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers"
1317         fc_list_resp = requests.get(url, headers=headers)
1318         self.assertEqual(fc_list_resp.status_code, 200)
1319         self.assertEqual(len(json.loads(fc_list_resp.content)["flow_classifiers"]), 1)  # only fc1
1320
1321         print('->>>>>>> test Neutron SFC Flow Classifier Show ->>>>>>>>>>>>>>>')
1322         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1323         url = "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc1_id
1324         fc1_show_resp = requests.get(url, headers=headers)
1325         self.assertEqual(fc1_show_resp.status_code, 200)
1326         self.assertEqual(json.loads(fc1_show_resp.content)["flow_classifier"]["name"], "fc1")
1327
1328
1329         print('->>>>>>> test Neutron SFC Port Chain Create ->>>>>>>>>>>>>>>')
1330         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1331         url = "http://0.0.0.0:19696/v2.0/sfc/port_chains"
1332         pc1_resp = requests.post(url, data='{"port_chain": {"name": "pc1", "port_pair_groups": ["%s"], "flow_classifiers": ["%s"]}}' % (ppg1_id, fc1_id), headers=headers)
1333         self.assertEqual(pc1_resp.status_code, 201)
1334         pc2_resp = requests.post(url, data='{"port_chain": {"name": "pc2", "port_pair_groups": ["%s"], "flow_classifiers": ["%s"]}}' % (ppg1_id, fc1_id), headers=headers)
1335         self.assertEqual(pc2_resp.status_code, 201)
1336
1337         pc1_id = json.loads(pc1_resp.content)["port_chain"]["id"]
1338         pc2_id = json.loads(pc2_resp.content)["port_chain"]["id"]
1339
1340         print('->>>>>>> test Neutron SFC Port Chain Update ->>>>>>>>>>>>>>>')
1341         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1342         url = "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc2_id
1343         pc2_update_resp = requests.put(url, data='{"port_chain": {"description": "port_chain_update"}}', headers=headers)
1344         self.assertEqual(pc2_update_resp.status_code, 200)
1345         self.assertEqual(json.loads(pc2_update_resp.content)["port_chain"]["description"], "port_chain_update")
1346
1347         print('->>>>>>> test Neutron SFC Port Chain Delete ->>>>>>>>>>>>>>>')
1348         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1349         url = "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc2_id
1350         pc2_delete_resp = requests.delete(url, headers=headers)
1351         self.assertEqual(pc2_delete_resp.status_code, 204)
1352
1353         print('->>>>>>> test Neutron SFC Port Chain List ->>>>>>>>>>>>>>>')
1354         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1355         url = "http://0.0.0.0:19696/v2.0/sfc/port_chains"
1356         pc_list_resp = requests.get(url, headers=headers)
1357         self.assertEqual(pc_list_resp.status_code, 200)
1358         self.assertEqual(len(json.loads(pc_list_resp.content)["port_chains"]), 1)  # only pc1
1359
1360         print('->>>>>>> test Neutron SFC Port Chain Show ->>>>>>>>>>>>>>>')
1361         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1362         url = "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc1_id
1363         pc1_show_resp = requests.get(url, headers=headers)
1364         self.assertEqual(pc1_show_resp.status_code, 200)
1365         self.assertEqual(json.loads(pc1_show_resp.content)["port_chain"]["name"], "pc1")
1366
1367 if __name__ == '__main__':
1368     unittest.main()