This page details the test specification for ACM for all new and existing functionality.

Prerequisites

Access to a development laptop capable of running many docker containers
Access to a Kubernetes cluster, either locally or remotely (if carrying out kubernetes participant tests)

Environment Setup

The immediate components like, acm, participants, databases etc will be deployed in your local environment using docker compose configurations from the policy/docker repo details are in the documentation here. However, we want to add mock participants for http, k8s and policy participants. So, we have to replace the docker-compose.yaml in the policy/docker `/compose` directory with this one

Once this change is made, we can bring up all our required components with `./start-compose.sh policy-clamp-runtime-acm`

Test Group Setup Steps

	Steps for Scenario Setup	Scenario Finish Steps
Successful Endpoint Interaction	Deploy relevant policy components with instructions give in the above section In this case, we will be testing that the behaviour of the participant is correct in successful situations The mock participant can be used for http, k8s and policy participants Mock participant is also deployed with the policy docker compose. There is a postman collection specifically for the successful endpoint interaction scenario here Once the docker containers are deployed, you can confirm their health with the healthcheck calls specified in the collection for acm and the participants. After each test or set of tests, the relevant calls in directory "Cleanup ACs" should be run. e.g. undeploy, deprime etc.
Non-Successful Endpoint Interaction
Failure Handling Scenario	Deploy relevant policy components with instructions give in the above section In this case, we will be testing that the behaviour of the participant is correct in failure situations The mock participant can be used for http, k8s and policy participants Mock participant is also deployed with the policy docker compose. There is a postman collection specifically for the failure handling scenario here Once the docker containers are deployed, you can confirm their health with the healthcheck calls specified in the collection for acm and the participants. After each test or set of tests, the relevant calls in directory "Cleanup ACs" should be run. e.g. undeploy, deprime etc.
Participant Set Properties Scenario	Deploy relevant policy components with instructions give in the above section In this case, we will be testing that the behaviour of the participant is correct when the participant is used to set properties in "outProperties" The mock participant can be used for http, k8s and policy participants - the example will be for the http participant Mock participant is also deployed with the policy docker compose. There is a postman collection specifically for the participant set properties scenario here Once the docker containers are deployed, you can confirm their health with the healthcheck calls specified in the collection for acm and the participants. After each test or set of tests, the relevant calls in directory "Cleanup ACs" should be run. e.g. undeploy, deprime etc.
Participant Restart Scenario	Deploy relevant policy components with instructions give in the above section In this case, we will be testing that the behaviour of the participant is correct when the participant is restarted at various stages. The mock participant can be used for http, k8s and policy participants - the example will be for the http participant Mock participant is also deployed with the policy docker compose. There is a postman collection specifically for the participant restart scenario here Once the docker containers are deployed, you can confirm their health with the healthcheck calls specified in the collection for acm and the participants. After each test or set of tests, the relevant calls in directory "Cleanup ACs" should be run. Each restart test includes the following common steps to be executed. Manually restart the container or mvn application of one of the participant. After the participant comes up and sends a register event to the runtime , Execute GET participant - should provide 200 response. Verify the participant state is set to "RESTARTING". Execute the corresponding REST call relevant to the test for validating the restart scenario. Execute GET participant after a few seconds of delay to verify the participant is set back to ONLINE by the runtime.
Multiple Simultaneous Message Scenario
Timeout Scenario	Deploy relevant policy components with instructions give in the above section In this case, we will be testing that the behaviour of the acm timeout functionality is correct. The mock participant can be used for http, k8s and policy participants - the example will be for the http participant Mock participant is also deployed with the policy docker compose. As the timeout is specifically set in the properties file of the ACM runtime, a special properties file is added here, which must be supplied to the docker-compose.yaml file. There is a postman collection specifically for the timeout scenario here Once the docker containers are deployed, you can confirm their health with the healthcheck calls specified in the collection for acm and the participants. After each test or set of tests, the relevant calls in directory "Cleanup ACs" should be run. Note that, by default, the timeout threshold is set to 30 seconds. The participant time to carry out different operations (priming, deploying etc) is set to 100 seconds by default. Once the state of the instance or definition is in TIMEOUT, that means the user can cancel the operation with a rest call. For example, if the PRIME is in TIMEOUT, the user can DEPRIME.
Update Scenario	Deploy relevant policy components with instructions given in the above section In this case, we will be testing the behavior of ACM update properties functionality is correct Mock participant can be used for http, k8s and policy participant - the example will be for the http participant Please find the postman collection for update scenario here Once the docker containers are deployed, you can confirm their health with healthcheck calls specified in the collection for acm and the participants. After each test or set of tests, the relevant calls in directory "Cleanup ACs" should be run.
Check Validation Scenario	Deploy relevant policy components with instructions give in the above section In this case, we will be testing that the behaviour of the participant and checking the validaton scenarios The mock participant can be used for http, k8s and policy participants Mock participant is also deployed with the policy docker compose. There is a postman collection specifically for the checking validation scenario here Once the docker containers are deployed, you can confirm their health with the healthcheck calls specified in the collection for acm and the participants. After each test or set of tests, the relevant calls in directory "Cleanup ACs" should be run. e.g. undeploy, deprime etc.

Test Cases

In all test cases, that are calling rest endpoints, it is the ACM rest API that is being called. The url prefix to each rest call is: IP_ADDRESS:RUNTIME_PORT/onap/policy/clamp/acm/v2/. Use the provided POSTMAN collection to make the relevant calls.

Functionality Being Tested

Title

Test case

Steps

Expected Result

Test Result
PASS/FAIL

Notes

Mock Participant

Failure Handling

Prime AC Def and confirm test failure from http, k8s and policy participants

Prime AC def - http, k8s and policy participants should send back error message

Call each put request in the "Prime Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Finally call "Get commission"

200 response

In the response json, we should see – "state": "PRIMING" – and also a message in each element "Prime failed!"

HTTP Participant, K8s Participant, Policy Participant

Y

Failure Handling

Deprime AC Def and confirm test failure from http, k8s and policy participants

Deprime AC def - http, k8s and policy participants should send back error message

Call each put request in the "Deprime Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Depriming AC definition" - response should be 202
Finally call "Get commission"

200 response

In the response json, we should see – "state": "PRIMED" – and also a message in each element "Deprime failed!"

HTTP Participant, K8s Participant, Policy Participant

Y

Failure Handling

Deploy AC instance and confirm test failure from http, k8s and policy participants

Deploy AC instance - http, k8s and policy participants should send back error message

Call each put request in the "Deploy Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Finally, we call "Get Instantiated List" and should get a 200 response

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "DEPLOYING"

Each element should contain the message "Deploy failed!"

HTTP Participant, K8s Participant, Policy Participant

Y

Failure Handling

Undeploy AC instance and confirm test failure from http, k8s and policy participants

Undeploy AC instance - http, k8s and policy participants should send back error message

Call each put request in the "Undeploy Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Undeploy Instantiated" call from the collection and should get a 202 response
Call "Get Instantiated List" once again

200 response

we should see the overall "deployState: UNDEPLOYING" with a message in each element that says "Deployed"

HTTP Participant, K8s Participant, Policy Participant

Y

Failure Handling

Delete AC instance and confirm test failure from http, k8s and policy participants

Delete AC instance - http, k8s and policy participants should send back error message

