near-rt-ric-simulator/tests/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 import json
  21
  22 #Version of simulator
  23 INTERFACE_VERSION="STD_1.1.3"
  24
  25 from unittest_setup import SERVER_URL, HOST_IP, PORT_NUMBER, setup_env, client
  26
  27 #Setup env and import paths
  28 setup_env(INTERFACE_VERSION)
  29
  30 from compare_json import compare
  31
  32 def test_apis(client):
  33
  34     # Simulator hello world
  35     response=client.get(SERVER_URL)
  36     assert response.status_code == 200
  37
  38     # Check used and implemented interfaces
  39     response=client.get(SERVER_URL+'container_interfaces')
  40     assert response.status_code == 200
  41     assert response.data ==  b"Current interface: STD_1.1.3  All supported A1 interface yamls in this container: ['OSC_2.1.0', 'STD_1.1.3']"
  42
  43     # Reset simulator instances
  44     response=client.post(SERVER_URL+'deleteinstances')
  45     assert response.status_code == 200
  46
  47     # Reset simulator, all
  48     response=client.post(SERVER_URL+'deleteall')
  49     assert response.status_code == 200
  50
  51     # API: Get policy instances, shall be empty
  52     data_policy_get = [ ]
  53     response=client.get(SERVER_URL+'A1-P/v1/policies')
  54     assert response.status_code == 200
  55     result=json.loads(response.data)
  56     res=compare(data_policy_get, result)
  57     assert res == True
  58
  59     #API: Create policy instance pi1
  60     data_pi1 = {
  61         "scope": {
  62             "ueId": "ue1",
  63             "groupId": "group1",
  64             "sliceId": "slice1",
  65             "qosId": "qos1",
  66             "cellId": "cell1"
  67             },
  68         "statement": {
  69             "priorityLevel": 5
  70         }
  71     }
  72     # header for json payload
  73     header = {
  74         "Content-Type" : "application/json"
  75     }
  76     response=client.put(SERVER_URL+'A1-P/v1/policies/pi1', headers=header, data=json.dumps(data_pi1))
  77     assert response.status_code == 201
  78     result=json.loads(response.data)
  79     res=compare(data_pi1, result)
  80     assert res == True
  81
  82     #API: Update policy instance pi1
  83     data_pi1_updated = {
  84         "scope": {
  85             "ueId": "ue1",
  86             "groupId": "group1",
  87             "sliceId": "slice1",
  88             "qosId": "qos1",
  89             "cellId": "cell1"
  90             },
  91         "statement": {
  92             "priorityLevel": 6
  93         }
  94     }
  95     response=client.put(SERVER_URL+'A1-P/v1/policies/pi1', headers=header, data=json.dumps(data_pi1_updated))
  96     assert response.status_code == 200
  97     result=json.loads(response.data)
  98     res=compare(data_pi1_updated, result)
  99     assert res == True
 100
 101     #API: Create policy instance pi9, bad json
 102     response=client.put(SERVER_URL+'A1-P/v1/policies/pi9', headers=header, data="test")
 103     assert response.status_code == 400
 104
 105     # API: Get policy instances, shall contain pi1
 106     data_policy_get = [ "pi1" ]
 107     response=client.get(SERVER_URL+'A1-P/v1/policies')
 108     assert response.status_code == 200
 109     result=json.loads(response.data)
 110     res=compare(data_policy_get, result)
 111     assert res == True
 112
 113     # API: Create policy instance pi2 (copy of pi1). Shall fail
 114     data_create_errror_pi1 = {
 115         "title" : "The policy json already exists.",
 116         "status" : 400,
 117         "instance" : "pi2"
 118     }
 119     response=client.put(SERVER_URL+'A1-P/v1/policies/pi2', headers=header, data=json.dumps(data_pi1_updated))
 120     assert response.status_code == 400
 121     result=json.loads(response.data)
 122     res=compare(data_create_errror_pi1, result)
 123     assert res == True
 124
 125     # Set force response code 409. ==="
 126     response=client.post(SERVER_URL+'forceresponse?code=409')
 127     assert response.status_code == 200
 128
 129     # API: Get policy instances, shall fail
 130     data_get_errror = {
 131         "title" : "Conflict",
 132         "status" : 409,
 133         "detail" : "Request could not be processed in the current state of the resource"
 134     }
 135     response=client.get(SERVER_URL+'A1-P/v1/policies')
 136     assert response.status_code == 409
 137     result=json.loads(response.data)
 138     res=compare(data_get_errror, result)
 139     assert res == True
 140
 141     # Reset force response
 142     response=client.post(SERVER_URL+'forceresponse')
 143     assert response.status_code == 200
 144     assert response.data ==  b"Force response code: None set for one single A1 response"
 145
 146     ###
 147     ### Repeating the above two test for code coverage
 148     ###
 149     # Set force response code 400
 150     response=client.post(SERVER_URL+'forceresponse?code=400')
 151     assert response.status_code == 200
 152
 153     #API: Create policy instance pi3, shall fail
 154     data_pi3 = {
 155         "scope": {
 156             "ueId": "ue3"
 157             },
 158         "statement": {
 159             "priorityLevel": 5
 160         }
 161     }
 162     data_get_errror = {
 163         "title" : "Bad request",
 164         "status" : 400,
 165         "detail" : "Object in payload not properly formulated or not related to the method"
 166     }
 167     response=client.put(SERVER_URL+'A1-P/v1/policies/pi3', headers=header, data=json.dumps(data_pi3))
 168     assert response.status_code == 400
 169     result=json.loads(response.data)
 170     res=compare(data_get_errror, result)
 171     assert res == True
 172
 173     # Set force response code 404
 174     response=client.post(SERVER_URL+'forceresponse?code=404')
 175     assert response.status_code == 200
 176
 177     # API: Get policy instance pi1, shall fail =="
 178     data_get_errror = {
 179         "title" : "Not found",
 180         "status" : 404,
 181         "detail" : "No resource found at the URI"
 182     }
 183     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1')
 184     assert response.status_code == 404
 185     result=json.loads(response.data)
 186     res=compare(data_get_errror, result)
 187     assert res == True
 188
 189     # Set force response code 405
 190     response=client.post(SERVER_URL+'forceresponse?code=405')
 191     assert response.status_code == 200
 192
 193     # API: Delete policy instances pi1, shall fail =="
 194     data_get_errror = {
 195         "title" : "Method not allowed",
 196         "status" : 405,
 197         "detail" : "Method not allowed for the URI"
 198     }
 199     response=client.delete(SERVER_URL+'A1-P/v1/policies/pi1')
 200     assert response.status_code == 405
 201     result=json.loads(response.data)
 202     res=compare(data_get_errror, result)
 203     assert res == True
 204
 205     # Set force response code 429
 206     response=client.post(SERVER_URL+'forceresponse?code=429')
 207     assert response.status_code == 200
 208
 209     # API: Get policy status pi3, shall fail =="
 210     data_get_errror = {
 211         "title" : "Too many requests",
 212         "status" : 429,
 213         "detail" : "Too many requests have been sent in a given amount of time"
 214     }
 215     response=client.get(SERVER_URL+'A1-P/v1/policies/pi3/status')
 216     assert response.status_code == 429
 217     result=json.loads(response.data)
 218     res=compare(data_get_errror, result)
 219     assert res == True
 220
 221     # Set force response code 507
 222     response=client.post(SERVER_URL+'forceresponse?code=507')
 223     assert response.status_code == 200
 224
 225     # API: Get policy instances, shall fail
 226     data_get_errror = {
 227         "title" : "Insufficient storage",
 228         "status" : 507,
 229         "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"
 230     }
 231     response=client.get(SERVER_URL+'A1-P/v1/policies')
 232     assert response.status_code == 507
 233     result=json.loads(response.data)
 234     res=compare(data_get_errror, result)
 235     assert res == True
 236
 237     # Set force response code 503. ==="
 238     response=client.post(SERVER_URL+'forceresponse?code=503')
 239     assert response.status_code == 200
 240
 241     # API: Get policy instances, shall fail
 242     data_get_errror = {
 243         "title" : "Service unavailable",
 244         "status" : 503,
 245         "detail" : "The provider is currently unable to handle the request due to a temporary overload"
 246     }
 247     response=client.get(SERVER_URL+'A1-P/v1/policies')
 248     assert response.status_code == 503
 249     result=json.loads(response.data)
 250     res=compare(data_get_errror, result)
 251     assert res == True
 252
 253     # Set force response code 555. ==="
 254     response=client.post(SERVER_URL+'forceresponse?code=555')
 255     assert response.status_code == 200
 256
 257     # API: Get policy instances, shall fail
 258     data_get_errror = {
 259         "title" : "Unknown",
 260         "status" : "555",
 261         "detail" : "Not implemented response code"
 262     }
 263     response=client.get(SERVER_URL+'A1-P/v1/policies')
 264     assert response.status_code == 555
 265     result=json.loads(response.data)
 266     res=compare(data_get_errror, result)
 267     assert res == True
 268
 269     ###
 270     ### End of repeated test
 271     ###
 272
 273
 274     # API: Get policy status
 275     data_policy_status = {
 276         "enforceStatus" : "UNDEFINED"
 277     }
 278     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1/status')
 279     assert response.status_code == 200
 280     result=json.loads(response.data)
 281     res=compare(data_policy_status, result)
 282     assert res == True
 283
 284     # API: Create policy instance pi2
 285     data_pi2 = {
 286         "scope": {
 287             "ueId": "ue2",
 288             "groupId": "group2",
 289             "sliceId": "slice2",
 290             "qosId": "qos2",
 291             "cellId": "cell2"
 292             },
 293         "statement": {
 294             "priorityLevel": 10
 295         }
 296     }
 297     response=client.put(SERVER_URL+'A1-P/v1/policies/pi2', headers=header, data=json.dumps(data_pi2))
 298     assert response.status_code == 201
 299     result=json.loads(response.data)
 300     res=compare(data_pi2, result)
 301     assert res == True
 302
 303
 304     # API: Update policy instance pi2
 305     # Reuse same policy data
 306     response=client.put(SERVER_URL+'A1-P/v1/policies/pi2?notificationDestination=http://'+HOST_IP+':'+PORT_NUMBER+'/statustest', headers=header, data=json.dumps(data_pi2))
 307     assert response.status_code == 200
 308     result=json.loads(response.data)
 309     res=compare(data_pi2, result)
 310     assert res == True
 311
 312     # API: Get policy instances, shall contain pi1 and pi2
 313     data_policy_get = [ "pi1", "pi2" ]
 314     response=client.get(SERVER_URL+'A1-P/v1/policies')
 315     assert response.status_code == 200
 316     result=json.loads(response.data)
 317     res=compare(data_policy_get, result)
 318     assert res == True
 319
 320     # Set force delay 10
 321     response=client.post(SERVER_URL+'forcedelay?delay=10')
 322     assert response.status_code == 200
 323     assert response.data ==  b"Force delay: 10 sec set for all A1 responses"
 324
 325     # API: Get policy instances, shall contain pi1 and pi2 and delayed 10 sec
 326     data_policy_get = [ "pi1", "pi2" ]
 327     response=client.get(SERVER_URL+'A1-P/v1/policies')
 328     assert response.status_code == 200
 329     result=json.loads(response.data)
 330     res=compare(data_policy_get, result)
 331     assert res == True
 332
 333     # Reset force delay
 334     response=client.post(SERVER_URL+'forcedelay')
 335     assert response.status_code == 200
 336     assert response.data ==  b"Force delay: None sec set for all A1 responses"
 337
 338     # API: GET policy instance pi1
 339     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1')
 340     assert response.status_code == 200
 341     result=json.loads(response.data)
 342     res=compare(data_pi1_updated, result)
 343     assert res == True
 344
 345     # API: GET policy instance pi2
 346     response=client.get(SERVER_URL+'A1-P/v1/policies/pi2')
 347     assert response.status_code == 200
 348     result=json.loads(response.data)
 349     res=compare(data_pi2, result)
 350     assert res == True
 351
 352     # API: GET policy instance pi9, shall fail
 353     response=client.get(SERVER_URL+'A1-P/v1/policies/pi9')
 354     assert response.status_code == 404
 355
 356     # API: DELETE policy instance pi1
 357     response=client.delete(SERVER_URL+'A1-P/v1/policies/pi1')
 358     assert response.status_code == 204
 359
 360     # API: DELETE policy instance pi9, shall fail
 361     response=client.delete(SERVER_URL+'A1-P/v1/policies/pi9')
 362     assert response.status_code == 404
 363
 364     # API: Get policy status for pi1, shall fail
 365     data_get_errror = {
 366         "title" : "The policy identity does not exist.",
 367         "status" : 404,
 368         "detail" : "There is no existing policy instance with the identity: pi1",
 369         "instance" : "pi1"
 370     }
 371     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1/status')
 372     assert response.status_code == 404
 373     result=json.loads(response.data)
 374     res=compare(data_get_errror, result)
 375     assert res == True
 376
 377     # Set status for policy instance pi2
 378     response=client.put(SERVER_URL+'status?policyid=pi2&status=OK')
 379     assert response.status_code == 200
 380
 381     # API: Get policy status for pi2
 382     data_get_status = {
 383         "enforceStatus" : "OK"
 384     }
 385     response=client.get(SERVER_URL+'A1-P/v1/policies/pi2/status')
 386     assert response.status_code == 200
 387     result=json.loads(response.data)
 388     res=compare(data_get_status, result)
 389     assert res == True
 390
 391     # Set status for policy instance pi2
 392     response=client.put(SERVER_URL+'status?policyid=pi2&status=NOTOK&reason=notok_reason')
 393     assert response.status_code == 200
 394
 395     # API: Get policy status for pi2
 396     data_get_status = {
 397         "enforceStatus" : "NOTOK",
 398         "enforceReason" : "notok_reason"
 399     }
 400     response=client.get(SERVER_URL+'A1-P/v1/policies/pi2/status')
 401     assert response.status_code == 200
 402     result=json.loads(response.data)
 403     res=compare(data_get_status, result)
 404     assert res == True
 405
 406     #Found no way to test these functions
 407     #'sendstatus' will send a http request that will fail
 408     #since no server will receive the call
 409     #These function is instead tested when running the bash script in the 'test' dir
 410     # # Send status for pi2
 411     # response=client.post(SERVER_URL+'sendstatus?policyid=pi2')
 412     # assert response.status_code == 200
 413     # result=json.loads(response.data)
 414     # res=compare(data_get_status, result)
 415     # assert res == True
 416
 417     # # Send status, shall fail
 418     # response=client.post(SERVER_URL+'sendstatus')
 419     # assert response.status_code == 400
 420
 421     # # Send status pi9, shall fail
 422     # response=client.post(SERVER_URL+'sendstatus?policyid=pi9')
 423     # assert response.status_code == 404
 424
 425     # Set status for policy instance , shall fail
 426     response=client.put(SERVER_URL+'status')
 427     assert response.status_code == 400
 428
 429     # Set status for policy instance pi9, shall fail
 430     response=client.put(SERVER_URL+'status?policyid=pi9')
 431     assert response.status_code == 404
 432
 433     # Set status for policy instance pi2, shall fail
 434     response=client.put(SERVER_URL+'status?policyid=pi2')
 435     assert response.status_code == 400
 436
 437
 438     # Get counter: intstance
 439     response=client.get(SERVER_URL+'counter/num_instances')
 440     assert response.status_code == 200
 441     assert response.data ==  b"1"
 442
 443     # Get counter: types (shall be 0)
 444     response=client.get(SERVER_URL+'counter/num_types')
 445     assert response.status_code == 200
 446     assert response.data ==  b"0"
 447
 448     # Get counter: interface
 449     response=client.get(SERVER_URL+'counter/interface')
 450     assert response.status_code == 200
 451     assert response.data ==  b"STD_1.1.3"
 452
 453     # Get counter: remote hosts
 454     response=client.get(SERVER_URL+'counter/remote_hosts')
 455     assert response.status_code == 200
 456
 457     # Get counter: test, shall fail
 458     response=client.get(SERVER_URL+'counter/test')
 459     assert response.status_code == 404