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         time.sleep(2)
  59
  60         # start Mininet network
  61         self.startNet()
  62         time.sleep(2)
  63
  64     @unittest.skip("temporarily disabled")
  65     def testChainingDummy(self):
  66         print('->>>>>>> test Chaining Class->>>>>>>>>>>>>>>')
  67         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  68         print(" ")
  69
  70         headers = {'Content-type': 'application/json'}
  71         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_chaining.json")).read()
  72         url = "http://0.0.0.0:8004/v1/tenantabc123/stacks"
  73         requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)), headers=headers)
  74
  75
  76         print('->>>>>>> test Chaining Versions ->>>>>>>>>>>>>>>')
  77         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  78         url = "http://0.0.0.0:4000/"
  79         listapiversionstackresponse = requests.get(url, headers=headers)
  80         self.assertEqual(listapiversionstackresponse.status_code, 200)
  81         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"][0]["id"], "v1")
  82         print(" ")
  83
  84         print('->>>>>>> test Chaining List ->>>>>>>>>>>>>>>')
  85         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  86         url = "http://0.0.0.0:4000/v1/chain/list"
  87         chainlistresponse = requests.get(url, headers=headers)
  88         self.assertEqual(chainlistresponse.status_code, 200)
  89         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
  90         print(" ")
  91
  92         print('->>>>>>> test Loadbalancing List ->>>>>>>>>>>>>>>')
  93         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
  94         url = "http://0.0.0.0:4000/v1/lb/list"
  95         lblistresponse = requests.get(url, headers=headers)
  96         self.assertEqual(lblistresponse.status_code, 200)
  97         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"], [])
  98         print(" ")
  99
 100         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/iper-in-0"
 101         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 102         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 103         url = "http://0.0.0.0:4000/v1/chain/%s" %(testchain)
 104         chainvnfresponse = requests.put(url)
 105         self.assertEqual(chainvnfresponse.status_code, 200)
 106         self.assertGreaterEqual(json.loads(chainvnfresponse.content)["cookie"], 0)
 107         print(" ")
 108
 109         print('->>>>>>> test Chaining List ->>>>>>>>>>>>>>>')
 110         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 111         url = "http://0.0.0.0:4000/v1/chain/list"
 112         chainlistresponse = requests.get(url, headers=headers)
 113         self.assertEqual(chainlistresponse.status_code, 200)
 114         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_vnf"], "dc0_s1_firewall1")
 115         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_intf"], "fire-out-0")
 116         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_vnf"], "dc0_s1_iperf1")
 117         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_intf"], "iper-in-0")
 118         print(" ")
 119
 120         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 121         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 122         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 123         deletechainvnfresponse = requests.delete(url)
 124         self.assertEqual(deletechainvnfresponse.status_code, 200)
 125         self.assertEqual(deletechainvnfresponse.content, "true")
 126         print(" ")
 127
 128         print('->>>>>>> test Chaining List If Empty Again ->>>>>>>>>>>>>>>')
 129         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 130         url = "http://0.0.0.0:4000/v1/chain/list"
 131         chainlistresponse = requests.get(url, headers=headers)
 132         self.assertEqual(chainlistresponse.status_code, 200)
 133         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
 134         print(" ")
 135
 136         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/iper-in-0"
 137         print('->>>>>>> test Stack Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 138         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 139         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 140         stackchainvnfresponse = requests.post(url, data=json.dumps(json.loads('{"path":["dc1.s1", "s1","s2","s3","s1","dc1.s1"]}')), headers=headers)
 141         self.assertEqual(stackchainvnfresponse.status_code, 200)
 142         print (stackchainvnfresponse.content)
 143         self.assertGreaterEqual(json.loads(stackchainvnfresponse.content)["cookie"], 0)
 144         print(" ")
 145
 146
 147         print('->>>>>>> test Stack Chaining List ->>>>>>>>>>>>>>>')
 148         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 149         url = "http://0.0.0.0:4000/v1/chain/list"
 150         chainlistresponse = requests.get(url, headers=headers)
 151         self.assertEqual(chainlistresponse.status_code, 200)
 152         print (chainlistresponse.content)
 153         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_vnf"], "dc0_s1_firewall1")
 154         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["dst_intf"], "fire-out-0")
 155         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_vnf"], "dc0_s1_iperf1")
 156         self.assertEqual(json.loads(chainlistresponse.content)["chains"][0]["src_intf"], "iper-in-0")
 157         self.assertItemsEqual(json.loads(chainlistresponse.content)["chains"][0]["path"],['dc1.s1', 's1', 's2', 's3', 's1', 'dc1.s1'])
 158         print(" ")
 159
 160         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 161         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 162         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 163         deletechainvnfresponse = requests.delete(url)
 164         self.assertEqual(deletechainvnfresponse.status_code, 200)
 165         self.assertEqual(deletechainvnfresponse.content, "true")
 166         print(" ")
 167
 168         print('->>>>>>> test Chaining List If Empty Again ->>>>>>>>>>>>>>>')
 169         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 170         url = "http://0.0.0.0:4000/v1/chain/list"
 171         chainlistresponse = requests.get(url, headers=headers)
 172         self.assertEqual(chainlistresponse.status_code, 200)
 173         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
 174         print(" ")
 175
 176
 177         testchain = "dc0_s1_firewall1/non-existing-interface/dc0_s1_iperf1/iper-in-0"
 178         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 179         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 180         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 181         chainvnfresponse = requests.put(url)
 182         self.assertEqual(chainvnfresponse.status_code, 501)
 183         print(" ")
 184
 185         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/non-existing-interface"
 186         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 187         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 188         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 189         chainvnfresponse = requests.put(url)
 190         self.assertEqual(chainvnfresponse.status_code, 501)
 191         print(" ")
 192
 193         testchain = "dc0_s1_firewall1/non-existing-interface/dc0_s1_iperf1/iper-in-0"
 194         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 195         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 196         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 197         deletechainvnfresponse = requests.delete(url)
 198         self.assertEqual(deletechainvnfresponse.status_code, 501)
 199         print(" ")
 200
 201         testchain = "dc0_s1_firewall1/fire-out-0/dc0_s1_iperf1/non-existing-interface"
 202         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 203         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 204         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 205         deletechainvnfresponse = requests.delete(url)
 206         self.assertEqual(deletechainvnfresponse.status_code, 501)
 207         print(" ")
 208
 209         testchain = "non-existent-dc/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 210         print('->>>>>>> test Chain VNF Non-Existing DC ->>>>>>>>>>>>>>>')
 211         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 212         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 213         chainvnfresponse = requests.put(url)
 214         self.assertEqual(chainvnfresponse.status_code, 500)
 215         print(" ")
 216
 217
 218         testchain = "dc0/s1/firewall1/non-existent:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 219         print('->>>>>>> test Chain VNF Non-Existing Interfaces ->>>>>>>>>>>>>>>')
 220         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 221         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 222         chainvnfresponse = requests.put(url)
 223         self.assertEqual(chainvnfresponse.status_code, 500)
 224         print(" ")
 225
 226         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/non-existent:cp02:input"
 227         print('->>>>>>> test Chain VNF Non-Existing Interfaces ->>>>>>>>>>>>>>>')
 228         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 229         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 230         chainvnfresponse = requests.put(url)
 231         self.assertEqual(chainvnfresponse.status_code, 500)
 232         print(" ")
 233
 234         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 235         print('->>>>>>> test Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 236         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 237         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 238         chainvnfresponse = requests.put(url)
 239         print (chainvnfresponse.content)
 240         self.assertEqual(chainvnfresponse.status_code, 200)
 241         self.assertGreaterEqual(json.loads(chainvnfresponse.content)["cookie"], 0)
 242         print(" ")
 243
 244         print('->>>>>>> test Chain VNF Delete Chain ->>>>>>>>>>>>>>>')
 245         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 246         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 247         deletechainvnfresponse = requests.delete(url)
 248         self.assertEqual(deletechainvnfresponse.status_code, 200)
 249         self.assertEqual(deletechainvnfresponse.content, "true")
 250         print(" ")
 251
 252         print('->>>>>>> test Chaining List If Empty Again ->>>>>>>>>>>>>>>')
 253         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 254         url = "http://0.0.0.0:4000/v1/chain/list"
 255         chainlistresponse = requests.get(url, headers=headers)
 256         self.assertEqual(chainlistresponse.status_code, 200)
 257         self.assertEqual(json.loads(chainlistresponse.content)["chains"], [])
 258         print(" ")
 259
 260         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 261         print('->>>>>>> test Stack Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 262         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 263         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 264         stackchainvnfresponse = requests.post(url, data=json.dumps(
 265             json.loads('{"path":["dc1.s1", "s1","s2","s3","s1","dc1.s1"]}')), headers=headers)
 266         self.assertEqual(stackchainvnfresponse.status_code, 200)
 267         print (stackchainvnfresponse.content)
 268         self.assertGreaterEqual(json.loads(stackchainvnfresponse.content)["cookie"], 0)
 269         print(" ")
 270
 271         testchain = "dc0/s1/firewall1/firewall1:cp03:output/dc0/s1/iperf1/iperf1:cp02:input"
 272         print('->>>>>>> test Stack Chain VNF Interfaces ->>>>>>>>>>>>>>>')
 273         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 274         url = "http://0.0.0.0:4000/v1/chain/%s" % (testchain)
 275         stackchainvnfresponse = requests.delete(url, headers=headers)
 276         self.assertEqual(stackchainvnfresponse.status_code, 200)
 277         print(" ")
 278
 279
 280         print('->>>>>>> test Loadbalancing ->>>>>>>>>>>>>>>')
 281         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 282         url = "http://0.0.0.0:4000/v1/lb/dc0/s1/firewall1/firewall1:cp03:output"
 283         lblistresponse = requests.post(url, data=json.dumps(
 284             {"dst_vnf_interfaces":[{"pop":"dc0","stack":"s1","server":"iperf1","port":"iperf1:cp02:input"}]})
 285             , headers=headers)
 286         print (lblistresponse.content)
 287         self.assertEqual(lblistresponse.status_code, 200)
 288         self.assertIn("dc0_s1_firewall1:fire-out-0", lblistresponse.content)
 289         print(" ")
 290
 291         print('->>>>>>> test Loadbalancing List ->>>>>>>>>>>>>>>')
 292         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 293         url = "http://0.0.0.0:4000/v1/lb/list"
 294         lblistresponse = requests.get(url, headers=headers)
 295         self.assertEqual(lblistresponse.status_code, 200)
 296         print (lblistresponse.content )
 297         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_vnf"], "dc0_s1_iperf1")
 298         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_intf"], "iper-in-0")
 299         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_vnf"], "dc0_s1_firewall1")
 300         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_intf"],"fire-out-0")
 301         print(" ")
 302
 303         print('->>>>>>> test delete Loadbalancing ->>>>>>>>>>>>>>>')
 304         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 305         url = "http://0.0.0.0:4000/v1/lb/dc0/s1/firewall1/firewall1:cp03:output"
 306         lbdeleteresponse = requests.delete(url, headers=headers)
 307         print (lbdeleteresponse.content)
 308         self.assertEqual(lbdeleteresponse.status_code, 200)
 309         print(" ")
 310
 311         print('->>>>>>> testFloatingLoadbalancer ->>>>>>>>>>>>>>>')
 312         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 313         url = "http://0.0.0.0:4000/v1/lb/dc0/floating/bla/blubb"
 314         lblistresponse = requests.post(url, data=json.dumps(
 315             {"dst_vnf_interfaces":[{"pop":"dc0","stack":"s1","server":"iperf1","port":"iperf1:cp02:input"}]})
 316             , headers=headers)
 317         print (lblistresponse.content)
 318         self.assertEqual(lblistresponse.status_code, 200)
 319         resp = json.loads(lblistresponse.content)
 320         self.assertIsNotNone(resp.get('cookie'))
 321         self.assertIsNotNone(resp.get('floating_ip'))
 322         cookie = resp.get('cookie')
 323         print(" ")
 324
 325         print('->>>>>>> testDeleteFloatingLoadbalancer ->>>>>>>>>>>>>>>')
 326         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 327         url = "http://0.0.0.0:4000/v1/lb/dc0/floating/%s/blubb" % cookie
 328         lblistresponse = requests.delete(url, headers=headers)
 329         print (lblistresponse.content)
 330         self.assertEqual(lblistresponse.status_code, 200)
 331         print(" ")
 332
 333         print('->>>>>>> testLoadbalancingCustomPath ->>>>>>>>>>>>>>>')
 334         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 335         url = "http://0.0.0.0:4000/v1/lb/dc0_s1_firewall1/fire-out-0"
 336         lblistresponse = requests.post(url, data=json.dumps(
 337             {"dst_vnf_interfaces":{"dc0_s1_iperf1":"iper-in-0"},
 338              "path": {"dc0_s1_iperf1": {"iper-in-0": ["dc1.s1", "s1","s2","s3","s1","dc1.s1"]}}}), headers=headers)
 339         print (lblistresponse.content)
 340         self.assertEqual(lblistresponse.status_code, 200)
 341         self.assertIn("dc0_s1_firewall1:fire-out-0", lblistresponse.content)
 342         print(" ")
 343
 344         print('->>>>>>> testLoadbalancingListCustomPath ->>>>>>>>>>>>>>>')
 345         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 346         url = "http://0.0.0.0:4000/v1/lb/list"
 347         lblistresponse = requests.get(url, headers=headers)
 348         self.assertEqual(lblistresponse.status_code, 200)
 349         print (lblistresponse.content )
 350         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_vnf"], "dc0_s1_iperf1")
 351         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["dst_intf"], "iper-in-0")
 352         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["paths"][0]["path"],
 353                          ["dc1.s1", "s1","s2","s3","s1","dc1.s1"] )
 354         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_vnf"], "dc0_s1_firewall1")
 355         self.assertEqual(json.loads(lblistresponse.content)["loadbalancers"][0]["src_intf"],"fire-out-0")
 356         print(" ")
 357
 358
 359         print('->>>>>>> test Delete Loadbalancing ->>>>>>>>>>>>>>>')
 360         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 361         url = "http://0.0.0.0:4000/v1/lb/dc0_s1_firewall1/fire-out-0"
 362         lblistresponse = requests.delete(url, headers=headers)
 363         self.assertEqual(lblistresponse.status_code, 200)
 364         print(" ")
 365
 366         print('->>>>>>> test Query Topology ->>>>>>>>>>>>>>>')
 367         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 368         url = "http://0.0.0.0:4000/v1/topo"
 369         topolistresponse = requests.get(url, headers=headers)
 370         print(topolistresponse.content)
 371         self.assertEqual(topolistresponse.status_code, 200)
 372         print(" ")
 373
 374
 375     def testNovaDummy(self):
 376         print('->>>>>>> test Nova Dummy Class->>>>>>>>>>>>>>>')
 377         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 378         print(" ")
 379
 380         headers = {'Content-type': 'application/json'}
 381         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_create_stack.json")).read()
 382         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 383         requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)),
 384                       headers=headers)
 385
 386         print('->>>>>>> test Nova List Versions ->>>>>>>>>>>>>>>')
 387         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 388         url = "http://0.0.0.0:18774/"
 389         listapiversionnovaresponse = requests.get(url, headers=headers)
 390         self.assertEqual(listapiversionnovaresponse.status_code, 200)
 391         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["id"], "v2.1")
 392         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["status"], "CURRENT")
 393         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["version"], "2.38")
 394         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["min_version"], "2.1")
 395         self.assertEqual(json.loads(listapiversionnovaresponse.content)["versions"][0]["updated"], "2013-07-23T11:33:21Z")
 396         print(" ")
 397
 398         print('->>>>>>> test Nova Version Show ->>>>>>>>>>>>>>>')
 399         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 400         url = "http://0.0.0.0:18774/v2.1/id_bla"
 401         listapiversion21novaresponse = requests.get(url, headers=headers)
 402         self.assertEqual(listapiversion21novaresponse.status_code, 200)
 403         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["id"], "v2.1")
 404         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["status"], "CURRENT")
 405         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["version"], "2.38")
 406         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["min_version"], "2.1")
 407         self.assertEqual(json.loads(listapiversion21novaresponse.content)["version"]["updated"], "2013-07-23T11:33:21Z")
 408         print(" ")
 409
 410         print('->>>>>>> test Nova Version List Server APIs ->>>>>>>>>>>>>>>')
 411         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 412         url = "http://0.0.0.0:18774/v2.1/id_bla/servers"
 413         listserverapisnovaresponse = requests.get(url, headers=headers)
 414         self.assertEqual(listserverapisnovaresponse.status_code, 200)
 415         self.assertNotEqual(json.loads(listserverapisnovaresponse.content)["servers"][0]["name"], "")
 416         print(" ")
 417
 418         print('->>>>>>> test Nova Delete Server APIs ->>>>>>>>>>>>>>>')
 419         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 420         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json.loads(listserverapisnovaresponse.content)["servers"][0]["id"])
 421         deleteserverapisnovaresponse = requests.delete(url, headers=headers)
 422         self.assertEqual(deleteserverapisnovaresponse.status_code, 204)
 423         print(" ")
 424
 425         print('->>>>>>> test Nova Delete Non-Existing Server APIs ->>>>>>>>>>>>>>>')
 426         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 427         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/non-existing-ix"
 428         deleteserverapisnovaresponse = requests.delete(url, headers=headers)
 429         self.assertEqual(deleteserverapisnovaresponse.status_code, 404)
 430         print(" ")
 431
 432
 433         print('->>>>>>> testNovaVersionListServerAPIs_withPortInformation ->>>>>>>>>>>>>>>')
 434         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 435         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/andPorts"
 436         listserverapisnovaresponse = requests.get(url, headers=headers)
 437         self.assertEqual(listserverapisnovaresponse.status_code, 200)
 438         self.assertNotEqual(json.loads(listserverapisnovaresponse.content)["servers"][0]["name"], "")
 439         print(" ")
 440
 441         print('->>>>>>> test Nova List Flavors ->>>>>>>>>>>>>>>')
 442         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 443         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors"
 444         listflavorsresponse = requests.get(url, headers=headers)
 445         self.assertEqual(listflavorsresponse.status_code, 200)
 446         self.assertIn(json.loads(listflavorsresponse.content)["flavors"][0]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 447         self.assertIn(json.loads(listflavorsresponse.content)["flavors"][1]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 448         self.assertIn(json.loads(listflavorsresponse.content)["flavors"][2]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 449         print(" ")
 450
 451         print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
 452         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 453         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors"
 454         addflavorsresponse = requests.post(url,
 455                                            data='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
 456                                            headers=headers)
 457         self.assertEqual(addflavorsresponse.status_code, 200)
 458         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["id"])
 459         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["links"][0]['href'])
 460         print(" ")
 461
 462         print('->>>>>>> test Nova List Flavors Detail ->>>>>>>>>>>>>>>')
 463         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 464         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
 465         listflavorsdetailresponse = requests.get(url, headers=headers)
 466         self.assertEqual(listflavorsdetailresponse.status_code, 200)
 467         self.assertIn(json.loads(listflavorsdetailresponse.content)["flavors"][0]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 468         self.assertIn(json.loads(listflavorsdetailresponse.content)["flavors"][1]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 469         self.assertIn(json.loads(listflavorsdetailresponse.content)["flavors"][2]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
 470         print(" ")
 471
 472         print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
 473         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 474         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
 475         addflavorsresponse = requests.post(url,
 476                                            data='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
 477                                            headers=headers)
 478         self.assertEqual(addflavorsresponse.status_code, 200)
 479         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["id"])
 480         self.assertIsNotNone(json.loads(addflavorsresponse.content)["flavor"]["links"][0]['href'])
 481         print(" ")
 482
 483         print('->>>>>>> test Nova List Flavor By Id ->>>>>>>>>>>>>>>')
 484
 485         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 486         url = "http://0.0.0.0:18774/v2.1/id_bla/flavors/%s" % (json.loads(listflavorsdetailresponse.content)["flavors"][0]["name"])
 487         listflavorsbyidresponse = requests.get(url, headers=headers)
 488         self.assertEqual(listflavorsbyidresponse.status_code, 200)
 489         self.assertEqual(json.loads(listflavorsbyidresponse.content)["flavor"]["id"], json.loads(listflavorsdetailresponse.content)["flavors"][0]["id"])
 490         print(" ")
 491
 492         print('->>>>>>> test Nova List Images ->>>>>>>>>>>>>>>')
 493         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 494         url = "http://0.0.0.0:18774/v2.1/id_bla/images"
 495         listimagesresponse = requests.get(url, headers=headers)
 496         self.assertEqual(listimagesresponse.status_code, 200)
 497         print(listimagesresponse.content)
 498         # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
 499         #self.assertIn(json.loads(listimagesresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 500         #self.assertIn(json.loads(listimagesresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 501         #self.assertIn(json.loads(listimagesresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 502         print(" ")
 503
 504         print('->>>>>>> test Nova List Images Details ->>>>>>>>>>>>>>>')
 505         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 506         url = "http://0.0.0.0:18774/v2.1/id_bla/images/detail"
 507         listimagesdetailsresponse = requests.get(url, headers=headers)
 508         self.assertEqual(listimagesdetailsresponse.status_code, 200)
 509         # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
 510         #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 511         #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 512         #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
 513         self.assertEqual(json.loads(listimagesdetailsresponse.content)["images"][0]["metadata"]["architecture"],"x86_64")
 514         print(" ")
 515
 516         print('->>>>>>> test Nova List Image By Id ->>>>>>>>>>>>>>>')
 517         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 518         url = "http://0.0.0.0:18774/v2.1/id_bla/images/%s" % (json.loads(listimagesdetailsresponse.content)["images"][0]["id"])
 519         listimagebyidresponse = requests.get(url, headers=headers)
 520         self.assertEqual(listimagebyidresponse.status_code, 200)
 521         self.assertEqual(json.loads(listimagebyidresponse.content)["image"]["id"],json.loads(listimagesdetailsresponse.content)["images"][0]["id"])
 522         print(" ")
 523
 524         print('->>>>>>> test Nova List Image By Non-Existend Id ->>>>>>>>>>>>>>>')
 525         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 526         url = "http://0.0.0.0:18774/v2.1/id_bla/images/non_existing_id"
 527         listimagebynonexistingidresponse = requests.get(url, headers=headers)
 528         self.assertEqual(listimagebynonexistingidresponse.status_code, 404)
 529         print(" ")
 530
 531         #find ubuntu id
 532         for image in json.loads(listimagesresponse.content)["images"]:
 533             if image["name"] == "ubuntu:trusty":
 534                 ubuntu_image_id = image["id"]
 535
 536
 537
 538         print('->>>>>>> test Nova Create Server Instance ->>>>>>>>>>>>>>>')
 539         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 540         url = "http://0.0.0.0:18774/v2.1/id_bla/servers"
 541         data = '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json.loads(listflavorsresponse.content)["flavors"][0]["id"], ubuntu_image_id)
 542         createserverinstance = requests.post(url, data=data, headers=headers)
 543         self.assertEqual(createserverinstance.status_code, 200)
 544         self.assertEqual(json.loads(createserverinstance.content)["server"]["image"]["id"], ubuntu_image_id)
 545         print(" ")
 546
 547         print('->>>>>>> test Nova Create Server Instance With Already Existing Name ->>>>>>>>>>>>>>>')
 548         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 549         url = "http://0.0.0.0:18774/v2.1/id_bla/servers"
 550         data = '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json.loads(listflavorsresponse.content)["flavors"][0]["id"], ubuntu_image_id)
 551         createserverinstance = requests.post(url, data=data, headers=headers)
 552         self.assertEqual(createserverinstance.status_code, 409)
 553         print(" ")
 554
 555         print('->>>>>>> test Nova Version List Server APIs Detailed ->>>>>>>>>>>>>>>')
 556         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 557         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/detail"
 558         listserverapisdetailedresponse = requests.get(url, headers=headers)
 559         self.assertEqual(listserverapisdetailedresponse.status_code, 200)
 560         self.assertEqual(json.loads(listserverapisdetailedresponse.content)["servers"][0]["status"], "ACTIVE")
 561         print(" ")
 562
 563         print('->>>>>>> test Nova Show Server Details ->>>>>>>>>>>>>>>')
 564         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 565         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json.loads(listserverapisdetailedresponse.content)["servers"][0]["id"])
 566         listserverdetailsresponse = requests.get(url, headers=headers)
 567         self.assertEqual(listserverdetailsresponse.status_code, 200)
 568         self.assertEqual(json.loads(listserverdetailsresponse.content)["server"]["flavor"]["links"][0]["rel"], "bookmark")
 569         print(" ")
 570
 571         print('->>>>>>> test Nova Show Non-Existing Server Details ->>>>>>>>>>>>>>>')
 572         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 573         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/non_existing_server_id"
 574         listnonexistingserverdetailsresponse = requests.get(url, headers=headers)
 575         self.assertEqual(listnonexistingserverdetailsresponse.status_code, 404)
 576         print(" ")
 577
 578
 579
 580     def testNeutronDummy(self):
 581         print('->>>>>>> test Neutron Dummy Class->>>>>>>>>>>>>>>')
 582         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 583         print(" ")
 584
 585         headers = {'Content-type': 'application/json'}
 586         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_create_stack.json")).read()
 587         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 588         requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)), headers=headers)
 589         # test_heatapi_keystone_get_token = open("test_heatapi_keystone_get_token.json").read()
 590
 591         print('->>>>>>> test Neutron List Versions ->>>>>>>>>>>>>>>')
 592         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 593         url = "http://0.0.0.0:19696/"
 594         listapiversionstackresponse = requests.get(url, headers=headers)
 595         self.assertEqual(listapiversionstackresponse.status_code, 200)
 596         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"][0]["id"], "v2.0")
 597         print(" ")
 598
 599         print('->>>>>>> test Neutron Show API v2.0 ->>>>>>>>>>>>>>>')
 600         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 601         url = "http://0.0.0.0:19696/v2.0"
 602         listapiversionv20response = requests.get(url, headers=headers)
 603         self.assertEqual(listapiversionv20response.status_code, 200)
 604         self.assertEqual(json.loads(listapiversionv20response.content)["resources"][0]["name"], "subnet")
 605         self.assertEqual(json.loads(listapiversionv20response.content)["resources"][1]["name"], "network")
 606         self.assertEqual(json.loads(listapiversionv20response.content)["resources"][2]["name"], "ports")
 607         print(" ")
 608
 609         print('->>>>>>> test Neutron List Networks ->>>>>>>>>>>>>>>')
 610         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 611         url = "http://0.0.0.0:19696/v2.0/networks"
 612         listnetworksesponse1 = requests.get(url, headers=headers)
 613         self.assertEqual(listnetworksesponse1.status_code, 200)
 614         self.assertEqual(json.loads(listnetworksesponse1.content)["networks"][0]["status"], "ACTIVE")
 615         listNetworksId = json.loads(listnetworksesponse1.content)["networks"][0]["id"]
 616         listNetworksName = json.loads(listnetworksesponse1.content)["networks"][0]["name"]
 617         listNetworksId2 = json.loads(listnetworksesponse1.content)["networks"][1]["id"]
 618         print(" ")
 619
 620         print('->>>>>>> test Neutron List Non-Existing Networks ->>>>>>>>>>>>>>>')
 621         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 622         url = "http://0.0.0.0:19696/v2.0/networks?name=non_existent_network_name"
 623         listnetworksesponse2 = requests.get(url,headers=headers)
 624         self.assertEqual(listnetworksesponse2.status_code, 404)
 625         print(" ")
 626
 627         print('->>>>>>> test Neutron List Networks By Name ->>>>>>>>>>>>>>>')
 628         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 629         url = "http://0.0.0.0:19696/v2.0/networks?name=" + listNetworksName #tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
 630         listnetworksesponse3 = requests.get(url, headers=headers)
 631         self.assertEqual(listnetworksesponse3.status_code, 200)
 632         self.assertEqual(json.loads(listnetworksesponse3.content)["networks"][0]["name"], listNetworksName)
 633         print(" ")
 634
 635         print('->>>>>>> test Neutron List Networks By Id ->>>>>>>>>>>>>>>')
 636         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 637         url = "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId  # tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
 638         listnetworksesponse4 = requests.get(url, headers=headers)
 639         self.assertEqual(listnetworksesponse4.status_code, 200)
 640         self.assertEqual(json.loads(listnetworksesponse4.content)["networks"][0]["id"], listNetworksId)
 641         print(" ")
 642
 643         print('->>>>>>> test Neutron List Networks By Multiple Ids ->>>>>>>>>>>>>>>')
 644         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 645         url = "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId + "&id="+ listNetworksId2 # tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
 646         listnetworksesponse5 = requests.get(url, headers=headers)
 647         self.assertEqual(listnetworksesponse5.status_code, 200)
 648         self.assertEqual(json.loads(listnetworksesponse5.content)["networks"][0]["id"], listNetworksId)
 649         self.assertEqual(json.loads(listnetworksesponse5.content)["networks"][1]["id"], listNetworksId2)
 650         print(" ")
 651
 652         print('->>>>>>> test Neutron Show Network ->>>>>>>>>>>>>>>')
 653         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 654         url = "http://0.0.0.0:19696/v2.0/networks/"+listNetworksId
 655         shownetworksesponse = requests.get(url, headers=headers)
 656         self.assertEqual(shownetworksesponse.status_code, 200)
 657         self.assertEqual(json.loads(shownetworksesponse.content)["network"]["status"], "ACTIVE")
 658         print(" ")
 659
 660         print('->>>>>>> test Neutron Show Network Non-ExistendNetwork ->>>>>>>>>>>>>>>')
 661         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 662         url = "http://0.0.0.0:19696/v2.0/networks/non_existent_network_id"
 663         shownetworksesponse2 = requests.get(url, headers=headers)
 664         self.assertEqual(shownetworksesponse2.status_code, 404)
 665         print(" ")
 666
 667         print('->>>>>>> test Neutron Create Network ->>>>>>>>>>>>>>>')
 668         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 669         url = "http://0.0.0.0:19696/v2.0/networks"
 670         createnetworkresponse = requests.post(url, data='{"network": {"name": "sample_network","admin_state_up": true}}', headers=headers)
 671         self.assertEqual(createnetworkresponse.status_code, 201)
 672         self.assertEqual(json.loads(createnetworkresponse.content)["network"]["status"], "ACTIVE")
 673         print(" ")
 674
 675         print('->>>>>>> test Neutron Create Network With Existing Name ->>>>>>>>>>>>>>>')
 676         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 677         url = "http://0.0.0.0:19696/v2.0/networks"
 678         createnetworkresponsefailure = requests.post(url,data='{"network": {"name": "sample_network","admin_state_up": true}}',headers=headers)
 679         self.assertEqual(createnetworkresponsefailure.status_code, 400)
 680         print(" ")
 681
 682         print('->>>>>>> test Neutron Update Network ->>>>>>>>>>>>>>>')
 683         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 684         url = "http://0.0.0.0:19696/v2.0/networks/%s" % (json.loads(createnetworkresponse.content)["network"]["id"])
 685         updatenetworkresponse = requests.put(url, data='{"network": {"status": "ACTIVE", "admin_state_up":true, "tenant_id":"abcd123", "name": "sample_network_new_name", "shared":false}}' , headers=headers)
 686         self.assertEqual(updatenetworkresponse.status_code, 200)
 687         self.assertEqual(json.loads(updatenetworkresponse.content)["network"]["name"], "sample_network_new_name")
 688         self.assertEqual(json.loads(updatenetworkresponse.content)["network"]["tenant_id"], "abcd123")
 689         print(" ")
 690
 691         print('->>>>>>> test Neutron Update Non-Existing Network ->>>>>>>>>>>>>>>')
 692         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 693         url = "http://0.0.0.0:19696/v2.0/networks/non-existing-name123"
 694         updatenetworkresponse = requests.put(url, data='{"network": {"name": "sample_network_new_name"}}', headers=headers)
 695         self.assertEqual(updatenetworkresponse.status_code, 404)
 696         print(" ")
 697
 698         print('->>>>>>> test Neutron List Subnets ->>>>>>>>>>>>>>>')
 699         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 700         url = "http://0.0.0.0:19696/v2.0/subnets"
 701         listsubnetsresponse = requests.get(url, headers=headers)
 702         listSubnetName = json.loads(listsubnetsresponse.content)["subnets"][0]["name"]
 703         listSubnetId = json.loads(listsubnetsresponse.content)["subnets"][0]["id"]
 704         listSubnetId2 = json.loads(listsubnetsresponse.content)["subnets"][1]["id"]
 705         self.assertEqual(listsubnetsresponse.status_code, 200)
 706         self.assertNotIn('None', listSubnetName)
 707         print(" ")
 708
 709         print('->>>>>>> test Neutron List Subnets By Name ->>>>>>>>>>>>>>>')
 710         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 711         url = "http://0.0.0.0:19696/v2.0/subnets?name="+listSubnetName
 712         listsubnetByNameresponse = requests.get(url, headers=headers)
 713         self.assertEqual(listsubnetByNameresponse.status_code, 200)
 714         self.assertNotIn('None', json.loads(listsubnetByNameresponse.content)["subnets"][0]["name"])
 715         print(" ")
 716
 717         print('->>>>>>> test Neutron List Subnets By Id ->>>>>>>>>>>>>>>')
 718         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 719         url = "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId
 720         listsubnetsbyidresponse = requests.get(url, headers=headers)
 721         self.assertEqual(listsubnetsbyidresponse.status_code, 200)
 722         self.assertNotIn("None", json.loads(listsubnetsbyidresponse.content)["subnets"][0]["name"])
 723         print(" ")
 724
 725         print('->>>>>>> test Neutron List Subnets By Multiple Id ->>>>>>>>>>>>>>>')
 726         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 727         url = "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId +"&id="+listSubnetId2
 728         listsubnetsbymultipleidsresponse = requests.get(url, headers=headers)
 729         self.assertEqual(listsubnetsbymultipleidsresponse.status_code, 200)
 730         self.assertNotIn("None", json.loads(listsubnetsbymultipleidsresponse.content)["subnets"][0]["name"])
 731         print(" ")
 732
 733
 734
 735         print('->>>>>>> test Neutron Show Subnet->>>>>>>>>>>>>>>')
 736         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 737         url = "http://0.0.0.0:19696/v2.0/subnets/%s" % (json.loads(listsubnetsresponse.content)["subnets"][0]["id"])
 738         showsubnetsresponse = requests.get(url, headers=headers)
 739         self.assertEqual(showsubnetsresponse.status_code, 200)
 740         self.assertNotIn("None", json.loads(showsubnetsresponse.content)["subnet"]["name"])
 741         print(" ")
 742
 743         print('->>>>>>> test Neutron Show Non-Existing Subnet->>>>>>>>>>>>>>>')
 744         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 745         url = "http://0.0.0.0:19696/v2.0/subnets/non-existing-id123"
 746         showsubnetsresponse = requests.get(url, headers=headers)
 747         self.assertEqual(showsubnetsresponse.status_code, 404)
 748         print(" ")
 749
 750
 751         print('->>>>>>> test Neutron Create Subnet ->>>>>>>>>>>>>>>')
 752         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 753         url = "http://0.0.0.0:19696/v2.0/subnets"
 754         createsubnetdata = '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 755         createsubnetresponse = requests.post(url, data=createsubnetdata, headers=headers)
 756         self.assertEqual(createsubnetresponse.status_code, 201)
 757         self.assertEqual(json.loads(createsubnetresponse.content)["subnet"]["name"], "new_subnet")
 758         print(" ")
 759
 760         print('->>>>>>> test Neutron Create Second Subnet ->>>>>>>>>>>>>>>')
 761         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 762         url = "http://0.0.0.0:19696/v2.0/subnets"
 763         createsubnetdata = '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 764         createsubnetfailureresponse = requests.post(url, data=createsubnetdata, headers=headers)
 765         self.assertEqual(createsubnetfailureresponse.status_code, 409)
 766         print(" ")
 767
 768         print('->>>>>>> test Neutron Update Subnet ->>>>>>>>>>>>>>>')
 769         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 770         url = "http://0.0.0.0:19696/v2.0/subnets/%s" % (json.loads(createsubnetresponse.content)["subnet"]["id"])
 771         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} }'
 772         updatesubnetresponse = requests.put(url, data=updatesubnetdata, headers=headers)
 773         self.assertEqual(updatesubnetresponse.status_code, 200)
 774         self.assertEqual(json.loads(updatesubnetresponse.content)["subnet"]["name"], "new_subnet_new_name")
 775         print(" ")
 776
 777         print('->>>>>>> test Neutron Update Non-Existing Subnet ->>>>>>>>>>>>>>>')
 778         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 779         url = "http://0.0.0.0:19696/v2.0/subnets/non-existing-subnet-12345"
 780         updatenonexistingsubnetdata = '{"subnet": {"name": "new_subnet_new_name"} }'
 781         updatenonexistingsubnetresponse = requests.put(url, data=updatenonexistingsubnetdata, headers=headers)
 782         self.assertEqual(updatenonexistingsubnetresponse.status_code, 404)
 783         print(" ")
 784
 785
 786
 787         print('->>>>>>> test Neutron List Ports ->>>>>>>>>>>>>>>')
 788         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 789         url = "http://0.0.0.0:19696/v2.0/ports"
 790         listportsesponse = requests.get(url, headers=headers)
 791         self.assertEqual(listportsesponse.status_code, 200)
 792         self.assertEqual(json.loads(listportsesponse.content)["ports"][0]["status"], "ACTIVE")
 793         listPortsName = json.loads(listportsesponse.content)["ports"][0]["name"]
 794         listPortsId1 = json.loads(listportsesponse.content)["ports"][0]["id"]
 795         listPortsId2 = json.loads(listportsesponse.content)["ports"][1]["id"]
 796         print(" ")
 797
 798         print('->>>>>>> test Neutron List Ports By Name ->>>>>>>>>>>>>>>')
 799         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 800         url = "http://0.0.0.0:19696/v2.0/ports?name=" + listPortsName
 801         listportsbynameesponse = requests.get(url, headers=headers)
 802         self.assertEqual(listportsbynameesponse.status_code, 200)
 803         self.assertEqual(json.loads(listportsbynameesponse.content)["ports"][0]["name"], listPortsName)
 804         print(" ")
 805
 806         print('->>>>>>> test Neutron List Ports By Id ->>>>>>>>>>>>>>>')
 807         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 808         url = "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1
 809         listportsbyidesponse = requests.get(url, headers=headers)
 810         self.assertEqual(listportsbyidesponse.status_code, 200)
 811         self.assertEqual(json.loads(listportsbyidesponse.content)["ports"][0]["id"], listPortsId1)
 812         print(" ")
 813
 814         print('->>>>>>> test Neutron List Ports By Multiple Ids ->>>>>>>>>>>>>>>')
 815         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 816         url = "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1 +"&id="+listPortsId2
 817         listportsbymultipleidsesponse = requests.get(url, headers=headers)
 818         self.assertEqual(listportsbymultipleidsesponse.status_code, 200)
 819         self.assertEqual(json.loads(listportsbymultipleidsesponse.content)["ports"][0]["id"], listPortsId1)
 820         print(" ")
 821
 822         print('->>>>>>> test Neutron List Non-Existing Ports ->>>>>>>>>>>>>>>')
 823         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 824         url = "http://0.0.0.0:19696/v2.0/ports?id=non-existing-port-id"
 825         listportsbynonexistingidsesponse = requests.get(url, headers=headers)
 826         self.assertEqual(listportsbynonexistingidsesponse.status_code, 404)
 827         print(" ")
 828
 829         print('->>>>>>> test Neutron Show Port ->>>>>>>>>>>>>>>')
 830         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 831         url = "http://0.0.0.0:19696/v2.0/ports/%s" % (json.loads(listportsesponse.content)["ports"][0]["id"])
 832         showportresponse = requests.get(url, headers=headers)
 833         self.assertEqual(showportresponse.status_code, 200)
 834         self.assertEqual(json.loads(showportresponse.content)["port"]["status"], "ACTIVE")
 835         print(" ")
 836
 837         print('->>>>>>> test Neutron Show Non-Existing Port ->>>>>>>>>>>>>>>')
 838         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 839         url = "http://0.0.0.0:19696/v2.0/ports/non-existing-portid123"
 840         shownonexistingportresponse = requests.get(url, headers=headers)
 841         self.assertEqual(shownonexistingportresponse.status_code, 404)
 842         print(" ")
 843
 844         print('->>>>>>> test Neutron Create Port In Non-Existing Network ->>>>>>>>>>>>>>>')
 845         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 846         url = "http://0.0.0.0:19696/v2.0/ports"
 847         createnonexistingportdata = '{"port": {"name": "new_port", "network_id": "non-existing-id"} }'
 848         createnonexistingnetworkportresponse = requests.post(url, data=createnonexistingportdata, headers=headers)
 849         self.assertEqual(createnonexistingnetworkportresponse.status_code, 404)
 850         print(" ")
 851
 852         print('->>>>>>> test Neutron Create Port ->>>>>>>>>>>>>>>')
 853         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 854         url = "http://0.0.0.0:19696/v2.0/ports"
 855         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"])
 856         createportresponse = requests.post(url, data=createportdata, headers=headers)
 857         self.assertEqual(createportresponse.status_code, 201)
 858         print (createportresponse.content)
 859         self.assertEqual(json.loads(createportresponse.content)["port"]["name"], "new_port")
 860         print(" ")
 861
 862         print('->>>>>>> test Neutron Create Port With Existing Name ->>>>>>>>>>>>>>>')
 863         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 864         url = "http://0.0.0.0:19696/v2.0/ports"
 865         createportwithexistingnamedata = '{"port": {"name": "new_port", "network_id": "%s"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 866         createportwithexistingnameresponse = requests.post(url, data=createportwithexistingnamedata, headers=headers)
 867         self.assertEqual(createportwithexistingnameresponse.status_code, 500)
 868         print(" ")
 869
 870         print('->>>>>>> test Neutron Create Port Without Name ->>>>>>>>>>>>>>>')
 871         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 872         url = "http://0.0.0.0:19696/v2.0/ports"
 873         createportdatawithoutname = '{"port": {"network_id": "%s"} }' % (json.loads(createnetworkresponse.content)["network"]["id"])
 874         createportwithoutnameresponse = requests.post(url, data=createportdatawithoutname, headers=headers)
 875         self.assertEqual(createportwithoutnameresponse.status_code, 201)
 876         self.assertIn("port:cp", json.loads(createportwithoutnameresponse.content)["port"]["name"])
 877         print(" ")
 878
 879         print('->>>>>>> test Neutron Update Port ->>>>>>>>>>>>>>>')
 880         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 881         print(json.loads(createportresponse.content)["port"]["name"])
 882         url = "http://0.0.0.0:19696/v2.0/ports/%s" % (json.loads(createportresponse.content)["port"]["name"])
 883         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"} }'
 884         updateportresponse = requests.put(url, data=updateportdata, headers=headers)
 885         self.assertEqual(updateportresponse.status_code, 200)
 886         self.assertEqual(json.loads(updateportresponse.content)["port"]["name"], "new_port_new_name")
 887         print(" ")
 888
 889         print('->>>>>>> test Neutron Update Non-Existing Port ->>>>>>>>>>>>>>>')
 890         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 891         url = "http://0.0.0.0:19696/v2.0/ports/non-existing-port-ip"
 892         updatenonexistingportdata = '{"port": {"name": "new_port_new_name"} }'
 893         updatenonexistingportresponse = requests.put(url, data=updatenonexistingportdata, headers=headers)
 894         self.assertEqual(updatenonexistingportresponse.status_code, 404)
 895         print(" ")
 896
 897         print('->>>>>>> test Neutron Delete Port ->>>>>>>>>>>>>>>')
 898         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 899         righturl = "http://0.0.0.0:19696/v2.0/ports/%s" % (json.loads(createportresponse.content)["port"]["id"])
 900         deleterightportresponse = requests.delete(righturl, headers=headers)
 901         self.assertEqual(deleterightportresponse.status_code, 204)
 902         print(" ")
 903
 904
 905         print('->>>>>>> test Neutron Delete Non-Existing Port ->>>>>>>>>>>>>>>')
 906         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 907         wrongurl = "http://0.0.0.0:19696/v2.0/ports/unknownid"
 908         deletewrongportresponse = requests.delete(wrongurl, headers=headers)
 909         self.assertEqual(deletewrongportresponse.status_code, 404)
 910         print(" ")
 911
 912         print('->>>>>>> test Neutron Delete Subnet ->>>>>>>>>>>>>>>')
 913         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 914         wrongurl = "http://0.0.0.0:19696/v2.0/subnets/unknownid"
 915         righturl = "http://0.0.0.0:19696/v2.0/subnets/%s" % (json.loads(updatesubnetresponse.content)["subnet"]["id"])
 916         deletewrongsubnetresponse = requests.delete(wrongurl, headers=headers)
 917         deleterightsubnetresponse = requests.delete(righturl, headers=headers)
 918         self.assertEqual(deletewrongsubnetresponse.status_code, 404)
 919         self.assertEqual(deleterightsubnetresponse.status_code, 204)
 920         print(" ")
 921
 922         print('->>>>>>> test Neutron Delete Network ->>>>>>>>>>>>>>>')
 923         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 924         righturl = "http://0.0.0.0:19696/v2.0/networks/%s" % (json.loads(createnetworkresponse.content)["network"]["id"])
 925         deleterightnetworkresponse = requests.delete(righturl, headers=headers)
 926         self.assertEqual(deleterightnetworkresponse.status_code, 204)
 927         print(" ")
 928
 929         print('->>>>>>> test Neutron Delete Non-Existing Network ->>>>>>>>>>>>>>>')
 930         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 931         wrongurl = "http://0.0.0.0:19696/v2.0/networks/unknownid"
 932         deletewrongnetworkresponse = requests.delete(wrongurl, headers=headers)
 933         self.assertEqual(deletewrongnetworkresponse.status_code, 404)
 934         print(" ")
 935
 936     def testKeystomeDummy(self):
 937         print('->>>>>>> test Keystone Dummy Class->>>>>>>>>>>>>>>')
 938         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 939         print(" ")
 940
 941         headers = {'Content-type': 'application/json'}
 942         test_heatapi_keystone_get_token = open(os.path.join(os.path.dirname(__file__), "test_heatapi_keystone_get_token.json")).read()
 943
 944         print('->>>>>>> test Keystone List Versions ->>>>>>>>>>>>>>>')
 945         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 946         url = "http://0.0.0.0:15000/"
 947         listapiversionstackresponse = requests.get(url, headers=headers)
 948         self.assertEqual(listapiversionstackresponse.status_code, 200)
 949         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"]["values"][0]["id"], "v2.0")
 950         print(" ")
 951
 952         print('->>>>>>> test Keystone Show ApiV2 ->>>>>>>>>>>>>>>')
 953         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 954         url = "http://0.0.0.0:15000/v2.0"
 955         showapiversionstackresponse = requests.get(url, headers=headers)
 956         self.assertEqual(showapiversionstackresponse.status_code, 200)
 957         self.assertEqual(json.loads(showapiversionstackresponse.content)["version"]["id"], "v2.0")
 958         print(" ")
 959
 960         print('->>>>>>> test Keystone Get Token ->>>>>>>>>>>>>>>')
 961         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 962         url = "http://0.0.0.0:15000/v2.0/tokens"
 963         gettokenstackresponse = requests.post(url, data=json.dumps(json.loads(test_heatapi_keystone_get_token)), headers=headers)
 964         self.assertEqual(gettokenstackresponse.status_code, 200)
 965         self.assertEqual(json.loads(gettokenstackresponse.content)["access"]["user"]["name"], "tenantName")
 966         print(" ")
 967
 968
 969     def testHeatDummy(self):
 970         print('->>>>>>> test Heat Dummy Class->>>>>>>>>>>>>>>')
 971         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 972         print(" ")
 973
 974         headers = {'Content-type': 'application/json'}
 975         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_create_stack.json")).read()
 976         test_heatapi_template_update_stack = open(os.path.join(os.path.dirname(__file__), "test_heatapi_template_update_stack.json")).read()
 977
 978         print('->>>>>>> test Heat List API Versions Stack ->>>>>>>>>>>>>>>')
 979         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 980         url = "http://0.0.0.0:18004/"
 981         listapiversionstackresponse = requests.get(url, headers=headers)
 982         self.assertEqual(listapiversionstackresponse.status_code, 200)
 983         self.assertEqual(json.loads(listapiversionstackresponse.content)["versions"][0]["id"], "v1.0")
 984         print(" ")
 985
 986         print('->>>>>>> test Create Stack ->>>>>>>>>>>>>>>')
 987         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 988         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 989         createstackresponse = requests.post(url, data=json.dumps(json.loads(test_heatapi_template_create_stack)), headers=headers)
 990         self.assertEqual(createstackresponse.status_code, 201)
 991         self.assertNotEqual(json.loads(createstackresponse.content)["stack"]["id"], "")
 992         print(" ")
 993
 994         print('->>>>>>> test Create Stack With Existing Name ->>>>>>>>>>>>>>>')
 995         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
 996         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
 997         createstackwithexistingnameresponse = requests.post(url, data='{"stack_name" : "s1"}', headers=headers)
 998         self.assertEqual(createstackwithexistingnameresponse.status_code, 409)
 999         print(" ")