Call each put request in the "Delete Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Undeploy Instantiated" call from the collection and should get a 202 response
Then, we can call "Delete Instantiated" - should get a 202
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "DELETING"

Each element should contain the message "Undeployed"

HTTP Participant, K8s Participant, Policy Participant

Y

Failure Handling

Update AC instance and confirm test failure from http, k8s and policy participants

Update AC instance - http, k8s and policy participants should send back error message

Call each put request in the "Update Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Update Instantiation AC" call from the collection and should get a 200 response
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "UPDATING"

Each element should contain the message "Update failed!"

HTTP Participant, K8s Participant, Policy Participant

Y

Failure Handling

Unlock AC instance and confirm test failure from http, k8s and policy participants

Unlock AC instance - http, k8s and policy participants should send back error message

Call each put request in the "Unlock Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Unlock Instantiated" call from the collection and should get a 202 response
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "UNLOCKING"

Each element should contain the message "Unlock failed!"

HTTP Participant, K8s Participant, Policy Participant

Y

Failure Handling

Lock AC instance and confirm test failure from http, k8s and policy participants

Lock AC instance - http, k8s and policy participants should send back error message

Call each put request in the "Lock Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should beDeploy 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Unlock Instantiated" call from the collection and should get a 202 response
Then, call "Lock Instantiated" from the collection - should get a 202 response
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "LOCKING"

Each element should contain the message "Unlocked"

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Prime AC Def and confirm timeout from http, k8s and policy participants

Prime AC def - http, k8s and policy participants operation should timeout after 30 seconds

Call each put request in the "Prime Timeout Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Wait 30 seconds.
Call "Get commission" - should have a 200 response. In the response json, we should see – "state": "PRIMING" – and also a stateChangeResult: TIMEOUT.
At this stage, because the operation timed out (after 30 seconds), we can deprime (should be before the 100 second priming success time). Call "Depriming AC definition" - response should be 202.
Call "GET Commission" once again.

200 response

In the response json, we should see – "state": "COMMISSIONED" – and also a stateChangeResult: NO_ERROR - so depriming has worked after the timeout.

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Deprime AC Def and confirm timeout from http, k8s and policy participants

Deprime AC def - http, k8s and policy participants should timeout after 30 seconds

Call each put request in the "Deprime Timeout Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Depriming AC definition" - response should be 202
Wait 30 seconds
Call "Get commission" - should have a 200 response. In the response json, we should see – "state": "DEPRIMING" – and also a stateChangeResult: TIMEOUT.
At this stage, because the operation timed out (after 30 seconds), we can re-prime (should be before the 100 second depriming success time). Call "Priming AC definition" - response should be 202.
Call "Get commission"

200 response

In the response json, we should see – "state": "PRIMED" – and also a stateChangeResult: NO_ERROR

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Deploy AC instance and confirm timeout from http, k8s and policy participants

Deploy AC instance - http, k8s and policy participants should timeout after 30 seconds

Call each put request in the "Deploy Timeout Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Wait 30 seconds
Call "Get Instantiated List" and should get a 200 response. The stateChangeResult should be TIMEOUT.
At this stage, because the operation timed out (after 30 seconds), we can undeploy (should be before the 100 second undeploy success time). Call "Undeploy Instantiated" - response should be 202.
Call "Get Instantiated List"

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "UNDEPLOYED"

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Undeploy AC instance and confirm timeout from http, k8s and policy participants

Undeploy AC instance - http, k8s and policy participants should timeout after 30 seconds

Call each put request in the "Undeploy Timeout Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Undeploy Instantiated" - response should be 202
Wait 30 seconds
Call "Get Instantiated List" and should get a 200 response The stateChangeResult should be TIMEOUT.
At this stage, because the operation timed out (after 30 seconds), we can deploy (should be before the 100 second undeploy success time). Call "Deploy Instantiated" - response should be 202.
Call "Get Instantiated List" once again

200 response

we should see the overall "deployState: DEPLOYED" with a message in each element that says "Deployed"

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Delete AC instance and confirm timeout from http, k8s and policy participants

Delete AC instance - http, k8s and policy participants should timeout after 30 seconds

Call each put request in the "Delete Timeout Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Undeploy Instantiated" call from the collection and should get a 202 response
Then, we can call "Delete Instantiated" - should get a 202
Wait 30 seconds
Call "Get Instantiated List" and should get a 200 response The stateChangeResult should be TIMEOUT.
Call each put request in the "Update Timeout Scenario" directory - each should return 200. This will shorten the delay for DELETE
At this stage, because the operation timed out (after 30 seconds), we can try delete again (should be before the 100 second delete success time). Call "Deploy Instantiated" - response should be 202.
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

It should be empty

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Update AC instance and confirm timeout from http, k8s and policy participants

Update AC instance - http, k8s and policy participants should timeout after 30 seconds

Call each put request in the "Update Failure Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Update Instantiation AC" call from the collection and should get a 200 response
Wait 30 seconds
Call "Get Instantiated List" and should get a 200 response The stateChangeResult should be TIMEOUT.
Call each put request in the "Delete Timeout Scenario" directory - each should return 200. This will shorten the delay for UPDATE
At this stage, because the operation timed out (after 30 seconds), we can try to update again (should be before the 100 second update success time). Call "Update Instantiated" - response should be 202.
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "DEPLOYED"

Each element should contain the message "Updated!"

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Unlock AC instance and confirm timeout from http, k8s and policy participants

Unlock AC instance - http, k8s and policy participants should timeout after 30 seconds

Call each put request in the "Unlock Timeout Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Unlock Instantiated" call from the collection and should get a 202 response
Wait 30 seconds
Call "Get Instantiated List" and should get a 200 response The stateChangeResult should be TIMEOUT.
At this stage, because the operation timed out (after 30 seconds), we can try to lock (should be before the 100 second update success time). Call "Lock Instantiated" - response should be 202.
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "LOCKED"

HTTP Participant, K8s Participant, Policy Participant

Y

Timeout

Lock AC instance and confirm timeout from http, k8s and policy participants

Lock AC instance - http, k8s and policy participants should timeout after 30 seconds

Call each put request in the "Lock Timeout Scenario" directory - each should return 200
Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC.
Now, we call the "Unlock Instantiated" call from the collection and should get a 202 response
Then, call "Lock Instantiated" from the collection - should get a 202 response
Wait 30 seconds
Call "Get Instantiated List" and should get a 200 response The stateChangeResult should be TIMEOUT.
At this stage, because the operation timed out (after 30 seconds), we can try to unlock (should be before the 100 second update success time). Call "Unlock Instantiated" - response should be 202.
Finally, Call "Get Instantiated List" once again

200 response with an "automationCompositionList"

In the JSON returned, the instance deployState should be "UNLOCKED"

HTTP Participant, K8s Participant, Policy Participant

Y

Participant Out Properties

Set outProperties using the participant and retrieve them from the database

Any properties we set on the participant-side "outProperties" object should be retrievable from ACM

Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC. We should also be able to see an empty "outProperties" object under the http element.
Call "Set outProperties in http-participant" - the response should be 200.
Finally, Call "Get Instantiated List".

200 response with an "automationCompositionList"

The outProperties object should now look like the json illustrated in the next column

"outProperties": {
"deleteAll": "true",
"nest": {
"birdone": "sparrow",
"birdtwo": "cuckoo",
"egg": 4
},
"list": [
{
"id": 1
},
{
"id": 2
}
]
}

