near-rt-ric-simulator/tests/STD_1.1.3/test_std_1_1_3.py

   1 #  ============LICENSE_START===============================================
   2 #  Copyright (C) 2020 Nordix Foundation. All rights reserved.
   3 #  ========================================================================
   4 #  Licensed under the Apache License, Version 2.0 (the "License");
   5 #  you may not use this file except in compliance with the License.
   6 #  You may obtain a copy of the License at
   7 #
   8 #       http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 #  Unless required by applicable law or agreed to in writing, software
  11 #  distributed under the License is distributed on an "AS IS" BASIS,
  12 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 #  See the License for the specific language governing permissions and
  14 #  limitations under the License.
  15 #  ============LICENSE_END=================================================
  16 #
  17
  18 # This test case test the STD_1.1.3 version of the simulator
  19
  20 from unittest import TestCase
  21 import sys
  22 import os
  23 import threading
  24 import requests
  25 import json
  26
  27 #Constants for the test case
  28 INTERFACE_VERSION="STD_1.1.3"
  29 PORT_NUMBER="2224"
  30 HOST_IP="localhost"
  31 SERVER_URL="http://"+HOST_IP+":"+PORT_NUMBER+"/"
  32
  33 cwd=os.getcwd()+"/"
  34 # Env TESTS_BASE_PATH is set when executed via tox.ini
  35 # If basic test is executed from cmd line, that env var is not needed
  36 if 'TESTS_BASE_PATH' in os.environ:
  37      cwd=os.environ['TESTS_BASE_PATH']+"/"+INTERFACE_VERSION+"/"
  38 TESTDATA=cwd+"/../../test/"+INTERFACE_VERSION+"/jsonfiles/"
  39
  40 #Env var to setup api version and host logging
  41 os.environ['APIPATH'] = cwd+"/../../api/"+INTERFACE_VERSION
  42 os.environ['REMOTE_HOSTS_LOGGING'] = "ON"
  43
  44 # Paths need to run the sim, including needed source file dirs
  45 sys.path.append(os.path.abspath(cwd+'../../src/common'))
  46 sys.path.append(os.path.abspath(cwd+'../../test/common'))
  47 sys.path.append(os.path.abspath(cwd+'../../src/'+INTERFACE_VERSION))
  48 os.chdir(cwd+"../../src/"+INTERFACE_VERSION)
  49
  50 import main
  51 from compare_json import compare
  52
  53 class TestCase1(TestCase):
  54     from main import app
  55     server = None
  56
  57     def startServer(self):
  58         self.app.run(port=PORT_NUMBER, host=HOST_IP, threaded=True)
  59
  60     def setUp(self):
  61         self.server=threading.Thread(target=self.startServer, args=())
  62         self.server.daemon = True
  63         self.server.start()
  64
  65     # executed after each test
  66     def tearDown(self):
  67         self.server.killed=True
  68
  69     #from main import app
  70     def test_apis(self):
  71
  72         # header for json payload
  73         header = {
  74             "Content-Type" : "application/json"
  75         }
  76
  77         # Simulator hello world
  78         response=requests.get(SERVER_URL)
  79         self.assertEqual(response.status_code, 200)
  80
  81         # Check used and implemented interfaces
  82         response=requests.get(SERVER_URL+'container_interfaces')
  83         self.assertEqual(response.status_code, 200)
  84         self.assertEqual(response.text,  "Current interface: STD_1.1.3  All supported A1 interface yamls in this container: ['OSC_2.1.0', 'STD_1.1.3']")
  85
  86         # Reset simulator instances
  87         response=requests.post(SERVER_URL+'deleteinstances')
  88         self.assertEqual(response.status_code, 200)
  89
  90         # Reset simulator, all
  91         response=requests.post(SERVER_URL+'deleteall')
  92         self.assertEqual(response.status_code, 200)
  93
  94         # API: Get policy instances, shall be empty
  95         data_policy_get = [ ]
  96         response=requests.get(SERVER_URL+'A1-P/v1/policies')
  97         self.assertEqual(response.status_code, 200)
  98         result=json.loads(response.text)
  99         res=compare(data_policy_get, result)
 100         self.assertEqual(res, True)
 101
 102         #API: Create policy instance pi1
 103         data_pi1 = {
 104             "scope": {
 105                 "ueId": "ue1",
 106                 "groupId": "group1",
 107                 "sliceId": "slice1",
 108                 "qosId": "qos1",
 109                 "cellId": "cell1"
 110                 },
 111             "statement": {
 112                 "priorityLevel": 5
 113             }
 114         }
 115         response=requests.put(SERVER_URL+'A1-P/v1/policies/pi1', headers=header, data=json.dumps(data_pi1))
 116         self.assertEqual(response.status_code, 201)
 117         result=json.loads(response.text)
 118         res=compare(data_pi1, result)
 119         self.assertEqual(res, True)
 120
 121         #API: Update policy instance pi1
 122         data_pi1_updated = {
 123             "scope": {
 124                 "ueId": "ue1",
 125                 "groupId": "group1",
 126                 "sliceId": "slice1",
 127                 "qosId": "qos1",
 128                 "cellId": "cell1"
 129                 },
 130             "statement": {
 131                 "priorityLevel": 6
 132             }
 133         }
 134         response=requests.put(SERVER_URL+'A1-P/v1/policies/pi1', headers=header, data=json.dumps(data_pi1_updated))
 135         self.assertEqual(response.status_code, 200)
 136         result=json.loads(response.text)
 137         res=compare(data_pi1_updated, result)
 138         self.assertEqual(res, True)
 139
 140         #API: Create policy instance pi9, bad json
 141         response=requests.put(SERVER_URL+'A1-P/v1/policies/pi9', headers=header, data="test")
 142         self.assertEqual(response.status_code, 400)
 143
 144         # API: Get policy instances, shall contain pi1
 145         data_policy_get = [ "pi1" ]
 146         response=requests.get(SERVER_URL+'A1-P/v1/policies')
 147         self.assertEqual(response.status_code, 200)
 148         result=json.loads(response.text)
 149         res=compare(data_policy_get, result)
 150         self.assertEqual(res, True)
 151
 152         # API: Create policy instance pi2 (copy of pi1). Shall fail
 153         data_create_errror_pi1 = {
 154             "title" : "The policy json already exists.",
 155             "status" : 400,
 156             "instance" : "pi2"
 157         }
 158         response=requests.put(SERVER_URL+'A1-P/v1/policies/pi2', headers=header, data=json.dumps(data_pi1_updated))
 159         self.assertEqual(response.status_code, 400)
 160         result=json.loads(response.text)
 161         res=compare(data_create_errror_pi1, result)
 162         self.assertEqual(res, True)
 163
 164         # Set force response code 409. ==="
 165         response=requests.post(SERVER_URL+'forceresponse?code=409')
 166         self.assertEqual(response.status_code, 200)
 167
 168         # API: Get policy instances, shall fail
 169         data_get_errror = {
 170             "title" : "Conflict",
 171             "status" : 409,
 172             "detail" : "Request could not be processed in the current state of the resource"
 173         }
 174         response=requests.get(SERVER_URL+'A1-P/v1/policies')
 175         self.assertEqual(response.status_code, 409)
 176         result=json.loads(response.text)
 177         res=compare(data_get_errror, result)
 178         self.assertEqual(res, True)
 179
 180         # Reset force response
 181         response=requests.post(SERVER_URL+'forceresponse')
 182         self.assertEqual(response.status_code, 200)
 183         self.assertEqual(response.text,  "Force response code: None set for one single A1 response")
 184
 185         ###
 186         ### Repeating the above two test for code coverage
 187         ###
 188         # Set force response code 400
 189         response=requests.post(SERVER_URL+'forceresponse?code=400')
 190         self.assertEqual(response.status_code, 200)
 191
 192         #API: Create policy instance pi3, shall fail
 193         data_pi3 = {
 194             "scope": {
 195                 "ueId": "ue3"
 196                 },
 197             "statement": {
 198                 "priorityLevel": 5
 199             }
 200         }
 201         data_get_errror = {
 202             "title" : "Bad request",
 203             "status" : 400,
 204             "detail" : "Object in payload not properly formulated or not related to the method"
 205         }
 206         response=requests.put(SERVER_URL+'A1-P/v1/policies/pi3', headers=header, data=json.dumps(data_pi3))
 207         self.assertEqual(response.status_code, 400)
 208         result=json.loads(response.text)
 209         res=compare(data_get_errror, result)
 210         self.assertEqual(res, True)
 211
 212         # Set force response code 404
 213         response=requests.post(SERVER_URL+'forceresponse?code=404')
 214         self.assertEqual(response.status_code, 200)
 215
 216         # API: Get policy instance pi1, shall fail =="
 217         data_get_errror = {
 218             "title" : "Not found",
 219             "status" : 404,
 220             "detail" : "No resource found at the URI"
 221         }
 222         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi1')
 223         self.assertEqual(response.status_code, 404)
 224         result=json.loads(response.text)
 225         res=compare(data_get_errror, result)
 226         self.assertEqual(res, True)
 227
 228         # Set force response code 405
 229         response=requests.post(SERVER_URL+'forceresponse?code=405')
 230         self.assertEqual(response.status_code, 200)
 231
 232         # API: Delete policy instances pi1, shall fail =="
 233         data_get_errror = {
 234             "title" : "Method not allowed",
 235             "status" : 405,
 236             "detail" : "Method not allowed for the URI"
 237         }
 238         response=requests.delete(SERVER_URL+'A1-P/v1/policies/pi1')
 239         self.assertEqual(response.status_code, 405)
 240         result=json.loads(response.text)
 241         res=compare(data_get_errror, result)
 242         self.assertEqual(res, True)
 243
 244         # Set force response code 429
 245         response=requests.post(SERVER_URL+'forceresponse?code=429')
 246         self.assertEqual(response.status_code, 200)
 247
 248         # API: Get policy status pi3, shall fail =="
 249         data_get_errror = {
 250             "title" : "Too many requests",
 251             "status" : 429,
 252             "detail" : "Too many requests have been sent in a given amount of time"
 253         }
 254         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi3/status')
 255         self.assertEqual(response.status_code, 429)
 256         result=json.loads(response.text)
 257         res=compare(data_get_errror, result)
 258         self.assertEqual(res, True)
 259
 260         # Set force response code 507
 261         response=requests.post(SERVER_URL+'forceresponse?code=507')
 262         self.assertEqual(response.status_code, 200)
 263
 264         # API: Get policy instances, shall fail
 265         data_get_errror = {
 266             "title" : "Insufficient storage",
 267             "status" : 507,
 268             "detail" : "The method could not be performed on the resource because the provider is unable to store the representation needed to successfully complete the request"
 269         }
 270         response=requests.get(SERVER_URL+'A1-P/v1/policies')
 271         self.assertEqual(response.status_code, 507)
 272         result=json.loads(response.text)
 273         res=compare(data_get_errror, result)
 274         self.assertEqual(res, True)
 275
 276         # Set force response code 503. ==="
 277         response=requests.post(SERVER_URL+'forceresponse?code=503')
 278         self.assertEqual(response.status_code, 200)
 279
 280         # API: Get policy instances, shall fail
 281         data_get_errror = {
 282             "title" : "Service unavailable",
 283             "status" : 503,
 284             "detail" : "The provider is currently unable to handle the request due to a temporary overload"
 285         }
 286         response=requests.get(SERVER_URL+'A1-P/v1/policies')
 287         self.assertEqual(response.status_code, 503)
 288         result=json.loads(response.text)
 289         res=compare(data_get_errror, result)
 290         self.assertEqual(res, True)
 291
 292         # Set force response code 555. ==="
 293         response=requests.post(SERVER_URL+'forceresponse?code=555')
 294         self.assertEqual(response.status_code, 200)
 295
 296         # API: Get policy instances, shall fail
 297         data_get_errror = {
 298             "title" : "Unknown",
 299             "status" : "555",
 300             "detail" : "Not implemented response code"
 301         }
 302         response=requests.get(SERVER_URL+'A1-P/v1/policies')
 303         self.assertEqual(response.status_code, 555)
 304         result=json.loads(response.text)
 305         res=compare(data_get_errror, result)
 306         self.assertEqual(res, True)
 307
 308         ###
 309         ### End of repeated test
 310         ###
 311
 312
 313         # API: Get policy status
 314         data_policy_status = {
 315             "enforceStatus" : "UNDEFINED"
 316         }
 317         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi1/status')
 318         self.assertEqual(response.status_code, 200)
 319         result=json.loads(response.text)
 320         res=compare(data_policy_status, result)
 321         self.assertEqual(res, True)
 322
 323         # API: Create policy instance pi2
 324         data_pi2 = {
 325             "scope": {
 326                 "ueId": "ue2",
 327                 "groupId": "group2",
 328                 "sliceId": "slice2",
 329                 "qosId": "qos2",
 330                 "cellId": "cell2"
 331                 },
 332             "statement": {
 333                 "priorityLevel": 10
 334             }
 335         }
 336         response=requests.put(SERVER_URL+'A1-P/v1/policies/pi2', headers=header, data=json.dumps(data_pi2))
 337         self.assertEqual(response.status_code, 201)
 338         result=json.loads(response.text)
 339         res=compare(data_pi2, result)
 340         self.assertEqual(res, True)
 341
 342
 343         # API: Update policy instance pi2
 344         # Reuse same policy data
 345         response=requests.put(SERVER_URL+'A1-P/v1/policies/pi2?notificationDestination=http://'+HOST_IP+':'+PORT_NUMBER+'/statustest', headers=header, data=json.dumps(data_pi2))
 346         self.assertEqual(response.status_code, 200)
 347         result=json.loads(response.text)
 348         res=compare(data_pi2, result)
 349         self.assertEqual(res, True)
 350
 351         # API: Get policy instances, shall contain pi1 and pi2
 352         data_policy_get = [ "pi1", "pi2" ]
 353         response=requests.get(SERVER_URL+'A1-P/v1/policies')
 354         self.assertEqual(response.status_code, 200)
 355         result=json.loads(response.text)
 356         res=compare(data_policy_get, result)
 357         self.assertEqual(res, True)
 358
 359         # Set force delay 10
 360         response=requests.post(SERVER_URL+'forcedelay?delay=10')
 361         self.assertEqual(response.status_code, 200)
 362         self.assertEqual(response.text,  "Force delay: 10 sec set for all A1 responses")
 363
 364         # API: Get policy instances, shall contain pi1 and pi2 and delayed 10 sec
 365         data_policy_get = [ "pi1", "pi2" ]
 366         response=requests.get(SERVER_URL+'A1-P/v1/policies')
 367         self.assertEqual(response.status_code, 200)
 368         result=json.loads(response.text)
 369         res=compare(data_policy_get, result)
 370         self.assertEqual(res, True)
 371
 372         # Reset force delay
 373         response=requests.post(SERVER_URL+'forcedelay')
 374         self.assertEqual(response.status_code, 200)
 375         self.assertEqual(response.text,  "Force delay: None sec set for all A1 responses")
 376
 377         # API: GET policy instance pi1
 378         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi1')
 379         self.assertEqual(response.status_code, 200)
 380         result=json.loads(response.text)
 381         res=compare(data_pi1_updated, result)
 382         self.assertEqual(res, True)
 383
 384         # API: GET policy instance pi2
 385         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi2')
 386         self.assertEqual(response.status_code, 200)
 387         result=json.loads(response.text)
 388         res=compare(data_pi2, result)
 389         self.assertEqual(res, True)
 390
 391         # API: GET policy instance pi9, shall fail
 392         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi9')
 393         self.assertEqual(response.status_code, 404)
 394
 395         # API: DELETE policy instance pi1
 396         response=requests.delete(SERVER_URL+'A1-P/v1/policies/pi1')
 397         self.assertEqual(response.status_code, 204)
 398
 399         # API: DELETE policy instance pi9, shall fail
 400         response=requests.delete(SERVER_URL+'A1-P/v1/policies/pi9')
 401         self.assertEqual(response.status_code, 404)
 402
 403         # API: Get policy status for pi1, shall fail
 404         data_get_errror = {
 405             "title" : "The policy identity does not exist.",
 406             "status" : 404,
 407             "detail" : "There is no existing policy instance with the identity: pi1",
 408             "instance" : "pi1"
 409         }
 410         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi1/status')
 411         self.assertEqual(response.status_code, 404)
 412         result=json.loads(response.text)
 413         res=compare(data_get_errror, result)
 414         self.assertEqual(res, True)
 415
 416         # Set status for policy instance pi2
 417         response=requests.put(SERVER_URL+'status?policyid=pi2&status=OK')
 418         self.assertEqual(response.status_code, 200)
 419
 420         # API: Get policy status for pi2
 421         data_get_status = {
 422             "enforceStatus" : "OK"
 423         }
 424         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi2/status')
 425         self.assertEqual(response.status_code, 200)
 426         result=json.loads(response.text)
 427         res=compare(data_get_status, result)
 428         self.assertEqual(res, True)
 429
 430         # Set status for policy instance pi2
 431         response=requests.put(SERVER_URL+'status?policyid=pi2&status=NOTOK&reason=notok_reason')
 432         self.assertEqual(response.status_code, 200)
 433
 434         # API: Get policy status for pi2
 435         data_get_status = {
 436             "enforceStatus" : "NOTOK",
 437             "enforceReason" : "notok_reason"
 438         }
 439         response=requests.get(SERVER_URL+'A1-P/v1/policies/pi2/status')
 440         self.assertEqual(response.status_code, 200)
 441         result=json.loads(response.text)
 442         res=compare(data_get_status, result)
 443         self.assertEqual(res, True)
 444
 445         # Send status for pi2
 446         response=requests.post(SERVER_URL+'sendstatus?policyid=pi2')
 447         self.assertEqual(response.status_code, 200)
 448         result=json.loads(response.text)
 449         res=compare(data_get_status, result)
 450         self.assertEqual(res, True)
 451
 452         # Send status, shall fail
 453         response=requests.post(SERVER_URL+'sendstatus')
 454         self.assertEqual(response.status_code, 400)
 455
 456         # Send status pi9, shall fail
 457         response=requests.post(SERVER_URL+'sendstatus?policyid=pi9')
 458         self.assertEqual(response.status_code, 404)
 459
 460         # Set status for policy instance , shall fail
 461         response=requests.put(SERVER_URL+'status')
 462         self.assertEqual(response.status_code, 400)
 463
 464         # Set status for policy instance pi9, shall fail
 465         response=requests.put(SERVER_URL+'status?policyid=pi9')
 466         self.assertEqual(response.status_code, 404)
 467
 468         # Set status for policy instance pi2, shall fail
 469         response=requests.put(SERVER_URL+'status?policyid=pi2')
 470         self.assertEqual(response.status_code, 400)
 471
 472
 473         # Get counter: intstance
 474         response=requests.get(SERVER_URL+'counter/num_instances')
 475         self.assertEqual(response.status_code, 200)
 476         self.assertEqual(response.text,  "1")
 477
 478         # Get counter: types (shall be 0)
 479         response=requests.get(SERVER_URL+'counter/num_types')
 480         self.assertEqual(response.status_code, 200)
 481         self.assertEqual(response.text,  "0")
 482
 483         # Get counter: interface
 484         response=requests.get(SERVER_URL+'counter/interface')
 485         self.assertEqual(response.status_code, 200)
 486         self.assertEqual(response.text,  "STD_1.1.3")
 487
 488         # Get counter: remote hosts
 489         response=requests.get(SERVER_URL+'counter/remote_hosts')
 490         self.assertEqual(response.status_code, 200)
 491
 492         # Get counter: test, shall fail
 493         response=requests.get(SERVER_URL+'counter/test')
 494         self.assertEqual(response.status_code, 404)