1000
1001         print('->>>>>>> test Create Stack With Unsupported Version ->>>>>>>>>>>>>>>')
1002         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1003         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
1004         createstackwitheunsupportedversionresponse = requests.post(url, data='{"stack_name" : "stackname123", "template" : {"heat_template_version": "2015-04-29"}}', headers=headers)
1005         self.assertEqual(createstackwitheunsupportedversionresponse.status_code, 400)
1006         print(" ")
1007
1008
1009         print('->>>>>>> test List Stack ->>>>>>>>>>>>>>>')
1010         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1011         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
1012         liststackresponse = requests.get(url, headers=headers)
1013         self.assertEqual(liststackresponse.status_code, 200)
1014         self.assertEqual(json.loads(liststackresponse.content)["stacks"][0]["stack_status"], "CREATE_COMPLETE")
1015         print(" ")
1016
1017
1018         print('->>>>>>> test Show Stack ->>>>>>>>>>>>>>>')
1019         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1020         url = "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s"% json.loads(createstackresponse.content)['stack']['id']
1021         liststackdetailsresponse = requests.get(url, headers=headers)
1022         self.assertEqual(liststackdetailsresponse.status_code, 200)
1023         self.assertEqual(json.loads(liststackdetailsresponse.content)["stack"]["stack_status"], "CREATE_COMPLETE")
1024         print(" ")
1025
1026         print('->>>>>>> test Show Non-Exisitng Stack ->>>>>>>>>>>>>>>')
1027         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1028         url = "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/non_exisitng_id123"
1029         listnonexistingstackdetailsresponse = requests.get(url, headers=headers)
1030         self.assertEqual(listnonexistingstackdetailsresponse.status_code, 404)
1031         print(" ")
1032
1033         print('->>>>>>> test Update Stack ->>>>>>>>>>>>>>>')
1034         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1035         url = "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/%s"% json.loads(createstackresponse.content)['stack']['id']
1036         updatestackresponse = requests.put(url, data=json.dumps(json.loads(test_heatapi_template_update_stack)),
1037                                             headers=headers)
1038         self.assertEqual(updatestackresponse.status_code, 202)
1039         liststackdetailsresponse = requests.get(url, headers=headers)
1040         self.assertEqual(json.loads(liststackdetailsresponse.content)["stack"]["stack_status"], "UPDATE_COMPLETE")
1041         print(" ")
1042
1043         print('->>>>>>> test Update Non-Existing Stack ->>>>>>>>>>>>>>>')
1044         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1045         url = "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/non_existing_id_1234"
1046         updatenonexistingstackresponse = requests.put(url, data={"non": "sense"}, headers=headers)
1047         self.assertEqual(updatenonexistingstackresponse.status_code, 404)
1048         print(" ")
1049
1050         print('->>>>>>> test Delete Stack ->>>>>>>>>>>>>>>')
1051         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1052         url = "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s" % \
1053               json.loads(createstackresponse.content)['stack']['id']
1054         deletestackdetailsresponse = requests.delete(url, headers=headers)
1055         self.assertEqual(deletestackdetailsresponse.status_code, 204)
1056         print(" ")
1057
1058
1059     def test_CombinedTesting(self):
1060         print('->>>>>>> test Combinded tests->>>>>>>>>>>>>>>')
1061         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1062         print(" ")
1063
1064         headers = {'Content-type': 'application/json'}
1065         test_heatapi_template_create_stack = open(os.path.join(os.path.dirname(__file__),
1066                                                                "test_heatapi_template_create_stack.json")).read()
1067         test_heatapi_template_update_stack = open(os.path.join(os.path.dirname(__file__),
1068                                                                "test_heatapi_template_update_stack.json")).read()
1069
1070         print('->>>>>>> test Combined Create Stack ->>>>>>>>>>>>>>>')
1071         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1072         url = "http://0.0.0.0:18004/v1/tenantabc123/stacks"
1073         createstackresponse = requests.post(url,
1074                                             data=json.dumps(json.loads(test_heatapi_template_create_stack)),
1075                                             headers=headers)
1076         self.assertEqual(createstackresponse.status_code, 201)
1077         self.assertNotEqual(json.loads(createstackresponse.content)["stack"]["id"], "")
1078         print(" ")
1079
1080         print('->>>>>>> test Combined Neutron List Ports ->>>>>>>>>>>>>>>')
1081         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1082         url = "http://0.0.0.0:19696/v2.0/ports"
1083         listportsesponse = requests.get(url, headers=headers)
1084         self.assertEqual(listportsesponse.status_code, 200)
1085         self.assertEqual(len(json.loads(listportsesponse.content)["ports"]), 9)
1086         for port in json.loads(listportsesponse.content)["ports"]:
1087             self.assertEqual(len(str(port['fixed_ips'][0]['subnet_id'])), 36)
1088         print(" ")
1089
1090         print('->>>>>>> test Combined Neutron List Networks ->>>>>>>>>>>>>>>')
1091         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1092         url = "http://0.0.0.0:19696/v2.0/networks"
1093         listnetworksesponse = requests.get(url, headers=headers)
1094         self.assertEqual(listnetworksesponse.status_code, 200)
1095         self.assertEqual(len(json.loads(listnetworksesponse.content)["networks"]), 10)
1096         for net in json.loads(listnetworksesponse.content)["networks"]:
1097             self.assertEqual(len(str(net['subnets'][0])), 36)
1098         print(" ")
1099
1100         print('->>>>>>> test Combined Update Stack ->>>>>>>>>>>>>>>')
1101         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1102         url = "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/%s"% \
1103               json.loads(createstackresponse.content)['stack']['id']
1104         updatestackresponse = requests.put(url,
1105                                            data=json.dumps(json.loads(test_heatapi_template_update_stack)),
1106                                            headers=headers)
1107         self.assertEqual(updatestackresponse.status_code, 202)
1108         liststackdetailsresponse = requests.get(url, headers=headers)
1109         self.assertEqual(json.loads(liststackdetailsresponse.content)["stack"]["stack_status"], "UPDATE_COMPLETE")
1110         print(" ")
1111
1112         print('->>>>>>> test Combined Neutron List Ports ->>>>>>>>>>>>>>>')
1113         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1114         url = "http://0.0.0.0:19696/v2.0/ports"
1115         listportsesponse = requests.get(url, headers=headers)
1116         self.assertEqual(listportsesponse.status_code, 200)
1117         self.assertEqual(len(json.loads(listportsesponse.content)["ports"]), 18)
1118         for port in json.loads(listportsesponse.content)["ports"]:
1119             self.assertEqual(len(str(port['fixed_ips'][0]['subnet_id'])), 36)
1120         print(" ")
1121
1122         print('->>>>>>> test Combined Neutron List Networks ->>>>>>>>>>>>>>>')
1123         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1124         url = "http://0.0.0.0:19696/v2.0/networks"
1125         listnetworksesponse = requests.get(url, headers=headers)
1126         self.assertEqual(listnetworksesponse.status_code, 200)
1127         self.assertEqual(len(json.loads(listnetworksesponse.content)["networks"]), 14)
1128         for net in json.loads(listnetworksesponse.content)["networks"]:
1129             self.assertEqual(len(str(net['subnets'][0])), 36)
1130         print(" ")
1131
1132
1133         # workflow create floating ip and assign it to a server
1134
1135         print('->>>>>>> CombinedNeutronCreateFloatingIP ->>>>>>>>>>>>>>>')
1136         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1137         url = "http://0.0.0.0:19696/v2.0/floatingips"
1138         createflip = requests.post(url, headers=headers,
1139                                             data='{"floatingip":{"floating_network_id":"default"}}')
1140         self.assertEqual(createflip.status_code, 200)
1141         self.assertIsNotNone(json.loads(createflip.content)["floatingip"].get("port_id"))
1142         port_id = json.loads(createflip.content)["floatingip"].get("port_id")
1143         print(" ")
1144
1145         print('->>>>>>> CombinedNovaGetServer ->>>>>>>>>>>>>>>')
1146         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1147         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/detail"
1148         listserverapisdetailedresponse = requests.get(url, headers=headers)
1149         self.assertEqual(listserverapisdetailedresponse.status_code, 200)
1150         self.assertEqual(json.loads(listserverapisdetailedresponse.content)["servers"][0]["status"], "ACTIVE")
1151         server_id = json.loads(listserverapisdetailedresponse.content)["servers"][0]["id"]
1152         print(" ")
1153
1154         print('->>>>>>> CombinedNovaAssignInterface ->>>>>>>>>>>>>>>')
1155         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1156         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s/os-interface" % server_id
1157         assign = requests.post(url, headers=headers,
1158                                             data='{"interfaceAttachment":{"net_id": "default"}}')
1159         self.assertEqual(assign.status_code, 202)
1160         self.assertIsNotNone(json.loads(assign.content)["interfaceAttachment"].get("port_id"))
1161         port_id = json.loads(assign.content)["interfaceAttachment"].get("port_id")
1162         print(" ")
1163
1164         print('->>>>>>> CombinedNovaDeleteInterface ->>>>>>>>>>>>>>>')
1165         print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
1166         url = "http://0.0.0.0:18774/v2.1/id_bla/servers/%s/os-interface/%s" % (server_id, port_id)
1167         getintfs = requests.delete(url, headers=headers)
1168         self.assertEqual(getintfs.status_code, 202)
1169         print(" ")
1170
1171
1172 if __name__ == '__main__':
1173     unittest.main()