Y

Participant Out Properties

Try to Set outProperties using the participant and retrieve them from the database before the instance is deployed

Any properties we set on the participant-side "outProperties" object should not be retrievable from ACM before the instance is deployed

Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Get Instantiated List" and should get a 200 response and we should see the "deployState: DEPLOYED" for the overall AC. We should also be able to see an empty "outProperties" object under the http element.
Call "Set outProperties in http-participant" - the response should be 200.
Finally, Call "Get Instantiated List".

200 response with an "automationCompositionList"

The outProperties object should be empty as before

Y

Multiple Messages Scenario

LOCK the instance in "DEPLOYING/UNLOCKING"
state

Execute PUT request on runtime acm.
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId}}/instances/{{instanceId}}

200 Response
The runtime should allow undeploy operation and deleting the instance when one or more element is stuck in DEPLOYING state

Non-Successful Endpoint Interaction

Delete AC defintion after priming

Delete the commissioned defintion type2 after
priming

Execute DELETE request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId2}}

400 Bad Request response.
Should not allow to delete when primed

"ACM not in COMMISSIONED state, Update of ACM Definition not allowed"

Non-Successful Endpoint Interaction

Update AC definition after priming

Update AC definition type 2 after priming

Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId2}}

406 Not acceptable response
Should not allow to update when primed

Non-Successful Endpoint Interaction

Shut down participant and Deploy

Shutdown one of the participants and trigger
deployment

Remove one of the participant.
Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances/{{instanceId1}}

406 Not acceptable response.
Verify if runtime is restricting the deploy operation when one
or more associated particpant is OFFLINE

Needs updating because of new validation that ppnt is online

Non-Successful Endpoint Interaction

Delete AC instance with OFFLINE
participant

Delete the AC instance after removing
participant

Execute DELETE request on runtime-acm
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId2}}/instances/{{instanceId2}}

202 Response
Verify if runtime accepts the delete AC instance request when the associated participant is in OFFLINE state
The overall state is stuck in DELETING and updated to TIMEOUT after the configured timeout is reached
Verify the user is allowed to order a state change after TIMEOUT is reached

Needs updating because of new validation that ppnt is online

Non-Successful Endpoint Interaction

Deprime AC defintion with
OFFLINE participant

Deprime AC defintion when the participant is
OFFLINE

Make sure the AC instance is deleted and shutdown the participant again.
Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId}}

202 Response
Verify the runtime allows to Deprime the definitions from all
the participants when one of the participant is OFFLINE
Verify the AC state is stuck in DEPRIMING and updated to TIMEOUT after the configured timeout is reached.

Needs updating because of new validation that ppnt is online

Non-Successful Endpoint Interaction

Verify restricted operations in deployed state

Try to perform the following operations
Delete the AC instance2
Deprime the Ac definition 2
Update the AC instance 2

All the perfomed operations should return 400 response. The instances should not be allowed to get
deleted or deprimed in Deployed state. Update IS allowed now

Non-Successful Endpoint Interaction

Update AC instance property after participant shutdown

Shutdown participant and trigger UPDATE

Shutdown the participant and trigger the update
property event on the runtime as per the steps specified above

Verify if the rest request is accepted with 202 response
Verify the PROPERTIES_UPDATE event is sent to the participants from runtime-acm.
The ACM instance state should be "UPDATING" until the properties update is completed in the participant.
The AC state should be updated as TIMEOUT after the configured timeout in runtime

This should be updated because the operation will no longer be allowed by ACM if the participant is OFFLINE

Non-Successful Endpoint Interaction

Shut down participant on
UNLOCKED state

Shut down one of the participants on UNLOCKED state

Manually stop one of the participants

???
Verify the behaviour of runtime when the participant is OFFLINE and the instances are deployed(it depend how restart will be implemented)

This should be updated because the operation will no longer be allowed by ACM if the participant is OFFLINE

Restart Testing

Restart acm runtime

Restart runtime application

Manually restart the container or mvn application

Verify if the runtime comes up and running and get synced with the
database. Retrieve participants and compositions from runtime endpoint.

microk8s kubectl delete pod policy-clamp-runtime-acm-7ff68ff9fd-kllb7
pod "policy-clamp-runtime-acm-7ff68ff9fd-kllb7" deleted

Restart Testing

Shut down participant after
priming

Restart any of the participant

Manually restart the container or mvn application
Execute GET request on the runtime-acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/participants/

Participants should get registered and get the primed definitions from runtime once they are up again.

Restart Testing

Shut down any of the participant

Delete one of the participants permanently.
Execute GET request on the runtime-acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/participants/

Verify the removed participants should have been marked OFFLINE by the runtime.
Verify fetching the automation compositions where the element of removed participants should not have participant ids associated. (it depend how restart will be implemented)

It needs 10 minutes on my deployment after requesting a Participant Report from all participants

Restart Testing

Restart participant after Priming

Restart any of the participant

Manually restart the container or mvn application

Fetch participants list from runtime, restarted participant should get reregistered with runtime again.
Fetch commisioned defintions, it should have elements with restarted participant id associated

Successful Endpoint Interaction

Verify Participant Registration

Verify all the participants

Call "Create AC Definition" - response should be 201
Call "Priming AC definition" - response should be 202
Call "Instantiation AC" - response should be 201
Call "Deploy Instantiated" - response should be 202
Call "Get Instantiated List" and should get a 200 response
Finally, call "Get participants" and should get a 200 response.

Verify all the deployed participants with their Ids and current status are retrieved

PASS

Successful Endpoint Interaction

CRUD
Automation Composition Types

Create Automation Composition Type 1

Call "Create AC Definition" - response should be 201
Call "Get AutomationCompositions" - response should be 200
Finally, verify AC Definition has been created and returned in the list.

201 Response with compositionId

PASS

Successful Endpoint Interaction

Create Automation composition Type 2

Call "Create AC Definition" with a different definition than previously created - response should be 201
Call "Get AutomationCompositions" - response should be 200
Finally, verify AC Definition has been created and returned in the list.

201 Response with compositionId

PASS

Successful Endpoint Interaction

Update AC definition

Update the AC type 1 with some changes
in the common properties

Call "

Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}

201 Response with composition Id

Successful Endpoint Interaction

Delete AC definition

Delete the Ac type 2

Call "Delete Automation Composition" for Composition 2 - response should be 200

200 Response

PASS

Successful Endpoint Interaction

Fetch Commissioned definition before Priming

Get all the commisioned definitions from db

Call "Get AutomationCompositions" - response should be 200
Finally, verify the two AC Definitions are retrieved with all elements.

OK

Code Block

language	yml
firstline	1
title	Response
linenumbers	true
collapse	true

