models-interactions/model-actors/actor.sdnr/src/test/java/org/onap/policy/controlloop/actor/sdnr/SdnrOperationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SdnrOperation
   4  * ================================================================================
   5  * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.controlloop.actor.sdnr;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.junit.Assert.assertNull;
  28 import static org.junit.Assert.assertSame;
  29 import static org.junit.Assert.assertTrue;
  30 import static org.mockito.Mockito.mock;
  31 import static org.mockito.Mockito.when;
  32
  33 import java.util.Arrays;
  34 import java.util.List;
  35 import java.util.concurrent.CompletableFuture;
  36 import java.util.concurrent.atomic.AtomicBoolean;
  37 import org.junit.After;
  38 import org.junit.AfterClass;
  39 import org.junit.Before;
  40 import org.junit.BeforeClass;
  41 import org.junit.Test;
  42 import org.onap.policy.controlloop.actor.test.BasicBidirectionalTopicOperation;
  43 import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
  44 import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
  45 import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
  46 import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation.Status;
  47 import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
  48 import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicParams;
  49 import org.onap.policy.controlloop.policy.PolicyResult;
  50 import org.onap.policy.sdnr.PciCommonHeader;
  51 import org.onap.policy.sdnr.PciMessage;
  52 import org.onap.policy.sdnr.PciRequest;
  53 import org.onap.policy.sdnr.util.StatusCodeEnum;
  54
  55 public class SdnrOperationTest extends BasicSdnrOperation {
  56
  57     private SdnrOperation operation;
  58
  59     @BeforeClass
  60     public static void setUpBeforeClass() throws Exception {
  61         BasicBidirectionalTopicOperation.initBeforeClass(MY_SINK, MY_SOURCE);
  62     }
  63
  64     @AfterClass
  65     public static void tearDownAfterClass() {
  66         destroyAfterClass();
  67     }
  68
  69     /**
  70      * Setup.
  71      */
  72     @Before
  73     @Override
  74     public void setUp() throws Exception {
  75         super.setUp();
  76
  77         operation = new SdnrOperation(params, config);
  78     }
  79
  80     @After
  81     @Override
  82     public void tearDown() {
  83         super.tearDown();
  84     }
  85
  86     @Test
  87     public void testSdnrOperation() {
  88         assertEquals(DEFAULT_ACTOR, operation.getActorName());
  89         assertEquals(DEFAULT_OPERATION, operation.getName());
  90     }
  91
  92     @Test
  93     public void testGetPropertyNames() {
  94         assertThat(operation.getPropertyNames()).isEqualTo(List.of(OperationProperties.EVENT_PAYLOAD));
  95     }
  96
  97     @Test
  98     public void testMakeRequest() {
  99         operation.generateSubRequestId(1);
 100
 101         PciMessage request = operation.makeRequest(1);
 102
 103         assertNotNull(request.getBody());
 104         assertEquals("1.0", request.getVersion());
 105         assertEquals("request", request.getType());
 106         assertEquals(DEFAULT_OPERATION.toLowerCase(), request.getRpcName());
 107
 108         PciRequest input = request.getBody().getInput();
 109         assertNotNull(input);
 110         assertEquals(DEFAULT_OPERATION, input.getAction());
 111
 112         PciCommonHeader header = input.getCommonHeader();
 113         assertNotNull(header);
 114         assertEquals(params.getRequestId(), header.getRequestId());
 115     }
 116
 117     @Test
 118     public void testGetExpectedKeyValues() {
 119         operation.generateSubRequestId(1);
 120
 121         PciMessage request = operation.makeRequest(1);
 122         assertEquals(Arrays.asList(request.getBody().getInput().getCommonHeader().getSubRequestId()),
 123                         operation.getExpectedKeyValues(50, request));
 124     }
 125
 126     /**
 127      * Tests "success" case with simulator.
 128      */
 129     @Test
 130     public void testSuccess() throws Exception {
 131         BidirectionalTopicParams opParams =
 132                         BidirectionalTopicParams.builder().sinkTopic(MY_SINK).sourceTopic(MY_SOURCE).build();
 133         config = new BidirectionalTopicConfig(blockingExecutor, opParams, topicMgr, SdnrOperation.SELECTOR_KEYS);
 134
 135         params = params.toBuilder().retry(0).timeoutSec(5).executor(blockingExecutor).build();
 136
 137         operation = new SdnrOperation(params, config) {
 138             @Override
 139             protected CompletableFuture<OperationOutcome> startGuardAsync() {
 140                 return null;
 141             }
 142         };
 143
 144         outcome = operation.start().get();
 145         assertEquals(PolicyResult.SUCCESS, outcome.getResult());
 146         assertTrue(outcome.getResponse() instanceof PciMessage);
 147     }
 148
 149     @Test
 150     public void testStartPreprocessorAsync() throws Exception {
 151         final CompletableFuture<OperationOutcome> future2 = new CompletableFuture<>();
 152         context = mock(ControlLoopEventContext.class);
 153         when(context.getEvent()).thenReturn(event);
 154         params = params.toBuilder().context(context).build();
 155
 156         AtomicBoolean guardStarted = new AtomicBoolean();
 157
 158         operation = new SdnrOperation(params, config) {
 159             @Override
 160             protected CompletableFuture<OperationOutcome> startGuardAsync() {
 161                 guardStarted.set(true);
 162                 return super.startGuardAsync();
 163             }
 164         };
 165         CompletableFuture<OperationOutcome> future3 = operation.startPreprocessorAsync();
 166
 167         assertNotNull(future3);
 168         assertFalse(future.isDone());
 169         assertTrue(guardStarted.get());
 170
 171         future2.complete(params.makeOutcome(null));
 172         assertTrue(executor.runAll(100));
 173         assertTrue(future3.isDone());
 174         assertEquals(PolicyResult.SUCCESS, future3.get().getResult());
 175     }
 176
 177     @Test
 178     public void testDetmStatusStringResponse() {
 179         final org.onap.policy.sdnr.Status status = response.getBody().getOutput().getStatus();
 180
 181         // null status
 182         response.getBody().getOutput().setStatus(null);
 183         assertEquals(Status.FAILURE, operation.detmStatus("", response));
 184         response.getBody().getOutput().setStatus(status);
 185
 186         // invalid code
 187         status.setCode(-45);
 188         assertEquals(Status.FAILURE, operation.detmStatus("", response));
 189
 190
 191         status.setValue(StatusCodeEnum.ACCEPTED.toString());
 192         status.setCode(StatusCodeEnum.toValue(StatusCodeEnum.ACCEPTED));
 193         assertEquals(Status.STILL_WAITING, operation.detmStatus("", response));
 194
 195         status.setValue(StatusCodeEnum.SUCCESS.toString());
 196         status.setCode(StatusCodeEnum.toValue(StatusCodeEnum.SUCCESS));
 197         assertEquals(Status.SUCCESS, operation.detmStatus("", response));
 198
 199         status.setValue(StatusCodeEnum.REJECT.toString());
 200         status.setCode(StatusCodeEnum.toValue(StatusCodeEnum.REJECT));
 201         assertEquals(Status.FAILURE, operation.detmStatus("", response));
 202
 203         status.setValue(StatusCodeEnum.REJECT.toString());
 204         status.setCode(313);
 205         assertEquals(Status.FAILURE, operation.detmStatus("", response));
 206
 207         status.setValue(StatusCodeEnum.ERROR.toString());
 208         status.setCode(StatusCodeEnum.toValue(StatusCodeEnum.ERROR));
 209         assertEquals(Status.FAILURE, operation.detmStatus("", response));
 210
 211         status.setValue(StatusCodeEnum.FAILURE.toString());
 212         status.setCode(450);
 213         assertEquals(Status.FAILURE, operation.detmStatus("", response));
 214     }
 215
 216     @Test
 217     public void testSetOutcome() {
 218         // with a status value
 219         checkOutcome();
 220         assertEquals(StatusCodeEnum.SUCCESS.toString(), outcome.getMessage());
 221
 222         // null status value
 223         response.getBody().getOutput().getStatus().setValue(null);
 224         checkOutcome();
 225
 226         // null status
 227         response.getBody().getOutput().setStatus(null);
 228         checkOutcome();
 229
 230         // null output
 231         response.getBody().setOutput(null);
 232         checkOutcome();
 233
 234         // null body
 235         response.setBody(null);
 236         checkOutcome();
 237     }
 238
 239     @Test
 240     public void testGetEventPayload() {
 241         // in neither property nor event
 242         assertNull(operation.getEventPayload());
 243
 244         // only in event
 245         event.setPayload("valueA2");
 246         assertEquals("valueA2", operation.getEventPayload());
 247
 248         // both - should choose the property
 249         operation.setProperty(OperationProperties.EVENT_PAYLOAD, "valueB");
 250         assertEquals("valueB", operation.getEventPayload());
 251
 252         // both - should choose the property, even if it's null
 253         operation.setProperty(OperationProperties.EVENT_PAYLOAD, null);
 254         assertNull(operation.getEventPayload());
 255     }
 256
 257     protected void checkOutcome() {
 258         assertSame(outcome, operation.setOutcome(outcome, PolicyResult.SUCCESS, response));
 259         assertEquals(PolicyResult.SUCCESS, outcome.getResult());
 260         assertNotNull(outcome.getMessage());
 261         assertSame(response, outcome.getResponse());
 262     }
 263 }