import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.util.Map;
+import java.util.TreeMap;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.onap.policy.common.parameters.BeanValidationResult;
-import org.onap.policy.controlloop.ControlLoopOperation;
-import org.onap.policy.controlloop.VirtualControlLoopEvent;
import org.onap.policy.controlloop.actorserviceprovider.ActorService;
+import org.onap.policy.controlloop.actorserviceprovider.Operation;
+import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.Operator;
-import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams.ControlLoopOperationParamsBuilder;
import org.onap.policy.controlloop.actorserviceprovider.spi.Actor;
-import org.onap.policy.controlloop.policy.Policy;
public class ControlLoopOperationParamsTest {
+ private static final String NULL_MSG = "null";
private static final String EXPECTED_EXCEPTION = "expected exception";
private static final String ACTOR = "my-actor";
private static final String OPERATION = "my-operation";
- private static final String TARGET = "my-target";
+ private static final String TARGET_ENTITY = "my-target";
+ private static final Integer RETRY = 3;
+ private static final Integer TIMEOUT = 100;
private static final UUID REQ_ID = UUID.randomUUID();
@Mock
private ActorService actorService;
@Mock
- private Consumer<ControlLoopOperation> completer;
-
- @Mock
- private ControlLoopEventContext context;
-
- @Mock
- private VirtualControlLoopEvent event;
+ private Consumer<OperationOutcome> completer;
@Mock
private Executor executor;
@Mock
- private CompletableFuture<ControlLoopOperation> operation;
+ private CompletableFuture<OperationOutcome> operFuture;
@Mock
private Operator operator;
@Mock
- private Policy policy;
+ private Operation operation;
@Mock
- private Consumer<ControlLoopOperation> starter;
+ private Consumer<OperationOutcome> starter;
+
+ private Map<String, Object> payload;
private ControlLoopOperationParams params;
- private ControlLoopOperation outcome;
+ private OperationOutcome outcome;
/**
when(actorService.getActor(ACTOR)).thenReturn(actor);
when(actor.getOperator(OPERATION)).thenReturn(operator);
- when(operator.startOperation(any())).thenReturn(operation);
+ when(operator.buildOperation(any())).thenReturn(operation);
+ when(operation.start()).thenReturn(operFuture);
- when(event.getRequestId()).thenReturn(REQ_ID);
-
- when(context.getEvent()).thenReturn(event);
-
- when(policy.getActor()).thenReturn(ACTOR);
- when(policy.getRecipe()).thenReturn(OPERATION);
+ payload = new TreeMap<>();
params = ControlLoopOperationParams.builder().actorService(actorService).completeCallback(completer)
- .context(context).executor(executor).policy(policy).startCallback(starter).target(TARGET)
- .build();
+ .requestId(REQ_ID).executor(executor).actor(ACTOR).operation(OPERATION).payload(payload)
+ .retry(RETRY).targetEntity(TARGET_ENTITY).timeoutSec(TIMEOUT)
+ .startCallback(starter).preprocessed(true).build();
- outcome = params.makeOutcome();
+ outcome = params.makeOutcome(TARGET_ENTITY);
}
@Test
public void testStart() {
- assertSame(operation, params.start());
-
- assertThatIllegalArgumentException().isThrownBy(() -> params.toBuilder().context(null).build().start());
- }
-
- @Test
- public void testGetActor() {
- assertEquals(ACTOR, params.getActor());
-
- // try with null policy
- assertEquals(ControlLoopOperationParams.UNKNOWN, params.toBuilder().policy(null).build().getActor());
+ assertThatIllegalArgumentException().isThrownBy(() -> params.toBuilder().requestId(null).build().start());
- // try with null name in the policy
- when(policy.getActor()).thenReturn(null);
- assertEquals(ControlLoopOperationParams.UNKNOWN, params.getActor());
+ assertSame(operFuture, params.start());
}
@Test
- public void testGetOperation() {
- assertEquals(OPERATION, params.getOperation());
-
- // try with null policy
- assertEquals(ControlLoopOperationParams.UNKNOWN, params.toBuilder().policy(null).build().getOperation());
+ public void testBuild() {
+ assertThatIllegalArgumentException().isThrownBy(() -> params.toBuilder().requestId(null).build().build());
- // try with null name in the policy
- when(policy.getRecipe()).thenReturn(null);
- assertEquals(ControlLoopOperationParams.UNKNOWN, params.getOperation());
+ assertSame(operation, params.build());
}
@Test
public void testGetRequestId() {
assertSame(REQ_ID, params.getRequestId());
-
- // try with null context
- assertNull(params.toBuilder().context(null).build().getRequestId());
-
- // try with null event
- when(context.getEvent()).thenReturn(null);
- assertNull(params.getRequestId());
}
@Test
assertEquals(ACTOR, outcome.getActor());
assertEquals(OPERATION, outcome.getOperation());
checkRemainingFields("with actor");
-
- // try again with a null policy
- outcome = params.toBuilder().policy(null).build().makeOutcome();
- assertEquals(ControlLoopOperationParams.UNKNOWN, outcome.getActor());
- assertEquals(ControlLoopOperationParams.UNKNOWN, outcome.getOperation());
- checkRemainingFields("unknown actor");
}
protected void checkRemainingFields(String testName) {
- assertEquals(testName, TARGET, outcome.getTarget());
- assertNotNull(testName, outcome.getStart());
+ assertEquals(testName, TARGET_ENTITY, outcome.getTarget());
+ assertNull(testName, outcome.getStart());
assertNull(testName, outcome.getEnd());
assertNull(testName, outcome.getSubRequestId());
- assertNull(testName, outcome.getOutcome());
+ assertNotNull(testName, outcome.getResult());
assertNull(testName, outcome.getMessage());
}
@Test
public void testValidateFields() {
- testValidate("actorService", "null", bldr -> bldr.actorService(null));
- testValidate("context", "null", bldr -> bldr.context(null));
- testValidate("executor", "null", bldr -> bldr.executor(null));
- testValidate("policy", "null", bldr -> bldr.policy(null));
- testValidate("target", "null", bldr -> bldr.target(null));
+ testValidate("actor", NULL_MSG, bldr -> bldr.actor(null));
+ testValidate("actorService", NULL_MSG, bldr -> bldr.actorService(null));
+ testValidate("executor", NULL_MSG, bldr -> bldr.executor(null));
+ testValidate("operation", NULL_MSG, bldr -> bldr.operation(null));
+ testValidate("requestId", NULL_MSG, bldr -> bldr.requestId(null));
+
+ // has no target entity
+ BeanValidationResult result = params.toBuilder().targetEntity(null).build().validate();
+ assertTrue(result.isValid());
// check edge cases
assertTrue(params.toBuilder().build().validate().isValid());
// these can be null
- assertTrue(params.toBuilder().startCallback(null).completeCallback(null).build().validate().isValid());
+ assertTrue(params.toBuilder().payload(null).retry(null).timeoutSec(null).startCallback(null)
+ .completeCallback(null).build().validate().isValid());
// test with minimal fields
- assertTrue(ControlLoopOperationParams.builder().actorService(actorService).context(context).policy(policy)
- .target(TARGET).build().validate().isValid());
+ assertTrue(ControlLoopOperationParams.builder().actorService(actorService).requestId(REQ_ID).actor(ACTOR)
+ .operation(OPERATION).targetEntity(TARGET_ENTITY).build().validate().isValid());
}
private void testValidate(String fieldName, String expected,
}
@Test
- public void testActorService() {
- assertSame(actorService, params.getActorService());
+ public void testGetActor() {
+ assertSame(ACTOR, params.getActor());
}
@Test
- public void testGetContext() {
- assertSame(context, params.getContext());
+ public void testGetActorService() {
+ assertSame(actorService, params.getActorService());
}
@Test
}
@Test
- public void testGetPolicy() {
- assertSame(policy, params.getPolicy());
+ public void testGetOperation() {
+ assertSame(OPERATION, params.getOperation());
+ }
+
+ @Test
+ public void testGetPayload() {
+ assertSame(payload, params.getPayload());
+
+ // should be null when unspecified
+ assertNull(ControlLoopOperationParams.builder().build().getPayload());
+ }
+
+ @Test
+ public void test() {
+ assertTrue(params.isPreprocessed());
+
+ // should be false when unspecified
+ assertFalse(ControlLoopOperationParams.builder().build().isPreprocessed());
+ }
+
+ @Test
+ public void testGetRetry() {
+ assertSame(RETRY, params.getRetry());
+
+ // should be null when unspecified
+ assertNull(ControlLoopOperationParams.builder().build().getRetry());
+ }
+
+ @Test
+ public void testGetTimeoutSec() {
+ assertSame(TIMEOUT, params.getTimeoutSec());
+
+ // should be 300 when unspecified
+ assertEquals(Integer.valueOf(300), ControlLoopOperationParams.builder().build().getTimeoutSec());
+
+ // null should be ok too
+ assertNull(ControlLoopOperationParams.builder().timeoutSec(null).build().getTimeoutSec());
}
@Test
}
@Test
- public void testGetTarget() {
- assertEquals(TARGET, params.getTarget());
+ public void testGetTargetEntity() {
+ assertEquals(TARGET_ENTITY, params.getTargetEntity());
}
}
Code Review / policy / models.git / blobdiff