{
    "service_templates": [
        {
            "tosca_definitions_version": "tosca_simple_yaml_1_3",
            "data_types": {
                "onap.datatypes.ToscaConceptIdentifier": {
                    "properties": {
                        "name": {
                            "name": "name",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        },
                        "version": {
                            "name": "version",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        }
                    },
                    "name": "onap.datatypes.ToscaConceptIdentifier",
                    "version": "0.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                },
                "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest": {
                    "properties": {
                        "restRequestId": {
                            "name": "restRequestId",
                            "type": "onap.datatypes.ToscaConceptIdentifier",
                            "type_version": "0.0.0",
                            "description": "The name and version of a REST request to be sent to a REST endpoint",
                            "required": true
                        },
                        "httpMethod": {
                            "name": "httpMethod",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The REST method to use",
                            "required": true,
                            "constraints": [
                                {
                                    "valid_values": [
                                        "POST",
                                        "PUT",
                                        "GET",
                                        "DELETE"
                                    ]
                                }
                            ]
                        },
                        "path": {
                            "name": "path",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The path of the REST request relative to the base URL",
                            "required": true
                        },
                        "body": {
                            "name": "body",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The body of the REST request for PUT and POST requests",
                            "required": false
                        },
                        "expectedResponse": {
                            "name": "expectedResponse",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "THe expected HTTP status code for the REST request",
                            "required": true,
                            "constraints": []
                        }
                    },
                    "name": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest",
                    "version": "1.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                },
                "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity": {
                    "properties": {
                        "configurationEntityId": {
                            "name": "configurationEntityId",
                            "type": "onap.datatypes.ToscaConceptIdentifier",
                            "type_version": "0.0.0",
                            "description": "The name and version of a Configuration Entity to be handled by the HTTP Automation Composition Element",
                            "required": true
                        },
                        "restSequence": {
                            "name": "restSequence",
                            "type": "list",
                            "type_version": "0.0.0",
                            "description": "A sequence of REST commands to send to the REST endpoint",
                            "required": false,
                            "entry_schema": {
                                "type": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest",
                                "type_version": "1.0.0"
                            }
                        }
                    },
                    "name": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity",
                    "version": "1.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                }
            },
            "node_types": {
                "org.onap.policy.clamp.acm.Participant": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": false
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.Participant",
                    "version": "1.0.1",
                    "derived_from": "tosca.nodetypes.Root",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.AutomationCompositionElement": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "Specifies the organization that provides the automation composition element",
                            "required": false,
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "startPhase": {
                            "name": "startPhase",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "A value indicating the start phase in which this automation composition element will be started, the first start phase is zero. Automation Composition Elements are started in their start_phase order and stopped in reverse start phase order. Automation Composition Elements with the same start phase are started and stopped simultaneously",
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "uninitializedToPassiveTimeout": {
                            "name": "uninitializedToPassiveTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from uninitialized to passive",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "passiveToRunningTimeout": {
                            "name": "passiveToRunningTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from passive to running",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "runningToPassiveTimeout": {
                            "name": "runningToPassiveTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from running to passive",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "passiveToUninitializedTimeout": {
                            "name": "passiveToUninitializedTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from passive to uninitialized",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.AutomationCompositionElement",
                    "version": "1.0.1",
                    "derived_from": "tosca.nodetypes.Root",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.AutomationComposition": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "Specifies the organization that provides the automation composition element",
                            "required": false,
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "elements": {
                            "name": "elements",
                            "type": "list",
                            "type_version": "0.0.0",
                            "description": "Specifies a list of automation composition element definitions that make up this automation composition definition",
                            "required": true,
                            "entry_schema": {
                                "type": "onap.datatypes.ToscaConceptIdentifier",
                                "type_version": "0.0.0"
                            },
                            "metadata": {
                                "common": "true"
                            }
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.AutomationComposition",
                    "version": "1.0.1",
                    "derived_from": "tosca.nodetypes.Root",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement": {
                    "properties": {
                        "chart": {
                            "name": "chart",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        },
                        "configs": {
                            "name": "configs",
                            "type": "list",
                            "type_version": "0.0.0",
                            "required": false
                        },
                        "requirements": {
                            "name": "requirements",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": false
                        },
                        "templates": {
                            "name": "templates",
                            "type": "list",
                            "type_version": "0.0.0",
                            "required": false
                        },
                        "values": {
                            "name": "values",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                    "version": "1.0.0",
                    "derived_from": "org.onap.policy.clamp.acm.AutomationCompositionElement",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.HttpAutomationCompositionElement": {
                    "properties": {
                        "baseUrl": {
                            "name": "baseUrl",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The base URL to be prepended to each path, identifies the host for the REST endpoints.",
                            "required": true
                        },
                        "httpHeaders": {
                            "name": "httpHeaders",
                            "type": "map",
                            "type_version": "0.0.0",
                            "description": "HTTP headers to send on REST requests",
                            "required": false,
                            "entry_schema": {
                                "type": "string",
                                "type_version": "0.0.0"
                            }
                        },
                        "configurationEntities": {
                            "name": "configurationEntities",
                            "type": "map",
                            "type_version": "0.0.0",
                            "description": "The connfiguration entities the Automation Composition Element is managing and their associated REST requests",
                            "required": true,
                            "entry_schema": {
                                "type": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity",
                                "type_version": "1.0.0"
                            }
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                    "version": "1.0.0",
                    "derived_from": "org.onap.policy.clamp.acm.AutomationCompositionElement",
                    "metadata": {}
                }
            },
            "topology_template": {
                "node_templates": {
                    "org.onap.k8s.acm.K8SAutomationCompositionParticipant": {
                        "type": "org.onap.policy.clamp.acm.Participant",
                        "type_version": "1.0.1",
                        "properties": {
                            "provider": "ONAP"
                        },
                        "name": "org.onap.k8s.acm.K8SAutomationCompositionParticipant",
                        "version": "2.3.4",
                        "metadata": {},
                        "description": "Participant for K8S"
                    },
                    "onap.policy.clamp.ac.element.K8S_StarterAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "startPhase": 0,
                            "uninitializedToPassiveTimeout": 300,
                            "podStatusCheckInterval": 30
                        },
                        "name": "onap.policy.clamp.ac.element.K8S_StarterAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the K8S microservice for AC Element Starter"
                    },
                    "onap.policy.clamp.ac.element.K8S_BridgeAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "startPhase": 0,
                            "uninitializedToPassiveTimeout": 300,
                            "podStatusCheckInterval": 30
                        },
                        "name": "onap.policy.clamp.ac.element.K8S_BridgeAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the K8S microservice for AC Element Bridge"
                    },
                    "onap.policy.clamp.ac.element.K8S_SinkAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "startPhase": 0,
                            "uninitializedToPassiveTimeout": 300,
                            "podStatusCheckInterval": 30
                        },
                        "name": "onap.policy.clamp.ac.element.K8S_SinkAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the K8S microservice for AC Element Sink"
                    },
                    "org.onap.policy.clamp.acm.HttpParticipant": {
                        "type": "org.onap.policy.clamp.acm.Participant",
                        "type_version": "1.0.1",
                        "properties": {
                            "provider": "ONAP"
                        },
                        "name": "org.onap.policy.clamp.acm.HttpParticipant",
                        "version": "2.3.4",
                        "metadata": {},
                        "description": "Participant for Http requests"
                    },
                    "onap.policy.clamp.ac.element.Http_StarterAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "uninitializedToPassiveTimeout": 300,
                            "startPhase": 1
                        },
                        "name": "onap.policy.clamp.ac.element.Http_StarterAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the http requests of AC Element Starter microservice"
                    },
                    "onap.policy.clamp.ac.element.Http_BridgeAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "uninitializedToPassiveTimeout": 300,
                            "startPhase": 1
                        },
                        "name": "onap.policy.clamp.ac.element.Http_BridgeAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the http requests of AC Element Bridge microservice"
                    },
                    "onap.policy.clamp.ac.element.Http_SinkAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "uninitializedToPassiveTimeout": 300,
                            "startPhase": 1
                        },
                        "name": "onap.policy.clamp.ac.element.Http_SinkAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the http requests of AC Element Sink microservice"
                    },
                    "onap.policy.clamp.ac.element.AutomationCompositionDefinition": {
                        "type": "org.onap.policy.clamp.acm.AutomationComposition",
                        "type_version": "1.0.1",
                        "properties": {
                            "provider": "ONAP",
                            "elements": [
                                {
                                    "name": "onap.policy.clamp.ac.element.K8S_StarterAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.K8S_BridgeAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.K8S_SinkAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.Http_StarterAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.Http_BridgeAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.Http_SinkAutomationCompositionElement",
                                    "version": "1.2.3"
                                }
                            ]
                        },
                        "name": "onap.policy.clamp.ac.element.AutomationCompositionDefinition",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition for Demo"
                    }
                },
                "policies": []
            },
            "name": "tosca",
            "version": "1.0.0",
            "metadata": {
                "compositionId": "8c3f8b69-7464-40dc-b034-0f73f200729f"
            }
        }
    ]
}

