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