Updated documentation and scripts using https between agent and MR
[nonrtric.git] / test / common / agent_api_functions.sh
1 #!/bin/bash
2
3 #  ============LICENSE_START===============================================
4 #  Copyright (C) 2020 Nordix Foundation. All rights reserved.
5 #  ========================================================================
6 #  Licensed under the Apache License, Version 2.0 (the "License");
7 #  you may not use this file except in compliance with the License.
8 #  You may obtain a copy of the License at
9 #
10 #       http://www.apache.org/licenses/LICENSE-2.0
11 #
12 #  Unless required by applicable law or agreed to in writing, software
13 #  distributed under the License is distributed on an "AS IS" BASIS,
14 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 #  See the License for the specific language governing permissions and
16 #  limitations under the License.
17 #  ============LICENSE_END=================================================
18 #
19
20 # This is a script that contains specific test functions for Policy Agent API
21
22 ### API functiond towards the Policy Agent
23
24 # Generic function to query the agent via the REST or DMAAP interface.
25 # Used by all other agent api test functions
26 # If operation prefix is '_BATCH' the the send and get response is split in two sequences,
27 # one for sending the requests and one for receiving the response
28 # but only when using the DMAAP interface
29 # REST or DMAAP is controlled of the base url of $ADAPTER
30 # arg: (GET|PUT|POST|DELETE|GET_BATCH|PUT_BATCH|POST_BATCH|DELETE_BATCH <url> [<file>]) | (RESPONSE <correlation-id>)
31 # (Not for test scripts)
32 __do_curl_to_agent() {
33     echo "(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
34         paramError=0
35
36     if [ $# -lt 2 ] || [ $# -gt 3 ]; then
37                 paramError=1
38     else
39                 timeout=""
40                 oper=""
41                 file=''
42                 httpcode=" -sw %{http_code}"
43                 accept=''
44                 content=''
45                 batch=0
46                 if [[ $1 == *"_BATCH" ]]; then
47                         batch=1
48                 fi
49                 if [ $# -gt 2 ]; then
50                         content=" -H Content-Type:application/json"
51                 fi
52                 if [ $1 == "GET" ] || [ $1 == "GET_BATCH" ]; then
53                         oper="GET"
54                         if [ $# -ne 2 ]; then
55                                 paramError=1
56                         fi
57                 elif [ $1 == "PUT" ] || [ $1 == "PUT_BATCH" ]; then
58                         oper="PUT"
59                         if [ $# -eq 3 ]; then
60                                 file=" --data-binary @$3"
61                         fi
62                         accept=" -H accept:application/json"
63                 elif [ $1 == "POST" ] || [ $1 == "POST_BATCH" ]; then
64                         oper="POST"
65                         accept=" -H accept:*/*"
66                         if [ $# -ne 2 ]; then
67                                 paramError=1
68                         fi
69                 elif [ $1 == "DELETE" ] || [ $1 == "DELETE_BATCH" ]; then
70                         oper="DELETE"
71                         if [ $# -ne 2 ]; then
72                                 paramError=1
73                         fi
74                 elif [ $1 == "RESPONSE" ]; then
75                         oper="RESPONSE"
76                         if [ $# -ne 2 ]; then
77                                 paramError=1
78                         fi
79                         if ! [ $ADAPTER == $DMAAPBASE ]; then
80                                 paramError=1
81                         fi
82                 else
83                         paramError=1
84                 fi
85         fi
86
87     if [ $paramError -eq 1 ]; then
88                 ((RES_CONF_FAIL++))
89         echo "-Incorrect number of parameters to __do_curl_agent " $@ >> $HTTPLOG
90         echo "-Expected: (GET|PUT|POST|DELETE|GET_BATCH|PUT_BATCH|POST_BATCH|DELETE_BATCH <url> [<file>]) | (RESPONSE <correlation-id>) [<file>]" >> $HTTPLOG
91         echo "-Returning response 000" >> $HTTPLOG
92         echo "-000"
93         return 1
94     fi
95
96     if [ $ADAPTER == $RESTBASE ] || [ $ADAPTER == $RESTBASE_SECURE ]; then
97         url=" "${ADAPTER}${2}
98         oper=" -X "$oper
99         curlString="curl -k "${oper}${timeout}${httpcode}${accept}${content}${url}${file}
100         echo " CMD: "$curlString >> $HTTPLOG
101                 if [ $# -eq 3 ]; then
102                         echo " FILE: $(<$3)" >> $HTTPLOG
103                 fi
104
105                 # Do retry for configured response codes, otherwise only one attempt
106                 maxretries=5
107                 while [ $maxretries -ge 0 ]; do
108
109                         let maxretries=maxretries-1
110                         res=$($curlString)
111                         retcode=$?
112                         if [ $retcode -ne 0 ]; then
113                                 echo " RETCODE: "$retcode >> $HTTPLOG
114                                 echo "000"
115                                 return 1
116                         fi
117                         retry=0
118                         echo " RESP: "$res >> $HTTPLOG
119                         status=${res:${#res}-3}
120                         if [ ! -z "${AGENT_RETRY_CODES}" ]; then
121                                 for retrycode in $AGENT_RETRY_CODES; do
122                                         if [ $retrycode -eq $status ]; then
123                                                 echo -e $RED" Retrying (according to set codes for retry), got status $status....."$ERED  >> $HTTPLOG
124                                                 sleep 1
125                                                 retry=1
126                                         fi
127                                 done
128                         fi
129                         if [ $retry -eq 0 ]; then
130                                 maxretries=-1
131                         fi
132                 done
133         echo $res
134         return 0
135     else
136                 if [ $oper != "RESPONSE" ]; then
137                         requestUrl=$2
138                         if [ $1 == "PUT" ] && [ $# -eq 3 ]; then
139                                 payload="$(cat $3 | tr -d '\n' | tr -d ' ' )"
140                                 echo "payload: "$payload >> $HTTPLOG
141                                 file=" --data-binary "$payload
142                         fi
143                         #urlencode the request url since it will be carried by send-request url
144                         requestUrl=$(python3 -c "from __future__ import print_function; import urllib.parse, sys; print(urllib.parse.quote(sys.argv[1]))"  "$2")
145                         url=" "${ADAPTER}"/send-request?url="${requestUrl}"&operation="${oper}
146                         curlString="curl -X POST${timeout}${httpcode}${content}${url}${file}"
147                         echo " CMD: "$curlString >> $HTTPLOG
148                         res=$($curlString)
149                         retcode=$?
150                         if [ $retcode -ne 0 ]; then
151                                 echo " RETCODE: "$retcode >> $HTTPLOG
152                                 echo "000"
153                                 return 1
154                         fi
155                         echo " RESP: "$res >> $HTTPLOG
156                         status=${res:${#res}-3}
157                         if [ $status -ne 200 ]; then
158                                 echo "000"
159                                 return 1
160                         fi
161                         cid=${res:0:${#res}-3}
162                         if [[ $batch -eq 1 ]]; then
163                                 echo $cid"200"
164                                 return 0
165                         fi
166                 fi
167                 if [ $oper == "RESPONSE" ] || [ $batch -eq 0 ]; then
168                         if [ $oper == "RESPONSE" ]; then
169                                 cid=$2
170                         fi
171                         url=" "${ADAPTER}"/receive-response?correlationid="${cid}
172                         curlString="curl -X GET"${timeout}${httpcode}${url}
173                         echo " CMD: "$curlString >> $HTTPLOG
174                         res=$($curlString)
175                         retcode=$?
176                         if [ $retcode -ne 0 ]; then
177                                 echo " RETCODE: "$retcode >> $HTTPLOG
178                                 echo "000"
179                                 return 1
180                         fi
181                         echo " RESP: "$res >> $HTTPLOG
182                         status=${res:${#res}-3}
183                         TS=$SECONDS
184                         # wait of the reply from the agent...
185                         while [ $status -eq 204 ]; do
186                                 if [ $(($SECONDS - $TS)) -gt 90 ]; then
187                                         echo " RETCODE: (timeout after 90s)" >> $HTTPLOG
188                                         echo "000"
189                                         return 1
190                                 fi
191                                 sleep 0.01
192                                 echo " CMD: "$curlString >> $HTTPLOG
193                                 res=$($curlString)
194                                 if [ $retcode -ne 0 ]; then
195                                         echo " RETCODE: "$retcode >> $HTTPLOG
196                                         echo "000"
197                                         return 1
198                                 fi
199                                 echo " RESP: "$res >> $HTTPLOG
200                                 status=${res:${#res}-3}
201                         done
202                         if [ $status -eq 200 ]; then
203                                 body=${res:0:${#res}-3}
204                                 echo $body
205                                 return 0
206                         fi
207                         echo "Status not 200, returning response 000" >> $HTTPLOG
208                         echo "0000"
209                         return 1
210                 fi
211     fi
212 }
213
214
215 #########################################################
216 #### Test case functions A1 Policy management service
217 #########################################################
218
219 # This function compare the size, towards a target value, of a json array returned from <url> of the Policy Agent.
220 # This is done immediately by setting PASS or FAIL or wait up to and optional timeout before setting PASS or FAIL
221 # args: json:<url> <target-value> [<timeout-in-seconds]
222 # (Function for test scripts)
223 api_equal() {
224     echo "(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
225         if [ $# -eq 2 ] || [ $# -eq 3 ]; then
226                 if [[ $1 == "json:"* ]]; then
227                         __var_test "Policy Agent" $LOCALHOST$POLICY_AGENT_EXTERNAL_PORT"/" $1 "=" $2 $3
228                         return 0
229                 fi
230         fi
231
232         ((RES_CONF_FAIL++))
233         __print_err "needs two or three args: json:<json-array-param> <target-value> [ timeout ]" $@
234         return 1
235 }
236
237 # API Test function: GET /policies
238 # args: <response-code> <ric-id>|NORIC <service-id>|NOSERVICE <policy-ype-id>|NOTYPE [ NOID | [<policy-id> <ric-id> <service-id> EMPTY|<policy-type-id> <template-file>]*]
239 # (Function for test scripts)
240 api_get_policies() {
241         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
242     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
243         ((RES_TEST++))
244         paramError=0
245         if [ $# -lt 4 ]; then
246                 paramError=1
247         elif [ $# -eq 5 ] && [ $5 != "NOID" ]; then
248                 paramError=1
249         elif [ $# -gt 4 ] && [ $(($#%5)) -ne 4 ]; then
250                 paramError=1
251         fi
252
253     if [ $paramError -ne 0 ]; then
254         __print_err "<response-code> <ric-id>|NORIC <service-id>|NOSERVICE <policy-type-id>|NOTYPE [ NOID | [<policy-id> <ric-id> <service-id> EMPTY|<policy-type-id> <template-file>]*]" $@
255         return 1
256     fi
257         queryparams=""
258         if [ $2 != "NORIC" ]; then
259                 queryparams="?ric="$2
260         fi
261         if [ $3 != "NOSERVICE" ]; then
262                 if [ -z $queryparams ]; then
263                         queryparams="?service="$3
264                 else
265                         queryparams=$queryparams"&service="$3
266                 fi
267         fi
268         if [ $4 != "NOTYPE" ]; then
269                 if [ -z $queryparams ]; then
270                         queryparams="?type="$4
271                 else
272                         queryparams=$queryparams"&type="$4
273                 fi
274         fi
275
276         query="/policies"$queryparams
277     res="$(__do_curl_to_agent GET $query)"
278     status=${res:${#res}-3}
279
280         if [ $status -ne $1 ]; then
281                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
282                 ((RES_FAIL++))
283                 __check_stop_at_error
284                 return 1
285         fi
286
287         if [ $# -gt 4 ]; then
288                 if [ $# -eq 5 ] && [ $5 == "NOID" ]; then
289                         targetJson="["
290                 else
291                         body=${res:0:${#res}-3}
292                         targetJson="["
293                         arr=(${@:5})
294
295                         for ((i=0; i<$(($#-4)); i=i+5)); do
296
297                                 if [ "$targetJson" != "[" ]; then
298                                         targetJson=$targetJson","
299                                 fi
300                                 targetJson=$targetJson"{\"id\":\"$UUID${arr[$i]}\",\"lastModified\":\"????\",\"ric\":\"${arr[$i+1]}\",\"service\":\"${arr[$i+2]}\",\"type\":"
301                                 if [ "${arr[$i+3]}" == "EMPTY" ]; then
302                                         targetJson=$targetJson"\"\","
303                                 else
304                                         targetJson=$targetJson"\"${arr[$i+3]}\","
305                                 fi
306                                 file=".p.json"
307                                 sed 's/XXX/'${arr[$i]}'/g' ${arr[$i+4]} > $file
308                                 json=$(cat $file)
309                                 targetJson=$targetJson"\"json\":"$json"}"
310                         done
311                 fi
312
313                 targetJson=$targetJson"]"
314                 echo "TARGET JSON: $targetJson" >> $HTTPLOG
315                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
316
317                 if [ $res -ne 0 ]; then
318                         echo -e $RED" FAIL, returned body not correct"$ERED
319                         ((RES_FAIL++))
320                         __check_stop_at_error
321                         return 1
322                 fi
323         fi
324
325         ((RES_PASS++))
326         echo -e $GREEN" PASS"$EGREEN
327         return 0
328
329 }
330
331 # API Test function: GET /policy
332 #args: <response-code>  <policy-id> [<template-file>]
333 # (Function for test scripts)
334 api_get_policy() {
335         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
336     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
337         ((RES_TEST++))
338
339     if [ $# -lt 2 ] || [ $# -gt 3 ]; then
340         __print_err "<response-code>  <policy-id> [<template-file>] " $@
341         return 1
342     fi
343
344         query="/policy?id=$UUID$2"
345         res="$(__do_curl_to_agent GET $query)"
346         status=${res:${#res}-3}
347
348         if [ $status -ne $1 ]; then
349                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
350                 ((RES_FAIL++))
351                 __check_stop_at_error
352                 return 1
353         fi
354
355         if [ $# -eq 3 ]; then
356                 #Create a policy json to compare with
357                 body=${res:0:${#res}-3}
358                 file=".p.json"
359                 sed 's/XXX/'${2}'/g' $3 > $file
360                 targetJson=$(< $file)
361                 echo "TARGET JSON: $targetJson" >> $HTTPLOG
362                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
363                 if [ $res -ne 0 ]; then
364                         echo -e $RED" FAIL, returned body not correct"$ERED
365                         ((RES_FAIL++))
366                         __check_stop_at_error
367                         return 1
368                 fi
369         fi
370
371         ((RES_PASS++))
372         echo -e $GREEN" PASS"$EGREEN
373         return 0
374 }
375
376 # API Test function: PUT /policy
377 # args: <response-code> <service-name> <ric-id> <policytype-id> <policy-id> <transient> <template-file> [<count>]
378 # (Function for test scripts)
379 api_put_policy() {
380         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
381     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
382         ((RES_TEST++))
383
384     if [ $# -lt 7 ] || [ $# -gt 8 ]; then
385         __print_err "<response-code> <service-name> <ric-id> <policytype-id> <policy-id> <transient>|NOTRANSIENT <template-file> [<count>]" $@
386         return 1
387     fi
388
389         ric=$3
390         count=0
391         max=1
392
393         if [ $# -eq 8 ]; then
394                 max=$8
395         fi
396
397         pid=$5
398         file=$7
399
400         while [ $count -lt $max ]; do
401                 query="/policy?id=$UUID$pid&ric=$ric&service=$2"
402
403                 if [ $4 != "NOTYPE" ]; then
404                         query=$query"&type=$4"
405                 fi
406
407                 if [ $6 != NOTRANSIENT ]; then
408                         query=$query"&transient=$6"
409                 fi
410
411                 file=".p.json"
412                 sed 's/XXX/'${pid}'/g' $7 > $file
413         res="$(__do_curl_to_agent PUT $query $file)"
414         status=${res:${#res}-3}
415                 echo -ne " Creating "$count"("$max")${SAMELINE}"
416                 if [ $status -ne $1 ]; then
417                         echo " Created "$count"?("$max")"
418                         echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
419                         ((RES_FAIL++))
420                         __check_stop_at_error
421                         return 1
422                 fi
423
424                 let pid=$pid+1
425                 let count=$count+1
426                 echo -ne " Created  "$count"("$max")${SAMELINE}"
427         done
428         echo ""
429
430         ((RES_PASS++))
431         echo -e $GREEN" PASS"$EGREEN
432         return 0
433 }
434
435 # API Test function: PUT /policy to run in batch
436 # args: <response-code> <service-name> <ric-id> <policytype-id> <policy-id> <transient> <template-file> [<count>]
437 # (Function for test scripts)
438 api_put_policy_batch() {
439         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
440     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
441         ((RES_TEST++))
442
443     if [ $# -lt 7 ] || [ $# -gt 8 ]; then
444         __print_err "<response-code> <service-name> <ric-id> <policytype-id> <policy-id> <transient> <template-file> [<count>]" $@
445         return 1
446     fi
447
448         ric=$3
449         count=0
450         max=1
451
452         if [ $# -eq 8 ]; then
453                 max=$8
454         fi
455
456         pid=$5
457         file=$7
458         ARR=""
459         while [ $count -lt $max ]; do
460                 query="/policy?id=$UUID$pid&ric=$ric&service=$2"
461
462                 if [ $4 != "NOTYPE" ]; then
463                         query=$query"&type=$4"
464                 fi
465
466                 if [ $6 != NOTRANSIENT ]; then
467                         query=$query"&transient=$6"
468                 fi
469
470                 file=".p.json"
471                 sed 's/XXX/'${pid}'/g' $7 > $file
472         res="$(__do_curl_to_agent PUT_BATCH $query $file)"
473         status=${res:${#res}-3}
474                 echo -ne " Requested(batch) "$count"("$max")${SAMELINE}"
475
476                 if [ $status -ne 200 ]; then
477                         echo " Requested(batch) "$count"?("$max")"
478                         echo -e $RED" FAIL. Exepected status 200 (in request), got "$status $ERED
479                         ((RES_FAIL++))
480                         __check_stop_at_error
481                         return 1
482                 fi
483                 cid=${res:0:${#res}-3}
484                 ARR=$ARR" "$cid
485                 let pid=$pid+1
486                 let count=$count+1
487                 echo -ne " Requested(batch)  "$count"("$max")${SAMELINE}"
488         done
489
490         echo ""
491         count=0
492         for cid in $ARR; do
493
494         res="$(__do_curl_to_agent RESPONSE $cid)"
495         status=${res:${#res}-3}
496                 echo -ne " Created(batch) "$count"("$max")${SAMELINE}"
497
498                 if [ $status -ne $1 ]; then
499                         echo " Created(batch) "$count"?("$max")"
500                         echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
501                         ((RES_FAIL++))
502                         __check_stop_at_error
503                         return 1
504                 fi
505
506                 let count=$count+1
507                 echo -ne " Created(batch)  "$count"("$max")${SAMELINE}"
508         done
509
510         echo ""
511
512         ((RES_PASS++))
513         echo -e $GREEN" PASS"$EGREEN
514         return 0
515 }
516
517 # API Test function: PUT /policy to run in i parallel for a number of rics
518 # args: <response-code> <service-name> <ric-id-base> <number-of-rics> <policytype-id> <policy-start-id> <transient> <template-file> <count-per-ric> <number-of-threads>
519 # (Function for test scripts)
520 api_put_policy_parallel() {
521         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
522     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
523         ((RES_TEST++))
524
525     if [ $# -ne 10 ]; then
526         __print_err " <response-code> <service-name> <ric-id-base> <number-of-rics> <policytype-id> <policy-start-id> <transient> <template-file> <count-per-ric> <number-of-threads>" $@
527         return 1
528     fi
529         resp_code=$1; shift;
530         serv=$1; shift
531         ric_base=$1; shift;
532         num_rics=$1; shift;
533         type=$1; shift;
534         start_id=$1; shift;
535         transient=$1; shift;
536         template=$1; shift;
537         count=$1; shift;
538         pids=$1; shift;
539
540         if [ $ADAPTER != $RESTBASE ] && [ $ADAPTER != $RESTBASE_SECURE ]; then
541                 echo " Info - api_put_policy_parallel uses only the agent REST interface - create over dmaap in parallel is not supported"
542                 echo " Info - will execute over agent REST"
543         fi
544
545         if [ $serv == "NOSERVICE" ]; then
546                 serv=""
547         fi
548         query="/policy?service=$serv"
549
550         if [ $type != "NOTYPE" ]; then
551                 query=$query"&type=$type"
552         fi
553
554         if [ $transient != NOTRANSIENT ]; then
555                 query=$query"&transient=$transient"
556         fi
557
558         urlbase=${ADAPTER}${query}
559
560         for ((i=1; i<=$pids; i++))
561         do
562                 uuid=$UUID
563                 if [ -z "$uuid" ]; then
564                         uuid="NOUUID"
565                 fi
566                 echo "" > ".pid${i}.res.txt"
567                 echo $resp_code $urlbase $ric_base $num_rics $uuid $start_id $template $count $pids $i > ".pid${i}.txt"
568                 echo $i
569         done  | xargs -n 1 -I{} -P $pids bash -c '{
570                 arg=$(echo {})
571                 echo " Parallel process $arg started"
572                 tmp=$(< ".pid${arg}.txt")
573                 python3 ../common/create_policies_process.py $tmp > .pid${arg}.res.txt
574         }'
575         msg=""
576         for ((i=1; i<=$pids; i++))
577         do
578                 file=".pid${i}.res.txt"
579                 tmp=$(< $file)
580                 if [ -z "$tmp" ]; then
581                         echo " Process $i : unknown result (result file empty"
582                         msg="failed"
583                 else
584                         res=${tmp:0:1}
585                         if [ $res == "0" ]; then
586                                 echo " Process $i : OK"
587                         else
588                                 echo " Process $i : failed - "${tmp:1}
589                                 msg="failed"
590                         fi
591                 fi
592         done
593         if [ -z $msg ]; then
594                 echo " $(($count*$num_rics)) policies created/updated"
595                 ((RES_PASS++))
596                 echo -e $GREEN" PASS"$EGREEN
597                 return 0
598         fi
599
600         echo -e $RED" FAIL. One of more processes failed to execute" $ERED
601         ((RES_FAIL++))
602         __check_stop_at_error
603         return 1
604 }
605
606 # API Test function: DELETE /policy
607 # args: <response-code> <policy-id> [count]
608 # (Function for test scripts)
609 api_delete_policy() {
610         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
611     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
612         ((RES_TEST++))
613
614     if [ $# -lt 2 ] || [ $# -gt 3 ]; then
615         __print_err "<response-code> <policy-id> [count]" $@
616         return 1
617     fi
618
619         count=0
620         max=1
621
622         if [ $# -eq 3 ]; then
623                 max=$3
624         fi
625
626         pid=$2
627
628         while [ $count -lt $max ]; do
629                 query="/policy?id="$UUID$pid
630                 res="$(__do_curl_to_agent DELETE $query)"
631                 status=${res:${#res}-3}
632                 echo -ne " Deleting "$count"("$max")${SAMELINE}"
633
634                 if [ $status -ne $1 ]; then
635                         echo " Deleted "$count"?("$max")"
636                         echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
637                         ((RES_FAIL++))
638                         __check_stop_at_error
639                         return 1
640                 fi
641                 let pid=$pid+1
642                 let count=$count+1
643                 echo -ne " Deleted  "$count"("$max")${SAMELINE}"
644         done
645         echo ""
646
647         ((RES_PASS++))
648         echo -e $GREEN" PASS"$EGREEN
649         return 0
650 }
651
652 # API Test function: DELETE /policy to run in batch
653 # args: <response-code> <policy-id> [count]
654 # (Function for test scripts)
655 api_delete_policy_batch() {
656         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
657     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
658         ((RES_TEST++))
659
660     if [ $# -lt 2 ] || [ $# -gt 3 ]; then
661         __print_err "<response-code> <policy-id> [count]" $@
662         return 1
663     fi
664
665         count=0
666         max=1
667
668         if [ $# -eq 3 ]; then
669                 max=$3
670         fi
671
672         pid=$2
673         ARR=""
674         while [ $count -lt $max ]; do
675                 query="/policy?id="$UUID$pid
676                 res="$(__do_curl_to_agent DELETE_BATCH $query)"
677                 status=${res:${#res}-3}
678                 echo -ne " Requested(batch) "$count"("$max")${SAMELINE}"
679
680                 if [ $status -ne 200 ]; then
681                         echo " Requested(batch) "$count"?("$max")"
682                         echo -e $RED" FAIL. Exepected status 200 (in request), got "$status $ERED
683                         ((RES_FAIL++))
684                         __check_stop_at_error
685                         return 1
686                 fi
687                 cid=${res:0:${#res}-3}
688                 ARR=$ARR" "$cid
689                 let pid=$pid+1
690                 let count=$count+1
691                 echo -ne " Requested(batch)  "$count"("$max")${SAMELINE}"
692         done
693
694         echo ""
695
696         count=0
697         for cid in $ARR; do
698
699         res="$(__do_curl_to_agent RESPONSE $cid)"
700         status=${res:${#res}-3}
701                 echo -ne " Deleted(batch) "$count"("$max")${SAMELINE}"
702
703                 if [ $status -ne $1 ]; then
704                         echo " Deleted(batch) "$count"?("$max")"
705                         echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
706                         ((RES_FAIL++))
707                         __check_stop_at_error
708                         return 1
709                 fi
710
711                 let count=$count+1
712                 echo -ne " Deleted(batch)  "$count"("$max")${SAMELINE}"
713         done
714
715         ((RES_PASS++))
716         echo -e $GREEN" PASS"$EGREEN
717         return 0
718 }
719
720 # API Test function: DELETE /policy to run in i parallel for a number of rics
721 # args: <response-code> <number-of-rics> <policy-start-id> <count-per-ric> <number-of-threads>
722 # (Function for test scripts)
723 api_delete_policy_parallel() {
724         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
725     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
726         ((RES_TEST++))
727
728     if [ $# -ne 5 ]; then
729         __print_err " <response-code> <ric-id-base> <number-of-rics> <policy-start-id> <count-per-ric> <number-of-threads>" $@
730         return 1
731     fi
732         resp_code=$1; shift;
733         num_rics=$1; shift;
734         start_id=$1; shift;
735         count=$1; shift;
736         pids=$1; shift;
737
738         if [ $ADAPTER != $RESTBASE ] && [ $ADAPTER != $RESTBASE_SECURE ]; then
739                 echo " Info - api_delete_policy_parallel uses only the agent REST interface - create over dmaap in parallel is not supported"
740                 echo " Info - will execute over agent REST"
741         fi
742
743         query="/policy"
744
745         urlbase=${ADAPTER}${query}
746
747         for ((i=1; i<=$pids; i++))
748         do
749                 uuid=$UUID
750                 if [ -z "$uuid" ]; then
751                         uuid="NOUUID"
752                 fi
753                 echo "" > ".pid${i}.del.res.txt"
754                 echo $resp_code $urlbase $num_rics $uuid $start_id $count $pids $i > ".pid${i}.del.txt"
755                 echo $i
756         done  | xargs -n 1 -I{} -P $pids bash -c '{
757                 arg=$(echo {})
758                 echo " Parallel process $arg started"
759                 tmp=$(< ".pid${arg}.del.txt")
760                 python3 ../common/delete_policies_process.py $tmp > .pid${arg}.del.res.txt
761         }'
762         msg=""
763         for ((i=1; i<=$pids; i++))
764         do
765                 file=".pid${i}.del.res.txt"
766                 tmp=$(< $file)
767                 if [ -z "$tmp" ]; then
768                         echo " Process $i : unknown result (result file empty"
769                         msg="failed"
770                 else
771                         res=${tmp:0:1}
772                         if [ $res == "0" ]; then
773                                 echo " Process $i : OK"
774                         else
775                                 echo " Process $i : failed - "${tmp:1}
776                                 msg="failed"
777                         fi
778                 fi
779         done
780         if [ -z $msg ]; then
781                 echo " $(($count*$num_rics)) deleted"
782                 ((RES_PASS++))
783                 echo -e $GREEN" PASS"$EGREEN
784                 return 0
785         fi
786
787         echo -e $RED" FAIL. One of more processes failed to execute" $ERED
788         ((RES_FAIL++))
789         __check_stop_at_error
790         return 1
791 }
792
793 # API Test function: GET /policy_ids
794 # args: <response-code> <ric-id>|NORIC <service-id>|NOSERVICE <type-id>|NOTYPE ([<policy-instance-id]*|NOID)
795 # (Function for test scripts)
796 api_get_policy_ids() {
797         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
798     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
799         ((RES_TEST++))
800
801     if [ $# -lt 4 ]; then
802                 __print_err "<response-code> <ric-id>|NORIC <service-id>|NOSERVICE <type-id>|NOTYPE ([<policy-instance-id]*|NOID)" $@
803                 return 1
804         fi
805
806         queryparams=""
807
808         if [ $2 != "NORIC" ]; then
809                 queryparams="?ric="$2
810         fi
811
812         if [ $3 != "NOSERVICE" ]; then
813                 if [ -z $queryparams ]; then
814                         queryparams="?service="$3
815                 else
816                         queryparams=$queryparams"&service="$3
817                 fi
818         fi
819         if [ $4 != "NOTYPE" ]; then
820                 if [ -z $queryparams ]; then
821                         queryparams="?type="$4
822                 else
823                         queryparams=$queryparams"&type="$4
824                 fi
825         fi
826
827         query="/policy_ids"$queryparams
828     res="$(__do_curl_to_agent GET $query)"
829     status=${res:${#res}-3}
830
831         if [ $status -ne $1 ]; then
832                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
833                 ((RES_FAIL++))
834                 __check_stop_at_error
835                 return 1
836         fi
837
838         if [ $# -gt 4 ]; then
839                 body=${res:0:${#res}-3}
840                 targetJson="["
841
842                 for pid in ${@:5} ; do
843                         if [ "$targetJson" != "[" ]; then
844                                 targetJson=$targetJson","
845                         fi
846                         if [ $pid != "NOID" ]; then
847                                 targetJson=$targetJson"\"$UUID$pid\""
848                         fi
849                 done
850
851                 targetJson=$targetJson"]"
852                 echo "TARGET JSON: $targetJson" >> $HTTPLOG
853                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
854
855                 if [ $res -ne 0 ]; then
856                         echo -e $RED" FAIL, returned body not correct"$ERED
857                         ((RES_FAIL++))
858                         __check_stop_at_error
859                         return 1
860                 fi
861         fi
862
863         ((RES_PASS++))
864         echo -e $GREEN" PASS"$EGREEN
865         return 0
866 }
867
868 # API Test function: GET /policy_schema
869 # args: <response-code> <policy-type-id> [<schema-file>]
870 # (Function for test scripts)
871 api_get_policy_schema() {
872         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
873     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
874         ((RES_TEST++))
875
876     if [ $# -lt 2 ] || [ $# -gt 3 ]; then
877         __print_err "<response-code> <policy-type-id> [<schema-file>]" $@
878         return 1
879     fi
880
881         query="/policy_schema?id=$2"
882         res="$(__do_curl_to_agent GET $query)"
883         status=${res:${#res}-3}
884
885         if [ $status -ne $1 ]; then
886                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
887                 ((RES_FAIL++))
888                 __check_stop_at_error
889                 return 1
890         fi
891
892         if [ $# -eq 3 ]; then
893
894                 body=${res:0:${#res}-3}
895
896                 targetJson=$(< $3)
897                 echo "TARGET JSON: $targetJson" >> $HTTPLOG
898                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
899
900                 if [ $res -ne 0 ]; then
901                         echo -e $RED" FAIL, returned body not correct"$ERED
902                         ((RES_FAIL++))
903                         __check_stop_at_error
904                         return 1
905                 fi
906         fi
907
908         ((RES_PASS++))
909         echo -e $GREEN" PASS"$EGREEN
910         return 0
911 }
912
913 # API Test function: GET /policy_schemas
914 # args: <response-code>  <ric-id>|NORIC [<schema-file>|NOFILE]*
915 # (Function for test scripts)
916 api_get_policy_schemas() {
917         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
918     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
919         ((RES_TEST++))
920
921     if [ $# -lt 2 ]; then
922         __print_err "<response-code> <ric-id>|NORIC [<schema-file>|NOFILE]*" $@
923         return 1
924     fi
925
926         query="/policy_schemas"
927         if [ $2 != "NORIC" ]; then
928                 query=$query"?ric="$2
929         fi
930
931         res="$(__do_curl_to_agent GET $query)"
932         status=${res:${#res}-3}
933
934         if [ $status -ne $1 ]; then
935                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
936                 ((RES_FAIL++))
937                 __check_stop_at_error
938                 return 1
939         fi
940
941         if [ $# -gt 2 ]; then
942                 body=${res:0:${#res}-3}
943                 targetJson="["
944
945                 for file in ${@:3} ; do
946                         if [ "$targetJson" != "[" ]; then
947                                 targetJson=$targetJson","
948                         fi
949                         if [ $file == "NOFILE" ]; then
950                                 targetJson=$targetJson"{}"
951                         else
952                                 targetJson=$targetJson$(< $file)
953                         fi
954                 done
955
956                 targetJson=$targetJson"]"
957                 echo "TARGET JSON: $targetJson" >> $HTTPLOG
958                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
959
960                 if [ $res -ne 0 ]; then
961                         echo -e $RED" FAIL, returned body not correct"$ERED
962                         ((RES_FAIL++))
963                         __check_stop_at_error
964                         return 1
965                 fi
966         fi
967
968         ((RES_PASS++))
969         echo -e $GREEN" PASS"$EGREEN
970         return 0
971 }
972
973 # API Test function: GET /policy_status
974 # arg: <response-code> <policy-id> (STD <enforce-status> [<reason>])|(OSC <instance-status> <has-been-deleted>)
975 # (Function for test scripts)
976 api_get_policy_status() {
977         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
978     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
979         ((RES_TEST++))
980     if [ $# -lt 4 ] || [ $# -gt 5 ]; then
981                 __print_err "<response-code> <policy-id> (STD <enforce-status> [<reason>])|(OSC <instance-status> <has-been-deleted>)" $@
982                 return 1
983         fi
984
985         targetJson=""
986
987         if [ $3 == "STD" ]; then
988                 targetJson="{\"enforceStatus\":\"$4\""
989                 if [ $# -eq 5 ]; then
990                         targetJson=$targetJson",\"reason\":\"$5\""
991                 fi
992                 targetJson=$targetJson"}"
993         elif [ $3 == "OSC" ]; then
994                 targetJson="{\"instance_status\":\"$4\""
995                 if [ $# -eq 5 ]; then
996                         targetJson=$targetJson",\"has_been_deleted\":\"$5\""
997                 fi
998                 targetJson=$targetJson",\"created_at\":\"????\"}"
999         else
1000                 __print_err "<response-code> (STD <enforce-status> [<reason>])|(OSC <instance-status> <has-been-deleted>)" $@
1001                 return 1
1002         fi
1003
1004         query="/policy_status?id="$UUID$2
1005
1006         res="$(__do_curl_to_agent GET $query)"
1007     status=${res:${#res}-3}
1008
1009         if [ $status -ne $1 ]; then
1010                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1011                 ((RES_FAIL++))
1012                 __check_stop_at_error
1013                 return 1
1014         fi
1015
1016         echo "TARGET JSON: $targetJson" >> $HTTPLOG
1017         body=${res:0:${#res}-3}
1018         res=$(python3 ../common/compare_json.py "$targetJson" "$body")
1019
1020         if [ $res -ne 0 ]; then
1021                 echo -e $RED" FAIL, returned body not correct"$ERED
1022                 ((RES_FAIL++))
1023                 __check_stop_at_error
1024                 return 1
1025         fi
1026
1027         ((RES_PASS++))
1028         echo -e $GREEN" PASS"$EGREEN
1029         return 0
1030 }
1031
1032 # API Test function: GET /policy_types
1033 # args: <response-code> [<ric-id>|NORIC [<policy-type-id>|EMPTY [<policy-type-id>]*]]
1034 # (Function for test scripts)
1035 api_get_policy_types() {
1036         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1037     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1038         ((RES_TEST++))
1039
1040     if [ $# -lt 1 ]; then
1041                 __print_err "<response-code> [<ric-id>|NORIC [<policy-type-id>|EMPTY [<policy-type-id>]*]]" $@
1042                 return 1
1043         fi
1044
1045         if [ $# -eq 1 ]; then
1046                 query="/policy_types"
1047         elif [ $2 == "NORIC" ]; then
1048                 query="/policy_types"
1049         else
1050                 query="/policy_types?ric=$2"
1051         fi
1052
1053     res="$(__do_curl_to_agent GET $query)"
1054     status=${res:${#res}-3}
1055
1056         if [ $status -ne $1 ]; then
1057                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1058                 ((RES_FAIL++))
1059                 __check_stop_at_error
1060                 return 1
1061         fi
1062
1063         if [ $# -gt 2 ]; then
1064                 body=${res:0:${#res}-3}
1065                 targetJson="["
1066
1067                 for pid in ${@:3} ; do
1068                         if [ "$targetJson" != "[" ]; then
1069                                 targetJson=$targetJson","
1070                         fi
1071                         if [ $pid == "EMPTY" ]; then
1072                                 pid=""
1073                         fi
1074                         targetJson=$targetJson"\"$pid\""
1075                 done
1076
1077                 targetJson=$targetJson"]"
1078                 echo "TARGET JSON: $targetJson" >> $HTTPLOG
1079                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
1080
1081                 if [ $res -ne 0 ]; then
1082                         echo -e $RED" FAIL, returned body not correct"$ERED
1083                         ((RES_FAIL++))
1084                         __check_stop_at_error
1085                         return 1
1086                 fi
1087         fi
1088
1089         ((RES_PASS++))
1090         echo -e $GREEN" PASS"$EGREEN
1091         return 0
1092 }
1093
1094 #########################################################
1095 #### Test case functions Health check
1096 #########################################################
1097
1098 # API Test function: GET /status
1099 # args: <response-code>
1100 # (Function for test scripts)
1101 api_get_status() {
1102         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1103     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1104         ((RES_TEST++))
1105     if [ $# -ne 1 ]; then
1106                 __print_err "<response-code>" $@
1107                 return 1
1108         fi
1109     query="/status"
1110     res="$(__do_curl_to_agent GET $query)"
1111     status=${res:${#res}-3}
1112
1113         if [ $status -ne $1 ]; then
1114                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1115                 ((RES_FAIL++))
1116                 __check_stop_at_error
1117                 return 1
1118         fi
1119
1120         ((RES_PASS++))
1121         echo -e $GREEN" PASS"$EGREEN
1122         return 0
1123 }
1124
1125 #########################################################
1126 #### Test case functions RIC Repository
1127 #########################################################
1128
1129 # API Test function: GET /ric
1130 # args: <reponse-code> <management-element-id> [<ric-id>]
1131 # (Function for test scripts)
1132 api_get_ric() {
1133         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1134     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1135         ((RES_TEST++))
1136     if [ $# -lt 2 ] || [ $# -gt 3 ]; then
1137                 __print_err "<reponse-code> <management-element-id> [<ric-id>]" $@
1138                 return 1
1139         fi
1140
1141         query="/ric?managedElementId="$2
1142
1143     res="$(__do_curl_to_agent GET $query)"
1144     status=${res:${#res}-3}
1145
1146         if [ $status -ne $1 ]; then
1147                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1148                 ((RES_FAIL++))
1149                 __check_stop_at_error
1150                 return 1
1151         fi
1152
1153         if [ $# -eq 3 ]; then
1154                 body=${res:0:${#res}-3}
1155                 if [ "$body" != "$3" ]; then
1156                         echo -e $RED" FAIL, returned body not correct"$ERED
1157                         ((RES_FAIL++))
1158                         __check_stop_at_error
1159                         return 1
1160                 fi
1161         fi
1162
1163         ((RES_PASS++))
1164         echo -e $GREEN" PASS"$EGREEN
1165         return 0
1166 }
1167
1168 # API test function: GET /rics
1169 # args: <reponse-code> <policy-type-id>|NOTYPE [<space-separate-string-of-ricinfo>]
1170 # example of <space-separate-string-of-ricinfo> = "ricsim_g1_1:me1_ricsim_g1_1,me2_ricsim_g1_1:1,2,4 ricsim_g1_1:me2_........."
1171 # format of ric-info:  <ric-id>:<list-of-mes>:<list-of-policy-type-ids>
1172 # (Function for test scripts)
1173 api_get_rics() {
1174         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1175     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1176         ((RES_TEST++))
1177
1178     if [ $# -lt 2 ]; then
1179                 __print_err "<reponse-code> <policy-type-id>|NOTYPE [<space-separate-string-of-ricinfo>]" $@
1180                 return 1
1181         fi
1182
1183         query="/rics"
1184         if [ $2 != "NOTYPE" ]; then
1185         query="/rics?policyType="$2
1186         fi
1187
1188     res="$(__do_curl_to_agent GET $query)"
1189     status=${res:${#res}-3}
1190
1191         if [ $status -ne $1 ]; then
1192                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1193                 ((RES_FAIL++))
1194                 __check_stop_at_error
1195                 return 1
1196         fi
1197
1198         if [ $# -gt 2 ]; then
1199                 body=${res:0:${#res}-3}
1200                 res=$(python3 ../common/create_rics_json.py ".tmp_rics.json" "$3" )
1201                 if [ $res -ne 0 ]; then
1202                         echo -e $RED" FAIL, could not create target ric info json"$ERED
1203                         ((RES_FAIL++))
1204                         __check_stop_at_error
1205                         return 1
1206                 fi
1207
1208                 targetJson=$(<.tmp_rics.json)
1209         echo "TARGET JSON: $targetJson" >> $HTTPLOG
1210                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
1211                 if [ $res -ne 0 ]; then
1212                         echo -e $RED" FAIL, returned body not correct"$ERED
1213                         ((RES_FAIL++))
1214                         __check_stop_at_error
1215                         return 1
1216                 fi
1217         fi
1218
1219         ((RES_PASS++))
1220         echo -e $GREEN" PASS"$EGREEN
1221         return 0
1222 }
1223
1224 ##################################################################
1225 #### API Test case functions Service registry and supervision ####
1226 ##################################################################
1227
1228 # API test function: PUT /service
1229 # args: <response-code>  <service-name> <keepalive-timeout> <callbackurl>
1230 # (Function for test scripts)
1231 api_put_service() {
1232         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1233     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1234         ((RES_TEST++))
1235     if [ $# -ne 4 ]; then
1236         __print_err "<response-code>  <service-name> <keepalive-timeout> <callbackurl>" $@
1237         return 1
1238     fi
1239
1240     query="/service"
1241     json="{\"callbackUrl\": \""$4"\",\"keepAliveIntervalSeconds\": \""$3"\",\"serviceName\": \""$2"\"}"
1242     file=".tmp.json"
1243         echo "$json" > $file
1244
1245     res="$(__do_curl_to_agent PUT $query $file)"
1246     status=${res:${#res}-3}
1247
1248         if [ $status -ne $1 ]; then
1249                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1250                 ((RES_FAIL++))
1251                 __check_stop_at_error
1252                 return 1
1253         fi
1254
1255         ((RES_PASS++))
1256         echo -e $GREEN" PASS"$EGREEN
1257         return 0
1258 }
1259
1260 # API test function: GET /services
1261 #args: <response-code> [ (<query-service-name> <target-service-name> <keepalive-timeout> <callbackurl>) | (NOSERVICE <target-service-name> <keepalive-timeout> <callbackurl> [<target-service-name> <keepalive-timeout> <callbackurl>]* )]
1262 # (Function for test scripts)
1263 api_get_services() {
1264         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1265     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1266         ((RES_TEST++))
1267         #Number of accepted parameters: 1, 2, 4, 7, 10, 13,...
1268         paramError=1
1269         if [ $# -eq 1 ]; then
1270                 paramError=0
1271         elif [ $# -eq 2 ] && [ $2 != "NOSERVICE" ]; then
1272                 paramError=0
1273         elif [ $# -eq 5 ]; then
1274                 paramError=0
1275         elif [ $# -gt 5 ] && [ $2 == "NOSERVICE" ]; then
1276                 argLen=$(($#-2))
1277                 if [ $(($argLen%3)) -eq 0 ]; then
1278                         paramError=0
1279                 fi
1280         fi
1281
1282     if [ $paramError -ne 0 ]; then
1283                 __print_err "<response-code> [ (<query-service-name> <target-service-name> <keepalive-timeout> <callbackurl>) | (NOSERVICE <target-service-name> <keepalive-timeout> <callbackurl> [<target-service-name> <keepalive-timeout> <callbackurl>]* )]" $@
1284                 return 1
1285         fi
1286
1287     query="/services"
1288
1289     if [ $# -gt 1 ] && [ $2 != "NOSERVICE" ]; then
1290         query="/services?name="$2
1291         fi
1292
1293     res="$(__do_curl_to_agent GET $query)"
1294     status=${res:${#res}-3}
1295
1296         if [ $status -ne $1 ]; then
1297                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1298                 ((RES_FAIL++))
1299                 __check_stop_at_error
1300                 return 1
1301         fi
1302
1303         if [ $# -gt 2 ]; then
1304                 variableArgCount=$(($#-2))
1305                 body=${res:0:${#res}-3}
1306         targetJson="["
1307                 shift; shift;
1308                 cntr=0
1309                 while [ $cntr -lt $variableArgCount ]; do
1310                         servicename=$1; shift;
1311                         timeout=$1; shift;
1312                         callback=$1; shift;
1313                         if [ $cntr -gt 0 ]; then
1314                                 targetJson=$targetJson","
1315                         fi
1316                         # timeSinceLastActivitySeconds value cannot be checked since value varies
1317                         targetJson=$targetJson"{\"serviceName\": \""$servicename"\",\"keepAliveIntervalSeconds\": "$timeout",\"timeSinceLastActivitySeconds\":\"????\",\"callbackUrl\": \""$callback"\"}"
1318                         let cntr=cntr+3
1319                 done
1320                 targetJson=$targetJson"]"
1321                 echo "TARGET JSON: $targetJson" >> $HTTPLOG
1322                 res=$(python3 ../common/compare_json.py "$targetJson" "$body")
1323                 if [ $res -ne 0 ]; then
1324                         echo -e $RED" FAIL, returned body not correct"$ERED
1325                         ((RES_FAIL++))
1326                         __check_stop_at_error
1327                         return 1
1328                 fi
1329         fi
1330
1331         ((RES_PASS++))
1332         echo -e $GREEN" PASS"$EGREEN
1333         return 0
1334 }
1335
1336 # API test function: GET /services  (only checking service names)
1337 # args: <response-code> [<service-name>]*"
1338 # (Function for test scripts)
1339 api_get_service_ids() {
1340         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1341     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1342         ((RES_TEST++))
1343
1344     if [ $# -lt 1 ]; then
1345                 __print_err "<response-code> [<service-name>]*" $@
1346                 return 1
1347         fi
1348
1349     query="/services"
1350     res="$(__do_curl_to_agent GET $query)"
1351     status=${res:${#res}-3}
1352
1353         if [ $status -ne $1 ]; then
1354                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1355                 ((RES_FAIL++))
1356                 __check_stop_at_error
1357                 return 1
1358         fi
1359
1360         body=${res:0:${#res}-3}
1361         targetJson="["
1362         for rapp in ${@:2} ; do
1363                 if [ "$targetJson" != "[" ]; then
1364                         targetJson=$targetJson","
1365                 fi
1366                 targetJson=$targetJson"{\"callbackUrl\":\"????\",\"keepAliveIntervalSeconds\":\"????\",\"serviceName\":\""$rapp"\",\"timeSinceLastActivitySeconds\":\"????\"}"
1367         done
1368
1369         targetJson=$targetJson"]"
1370         echo "TARGET JSON: $targetJson" >> $HTTPLOG
1371         res=$(python3 ../common/compare_json.py "$targetJson" "$body")
1372
1373         if [ $res -ne 0 ]; then
1374                 echo -e $RED" FAIL, returned body not correct"$ERED
1375                 ((RES_FAIL++))
1376                 __check_stop_at_error
1377                 return 1
1378         fi
1379
1380         ((RES_PASS++))
1381         echo -e $GREEN" PASS"$EGREEN
1382         return 0
1383 }
1384
1385 # API test function: DELETE /services
1386 # args: <response-code> <service-name>
1387 # (Function for test scripts)
1388 api_delete_services() {
1389         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1390     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1391         ((RES_TEST++))
1392
1393     if [ $# -ne 2 ]; then
1394                 __print_err "<response-code> <service-name>" $@
1395                 return 1
1396         fi
1397
1398     query="/services?name="$2
1399     res="$(__do_curl_to_agent DELETE $query)"
1400     status=${res:${#res}-3}
1401
1402         if [ $status -ne $1 ]; then
1403                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1404                 ((RES_FAIL++))
1405                 __check_stop_at_error
1406                 return 1
1407         fi
1408
1409         ((RES_PASS++))
1410         echo -e $GREEN" PASS"$EGREEN
1411         return 0
1412 }
1413
1414 # API test function: PUT /services/keepalive
1415 # args: <response-code> <service-name>
1416 # (Function for test scripts)
1417 api_put_services_keepalive() {
1418         echo -e $BOLD"TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ $EBOLD
1419     echo "TEST(${BASH_LINENO[0]}): ${FUNCNAME[0]}" $@ >> $HTTPLOG
1420         ((RES_TEST++))
1421
1422     if [ $# -ne 2 ]; then
1423                 __print_err "<response-code> <service-name>" $@
1424                 return 1
1425         fi
1426
1427     query="/services/keepalive?name="$2
1428     res="$(__do_curl_to_agent PUT $query)"
1429     status=${res:${#res}-3}
1430
1431         if [ $status -ne $1 ]; then
1432                 echo -e $RED" FAIL. Exepected status "$1", got "$status $ERED
1433                 ((RES_FAIL++))
1434                 __check_stop_at_error
1435                 return 1
1436         fi
1437
1438         ((RES_PASS++))
1439         echo -e $GREEN" PASS"$EGREEN
1440         return 0
1441 }
1442