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