Successful Endpoint Interaction

Priming

Prime AC definition 1

Ensure AC Type 1 & 2 are commissioned.
Call "Prime Automation Composition Definition 1" - response 202
Finally, confirm compositionid1 is returned in the response body

202 response

PASS

Successful Endpoint Interaction

Prime AC definition 2

Ensure AC Type 1 & 2 are commissioned.
Call "Prime Automation Composition Definition 2" - response 202
Finally, confirm compositionid2 is returned in the response body

202 response

PASS

Create the composition Type 2 again after it was deleted earlier

Successful Endpoint Interaction

Fetch Commisioned definition after Priming

Get all the commisioned definitions from db

Call "Get AutomationCompositions" - response should be 200
Finally, verify the two AC Definitions are retrieved with all elements.

200 response

OK

Code Block

language	yml
firstline	1
title	Response
linenumbers	true
collapse	true

{
    "service_templates": [
        {
            "tosca_definitions_version": "tosca_simple_yaml_1_3",
            "data_types": {
                "onap.datatypes.ToscaConceptIdentifier": {
                    "properties": {
                        "name": {
                            "name": "name",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        },
                        "version": {
                            "name": "version",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        }
                    },
                    "name": "onap.datatypes.ToscaConceptIdentifier",
                    "version": "0.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                },
                "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest": {
                    "properties": {
                        "restRequestId": {
                            "name": "restRequestId",
                            "type": "onap.datatypes.ToscaConceptIdentifier",
                            "type_version": "0.0.0",
                            "description": "The name and version of a REST request to be sent to a REST endpoint",
                            "required": true
                        },
                        "httpMethod": {
                            "name": "httpMethod",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The REST method to use",
                            "required": true,
                            "constraints": [
                                {
                                    "valid_values": [
                                        "POST",
                                        "PUT",
                                        "GET",
                                        "DELETE"
                                    ]
                                }
                            ]
                        },
                        "path": {
                            "name": "path",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The path of the REST request relative to the base URL",
                            "required": true
                        },
                        "body": {
                            "name": "body",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The body of the REST request for PUT and POST requests",
                            "required": false
                        },
                        "expectedResponse": {
                            "name": "expectedResponse",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "THe expected HTTP status code for the REST request",
                            "required": true,
                            "constraints": []
                        }
                    },
                    "name": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest",
                    "version": "1.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                },
                "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity": {
                    "properties": {
                        "configurationEntityId": {
                            "name": "configurationEntityId",
                            "type": "onap.datatypes.ToscaConceptIdentifier",
                            "type_version": "0.0.0",
                            "description": "The name and version of a Configuration Entity to be handled by the HTTP Automation Composition Element",
                            "required": true
                        },
                        "restSequence": {
                            "name": "restSequence",
                            "type": "list",
                            "type_version": "0.0.0",
                            "description": "A sequence of REST commands to send to the REST endpoint",
                            "required": false,
                            "entry_schema": {
                                "type": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest",
                                "type_version": "1.0.0"
                            }
                        }
                    },
                    "name": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity",
                    "version": "1.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                }
            },
            "node_types": {
                "org.onap.policy.clamp.acm.Participant": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": false
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.Participant",
                    "version": "1.0.1",
                    "derived_from": "tosca.nodetypes.Root",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.AutomationCompositionElement": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "Specifies the organization that provides the automation composition element",
                            "required": false,
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "startPhase": {
                            "name": "startPhase",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "A value indicating the start phase in which this automation composition element will be started, the first start phase is zero. Automation Composition Elements are started in their start_phase order and stopped in reverse start phase order. Automation Composition Elements with the same start phase are started and stopped simultaneously",
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "uninitializedToPassiveTimeout": {
                            "name": "uninitializedToPassiveTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from uninitialized to passive",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "passiveToRunningTimeout": {
                            "name": "passiveToRunningTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from passive to running",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "runningToPassiveTimeout": {
                            "name": "runningToPassiveTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from running to passive",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "passiveToUninitializedTimeout": {
                            "name": "passiveToUninitializedTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from passive to uninitialized",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.AutomationCompositionElement",
                    "version": "1.0.1",
                    "derived_from": "tosca.nodetypes.Root",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.AutomationComposition": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "Specifies the organization that provides the automation composition element",
                            "required": false,
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "elements": {
                            "name": "elements",
                            "type": "list",
                            "type_version": "0.0.0",
                            "description": "Specifies a list of automation composition element definitions that make up this automation composition definition",
                            "required": true,
                            "entry_schema": {
                                "type": "onap.datatypes.ToscaConceptIdentifier",
                                "type_version": "0.0.0"
                            },
                            "metadata": {
                                "common": "true"
                            }
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.AutomationComposition",
                    "version": "1.0.1",
                    "derived_from": "tosca.nodetypes.Root",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement": {
                    "properties": {
                        "chart": {
                            "name": "chart",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        },
                        "configs": {
                            "name": "configs",
                            "type": "list",
                            "type_version": "0.0.0",
                            "required": false
                        },
                        "requirements": {
                            "name": "requirements",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": false
                        },
                        "templates": {
                            "name": "templates",
                            "type": "list",
                            "type_version": "0.0.0",
                            "required": false
                        },
                        "values": {
                            "name": "values",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                    "version": "1.0.0",
                    "derived_from": "org.onap.policy.clamp.acm.AutomationCompositionElement",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.HttpAutomationCompositionElement": {
                    "properties": {
                        "baseUrl": {
                            "name": "baseUrl",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The base URL to be prepended to each path, identifies the host for the REST endpoints.",
                            "required": true
                        },
                        "httpHeaders": {
                            "name": "httpHeaders",
                            "type": "map",
                            "type_version": "0.0.0",
                            "description": "HTTP headers to send on REST requests",
                            "required": false,
                            "entry_schema": {
                                "type": "string",
                                "type_version": "0.0.0"
                            }
                        },
                        "configurationEntities": {
                            "name": "configurationEntities",
                            "type": "map",
                            "type_version": "0.0.0",
                            "description": "The connfiguration entities the Automation Composition Element is managing and their associated REST requests",
                            "required": true,
                            "entry_schema": {
                                "type": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity",
                                "type_version": "1.0.0"
                            }
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                    "version": "1.0.0",
                    "derived_from": "org.onap.policy.clamp.acm.AutomationCompositionElement",
                    "metadata": {}
                }
            },
            "topology_template": {
                "node_templates": {
                    "org.onap.k8s.acm.K8SAutomationCompositionParticipant": {
                        "type": "org.onap.policy.clamp.acm.Participant",
                        "type_version": "1.0.1",
                        "properties": {
                            "provider": "ONAP"
                        },
                        "name": "org.onap.k8s.acm.K8SAutomationCompositionParticipant",
                        "version": "2.3.4",
                        "metadata": {},
                        "description": "Participant for K8S"
                    },
                    "onap.policy.clamp.ac.element.K8S_StarterAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "startPhase": 0,
                            "uninitializedToPassiveTimeout": 300,
                            "podStatusCheckInterval": 30
                        },
                        "name": "onap.policy.clamp.ac.element.K8S_StarterAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the K8S microservice for AC Element Starter"
                    },
                    "onap.policy.clamp.ac.element.K8S_BridgeAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "startPhase": 0,
                            "uninitializedToPassiveTimeout": 300,
                            "podStatusCheckInterval": 30
                        },
                        "name": "onap.policy.clamp.ac.element.K8S_BridgeAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the K8S microservice for AC Element Bridge"
                    },
                    "onap.policy.clamp.ac.element.K8S_SinkAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "startPhase": 0,
                            "uninitializedToPassiveTimeout": 300,
                            "podStatusCheckInterval": 30
                        },
                        "name": "onap.policy.clamp.ac.element.K8S_SinkAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the K8S microservice for AC Element Sink"
                    },
                    "org.onap.policy.clamp.acm.HttpParticipant": {
                        "type": "org.onap.policy.clamp.acm.Participant",
                        "type_version": "1.0.1",
                        "properties": {
                            "provider": "ONAP"
                        },
                        "name": "org.onap.policy.clamp.acm.HttpParticipant",
                        "version": "2.3.4",
                        "metadata": {},
                        "description": "Participant for Http requests"
                    },
                    "onap.policy.clamp.ac.element.Http_StarterAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "uninitializedToPassiveTimeout": 300,
                            "startPhase": 1
                        },
                        "name": "onap.policy.clamp.ac.element.Http_StarterAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the http requests of AC Element Starter microservice"
                    },
                    "onap.policy.clamp.ac.element.Http_BridgeAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "uninitializedToPassiveTimeout": 300,
                            "startPhase": 1
                        },
                        "name": "onap.policy.clamp.ac.element.Http_BridgeAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the http requests of AC Element Bridge microservice"
                    },
                    "onap.policy.clamp.ac.element.Http_SinkAutomationCompositionElement": {
                        "type": "org.onap.policy.clamp.acm.HttpAutomationCompositionElement",
                        "type_version": "1.0.0",
                        "properties": {
                            "provider": "ONAP",
                            "uninitializedToPassiveTimeout": 300,
                            "startPhase": 1
                        },
                        "name": "onap.policy.clamp.ac.element.Http_SinkAutomationCompositionElement",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition element for the http requests of AC Element Sink microservice"
                    },
                    "onap.policy.clamp.ac.element.AutomationCompositionDefinition": {
                        "type": "org.onap.policy.clamp.acm.AutomationComposition",
                        "type_version": "1.0.1",
                        "properties": {
                            "provider": "ONAP",
                            "elements": [
                                {
                                    "name": "onap.policy.clamp.ac.element.K8S_StarterAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.K8S_BridgeAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.K8S_SinkAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.Http_StarterAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.Http_BridgeAutomationCompositionElement",
                                    "version": "1.2.3"
                                },
                                {
                                    "name": "onap.policy.clamp.ac.element.Http_SinkAutomationCompositionElement",
                                    "version": "1.2.3"
                                }
                            ]
                        },
                        "name": "onap.policy.clamp.ac.element.AutomationCompositionDefinition",
                        "version": "1.2.3",
                        "metadata": {},
                        "description": "Automation composition for Demo"
                    }
                },
                "policies": []
            },
            "name": "tosca",
            "version": "1.0.0",
            "metadata": {
                "compositionId": "19210df5-c5bf-4431-862a-82b148cfb668"
            }
        },
        {
            "tosca_definitions_version": "tosca_simple_yaml_1_3",
            "data_types": {
                "onap.datatypes.ToscaConceptIdentifier": {
                    "properties": {
                        "name": {
                            "name": "name",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        },
                        "version": {
                            "name": "version",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": true
                        }
                    },
                    "name": "onap.datatypes.ToscaConceptIdentifier",
                    "version": "0.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                },
                "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest": {
                    "properties": {
                        "restRequestId": {
                            "name": "restRequestId",
                            "type": "onap.datatypes.ToscaConceptIdentifier",
                            "type_version": "0.0.0",
                            "description": "The name and version of a REST request to be sent to a REST endpoint",
                            "required": true
                        },
                        "httpMethod": {
                            "name": "httpMethod",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The REST method to use",
                            "required": true,
                            "constraints": [
                                {
                                    "valid_values": [
                                        "POST",
                                        "PUT",
                                        "GET",
                                        "DELETE"
                                    ]
                                }
                            ]
                        },
                        "path": {
                            "name": "path",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The path of the REST request relative to the base URL",
                            "required": true
                        },
                        "body": {
                            "name": "body",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "The body of the REST request for PUT and POST requests",
                            "required": false
                        },
                        "expectedResponse": {
                            "name": "expectedResponse",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "THe expected HTTP status code for the REST request",
                            "required": true,
                            "constraints": []
                        }
                    },
                    "name": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest",
                    "version": "1.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                },
                "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity": {
                    "properties": {
                        "configurationEntityId": {
                            "name": "configurationEntityId",
                            "type": "onap.datatypes.ToscaConceptIdentifier",
                            "type_version": "0.0.0",
                            "description": "The name and version of a Configuration Entity to be handled by the HTTP Automation Composition Element",
                            "required": true
                        },
                        "restSequence": {
                            "name": "restSequence",
                            "type": "list",
                            "type_version": "0.0.0",
                            "description": "A sequence of REST commands to send to the REST endpoint",
                            "required": false,
                            "entry_schema": {
                                "type": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.RestRequest",
                                "type_version": "1.0.0"
                            }
                        }
                    },
                    "name": "org.onap.datatypes.policy.clamp.acm.httpAutomationCompositionElement.ConfigurationEntity",
                    "version": "1.0.0",
                    "derived_from": "tosca.datatypes.Root",
                    "metadata": {}
                }
            },
            "node_types": {
                "org.onap.policy.clamp.acm.Participant": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "required": false
                        }
                    },
                    "name": "org.onap.policy.clamp.acm.Participant",
                    "version": "1.0.1",
                    "derived_from": "tosca.nodetypes.Root",
                    "metadata": {}
                },
                "org.onap.policy.clamp.acm.AutomationCompositionElement": {
                    "properties": {
                        "provider": {
                            "name": "provider",
                            "type": "string",
                            "type_version": "0.0.0",
                            "description": "Specifies the organization that provides the automation composition element",
                            "required": false,
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "startPhase": {
                            "name": "startPhase",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "A value indicating the start phase in which this automation composition element will be started, the first start phase is zero. Automation Composition Elements are started in their start_phase order and stopped in reverse start phase order. Automation Composition Elements with the same start phase are started and stopped simultaneously",
                            "required": false,
                            "constraints": [
                                {
                                    "greater_or_equal": "0"
                                }
                            ],
                            "metadata": {
                                "common": "true"
                            }
                        },
                        "uninitializedToPassiveTimeout": {
                            "name": "uninitializedToPassiveTimeout",
                            "type": "integer",
                            "type_version": "0.0.0",
                            "description": "The maximum time in seconds to wait for a state chage from uninitialized to passive",
                            "default": 60.0,
                            "required": false,
                            "constraints": [
                                {

Successful Endpoint Interaction

Create AC instance

Create AC instance 1

Execute POST request on runtime-acm
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances

200 Response with InstanceId

Successful Endpoint Interaction

Create AC instance 2

Execute POST request on runtime-acm
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId2}}/instances

200 Response with InstanceId

Successful Endpoint Interaction

Update AC instance

Update AC instance1 with wrong paramter

Execute PUT request on runtime-acm
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances

200 Response with Instance id

Successful Endpoint Interaction

Undeploy AC instance

Undeploy AC instance 1

Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances/{{instanceId1}}

Execute GET request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances/{{instanceId1}}

202 Response.
Verify the AC instance's is "UNDEPLOYED"

Successful Endpoint Interaction

Update AC instance

Update AC instance1 with correct paramter

Execute PUT request on runtime-acm
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances

200 Response with Instance id

Successful Endpoint Interaction

Delete AC instance

Delete AC instance2

Execute DELETE request on runtime-acm
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId2}}/instances/{{instanceId2}}

200 Response

Successful Endpoint Interaction

Deploy AC instance

Deploy AC instance 1

Make sure AC instance 1 and 2 are created.
Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances/{{instanceId1}}

Execute GET request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId1}}/instances/{{instanceId1}}

202 Response.
Verify the AC instance's admin state is "LOCKED".
No operation has been carried out by the participants. Depending on the participant being used and whether it has a specific implementation of lock and unlock.

Successful Endpoint Interaction

Deploy AC instance 2

Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId2}}/instances/{{instanceId2}}

202 Response.
Verify the AC instance's admin state is "LOCKED".
No operation has been carried out by the participants. Depending on the participant being used and whether it has a specific implementation of lock and unlock.

Successful Endpoint Interaction

Get deployed instance by id

Execute GET request on runtime ACM
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId}}/instances/{{instanceId}}

Verify the instance is retrieved and present in LOCKED state.

Successful Endpoint Interaction

UNLOCK the AC instance

Execute PUT request on runtime acm endpoint
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId2}}/instances/{{instanceId2}}

