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

   1 #  ============LICENSE_START===============================================
   2 #  Copyright (C) 2021 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', 'STD_2.0.0']"
  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 pi3 (copy of pi1).
 114     response=client.put(SERVER_URL+'A1-P/v1/policies/pi3', headers=header, data=json.dumps(data_pi1))
 115     assert response.status_code == 201
 116     result=json.loads(response.data)
 117     res=compare(data_pi1, result)
 118     assert res == True
 119
 120     # API: DELETE policy instance pi1
 121     response=client.delete(SERVER_URL+'A1-P/v1/policies/pi3')
 122     assert response.status_code == 204
 123
 124     # Set force response code 409. ==="
 125     response=client.post(SERVER_URL+'forceresponse?code=409')
 126     assert response.status_code == 200
 127
 128     # API: Get policy instances, shall fail
 129     data_get_errror = {
 130         "title" : "Conflict",
 131         "status" : 409,
 132         "detail" : "Request could not be processed in the current state of the resource"
 133     }
 134     response=client.get(SERVER_URL+'A1-P/v1/policies')
 135     assert response.status_code == 409
 136     result=json.loads(response.data)
 137     res=compare(data_get_errror, result)
 138     assert res == True
 139
 140     # Reset force response
 141     response=client.post(SERVER_URL+'forceresponse')
 142     assert response.status_code == 200
 143     assert response.data ==  b"Force response code: None set for one single A1 response"
 144
 145     ###
 146     ### Repeating the above two test for code coverage
 147     ###
 148     # Set force response code 400
 149     response=client.post(SERVER_URL+'forceresponse?code=400')
 150     assert response.status_code == 200
 151
 152     #API: Create policy instance pi3, shall fail
 153     data_pi3 = {
 154         "scope": {
 155             "ueId": "ue3"
 156             },
 157         "statement": {
 158             "priorityLevel": 5
 159         }
 160     }
 161     data_get_errror = {
 162         "title" : "Bad request",
 163         "status" : 400,
 164         "detail" : "Object in payload not properly formulated or not related to the method"
 165     }
 166     response=client.put(SERVER_URL+'A1-P/v1/policies/pi3', headers=header, data=json.dumps(data_pi3))
 167     assert response.status_code == 400
 168     result=json.loads(response.data)
 169     res=compare(data_get_errror, result)
 170     assert res == True
 171
 172     # Set force response code 404
 173     response=client.post(SERVER_URL+'forceresponse?code=404')
 174     assert response.status_code == 200
 175
 176     # API: Get policy instance pi1, shall fail =="
 177     data_get_errror = {
 178         "title" : "Not found",
 179         "status" : 404,
 180         "detail" : "No resource found at the URI"
 181     }
 182     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1')
 183     assert response.status_code == 404
 184     result=json.loads(response.data)
 185     res=compare(data_get_errror, result)
 186     assert res == True
 187
 188     # Set force response code 405
 189     response=client.post(SERVER_URL+'forceresponse?code=405')
 190     assert response.status_code == 200
 191
 192     # API: Delete policy instances pi1, shall fail =="
 193     data_get_errror = {
 194         "title" : "Method not allowed",
 195         "status" : 405,
 196         "detail" : "Method not allowed for the URI"
 197     }
 198     response=client.delete(SERVER_URL+'A1-P/v1/policies/pi1')
 199     assert response.status_code == 405
 200     result=json.loads(response.data)
 201     res=compare(data_get_errror, result)
 202     assert res == True
 203
 204     # Set force response code 429
 205     response=client.post(SERVER_URL+'forceresponse?code=429')
 206     assert response.status_code == 200
 207
 208     # API: Get policy status pi3, shall fail =="
 209     data_get_errror = {
 210         "title" : "Too many requests",
 211         "status" : 429,
 212         "detail" : "Too many requests have been sent in a given amount of time"
 213     }
 214     response=client.get(SERVER_URL+'A1-P/v1/policies/pi3/status')
 215     assert response.status_code == 429
 216     result=json.loads(response.data)
 217     res=compare(data_get_errror, result)
 218     assert res == True
 219
 220     # Set force response code 507
 221     response=client.post(SERVER_URL+'forceresponse?code=507')
 222     assert response.status_code == 200
 223
 224     # API: Get policy instances, shall fail
 225     data_get_errror = {
 226         "title" : "Insufficient storage",
 227         "status" : 507,
 228         "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"
 229     }
 230     response=client.get(SERVER_URL+'A1-P/v1/policies')
 231     assert response.status_code == 507
 232     result=json.loads(response.data)
 233     res=compare(data_get_errror, result)
 234     assert res == True
 235
 236     # Set force response code 503. ==="
 237     response=client.post(SERVER_URL+'forceresponse?code=503')
 238     assert response.status_code == 200
 239
 240     # API: Get policy instances, shall fail
 241     data_get_errror = {
 242         "title" : "Service unavailable",
 243         "status" : 503,
 244         "detail" : "The provider is currently unable to handle the request due to a temporary overload"
 245     }
 246     response=client.get(SERVER_URL+'A1-P/v1/policies')
 247     assert response.status_code == 503
 248     result=json.loads(response.data)
 249     res=compare(data_get_errror, result)
 250     assert res == True
 251
 252     # Set force response code 555. ==="
 253     response=client.post(SERVER_URL+'forceresponse?code=555')
 254     assert response.status_code == 200
 255
 256     # API: Get policy instances, shall fail
 257     data_get_errror = {
 258         "title" : "Unknown",
 259         "status" : "555",
 260         "detail" : "Not implemented response code"
 261     }
 262     response=client.get(SERVER_URL+'A1-P/v1/policies')
 263     assert response.status_code == 555
 264     result=json.loads(response.data)
 265     res=compare(data_get_errror, result)
 266     assert res == True
 267
 268     ###
 269     ### End of repeated test
 270     ###
 271
 272
 273     # API: Get policy status
 274     data_policy_status = {
 275         "enforceStatus" : "UNDEFINED"
 276     }
 277     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1/status')
 278     assert response.status_code == 200
 279     result=json.loads(response.data)
 280     res=compare(data_policy_status, result)
 281     assert res == True
 282
 283     # API: Create policy instance pi2
 284     data_pi2 = {
 285         "scope": {
 286             "ueId": "ue2",
 287             "groupId": "group2",
 288             "sliceId": "slice2",
 289             "qosId": "qos2",
 290             "cellId": "cell2"
 291             },
 292         "statement": {
 293             "priorityLevel": 10
 294         }
 295     }
 296     response=client.put(SERVER_URL+'A1-P/v1/policies/pi2', headers=header, data=json.dumps(data_pi2))
 297     assert response.status_code == 201
 298     result=json.loads(response.data)
 299     res=compare(data_pi2, result)
 300     assert res == True
 301
 302
 303     # API: Update policy instance pi2
 304     # Reuse same policy data
 305     response=client.put(SERVER_URL+'A1-P/v1/policies/pi2?notificationDestination=http://'+HOST_IP+':'+PORT_NUMBER+'/statustest', headers=header, data=json.dumps(data_pi2))
 306     assert response.status_code == 200
 307     result=json.loads(response.data)
 308     res=compare(data_pi2, result)
 309     assert res == True
 310
 311     # API: Get policy instances, shall contain pi1 and pi2
 312     data_policy_get = [ "pi1", "pi2" ]
 313     response=client.get(SERVER_URL+'A1-P/v1/policies')
 314     assert response.status_code == 200
 315     result=json.loads(response.data)
 316     res=compare(data_policy_get, result)
 317     assert res == True
 318
 319     # Set force delay 10
 320     response=client.post(SERVER_URL+'forcedelay?delay=10')
 321     assert response.status_code == 200
 322     assert response.data ==  b"Force delay: 10 sec set for all A1 responses"
 323
 324     # API: Get policy instances, shall contain pi1 and pi2 and delayed 10 sec
 325     data_policy_get = [ "pi1", "pi2" ]
 326     response=client.get(SERVER_URL+'A1-P/v1/policies')
 327     assert response.status_code == 200
 328     result=json.loads(response.data)
 329     res=compare(data_policy_get, result)
 330     assert res == True
 331
 332     # Reset force delay
 333     response=client.post(SERVER_URL+'forcedelay')
 334     assert response.status_code == 200
 335     assert response.data ==  b"Force delay: None sec set for all A1 responses"
 336
 337     # API: GET policy instance pi1
 338     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1')
 339     assert response.status_code == 200
 340     result=json.loads(response.data)
 341     res=compare(data_pi1_updated, result)
 342     assert res == True
 343
 344     # API: GET policy instance pi2
 345     response=client.get(SERVER_URL+'A1-P/v1/policies/pi2')
 346     assert response.status_code == 200
 347     result=json.loads(response.data)
 348     res=compare(data_pi2, result)
 349     assert res == True
 350
 351     # API: GET policy instance pi9, shall fail
 352     response=client.get(SERVER_URL+'A1-P/v1/policies/pi9')
 353     assert response.status_code == 404
 354
 355     # API: DELETE policy instance pi1
 356     response=client.delete(SERVER_URL+'A1-P/v1/policies/pi1')
 357     assert response.status_code == 204
 358
 359     # API: DELETE policy instance pi9, shall fail
 360     response=client.delete(SERVER_URL+'A1-P/v1/policies/pi9')
 361     assert response.status_code == 404
 362
 363     # API: Get policy status for pi1, shall fail
 364     data_get_errror = {
 365         "title" : "The policy identity does not exist.",
 366         "status" : 404,
 367         "detail" : "There is no existing policy instance with the identity: pi1",
 368         "instance" : "pi1"
 369     }
 370     response=client.get(SERVER_URL+'A1-P/v1/policies/pi1/status')
 371     assert response.status_code == 404
 372     result=json.loads(response.data)
 373     res=compare(data_get_errror, result)
 374     assert res == True
 375
 376     # Set status for policy instance pi2
 377     response=client.put(SERVER_URL+'status?policyid=pi2&status=OK')
 378     assert response.status_code == 200
 379
 380     # API: Get policy status for pi2
 381     data_get_status = {
 382         "enforceStatus" : "OK"
 383     }
 384     response=client.get(SERVER_URL+'A1-P/v1/policies/pi2/status')
 385     assert response.status_code == 200
 386     result=json.loads(response.data)
 387     res=compare(data_get_status, result)
 388     assert res == True
 389
 390     # Set status for policy instance pi2
 391     response=client.put(SERVER_URL+'status?policyid=pi2&status=NOTOK&reason=notok_reason')
 392     assert response.status_code == 200
 393
 394     # API: Get policy status for pi2
 395     data_get_status = {
 396         "enforceStatus" : "NOTOK",
 397         "enforceReason" : "notok_reason"
 398     }
 399     response=client.get(SERVER_URL+'A1-P/v1/policies/pi2/status')
 400     assert response.status_code == 200
 401     result=json.loads(response.data)
 402     res=compare(data_get_status, result)
 403     assert res == True
 404
 405     #Found no way to test these functions
 406     #'sendstatus' will send a http request that will fail
 407     #since no server will receive the call
 408     #These function is instead tested when running the bash script in the 'test' dir
 409     # # Send status for pi2
 410     # response=client.post(SERVER_URL+'sendstatus?policyid=pi2')
 411     # assert response.status_code == 200
 412     # result=json.loads(response.data)
 413     # res=compare(data_get_status, result)
 414     # assert res == True
 415
 416     # # Send status, shall fail
 417     # response=client.post(SERVER_URL+'sendstatus')
 418     # assert response.status_code == 400
 419
 420     # # Send status pi9, shall fail
 421     # response=client.post(SERVER_URL+'sendstatus?policyid=pi9')
 422     # assert response.status_code == 404
 423
 424     # Set status for policy instance , shall fail
 425     response=client.put(SERVER_URL+'status')
 426     assert response.status_code == 400
 427
 428     # Set status for policy instance pi9, shall fail
 429     response=client.put(SERVER_URL+'status?policyid=pi9')
 430     assert response.status_code == 404
 431
 432     # Set status for policy instance pi2, shall fail
 433     response=client.put(SERVER_URL+'status?policyid=pi2')
 434     assert response.status_code == 400
 435
 436
 437     # Get counter: intstance
 438     response=client.get(SERVER_URL+'counter/num_instances')
 439     assert response.status_code == 200
 440     assert response.data ==  b"1"
 441
 442     # Get counter: types (shall be 0)
 443     response=client.get(SERVER_URL+'counter/num_types')
 444     assert response.status_code == 200
 445     assert response.data ==  b"0"
 446
 447     # Get counter: interface
 448     response=client.get(SERVER_URL+'counter/interface')
 449     assert response.status_code == 200
 450     assert response.data ==  b"STD_1.1.3"
 451
 452     # Get counter: remote hosts
 453     response=client.get(SERVER_URL+'counter/remote_hosts')
 454     assert response.status_code == 200
 455
 456     # Get counter: test, shall fail
 457     response=client.get(SERVER_URL+'counter/test')
 458     assert response.status_code == 404