200 Response
Verify the k8s , http and policy participants have performed the intended operations on UNLOCKED state

Successful Endpoint Interaction

Verify the operational state

Fetch the operational state of the AC instance

Verify the instance elements are reporting operational state "ACTIVE" in
UNLOCKED state

Successful Endpoint Interaction

Verify the usage state

Fetch the usage state of the AC instance

Verify the instance elements are reporting usage state "IDLE/BUSY/AVAILABLE" in
UNLOCKED state

Successful Endpoint Interaction

Verify the operational state

Fetch the operational state of the AC instance

Verify the instance elements are reporting operational state "INACTIVE" in LOCKED state

Successful Endpoint Interaction

Verify the usage state

Fetch the usage state of the AC instance

Verify the instance elements are reporting usage state "IDLE/BUSY/AVAILABLE" in
LOCKED state

Successful Endpoint Interaction

Undeploy AC instance

LOCK the AC instance with instanceid

Make sure the AC instance is deployed and UNLOCKED successfully.
Execute PUT request on runtime acm.
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId}}/instances/{{instanceId}}

200 Response. The instance should be moved to LOCKED state. Participants should have removed the
corresponding deployments from the system

Successful Endpoint Interaction

Delete AC instance

Execute DELETE request on runtime acm
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId}}/instances/{{instanceId}}

202 Response. The AC instance should get deleted from the db.

Successful Endpoint Interaction

Deprime AC defintion

Execute PUT request on runtime ACM
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId}}
Verify fetching the commisioned defintions and make sure the AC elements are unassigned from the participants

202 Response. The AC instance should get deleted from the db.

Successful Endpoint Interaction

Delete AC defintion

Execute DELETE request on runtime ACM
{{address}}:{{runtimeport}}/onap/policy/clamp/acm/v2/compositions/{{compositionId}}

200 Response. The AC defintion should get deleted from the db

Timeout Scenario

Delay participant while
DEPLOYING

Delay the participant when instances are
deploying

Make sure the instance deployment takes longer time and
shutdown the participant when the instances are being deployed.
(Note: AcElement microservice can be used to alter the behaviour of deployment)

Verify the behaviour of runtime when the participant goes offline in the middle of deployment.
Verify the instance state to go TIMEOUT after the configured timeout is reached. (it depend how restart will be implemented)

Mock participant must be called with configuration for how long to delay. Participant shoul be ONLINE

Update Scenario

Update AC instance property on the deployed
instance

Verify updating of AC properties in runtime

Make sure the AC instance is deployed successfully. - Verify the 'GET instance' Api shows the instance state as 'Deployed'

Call "Instantiation AC" Api with the updated properties of the instance elements in the request body. - response should be 202

Verify the runtime logs that the 'PROPERTIES_UPDATE' event is sent to the participants from runtime-acm.

Call the 'GET instance' Api - should get the 200 response and the deploy state of the instance should be "UPDATING"

The ACM instance state should be "UPDATING" until the properties update is completed in the participant.
Verify the properties are updated in runtime database and the GET instance Api returns the instance state as 'Deployed' after update operation

Update Scenario

Update AC instance property on an Undeployed
instance

Verify updating of instance properties on an undeployed instance

Make sure the AC instances are in UNDEPLOYED state. - Verify the 'GET instance' Api shows the instance state as 'Undeployed'

Call "Instantiation AC" with the updated properties of the instance elements in the request body. - response should be 202

Call "get Instantiated List" - should get a 200 response and we should see the properties updated for the instance in the runtime database.

In this case, there should not be any PROPERTIES_UPDATE event sends out from the runtime as the instance is not yet deployed to the participant.

Restart Scenario

Restart participant after priming

Verify restarting of participant after the composition is primed.

Make sure the AC composition is commissioned and primed to the participants.

Execute the test step 8 specified in the restart scenario section of this document.

For the step 8d, execute the GET compositions to verify the Ac element info are primed to the restarted participant.

Verify the restarted participant is primed again by the runtime with the AC element info.

Restart Scenario

Restart after deployment

Verify restarting of participant after the deployment

Make sure an AC instance is deployed successfully and the GET instance Api returns 200 response with the deploy state 'Deployed'

Execute the test step 8 specified in the restart scenario section of this document.

For the step 8d, execute the GET instance Api to verify the Ac element info are in deployed state without any changes.

Verify the runtime logs for composition and instance events sent to the restarted participant.

The AC instance state should be preserved as 'DEPLOYED' without any changes.

Restart Scenario

Restart during deployment

Verify restarting of participant when the deployment is in progress

Trigger the deployment of an AC instance and make sure the AC instance is in DEPLOYING state. This can be achieved by using mock participant by configuring appropriate delays.

Execute the test step 8 specified in the restart scenario section of this document.

Verify the runtime sends out composition and instance info to the participant through kafka events.

Execute GET AC instance to verify the deployment gets executed by the participant again and the over all state is updated accordingly with success/fail
results

Restart Scenario

Restart during Undeployment

Verify restarting of participant when the undeployment is in progress

Trigger the undeployment of an AC instance and make sure the AC instance is in UNDEPLOYING state. This can be achieved by using mock participant by configuring appropriate delays.

Execute the test step 8 specified in the restart scenario section of this document.

Verify the runtime sends out composition and instance info to the participant through kafka events.

Execute GET AC instance to verify the undeployment gets executed by the participant again and the over all state is updated accordingly with success/fail
results

Restart Scenario

Restart during UPDATE

Verify restarting behavior of participant when the update operation is in progress

Make sure an AC instance is deployed successfully and the GET instance API returns 200 response with the deploy state DEPLOYED.

Trigger the update of an AC instance properties by executing the AC instantiation API call with updated properties on the request body.

Make sure the AC instance is in UPDATING state. This can be achieved by using mock participant by configuring appropriate delays.

Execute the test step 8 specified in the restart scenario section of this document.

Verify the runtime sends out composition and instance info to the participant through kafka events.

Execute GET AC instance to verify the updating operation gets executed by the participant again and the over all state is updated accordingly with success/fail
results
Verify fetching the AC instance to confirm the properties of the AC instance are updated as per the update request.

Handle multiple messages from ACM to Participant simultaneously

Description

Functionality to test	Test the ability for participants to Handle multiple messages.
Environment	CSIT with microk8s
Requirements and preconditions	Containers have to be configured to work at least with 4 CPU: resources: small: limits: cpu: 4
How to test	Create two instances and deploy/undeploy at same time
Expected result	Check into participants log, the threads that are executing deploy/undeploy at same time

Flow for participantHttp and participantKubernetes

Postman collection: ACM DEMO Test 2.postman_collection.json

Step	Result	Note
Call "Create Commissioned AC definition"	Success
Call "Priming AC definition"	Success
Call "Create AC Instantiation Group A"	Success
Call "Create AC Instantiation Group B"	Success
Call "Deploy instantiated Group A" and "Deploy instantiated Group B" at same time	Success
Check the participants log during deployment	threads that are executing deploy at same time
Check that elements of both groups are getting deployed	starter-a, bridge-a and sink-a for group A and starter-b, bridge-b and sink-b for group B
Call "Get instantiated Group A" to check the final state	check deployState as DEPLOYED
Call "Get instantiated Group B" to check the final state	check deployState as DEPLOYED
Check elements are working as expected	Check into the sink log the "Cycle completed"	microk8s kubectl logs <acm-sink-....> \| grep completed
Call "Undeploy instantiated Group A" and "Undeploy instantiated Group B" at same time	Success
Check the participants log during undeployment	threads that are executing undeploy at same time
Check that elements of both groups are getting undeployed
Call "Delete instantiated Group A" and "Delete instantiated Group B" at same time	Success
Depriming AC definition	Success
Delete AC definition

Timeout handling in AutomationComposition Definition and Instance

Description

Functionality to test	Test ACM runtime timeout handling during prime, deprime, delete, deploy, undeploy, update, lock and unlock
Environment	Custom Docker compose with three mock participants
Requirements and preconditions	reduce the time in runtime: runtime: participantParameters: heartBeatMs: 10000 maxStatusWaitMs: 10000 reduce the time in participant: participant: intermediaryParameters: reportingTimeIntervalMs: 8000
How to test	Configure mock participants to delay the operations of 30 seconds. The timeout will be triggered after 10 seconds
Expected result	During a change state, user cannot do any actions, with timeout, the user is allowed to replay the action or go back

Flow

Postman collection: DEMO Simulator.postman_collection.json

Step	Result	Note
Call "Create AC definition"	Success
Call "Post http-participant parameters"	Success	{ "deploySuccess": true, "undeploySuccess": true, "lockSuccess": true, "unlockSuccess": true, "deleteSuccess": true, "updateSuccess": true, "primeSuccess": true, "deprimeSuccess": true, "deployTimerMs": 30000, "undeployTimerMs": 30000, "lockTimerMs": 30000, "unlockTimerMs": 30000, "updateTimerMs": 30000, "deleteTimerMs": 30000, "primeTimerMs": 30000, "deprimeTimerMs": 30000 }
Call "Priming AC definition"	Success
At the time the state is "PRIMING" call: "Priming AC definition" "Depriming AC definition" "Delete AC definition"	Fail	User is not allowed to re-prime, deprime and delete when the participant is priming
At the time the state is "PRIMING" and stateChangeResult is "TIMEOUT"

during priming

:

call "Delete AC definition"

Fail

User is not allowed to delete when the participant is priming

At the time the state is "PRIMING" and stateChangeResult is "TIMEOUT"

during priming

:

call "Priming AC definition"

Success

User is allowed to re-prime when the participant is priming and timeout

At the time the state is "PRIMING" and stateChangeResult is "TIMEOUT"

during priming

:

call "Depriming AC definition"

Success

User is allowed to deprime when the participant is priming and timeout

At the time the state is "DEPRIMING" call:

"Priming AC definition"
"Depriming AC definition"
"Delete AC definition"

Fail

User is not allowed to prime, deprime and delete when the participant is depriming

At the time the state is "DEPRIMING" and stateChangeResult is "TIMEOUT"

during depriming

:

call "Delete AC definition"

Fail

User is not allowed to delete when the participant is depriming

At the time the state is "DEPRIMING" and stateChangeResult is "TIMEOUT"

during depriming

:

call "Depriming AC definition"

Success

User is allowed to deprime when the participant is depriming and timeout

At the time the state is "DEPRIMING" and stateChangeResult is "TIMEOUT"

during depriming

: call "Priming AC definition"	Success	User is allowed to prime when the participant is depriming and timeout
when participant in "PRIMED" call "Get commission"	Success and stateChangeResult = "NO_ERROR"
Call "Instantiation AC"	Success
Call "Deploy instantiated"	Success
	Success
	Success
	Success
	Success

Versions Compared

Old Version 36

New Version 37

Key

Prerequisites

Environment Setup

Test Group Setup Steps

Test Cases

Handle multiple messages from ACM to Participant simultaneously

Description

Functionality to test

Environment

Requirements and preconditions

How to test

Expected result

Flow for participantHttp and participantKubernetes

Timeout handling in AutomationComposition Definition and Instance

Description

Functionality to test

Environment

Requirements and preconditions

How to test

Expected result

Flow

Page Comparison

Versions Compared

Old Version 36

New Version 37

Key

Prerequisites

Environment Setup

Test Group Setup Steps

Test Cases

Handle multiple messages from ACM to Participant simultaneously

Description

Functionality to test

Environment

Requirements and preconditions

How to test

Expected result

Flow for participantHttp and participantKubernetes

Timeout handling in AutomationComposition Definition and Instance

Description

Functionality to test

Environment

Requirements and preconditions

How to test

Expected result

Flow