import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
var reports = healthcheck(manager);
serverChecks(reports);
checkReports(reports, List.of("STUCK"),
- HttpStatus.OK_200, HttpStatus.getMessage(200));
+ HttpStatus.OK_200, HttpStatus.getMessage(200));
checkReports(reports, List.of("echo"), 1, "[echo:{java.lang.String=1}]");
/* mock controller and clients stuck */
RestMockHealthCheck.stuck = true; // make the server named STUCK unresponsive
doAnswer(AdditionalAnswers
- .answersWithDelay((manager.getTimeoutSeconds() + 2) * 1000L,
- invocationOnMock -> new HashMap<String, Integer>()))
- .when(manager).getFactTypes(any(), any());
+ .answersWithDelay((manager.getTimeoutSeconds() + 2) * 1000L,
+ invocationOnMock -> new HashMap<String, Integer>()))
+ .when(manager).getFactTypes(any(), any());
reports = healthcheck(manager);
RestMockHealthCheck.stuck = false; // unstuck the server named STUCK
serverChecks(reports);
checkReports(reports, List.of("STUCK"),
- HealthCheckManager.TIMEOUT_CODE, HealthCheckManager.TIMEOUT_MESSAGE);
+ HealthCheckManager.TIMEOUT_CODE, HealthCheckManager.TIMEOUT_MESSAGE);
- assertTrue(RestMockHealthCheck.WAIT * 1000 > HealthCheckManagerTest.select(reports, "STUCK",
- HealthCheckManager.TIMEOUT_CODE, HealthCheckManager.TIMEOUT_MESSAGE)
- .get(0).getElapsedTime());
+ assertTrue(RestMockHealthCheck.wait * 1000 > HealthCheckManagerTest.select(reports, "STUCK",
+ HealthCheckManager.TIMEOUT_CODE, HealthCheckManager.TIMEOUT_MESSAGE)
+ .get(0).getElapsedTime());
feature.afterShutdown(PolicyEngineConstants.getManager());
}
- private void checkReports(Reports reports, List<String> reportNames, int code, String message) {
- reportNames
- .forEach(name -> assertEquals(1,
- HealthCheckManagerTest.select(reports, name, code, message).size()));
- }
-
- private Reports healthcheck(HealthCheck manager) {
- var reports = manager.healthCheck();
- logger.info("{}", reports);
- return reports;
- }
-
- private void checkOpen(int port) throws InterruptedException {
- if (!NetworkUtil.isTcpPortOpen("localhost", port, 5, 10000L)) {
- throw new IllegalStateException("cannot connect to port " + port);
- }
- }
-
- private void serverChecks(Reports reports) {
- checkReports(reports, List.of("HEALTHCHECK", "LIVENESS"),
- HttpStatus.OK_200, HttpStatus.getMessage(200));
- checkReports(reports, List.of("UNAUTH"),
- HttpStatus.UNAUTHORIZED_401, HttpStatus.getMessage(401));
- checkReports(reports, List.of(HealthCheckManager.ENGINE_NAME),
- HealthCheckManager.SUCCESS_CODE, HealthCheckManager.ENABLED_MESSAGE);
- }
-
@Test
void testGetSequenceNumber() {
assertEquals(1000, new HealthCheckFeature().getSequenceNumber());
assertFalse(feature.afterShutdown(null));
}
+ @Test
+ void testGetManager() {
+ assertNotNull(new HealthCheckFeature().getManager());
+ }
+
+ private void checkReports(Reports reports, List<String> reportNames, int code, String message) {
+ reportNames
+ .forEach(name -> assertEquals(1,
+ HealthCheckManagerTest.select(reports, name, code, message).size()));
+ }
+
+ private Reports healthcheck(HealthCheck manager) {
+ var reports = manager.healthCheck();
+ logger.info("{}", reports);
+ return reports;
+ }
+
+ private void checkOpen(int port) throws InterruptedException {
+ if (!NetworkUtil.isTcpPortOpen("localhost", port, 5, 10000L)) {
+ throw new IllegalStateException("cannot connect to port " + port);
+ }
+ }
+
+ private void serverChecks(Reports reports) {
+ checkReports(reports, List.of("HEALTHCHECK", "LIVENESS"),
+ HttpStatus.OK_200, HttpStatus.getMessage(200));
+ checkReports(reports, List.of("UNAUTH"),
+ HttpStatus.UNAUTHORIZED_401, HttpStatus.getMessage(401));
+ checkReports(reports, List.of(HealthCheckManager.ENGINE_NAME),
+ HealthCheckManager.SUCCESS_CODE, HealthCheckManager.ENABLED_MESSAGE);
+ }
+
/**
* Feature that returns a particular monitor.
*/
* ONAP
* ================================================================================
* Copyright (C) 2017-2018,2022 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2024 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
protected static final String OK_MESSAGE = "All Alive";
protected static volatile boolean stuck = false;
- protected static volatile long WAIT = 15;
+ protected static volatile long wait = 15;
@GET
@Path("healthcheck/test")
@Path("healthcheck/stuck")
@Produces({MediaType.APPLICATION_JSON, YamlMessageBodyHandler.APPLICATION_YAML})
public Response stuck() {
- await().atMost(WAIT, TimeUnit.SECONDS).until(() -> !stuck);
+ await().atMost(wait, TimeUnit.SECONDS).until(() -> !stuck);
return Response.status(Status.OK).entity("I may be stuck: " + stuck).build();
}
}
* ONAP
* ================================================================================
* Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2023 Nordix Foundation.
+ * Modifications Copyright (C) 2023-2024 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* Lifecycle FSM.
*/
@Getter
- public static LifecycleFsm fsm = new LifecycleFsm();
+ static LifecycleFsm fsm = new LifecycleFsm();
@Override
public int getSequenceNumber() {
* ================================================================================
* Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2019 Bell Canada.
- * Modifications Copyright (C) 2021, 2023 Nordix Foundation.
+ * Modifications Copyright (C) 2021, 2023-2024 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
List<ToscaPolicy> failedUndeployPolicies = undeployPolicies(policies);
if (!failedUndeployPolicies.isEmpty()) {
- logger.warn("update-policies: undeployment failures: {}", fsm.getPolicyIdsMessage(failedUndeployPolicies));
+ var failures = fsm.getPolicyIdsMessage(failedUndeployPolicies);
+ logger.warn("update-policies: undeployment failures: {}", failures);
failedUndeployPolicies.forEach(fsm::failedUndeployPolicyAction);
}
List<ToscaPolicy> failedDeployPolicies = deployPolicies(policies);
if (!failedDeployPolicies.isEmpty()) {
- logger.warn("update-policies: deployment failures: {}", fsm.getPolicyIdsMessage(failedDeployPolicies));
+ var failures = fsm.getPolicyIdsMessage(failedDeployPolicies);
+ logger.warn("update-policies: deployment failures: {}", failures);
failedDeployPolicies.forEach(fsm::failedDeployPolicyAction);
}
List<ToscaPolicy> preNonNativePolicies = fsm.getNonNativePolicies(preActivePoliciesMap);
preNonNativePolicies.retainAll(fsm.getNonNativePolicies(activePoliciesByType));
+ var nonNativePoliciesIds = fsm.getPolicyIdsMessage(preNonNativePolicies);
+ var activePoliciesIds = fsm.getPolicyIdsMessage(activeNativeArtifactPolicies);
+
logger.info("re-applying non-native policies {} because new native artifact policies have been found: {}",
- fsm.getPolicyIdsMessage(preNonNativePolicies), fsm.getPolicyIdsMessage(activeNativeArtifactPolicies));
+ nonNativePoliciesIds, activePoliciesIds);
List<ToscaPolicy> failedPolicies = syncPolicies(preNonNativePolicies, this::deployPolicy);
- logger.info("re-applying non-native policies failures: {}", fsm.getPolicyIdsMessage(failedPolicies));
+ var failedPoliciesIds = fsm.getPolicyIdsMessage(failedPolicies);
+ logger.info("re-applying non-native policies failures: {}", failedPoliciesIds);
return failedPolicies;
}
List<ToscaPolicy> preNativeArtifactPolicies = fsm.getNativeArtifactPolicies(preActivePoliciesMap);
preNativeArtifactPolicies.retainAll(fsm.getNativeArtifactPolicies(activePoliciesByType));
+ var candidateIds = fsm.getPolicyIdsMessage(preNativeArtifactPolicies);
+ var activeIds = fsm.getPolicyIdsMessage(activeNativeControllerPolicies);
+
logger.info("reapply candidate native artifact policies {} as new native controller policies {} were found",
- fsm.getPolicyIdsMessage(preNativeArtifactPolicies),
- fsm.getPolicyIdsMessage(activeNativeControllerPolicies));
+ candidateIds, activeIds);
// from the intersection, only need to reapply those for which there is a new native
// controller policy
}
}
+ var nativeArtPolIds = fsm.getPolicyIdsMessage(preNativeArtifactPoliciesToApply);
+ var newNativeCtrlPolIds = fsm.getPolicyIdsMessage(activeNativeControllerPolicies);
logger.info("reapply set of native artifact policies {} as new native controller policies {} were found",
- fsm.getPolicyIdsMessage(preNativeArtifactPoliciesToApply),
- fsm.getPolicyIdsMessage(activeNativeControllerPolicies));
+ nativeArtPolIds, newNativeCtrlPolIds);
List<ToscaPolicy> failedPolicies = syncPolicies(preNativeArtifactPoliciesToApply, this::deployPolicy);
- logger.info("re-applying native artifact policies failures: {}", fsm.getPolicyIdsMessage(failedPolicies));
+ var failedIds = fsm.getPolicyIdsMessage(failedPolicies);
+ logger.info("re-applying native artifact policies failures: {}", failedIds);
// since we want non-native policies to be reapplied when a new native artifact policy has been
// reapplied here, remove it from the preActivePolicies, so it is detected as new.
/*-
* ============LICENSE_START=======================================================
* Copyright (C) 2019-2022 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2021, 2023-2023 Nordix Foundation.
+ * Modifications Copyright (C) 2021, 2023-2024 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
private PdpUpdate getUndeployPolicyUpdate(List<ToscaPolicy> policies) {
PdpUpdate update = getPolicyUpdate();
- update.setPoliciesToBeUndeployed(LifecycleFeature.fsm.getPolicyIds(policies));
+ update.setPoliciesToBeUndeployed(LifecycleFeature.getFsm().getPolicyIds(policies));
return update;
}
import org.onap.policy.drools.system.PolicyControllerConstants;
import org.onap.policy.drools.util.KieUtils;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Controller Test Support.
@Getter
public class ControllerSupport {
+ private static final Logger logger = LoggerFactory.getLogger(ControllerSupport.class);
+
protected static final String JUNIT_KMODULE_DRL_PATH = "src/test/resources/lifecycle.drl";
protected static final String JUNIT_KMODULE_POM_PATH = "src/test/resources/lifecycle.pom";
protected static final String JUNIT_KMODULE_PATH = "src/test/resources/lifecycle.kmodule";
/**
* Create controller.
*/
- public PolicyController createController() throws IOException {
+ public void createController() throws IOException {
try {
PolicyController controller = getController();
controller.getDrools().delete(ToscaPolicy.class);
- return controller;
- } catch (IllegalArgumentException ignored) { // NOSONAR
- ; // checkstyle
+ } catch (IllegalArgumentException e) {
+ logger.debug("error when creating controller", e);
}
ReleaseId coordinates = installArtifact();
Properties controllerProps = getControllerProps(coordinates);
- return PolicyControllerConstants.getFactory().build(name, controllerProps);
+ PolicyControllerConstants.getFactory().build(name, controllerProps);
}
private Properties getControllerProps(ReleaseId coordinates) {
* Change final marker in static field.
*/
public static <T> Field unsetFinalStaticAccess(Class<T> clazz, String fieldName)
- throws NoSuchFieldException {
+ throws NoSuchFieldException {
Field field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2024 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.lifecycle;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.onap.policy.drools.lifecycle.LifecycleFsm.CONFIGURATION_PROPERTIES_NAME;
+
+import java.util.Properties;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.onap.policy.drools.persistence.FileSystemPersistence;
+import org.onap.policy.drools.persistence.SystemPersistenceConstants;
+import org.onap.policy.drools.system.PolicyController;
+import org.onap.policy.drools.system.PolicyEngine;
+
+@ExtendWith(MockitoExtension.class)
+class LifecycleFeatureTest {
+
+ LifecycleFeature feature;
+
+ @Mock
+ LifecycleFsm fsm;
+
+ @Mock
+ PolicyController controller;
+
+ @Mock
+ PolicyEngine engine;
+
+ AutoCloseable closeable;
+
+ @BeforeEach
+ void setUp() {
+ closeable = MockitoAnnotations.openMocks(this);
+
+ var props = new Properties();
+ var fileManager = mock(FileSystemPersistence.class);
+ lenient().when(fileManager.getProperties(CONFIGURATION_PROPERTIES_NAME)).thenReturn(props);
+
+ try (MockedStatic<SystemPersistenceConstants> constants =
+ Mockito.mockStatic(SystemPersistenceConstants.class)) {
+ constants.when(SystemPersistenceConstants::getManager).thenReturn(fileManager);
+ feature = mock(LifecycleFeature.class);
+ }
+ }
+
+ @AfterEach
+ void tearDown() throws Exception {
+ closeable.close();
+ }
+
+ @Test
+ void getSequenceNumber() {
+ when(feature.getSequenceNumber()).thenCallRealMethod();
+
+ assertEquals(1, feature.getSequenceNumber());
+ }
+
+ @Test
+ void afterStart() {
+ when(fsm.start()).thenReturn(true);
+ doNothing().when(fsm).start(controller);
+
+ when(feature.afterStart(engine)).thenCallRealMethod();
+ when(feature.afterStart(controller)).thenCallRealMethod();
+
+ try (MockedStatic<LifecycleFeature> factory = Mockito.mockStatic(LifecycleFeature.class)) {
+ factory.when(LifecycleFeature::getFsm).thenReturn(fsm);
+ assertEquals(fsm, LifecycleFeature.getFsm());
+
+ assertFalse(feature.afterStart(controller));
+ assertFalse(feature.afterStart(engine));
+ }
+ }
+
+ @Test
+ void beforeStop() {
+ when(fsm.stop()).thenReturn(true);
+ doNothing().when(fsm).stop(controller);
+
+ when(feature.beforeStop(engine)).thenCallRealMethod();
+ when(feature.beforeStop(controller)).thenCallRealMethod();
+
+ try (MockedStatic<LifecycleFeature> factory = Mockito.mockStatic(LifecycleFeature.class)) {
+ factory.when(LifecycleFeature::getFsm).thenReturn(fsm);
+ assertEquals(fsm, LifecycleFeature.getFsm());
+
+ assertFalse(feature.beforeStop(controller));
+ assertFalse(feature.beforeStop(engine));
+ }
+ }
+
+ @Test
+ void beforeShutdown() {
+ doNothing().when(fsm).shutdown();
+
+ when(feature.beforeShutdown(engine)).thenCallRealMethod();
+
+ try (MockedStatic<LifecycleFeature> factory = Mockito.mockStatic(LifecycleFeature.class)) {
+ factory.when(LifecycleFeature::getFsm).thenReturn(fsm);
+ assertEquals(fsm, LifecycleFeature.getFsm());
+
+ assertFalse(feature.beforeShutdown(engine));
+ }
+ }
+
+ @Test
+ void beforeLock() {
+ doNothing().when(fsm).stop(controller);
+
+ when(feature.beforeLock(controller)).thenCallRealMethod();
+
+ try (MockedStatic<LifecycleFeature> factory = Mockito.mockStatic(LifecycleFeature.class)) {
+ factory.when(LifecycleFeature::getFsm).thenReturn(fsm);
+ assertEquals(fsm, LifecycleFeature.getFsm());
+
+ assertFalse(feature.beforeLock(controller));
+ }
+ }
+
+ @Test
+ void afterUnlock() {
+ doNothing().when(fsm).start(controller);
+
+ when(feature.afterUnlock(controller)).thenCallRealMethod();
+
+ try (MockedStatic<LifecycleFeature> factory = Mockito.mockStatic(LifecycleFeature.class)) {
+ factory.when(LifecycleFeature::getFsm).thenReturn(fsm);
+ assertEquals(fsm, LifecycleFeature.getFsm());
+
+ assertFalse(feature.afterUnlock(controller));
+ }
+ }
+}
\ No newline at end of file
fsm.getPolicyIds(List.of(opPolicy, controllerPolicy)).toString());
}
+ @Test
+ void testGetSequenceNumber() {
+ assertEquals(1, new LifecycleFeature().getSequenceNumber());
+ }
+
protected void deployAllPolicies() {
fsm.deployedPolicyAction(controllerPolicy);
fsm.deployedPolicyAction(controller2Policy);
noopTopicProperties.put(PolicyEndPointProperties.PROPERTY_NOOP_SINK_TOPICS, TestConstants.APPC_CL_TOPIC);
TopicEndpointManager.getManager().addTopics(noopTopicProperties);
- savedFsm = LifecycleFeature.fsm;
+ savedFsm = LifecycleFeature.getFsm();
}
/**
public void init() throws CoderException, IOException, NoSuchFieldException, IllegalAccessException {
fsm = new LifecycleFsm() {
@Override
- protected ScheduledExecutorService makeExecutor() { // NOSONAR
+ protected ScheduledExecutorService makeExecutor() {
return new PseudoScheduledExecutorService(new TestTimeMulti());
}
};
protected void verifyNativeArtifactPolicies(List<ToscaPolicy> policies) throws CoderException {
// check that a brained controller exists for each native artifact policy
for (ToscaPolicy policy : policies) {
- NativeArtifactPolicy artifactPolicy = fsm.getDomainMaker().convertTo(policy, NativeArtifactPolicy.class);
- String controllerName = artifactPolicy.getProperties().getController().getName();
+ NativeArtifactPolicy naPolicy = fsm.getDomainMaker().convertTo(policy, NativeArtifactPolicy.class);
+ String controllerName = naPolicy.getProperties().getController().getName();
assertTrue(PolicyControllerConstants.getFactory().get(controllerName).getDrools().isBrained());
- assertEquals(artifactPolicy.getProperties().getRulesArtifact().getGroupId(),
+ assertEquals(naPolicy.getProperties().getRulesArtifact().getGroupId(),
PolicyControllerConstants.getFactory().get(controllerName).getDrools().getGroupId());
- assertEquals(artifactPolicy.getProperties().getRulesArtifact().getArtifactId(),
+ assertEquals(naPolicy.getProperties().getRulesArtifact().getArtifactId(),
PolicyControllerConstants.getFactory().get(controllerName).getDrools().getArtifactId());
- assertEquals(artifactPolicy.getProperties().getRulesArtifact().getVersion(),
+ assertEquals(naPolicy.getProperties().getRulesArtifact().getVersion(),
PolicyControllerConstants.getFactory().get(controllerName).getDrools().getVersion());
}
}
// and there is a controller policy for each controllerName
for (ToscaPolicy nativePolicy : nativeArtifactPolicies) {
- NativeArtifactPolicy artifactPolicy =
+ NativeArtifactPolicy naPolicy =
fsm.getDomainMaker().convertTo(nativePolicy, NativeArtifactPolicy.class);
- String artifactControllerName = artifactPolicy.getProperties().getController().getName();
+ String artifactControllerName = naPolicy.getProperties().getController().getName();
// brained controller check
assertTrue(PolicyControllerConstants.getFactory().get(artifactControllerName).getDrools().isBrained(),
protected List<ControllerPolicy> getNativeControllerPolicies(List<ToscaPolicy> nativePolicies,
String controllerName) {
- return nativePolicies.stream().map(controllerPolicy -> {
+ return nativePolicies.stream().map(nativePolicy -> {
try {
- return fsm.getDomainMaker().convertTo(controllerPolicy, ControllerPolicy.class);
+ return fsm.getDomainMaker().convertTo(nativePolicy, ControllerPolicy.class);
} catch (CoderException ex) {
- throw new RuntimeException(controllerPolicy.getIdentifier().toString(), ex);
+ throw new RuntimeException(nativePolicy.getIdentifier().toString(), ex);
}
- }).filter(controllerPolicy -> controllerName.equals(controllerPolicy.getProperties().getControllerName()))
+ }).filter(nativePolicy -> controllerName.equals(nativePolicy.getProperties().getControllerName()))
.collect(Collectors.toList());
}
@Test
void testUpdate() throws IOException, CoderException {
- // TODO: extract repeated similar assertion blocks into their own helper methods
-
PdpUpdate update = new PdpUpdate();
update.setName(PolicyEngineConstants.getManager().getPdpName());
update.setPdpGroup("W");
factPolicies = controllerSupport.getFacts(ToscaPolicy.class);
assertEquals(2, factPolicies.size());
- assertTrue(factPolicies.stream().noneMatch((ff) -> Objects.equals(toscaPolicyRestartV1, ff)));
- assertTrue(factPolicies.stream().anyMatch((ff) -> Objects.equals(toscaPolicyRestartV2, ff)));
- assertTrue(factPolicies.stream().anyMatch((ff) -> Objects.equals(toscaPolicyFirewall, ff)));
+ assertTrue(factPolicies.stream().noneMatch(ff -> Objects.equals(toscaPolicyRestartV1, ff)));
+ assertTrue(factPolicies.stream().anyMatch(ff -> Objects.equals(toscaPolicyRestartV2, ff)));
+ assertTrue(factPolicies.stream().anyMatch(ff -> Objects.equals(toscaPolicyFirewall, ff)));
assertEquals(2, fsm.policiesMap.size());
long originalInterval = fsm.getStatusTimerSeconds();
fsm.start(controllerSupport.getController());
assertSame(controllerSupport.getController(),
((PolicyTypeDroolsController) fsm.getController(
- new ToscaConceptIdentifier(
- ControllerSupport.POLICY_TYPE_COMPLIANT_OP, ControllerSupport.POLICY_TYPE_VERSION)))
+ new ToscaConceptIdentifier(
+ ControllerSupport.POLICY_TYPE_COMPLIANT_OP, ControllerSupport.POLICY_TYPE_VERSION)))
.controllers().get(0));
fsm.stop(controllerSupport.getController());
assertNull(fsm.getController(new ToscaConceptIdentifier(ControllerSupport.POLICY_TYPE_COMPLIANT_OP,
- ControllerSupport.POLICY_TYPE_VERSION)));
+ ControllerSupport.POLICY_TYPE_VERSION)));
fsm.shutdown();
}
assertBasicTerminated();
}
- private void simpleStart() {
- assertTrue(fsm.start());
- assertBasicPassive();
- }
-
- private void simpleStop() {
- assertTrue(fsm.stop());
- assertBasicTerminated();
- }
-
@Test
void testShutdown() throws Exception {
simpleStop();
fsm.shutdown();
}
- private void status() {
- waitUntil(5, TimeUnit.SECONDS, isStatus(PdpState.PASSIVE, 1));
- waitUntil(fsm.statusTimerSeconds + 2, TimeUnit.SECONDS, isStatus(PdpState.PASSIVE, 1 + 1));
- waitUntil(fsm.statusTimerSeconds + 2, TimeUnit.SECONDS, isStatus(PdpState.PASSIVE, 1 + 2));
- assertTrue(fsm.status());
- waitUntil(200, TimeUnit.MILLISECONDS, isStatus(PdpState.PASSIVE, 1 + 3));
- }
-
@Test
void testUpdate() throws CoderException {
controllerSupport.getController().getDrools().delete(ToscaPolicy.class);
int qlength = fsm.client.getSink().getRecentEvents().length;
PdpStatus lastStatus = new StandardCoder().decode(fsm.client.getSink().getRecentEvents()[qlength - 1],
- PdpStatus.class);
+ PdpStatus.class);
assertEquals("foo", lastStatus.getPdpType());
assertEquals(update.getRequestId(), lastStatus.getRequestId());
assertEquals(update.getRequestId(), lastStatus.getResponse().getResponseTo());
assertEquals("z", fsm.getSubGroup());
assertBasicPassive();
- ToscaPolicy toscaPolicy =
- getExamplesPolicy("policies/vCPE.policy.operational.input.tosca.json", "operational.restart");
+ var policyResourcePath = "policies/vCPE.policy.operational.input.tosca.json";
+ ToscaPolicy toscaPolicy = getExamplesPolicy(policyResourcePath, "operational.restart");
toscaPolicy.getProperties().put("controllerName", "lifecycle");
- update.setPoliciesToBeDeployed(List.of(toscaPolicy));
-
- assertFalse(fsm.update(update));
-
- assertEquals(PdpState.PASSIVE, fsm.state());
- assertEquals(interval, fsm.getStatusTimerSeconds());
- assertEquals(LifecycleFsm.DEFAULT_PDP_GROUP, fsm.getGroup());
- assertEquals("z", fsm.getSubGroup());
- assertBasicPassive();
-
- assertEquals(2, fsm.policyTypesMap.size());
- assertTrue(fsm.policiesMap.isEmpty());
+ verifyVcpePolicyDeployed(update, toscaPolicy, interval);
update.setPdpGroup(null);
update.setPdpSubgroup(null);
assertBasicPassive();
assertEquals(0, controllerSupport.getController().getDrools().factCount("junits"));
- // The "update" event will undeploy "toscaPolicy" and deploy "toscaPolicy2"
- ToscaPolicy toscaPolicy2 =
- getExamplesPolicy("policies/vFirewall.policy.operational.input.tosca.json", "operational.modifyconfig");
- toscaPolicy.getProperties().remove("controllerName");
- update.setPoliciesToBeUndeployed(List.of(toscaPolicy.getIdentifier()));
- update.setPoliciesToBeDeployed(List.of(toscaPolicy2));
- assertTrue(fsm.update(update));
- assertEquals(3, fsm.policyTypesMap.size());
- assertEquals(1, fsm.policiesMap.size());
- assertEquals(toscaPolicy2, fsm.policiesMap.get(toscaPolicy2.getIdentifier()));
- assertNull(fsm.policiesMap.get(toscaPolicy.getIdentifier()));
- assertEquals(0, controllerSupport.getController().getDrools().factCount("junits"));
-
- update.setPdpGroup(null);
- update.setPdpSubgroup(null);
- update.setPoliciesToBeUndeployed(List.of(toscaPolicy2.getIdentifier()));
- update.setPoliciesToBeDeployed(List.of());
- assertTrue(fsm.update(update));
- assertEquals(3, fsm.policyTypesMap.size());
- assertEquals(0, fsm.policiesMap.size());
- assertEquals(PdpState.PASSIVE, fsm.state());
- assertEquals(interval, fsm.getStatusTimerSeconds());
- assertEquals(LifecycleFsm.DEFAULT_PDP_GROUP, fsm.getGroup());
- assertNull(fsm.getSubGroup());
- assertBasicPassive();
- assertEquals(0, controllerSupport.getController().getDrools().factCount("junits"));
+ verifyUpdateUndeployToscaPolicyDeployToscaPolicy2(toscaPolicy, update, interval);
fsm.shutdown();
}
fsm.shutdown();
}
+ private void simpleStart() {
+ assertTrue(fsm.start());
+ assertBasicPassive();
+ }
+
+ private void simpleStop() {
+ assertTrue(fsm.stop());
+ assertBasicTerminated();
+ }
+
private void assertBasicTerminated() {
assertEquals(PdpState.TERMINATED, fsm.state.state());
assertFalse(fsm.isAlive());
assertFalse(fsm.statusTask.isCancelled());
assertFalse(fsm.statusTask.isDone());
}
+
+ private void status() {
+ waitUntil(5, TimeUnit.SECONDS, isStatus(PdpState.PASSIVE, 1));
+ waitUntil(fsm.statusTimerSeconds + 2, TimeUnit.SECONDS, isStatus(PdpState.PASSIVE, 1 + 1));
+ waitUntil(fsm.statusTimerSeconds + 2, TimeUnit.SECONDS, isStatus(PdpState.PASSIVE, 1 + 2));
+ assertTrue(fsm.status());
+ waitUntil(200, TimeUnit.MILLISECONDS, isStatus(PdpState.PASSIVE, 1 + 3));
+ }
+
+ private void verifyVcpePolicyDeployed(PdpUpdate update, ToscaPolicy toscaPolicy, long interval) {
+ update.setPoliciesToBeDeployed(List.of(toscaPolicy));
+
+ assertFalse(fsm.update(update));
+
+ assertEquals(PdpState.PASSIVE, fsm.state());
+ assertEquals(interval, fsm.getStatusTimerSeconds());
+ assertEquals(LifecycleFsm.DEFAULT_PDP_GROUP, fsm.getGroup());
+ assertEquals("z", fsm.getSubGroup());
+ assertBasicPassive();
+
+ assertEquals(2, fsm.policyTypesMap.size());
+ assertTrue(fsm.policiesMap.isEmpty());
+ }
+
+ private void verifyUpdateUndeployToscaPolicyDeployToscaPolicy2(ToscaPolicy toscaPolicy, PdpUpdate update,
+ long interval) throws CoderException {
+ // The "update" event will undeploy "toscaPolicy" and deploy "toscaPolicy2"
+ String policyResourcePath = "policies/vFirewall.policy.operational.input.tosca.json";
+ ToscaPolicy toscaPolicy2 = getExamplesPolicy(policyResourcePath, "operational.modifyconfig");
+ toscaPolicy.getProperties().remove("controllerName");
+ update.setPoliciesToBeUndeployed(List.of(toscaPolicy.getIdentifier()));
+ update.setPoliciesToBeDeployed(List.of(toscaPolicy2));
+ assertTrue(fsm.update(update));
+ assertEquals(3, fsm.policyTypesMap.size());
+ assertEquals(1, fsm.policiesMap.size());
+ assertEquals(toscaPolicy2, fsm.policiesMap.get(toscaPolicy2.getIdentifier()));
+ assertNull(fsm.policiesMap.get(toscaPolicy.getIdentifier()));
+ assertEquals(0, controllerSupport.getController().getDrools().factCount("junits"));
+
+ update.setPdpGroup(null);
+ update.setPdpSubgroup(null);
+ update.setPoliciesToBeUndeployed(List.of(toscaPolicy2.getIdentifier()));
+ update.setPoliciesToBeDeployed(List.of());
+ assertTrue(fsm.update(update));
+ assertEquals(3, fsm.policyTypesMap.size());
+ assertEquals(0, fsm.policiesMap.size());
+ assertEquals(PdpState.PASSIVE, fsm.state());
+ assertEquals(interval, fsm.getStatusTimerSeconds());
+ assertEquals(LifecycleFsm.DEFAULT_PDP_GROUP, fsm.getGroup());
+ assertNull(fsm.getSubGroup());
+ assertBasicPassive();
+ assertEquals(0, controllerSupport.getController().getDrools().factCount("junits"));
+ }
}
}
@Override
- public LifecycleState create(LifecycleFsm fsm) {
- return new LifecycleStateSafe(fsm);
+ public void create(LifecycleFsm fsm) {
+ new LifecycleStateSafe(fsm);
}
+ @Override
@Test
public void constructor() {
super.constructor();
}
@Override
- public LifecycleState create(LifecycleFsm fsm) {
- return new LifecycleStateTest(fsm);
+ public void create(LifecycleFsm fsm) {
+ new LifecycleStateTest(fsm);
}
+ @Override
@Test
public void constructor() {
super.constructor();
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import java.util.ArrayList;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.onap.policy.drools.persistence.SystemPersistenceConstants;
import org.onap.policy.models.pdp.concepts.PdpStateChange;
import org.onap.policy.models.pdp.concepts.PdpUpdate;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
/**
* Lifecycle State Unsupported Test.
this.state = state;
}
- public abstract LifecycleState create(LifecycleFsm fsm);
+ public abstract void create(LifecycleFsm fsm);
@Test
public void constructor() {
assertThatThrownBy(() -> state.transitionToState(active))
.isInstanceOf(UnsupportedOperationException.class);
}
+
+ @Test
+ public void updatePolicies() {
+ var list = new ArrayList<ToscaPolicy>();
+ assertThatThrownBy(() -> state.updatePolicies(list))
+ .isInstanceOf(UnsupportedOperationException.class);
+ }
}
package org.onap.policy.drools.lifecycle;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
-import org.junit.jupiter.api.BeforeEach;
+import java.util.ArrayList;
+import java.util.List;
import org.junit.jupiter.api.Test;
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.drools.domain.models.operational.OperationalPolicy;
import org.onap.policy.drools.system.PolicyControllerConstants;
+import org.onap.policy.drools.system.internal.AggregatedPolicyController;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
/**
// Operational vCPE Policies
private static final String OP_POLICY_NAME_VCPE = "operational.restart";
private static final String VCPE_OPERATIONAL_DROOLS_POLICY_JSON =
- "policies/vCPE.policy.operational.input.tosca.json";
+ "policies/vCPE.policy.operational.input.tosca.json";
private ToscaPolicy policy;
private PolicyTypeDroolsController controller;
/**
* Test initialization.
*/
- @BeforeEach
public void init() throws CoderException {
fsm = makeFsmWithPseudoTime();
policy = getExamplesPolicy(VCPE_OPERATIONAL_DROOLS_POLICY_JSON, OP_POLICY_NAME_VCPE);
}
@Test
- void testDeployUndeploy() {
+ void testDeployUndeploy() throws CoderException {
+ init();
/* non-existing controller */
assertFalse(controller.undeploy(policy));
assertFalse(controller.deploy(policy));
undeploy(); // one more time
}
+ @Test
+ void testNullExceptions() {
+ var mockController = mock(PolicyTypeDroolsController.class);
+ when(mockController.deploy(isNull())).thenCallRealMethod();
+ doCallRealMethod().when(mockController).remove(isNull());
+ when(mockController.undeploy(isNull())).thenCallRealMethod();
+ doCallRealMethod().when(mockController).add(isNull());
+
+ assertThatThrownBy(() -> mockController.deploy(null))
+ .hasMessageContaining("policy is marked non-null but is null");
+
+ assertThatThrownBy(() -> mockController.remove(null))
+ .hasMessageContaining("controller is marked non-null but is null");
+
+ assertThatThrownBy(() -> mockController.undeploy(null))
+ .hasMessageContaining("policy is marked non-null but is null");
+
+ assertThatThrownBy(() -> mockController.add(null))
+ .hasMessageContaining("controller is marked non-null but is null");
+ }
+
+ @Test
+ void testAddController_DoesNotMatchPolicyType() {
+ var newController = mock(AggregatedPolicyController.class);
+ when(newController.getPolicyTypes()).thenReturn(new ArrayList<>(List.of(mock(ToscaConceptIdentifier.class))));
+ when(newController.getName()).thenReturn("mockControllerName");
+
+ var mockController = mock(PolicyTypeDroolsController.class);
+ doCallRealMethod().when(mockController).add(newController);
+
+ assertThatThrownBy(() -> mockController.add(newController))
+ .hasMessageContaining("controller mockControllerName does not support");
+ }
+
protected void undeploy() {
assertTrue(controller.undeploy(policy));
assertFalse(controllerSupport.getController().getDrools().exists(policy));
/* idempotence */
assertTrue(controller.deploy(policy));
assertDeployed();
-
- // TODO: test a point version upgrade
}
private void assertUndeployed() {
class PolicyTypeNativeDroolsControllerTest extends LifecycleStateRunningTest {
private static final String EXAMPLE_NATIVE_DROOLS_POLICY_NAME = "example.controller";
private static final String EXAMPLE_NATIVE_DROOLS_POLICY_JSON =
- "src/test/resources/tosca-policy-native-controller-example.json";
+ "src/test/resources/tosca-policy-native-controller-example.json";
/**
* Test initialization.
ToscaPolicy policy = getPolicyFromFile(EXAMPLE_NATIVE_DROOLS_POLICY_JSON, EXAMPLE_NATIVE_DROOLS_POLICY_NAME);
ControllerPolicy controllerPolicy = fsm.getDomainMaker().convertTo(policy, ControllerPolicy.class);
PolicyTypeNativeDroolsController controller =
- new PolicyTypeNativeDroolsController(policy.getTypeIdentifier(), fsm);
+ new PolicyTypeNativeDroolsController(policy.getTypeIdentifier(), fsm);
assertTrue(controller.undeploy(policy));
assertThatIllegalArgumentException().isThrownBy(
() -> PolicyControllerConstants.getFactory().get(controllerPolicy.getName()));
TopicEndpointManager.getManager().addTopics(noopTopicProperties);
ToscaPolicy nativeControllerPolicy =
- getExamplesPolicy("policies/usecases.native.controller.policy.input.tosca.json", "usecases");
+ getExamplesPolicy("policies/usecases.native.controller.policy.input.tosca.json", "usecases");
PolicyTypeNativeDroolsController controller =
- new PolicyTypeNativeDroolsController(nativeControllerPolicy.getTypeIdentifier(), fsm);
+ new PolicyTypeNativeDroolsController(nativeControllerPolicy.getTypeIdentifier(), fsm);
assertTrue(controller.deploy(nativeControllerPolicy));
Properties properties = PolicyControllerConstants.getFactory().get("usecases").getProperties();
assertNull(properties.getProperty("rules.artifactId"));
assertNull(properties.getProperty("rules.version"));
+ assertSourceTopics(properties);
+
+ assertSinkTopics(properties);
+
+ assertEquals("test", properties.getProperty("notes"));
+ assertEquals("auto", properties.getProperty("persistence.type"));
+
+ assertTrue(controller.undeploy(nativeControllerPolicy));
+ }
+
+ private static void assertSourceTopics(Properties properties) {
assertEquals("dcae_topic,appc-cl,appc-lcm-write,sdnr-cl-rsp",
- properties.getProperty("noop.source.topics"));
- assertEquals("appc-cl,appc-lcm-read,policy-cl-mgt,dcae_cl_rsp",
- properties.getProperty("noop.sink.topics"));
+ properties.getProperty("noop.source.topics"));
assertEquals("org.onap.policy.controlloop.CanonicalOnset,org.onap.policy.controlloop.CanonicalAbated",
- properties.getProperty("noop.source.topics.dcae_topic.events"));
+ properties.getProperty("noop.source.topics.dcae_topic.events"));
+
assertEquals("[?($.closedLoopEventStatus == 'ONSET')]",
- properties
- .getProperty("noop.source.topics.dcae_topic.events.org.onap.policy.controlloop.CanonicalOnset.filter"));
+ properties.getProperty("noop.source.topics.dcae_topic.events."
+ + "org.onap.policy.controlloop.CanonicalOnset.filter"));
+
assertEquals("[?($.closedLoopEventStatus == 'ABATED')]",
- properties
- .getProperty("noop.source.topics.dcae_topic.events."
- + "org.onap.policy.controlloop.CanonicalAbated.filter"));
+ properties.getProperty("noop.source.topics.dcae_topic.events."
+ + "org.onap.policy.controlloop.CanonicalAbated.filter"));
+
assertEquals("org.onap.policy.controlloop.util.Serialization,gson",
- properties.getProperty("noop.source.topics.dcae_topic.events.custom.gson"));
+ properties.getProperty("noop.source.topics.dcae_topic.events.custom.gson"));
+
+ assertEquals("org.onap.policy.appc.Response",
+ properties.getProperty("noop.source.topics.appc-cl.events"));
- assertEquals("org.onap.policy.appc.Response", properties.getProperty("noop.source.topics.appc-cl.events"));
assertEquals("[?($.CommonHeader && $.Status)]",
- properties
- .getProperty("noop.source.topics.appc-cl.events.org.onap.policy.appc.Response.filter"));
+ properties.getProperty("noop.source.topics.appc-cl.events.org.onap.policy.appc.Response.filter"));
+
assertEquals("org.onap.policy.appc.util.Serialization,gsonPretty",
- properties.getProperty("noop.source.topics.appc-cl.events.custom.gson"));
+ properties.getProperty("noop.source.topics.appc-cl.events.custom.gson"));
assertEquals("org.onap.policy.appclcm.AppcLcmMessageWrapper",
- properties.getProperty("noop.source.topics.appc-lcm-write.events"));
+ properties.getProperty("noop.source.topics.appc-lcm-write.events"));
+
assertEquals("[?($.type == 'response')]",
- properties
- .getProperty("noop.source.topics.appc-lcm-write.events."
- + "org.onap.policy.appclcm.AppcLcmMessageWrapper.filter"));
+ properties.getProperty("noop.source.topics.appc-lcm-write.events."
+ + "org.onap.policy.appclcm.AppcLcmMessageWrapper.filter"));
+
assertEquals("org.onap.policy.appclcm.util.Serialization,gson",
- properties.getProperty("noop.source.topics.appc-lcm-write.events.custom.gson"));
+ properties.getProperty("noop.source.topics.appc-lcm-write.events.custom.gson"));
assertEquals("org.onap.policy.sdnr.PciResponseWrapper",
- properties.getProperty("noop.source.topics.sdnr-cl-rsp.events"));
+ properties.getProperty("noop.source.topics.sdnr-cl-rsp.events"));
+
assertEquals("[?($.type == 'response')]",
- properties
- .getProperty("noop.source.topics.sdnr-cl-rsp.events."
- + "org.onap.policy.sdnr.PciResponseWrapper.filter"));
+ properties.getProperty("noop.source.topics.sdnr-cl-rsp.events."
+ + "org.onap.policy.sdnr.PciResponseWrapper.filter"));
+
assertEquals("org.onap.policy.sdnr.util.Serialization,gson",
- properties.getProperty("noop.source.topics.sdnr-cl-rsp.events.custom.gson"));
+ properties.getProperty("noop.source.topics.sdnr-cl-rsp.events.custom.gson"));
+ }
+
+ private static void assertSinkTopics(Properties properties) {
+ assertEquals("appc-cl,appc-lcm-read,policy-cl-mgt,dcae_cl_rsp",
+ properties.getProperty("noop.sink.topics"));
+
+ assertEquals("org.onap.policy.appc.Request",
+ properties.getProperty("noop.sink.topics.appc-cl.events"));
- assertEquals("org.onap.policy.appc.Request", properties.getProperty("noop.sink.topics.appc-cl.events"));
assertEquals("org.onap.policy.appc.util.Serialization,gsonPretty",
- properties.getProperty("noop.sink.topics.appc-cl.events.custom.gson"));
+ properties.getProperty("noop.sink.topics.appc-cl.events.custom.gson"));
assertEquals("org.onap.policy.appclcm.AppcLcmMessageWrapper",
- properties.getProperty("noop.sink.topics.appc-lcm-read.events"));
+ properties.getProperty("noop.sink.topics.appc-lcm-read.events"));
+
assertEquals("org.onap.policy.appclcm.util.Serialization,gson",
- properties.getProperty("noop.sink.topics.appc-lcm-read.events.custom.gson"));
+ properties.getProperty("noop.sink.topics.appc-lcm-read.events.custom.gson"));
assertEquals("org.onap.policy.controlloop.VirtualControlLoopNotification",
- properties.getProperty("noop.sink.topics.policy-cl-mgt.events"));
- assertEquals("org.onap.policy.controlloop.util.Serialization,gsonPretty",
- properties.getProperty("noop.sink.topics.policy-cl-mgt.events.custom.gson"));
+ properties.getProperty("noop.sink.topics.policy-cl-mgt.events"));
- assertEquals("org.onap.policy.controlloop.ControlLoopResponse",
- properties.getProperty("noop.sink.topics.dcae_cl_rsp.events"));
assertEquals("org.onap.policy.controlloop.util.Serialization,gsonPretty",
- properties.getProperty("noop.sink.topics.dcae_cl_rsp.events.custom.gson"));
+ properties.getProperty("noop.sink.topics.policy-cl-mgt.events.custom.gson"));
- assertEquals("test", properties.getProperty("notes"));
- assertEquals("auto", properties.getProperty("persistence.type"));
+ assertEquals("org.onap.policy.controlloop.ControlLoopResponse",
+ properties.getProperty("noop.sink.topics.dcae_cl_rsp.events"));
- assertTrue(controller.undeploy(nativeControllerPolicy));
+ assertEquals("org.onap.policy.controlloop.util.Serialization,gsonPretty",
+ properties.getProperty("noop.sink.topics.dcae_cl_rsp.events.custom.gson"));
}
}
/* start up configuration */
- resourceLists("policyTypes", 2);
- get("policyTypes/onap.policies.native.drools.Artifact/1.0.0", Status.OK.getStatusCode());
- get("policyTypes/onap.policies.native.drools.Controller/1.0.0", Status.OK.getStatusCode());
- get("policyTypes/onap.policies.controlloop.operational.common.Drools/1.0.0", Status.NOT_FOUND.getStatusCode());
-
- resourceLists("policies", 0);
- get("policies/example.controller/1.0.0", Status.NOT_FOUND.getStatusCode());
- get("policies/example.artifact/1.0.0", Status.NOT_FOUND.getStatusCode());
+ assertStartup();
/* start lifecycle */
ToscaPolicy nativeControllerPolicy =
getPolicyFromFile(EXAMPLE_NATIVE_CONTROLLER_POLICY_JSON, EXAMPLE_NATIVE_CONTROLLER_POLICY_NAME);
- booleanPost("policies", toString(nativeControllerPolicy), Status.OK.getStatusCode(), Boolean.TRUE);
-
- assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").isAlive());
- assertFalse(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isBrained());
- assertFalse(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isAlive());
-
- get("policyTypes/onap.policies.controlloop.operational.common.Drools/1.0.0", Status.NOT_FOUND.getStatusCode());
-
- resourceLists("policies", 1);
- get("policies/example.controller/1.0.0", Status.OK.getStatusCode());
+ assertAddNativeControllerPolicy(nativeControllerPolicy);
/* add native artifact policy */
ToscaPolicy nativeArtifactPolicy =
getPolicyFromFile(EXAMPLE_NATIVE_ARTIFACT_POLICY_JSON, EXAMPLE_NATIVE_ARTIFACT_POLICY_NAME);
- booleanPost("policies", toString(nativeArtifactPolicy), Status.OK.getStatusCode(), Boolean.TRUE);
-
- assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").isAlive());
- assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isBrained());
- assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isAlive());
+ assertAddNativeArtifactPolicy(nativeArtifactPolicy);
/* verify new supported operational policy types */
- resourceLists("policyTypes", 5);
- get("policyTypes/onap.policies.native.drools.Artifact/1.0.0", Status.OK.getStatusCode());
- get("policyTypes/onap.policies.native.drools.Controller/1.0.0", Status.OK.getStatusCode());
- get("policyTypes/onap.policies.controlloop.operational.common.Drools/1.0.0", Status.OK.getStatusCode());
- get("policyTypes/onap.policies.type1.type2/1.0.0", Status.OK.getStatusCode());
- get("policyTypes/onap.policies.typeA/1.0.0", Status.OK.getStatusCode());
+ verifySupportedOperationalPolicyTypes(5, Status.OK);
/* verify controller and artifact policies */
/* individual deploy/undeploy operations */
+ assertDeployUndeploy(opPolicy);
+
+ /* delete native artifact policy */
+
+ verifyDeleteNativeArtifactPolicy(opPolicy);
+
+ /* delete native controller policy */
+
+ verifyDeleteNativeControllerPolicy(opPolicy);
+
+ metrics();
+ }
+
+ private void verifyDeleteNativeControllerPolicy(ToscaPolicy opPolicy) throws CoderException {
+ booleanDelete("policies/example.controller/1.0.0", Status.OK.getStatusCode());
+
+ verifySupportedOperationalPolicyTypes(2, Status.NOT_FOUND);
+
+ resourceLists("policies", 0);
+ get("policies/" + opPolicy.getName() + "/" + opPolicy.getVersion(), Status.NOT_FOUND.getStatusCode());
+ get("policies/example.artifact/1.0.0", Status.NOT_FOUND.getStatusCode());
+ get("policies/example.controller/1.0.0", Status.NOT_FOUND.getStatusCode());
+
+ assertThatIllegalArgumentException().isThrownBy(() -> PolicyControllerConstants.getFactory().get("lifecycle"));
+ opPolicy.getMetadata().remove("policy-id");
+ assertThat(listPost(toString(opPolicy), Status.NOT_ACCEPTABLE.getStatusCode())).isEmpty();
+ }
+
+ private void verifyDeleteNativeArtifactPolicy(ToscaPolicy opPolicy) {
+ booleanDelete("policies/example.artifact/1.0.0", Status.OK.getStatusCode());
+ assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").isAlive());
+ assertFalse(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isBrained());
+
+ verifySupportedOperationalPolicyTypes(2, Status.NOT_FOUND);
+
+ resourceLists("policies", 1);
+ get("policies/" + opPolicy.getName() + "/" + opPolicy.getVersion(), Status.NOT_FOUND.getStatusCode());
+ get("policies/example.artifact/1.0.0", Status.NOT_FOUND.getStatusCode());
+ get("policies/example.controller/1.0.0", Status.OK.getStatusCode());
+ }
+
+ private void assertDeployUndeploy(ToscaPolicy opPolicy) throws CoderException {
resourceLists("policies/operations", 3);
booleanPost("policies/operations/deployment", toString(opPolicy), Status.OK.getStatusCode(), Boolean.TRUE);
get("policies/" + opPolicy.getName() + "/" + opPolicy.getVersion(), Status.NOT_FOUND.getStatusCode());
get("policies/example.controller/1.0.0", Status.OK.getStatusCode());
get("policies/example.artifact/1.0.0", Status.OK.getStatusCode());
+ }
- /* delete native artifact policy */
+ private void verifySupportedOperationalPolicyTypes(int size, Status status) {
+ resourceLists("policyTypes", size);
+ get("policyTypes/onap.policies.native.drools.Artifact/1.0.0", Status.OK.getStatusCode());
+ get("policyTypes/onap.policies.native.drools.Controller/1.0.0", Status.OK.getStatusCode());
+ get("policyTypes/onap.policies.controlloop.operational.common.Drools/1.0.0", status.getStatusCode());
+ get("policyTypes/onap.policies.type1.type2/1.0.0", status.getStatusCode());
+ get("policyTypes/onap.policies.typeA/1.0.0", status.getStatusCode());
+ }
+
+ private void assertAddNativeArtifactPolicy(ToscaPolicy nativeArtifactPolicy) throws CoderException {
+ booleanPost("policies", toString(nativeArtifactPolicy), Status.OK.getStatusCode(), Boolean.TRUE);
+
+ assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").isAlive());
+ assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isBrained());
+ assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isAlive());
+ }
+
+ private void assertAddNativeControllerPolicy(ToscaPolicy nativeControllerPolicy) throws CoderException {
+ booleanPost("policies", toString(nativeControllerPolicy), Status.OK.getStatusCode(), Boolean.TRUE);
- booleanDelete("policies/example.artifact/1.0.0", Status.OK.getStatusCode());
assertTrue(PolicyControllerConstants.getFactory().get("lifecycle").isAlive());
assertFalse(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isBrained());
+ assertFalse(PolicyControllerConstants.getFactory().get("lifecycle").getDrools().isAlive());
- resourceLists("policyTypes", 2);
- get("policyTypes/onap.policies.native.drools.Artifact/1.0.0", Status.OK.getStatusCode());
- get("policyTypes/onap.policies.native.drools.Controller/1.0.0", Status.OK.getStatusCode());
get("policyTypes/onap.policies.controlloop.operational.common.Drools/1.0.0", Status.NOT_FOUND.getStatusCode());
- get("policyTypes/onap.policies.type1.type2/1.0.0", Status.NOT_FOUND.getStatusCode());
- get("policyTypes/onap.policies.typeA/1.0.0", Status.NOT_FOUND.getStatusCode());
resourceLists("policies", 1);
- get("policies/" + opPolicy.getName() + "/" + opPolicy.getVersion(), Status.NOT_FOUND.getStatusCode());
- get("policies/example.artifact/1.0.0", Status.NOT_FOUND.getStatusCode());
get("policies/example.controller/1.0.0", Status.OK.getStatusCode());
+ }
- /* delete native controller policy */
-
- booleanDelete("policies/example.controller/1.0.0", Status.OK.getStatusCode());
-
+ private void assertStartup() {
resourceLists("policyTypes", 2);
get("policyTypes/onap.policies.native.drools.Artifact/1.0.0", Status.OK.getStatusCode());
get("policyTypes/onap.policies.native.drools.Controller/1.0.0", Status.OK.getStatusCode());
get("policyTypes/onap.policies.controlloop.operational.common.Drools/1.0.0", Status.NOT_FOUND.getStatusCode());
- get("policyTypes/onap.policies.type1.type2/1.0.0", Status.NOT_FOUND.getStatusCode());
- get("policyTypes/onap.policies.typeA/1.0.0", Status.NOT_FOUND.getStatusCode());
resourceLists("policies", 0);
- get("policies/" + opPolicy.getName() + "/" + opPolicy.getVersion(), Status.NOT_FOUND.getStatusCode());
- get("policies/example.artifact/1.0.0", Status.NOT_FOUND.getStatusCode());
get("policies/example.controller/1.0.0", Status.NOT_FOUND.getStatusCode());
-
- assertThatIllegalArgumentException().isThrownBy(() -> PolicyControllerConstants.getFactory().get("lifecycle"));
- opPolicy.getMetadata().remove("policy-id");
- assertThat(listPost(toString(opPolicy), Status.NOT_ACCEPTABLE.getStatusCode())).isEmpty();
-
- metrics();
+ get("policies/example.artifact/1.0.0", Status.NOT_FOUND.getStatusCode());
}
private void testNotNativePolicy(ToscaPolicy toscaPolicy) throws CoderException {
public class PdpJmx implements PdpJmxMBean {
@Getter
- private static PdpJmx instance = new PdpJmx();
+ static PdpJmx instance = new PdpJmx();
private final AtomicLong updates = new AtomicLong();
private final AtomicLong actions = new AtomicLong();
package org.onap.policy.drools.server.restful;
+import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
+import static jakarta.ws.rs.core.Response.Status.CREATED;
+import static jakarta.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR;
+import static jakarta.ws.rs.core.Response.Status.NOT_ACCEPTABLE;
+import static jakarta.ws.rs.core.Response.Status.NOT_FOUND;
+import static jakarta.ws.rs.core.Response.Status.NOT_MODIFIED;
+import static jakarta.ws.rs.core.Response.Status.OK;
+import static jakarta.ws.rs.core.Response.Status.PARTIAL_CONTENT;
+import static org.onap.policy.drools.properties.DroolsPropertyConstants.PROPERTY_CONTROLLER_NAME;
+
import ch.qos.logback.classic.LoggerContext;
import com.google.re2j.Pattern;
import jakarta.ws.rs.Consumes;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
+import org.apache.commons.lang3.StringUtils;
import org.onap.policy.common.endpoints.event.comm.Topic;
import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure;
import org.onap.policy.common.endpoints.event.comm.TopicEndpointManager;
import org.onap.policy.common.endpoints.http.server.YamlMessageBodyHandler;
import org.onap.policy.common.utils.logging.LoggerUtils;
import org.onap.policy.drools.controller.DroolsController;
-import org.onap.policy.drools.properties.DroolsPropertyConstants;
-import org.onap.policy.drools.protocol.coders.EventProtocolCoder.CoderFilters;
import org.onap.policy.drools.protocol.coders.EventProtocolCoderConstants;
import org.onap.policy.drools.protocol.coders.JsonProtocolFilter;
-import org.onap.policy.drools.protocol.coders.ProtocolCoderToolset;
import org.onap.policy.drools.protocol.configuration.ControllerConfiguration;
import org.onap.policy.drools.protocol.configuration.PdpdConfiguration;
import org.onap.policy.drools.system.PolicyController;
import org.onap.policy.drools.system.PolicyControllerConstants;
+import org.onap.policy.drools.system.PolicyDroolsPdpRuntimeException;
import org.onap.policy.drools.system.PolicyEngineConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Consumes({MediaType.APPLICATION_JSON, YamlMessageBodyHandler.APPLICATION_YAML})
@ToString
public class RestManager implements SwaggerApi, DefaultApi, FeaturesApi, InputsApi,
- PropertiesApi, EnvironmentApi, SwitchesApi, ControllersApi,
- TopicsApi, ToolsApi {
+ PropertiesApi, EnvironmentApi, SwitchesApi, ControllersApi,
+ TopicsApi, ToolsApi {
private static final String OFFER_FAILED = "{}: cannot offer to topic {} because of {}";
private static final String CANNOT_PERFORM_OPERATION = "cannot perform operation";
- private static final String NO_FILTERS = " no filters";
- private static final String NOT_FOUND = " not found: ";
+ private static final String NO_FILTERS = " has no filters";
private static final String NOT_FOUND_MSG = " not found";
private static final String DOES_NOT_EXIST_MSG = " does not exist";
private static final String NOT_ACCEPTABLE_MSG = " not acceptable";
@GET
@Path("engine/swagger")
public Response swagger() {
-
- try (InputStream inputStream = getClass().getResourceAsStream(SWAGGER);
- BufferedReader reader = new BufferedReader(
- new InputStreamReader(Objects.requireNonNull(inputStream)))) {
- String contents = reader.lines()
- .collect(Collectors.joining(System.lineSeparator()));
- return Response.status(Response.Status.OK)
- .entity(contents)
- .build();
- } catch (IOException e) {
- logger.error("Cannot read swagger.json {} because of {}", e.getMessage(), e);
- return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
- .build();
+ try {
+ String contents = getSwaggerContents();
+ return Response.status(OK).entity(contents).build();
+ } catch (Exception e) {
+ logger.error("Cannot read swagger.json {} because of {}", e.getMessage(), e.toString());
+ return Response.status(INTERNAL_SERVER_ERROR).build();
}
}
@GET
@Path("engine")
public Response engine() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager()).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager()).build();
}
/**
} catch (final IllegalStateException e) {
logger.error("{}: cannot shutdown {} because of {}", this, PolicyEngineConstants.getManager(),
e.getMessage(), e);
- return Response.status(Response.Status.BAD_REQUEST).entity(PolicyEngineConstants.getManager()).build();
+ return Response.status(BAD_REQUEST).entity(PolicyEngineConstants.getManager()).build();
}
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager()).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager()).build();
}
/**
@GET
@Path("engine/features")
public Response engineFeatures() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager().getFeatures()).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getFeatures()).build();
}
@Override
@GET
@Path("engine/features/inventory")
public Response engineFeaturesInventory() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager().getFeatureProviders())
- .build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getFeatureProviders()).build();
}
/**
@Path("engine/features/{featureName}")
public Response engineFeature(@PathParam("featureName") String featureName) {
try {
- return Response.status(Response.Status.OK)
- .entity(PolicyEngineConstants.getManager().getFeatureProvider(featureName)).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getFeatureProvider(featureName))
+ .build();
} catch (final IllegalArgumentException iae) {
logger.debug("feature unavailable: {}", featureName, iae);
- return Response.status(Response.Status.NOT_FOUND).entity(new Error(iae.getMessage())).build();
+ return errorResponse(NOT_FOUND, iae.getMessage());
}
}
@GET
@Path("engine/inputs")
public Response engineInputs() {
- return Response.status(Response.Status.OK).entity(INPUTS).build();
+ return Response.status(OK).entity(INPUTS).build();
}
/**
@POST
@Path("engine/inputs/configuration")
public Response engineUpdate(PdpdConfiguration configuration) {
- final PolicyController controller = null;
- boolean success;
try {
- success = PolicyEngineConstants.getManager().configure(configuration);
+ if (PolicyEngineConstants.getManager().configure(configuration)) {
+ return Response.status(OK).entity(true).build();
+ }
} catch (final Exception e) {
- success = false;
logger.info("{}: cannot configure {} because of {}", this, PolicyEngineConstants.getManager(),
e.getMessage(), e);
}
- if (!success) {
- return Response.status(Response.Status.NOT_ACCEPTABLE).entity(new Error(CANNOT_PERFORM_OPERATION))
- .build();
- } else {
- return Response.status(Response.Status.OK).entity(controller).build();
- }
+ return errorResponse(NOT_ACCEPTABLE, CANNOT_PERFORM_OPERATION);
}
/**
@GET
@Path("engine/properties")
public Response engineProperties() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager().getProperties()).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getProperties()).build();
}
/**
@GET
@Path("engine/environment")
public Response engineEnvironment() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager().getEnvironment()).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getEnvironment()).build();
}
/**
@Path("engine/environment/{envProperty}")
@Consumes(MediaType.TEXT_PLAIN)
public Response engineEnvironmentProperty(@PathParam("envProperty") String envProperty) {
- return Response.status(Response.Status.OK)
- .entity(PolicyEngineConstants.getManager().getEnvironmentProperty(envProperty)).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getEnvironmentProperty(envProperty))
+ .build();
}
/**
@Produces(MediaType.TEXT_PLAIN)
public Response engineEnvironmentAdd(@PathParam("envProperty") String envProperty, String envValue) {
final String previousValue = PolicyEngineConstants.getManager().setEnvironmentProperty(envProperty, envValue);
- return Response.status(Response.Status.OK).entity(previousValue).build();
+ return Response.status(OK).entity(previousValue).build();
}
/**
@GET
@Path("engine/switches")
public Response engineSwitches() {
- return Response.status(Response.Status.OK).entity(SWITCHES).build();
+ return Response.status(OK).entity(SWITCHES).build();
}
/**
@PUT
@Path("engine/switches/activation")
public Response engineActivation() {
- var success = true;
try {
PolicyEngineConstants.getManager().activate();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager()).build();
} catch (final Exception e) {
- success = false;
logger.info("{}: cannot activate {} because of {}", this, PolicyEngineConstants.getManager(),
e.getMessage(), e);
}
- if (!success) {
- return Response.status(Response.Status.NOT_ACCEPTABLE).entity(new Error(CANNOT_PERFORM_OPERATION))
- .build();
- } else {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager()).build();
- }
+ return errorResponse(NOT_ACCEPTABLE, CANNOT_PERFORM_OPERATION);
}
/**
@DELETE
@Path("engine/switches/activation")
public Response engineDeactivation() {
- var success = true;
try {
PolicyEngineConstants.getManager().deactivate();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager()).build();
} catch (final Exception e) {
- success = false;
logger.info("{}: cannot deactivate {} because of {}", this, PolicyEngineConstants.getManager(),
e.getMessage(), e);
}
- if (!success) {
- return Response.status(Response.Status.NOT_ACCEPTABLE).entity(new Error(CANNOT_PERFORM_OPERATION))
- .build();
- } else {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager()).build();
- }
+ return errorResponse(NOT_ACCEPTABLE, CANNOT_PERFORM_OPERATION);
}
/**
@PUT
@Path("engine/switches/lock")
public Response engineLock() {
- final boolean success = PolicyEngineConstants.getManager().lock();
- if (success) {
- return Response.status(Status.OK).entity(PolicyEngineConstants.getManager()).build();
+ if (PolicyEngineConstants.getManager().lock()) {
+ return Response.status(OK).entity(PolicyEngineConstants.getManager()).build();
} else {
- return Response.status(Status.NOT_ACCEPTABLE).entity(new Error(CANNOT_PERFORM_OPERATION)).build();
+ return errorResponse(NOT_ACCEPTABLE, CANNOT_PERFORM_OPERATION);
}
}
@DELETE
@Path("engine/switches/lock")
public Response engineUnlock() {
- final boolean success = PolicyEngineConstants.getManager().unlock();
- if (success) {
- return Response.status(Status.OK).entity(PolicyEngineConstants.getManager()).build();
+ if (PolicyEngineConstants.getManager().unlock()) {
+ return Response.status(OK).entity(PolicyEngineConstants.getManager()).build();
} else {
- return Response.status(Status.NOT_ACCEPTABLE).entity(new Error(CANNOT_PERFORM_OPERATION)).build();
+ return errorResponse(NOT_ACCEPTABLE, CANNOT_PERFORM_OPERATION);
}
}
@GET
@Path("engine/controllers")
public Response controllers() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager().getPolicyControllerIds())
- .build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getPolicyControllerIds()).build();
}
/**
@GET
@Path("engine/controllers/inventory")
public Response controllerInventory() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager().getPolicyControllers())
- .build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getPolicyControllers()).build();
}
/**
@Path("engine/controllers")
public Response controllerAdd(Properties config) {
if (config == null) {
- return Response.status(Response.Status.BAD_REQUEST).entity(new Error("A configuration must be provided"))
- .build();
+ return errorResponse(BAD_REQUEST, "A configuration must be provided");
}
- final String controllerName = config.getProperty(DroolsPropertyConstants.PROPERTY_CONTROLLER_NAME);
+ var controllerName = config.getProperty(PROPERTY_CONTROLLER_NAME);
if (controllerName == null || controllerName.isEmpty()) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(
- "Configuration must have an entry for " + DroolsPropertyConstants.PROPERTY_CONTROLLER_NAME))
- .build();
+ return errorResponse(BAD_REQUEST, "Configuration must have an entry for "
+ + PROPERTY_CONTROLLER_NAME);
}
PolicyController controller;
try {
controller = PolicyControllerConstants.getFactory().get(controllerName);
if (controller != null) {
- return Response.status(Response.Status.NOT_MODIFIED).entity(controller).build();
+ return Response.status(NOT_MODIFIED).entity(controller).build();
}
} catch (final IllegalArgumentException e) {
logger.trace("OK ", e);
// This is OK
} catch (final IllegalStateException e) {
logger.info(FETCH_POLICY_FAILED, this, e.getMessage(), e);
- return Response.status(Response.Status.NOT_ACCEPTABLE).entity(new Error(controllerName + NOT_FOUND_MSG))
- .build();
+ return errorResponse(NOT_ACCEPTABLE, controllerName + NOT_FOUND_MSG);
}
try {
controller = PolicyEngineConstants.getManager().createPolicyController(
- config.getProperty(DroolsPropertyConstants.PROPERTY_CONTROLLER_NAME), config);
+ config.getProperty(PROPERTY_CONTROLLER_NAME), config);
} catch (IllegalArgumentException | IllegalStateException e) {
logger.warn("{}: cannot create policy-controller because of {}", this, e.getMessage(), e);
- return Response.status(Response.Status.BAD_REQUEST).entity(new Error(e.getMessage())).build();
+ return errorResponse(BAD_REQUEST, e.getMessage());
}
try {
- final boolean success = controller.start();
- if (!success) {
+ if (!controller.start()) {
logger.info("{}: cannot start {}", this, controller);
- return Response.status(Response.Status.PARTIAL_CONTENT)
- .entity(new Error(controllerName + " can't be started")).build();
+ return errorResponse(PARTIAL_CONTENT, controllerName + " can't be started");
}
} catch (final IllegalStateException e) {
logger.info("{}: cannot start {} because of {}", this, controller, e.getMessage(), e);
- return Response.status(Response.Status.PARTIAL_CONTENT).entity(controller).build();
+ return Response.status(PARTIAL_CONTENT).entity(controller).build();
}
- return Response.status(Response.Status.CREATED).entity(controller).build();
+ return Response.status(CREATED).entity(controller).build();
}
/**
@GET
@Path("engine/controllers/features")
public Response controllerFeatures() {
- return Response.status(Response.Status.OK).entity(PolicyEngineConstants.getManager().getFeatures()).build();
+ return Response.status(OK).entity(PolicyEngineConstants.getManager().getFeatures()).build();
}
/**
@GET
@Path("engine/controllers/features/inventory")
public Response controllerFeaturesInventory() {
- return Response.status(Response.Status.OK)
- .entity(PolicyControllerConstants.getFactory().getFeatureProviders()).build();
+ return Response.status(OK).entity(PolicyControllerConstants.getFactory().getFeatureProviders()).build();
}
/**
@Path("engine/controllers/features/{featureName}")
public Response controllerFeature(@PathParam("featureName") String featureName) {
try {
- return Response.status(Response.Status.OK)
- .entity(PolicyControllerConstants.getFactory().getFeatureProvider(featureName))
+ return Response.status(OK).entity(PolicyControllerConstants.getFactory().getFeatureProvider(featureName))
.build();
} catch (final IllegalArgumentException iae) {
logger.debug("{}: cannot feature {} because of {}", this, featureName, iae.getMessage(), iae);
- return Response.status(Response.Status.NOT_FOUND).entity(new Error(iae.getMessage())).build();
+ return errorResponse(NOT_FOUND, iae.getMessage());
}
}
public Response controller(@PathParam("controller") String controllerName) {
return catchArgStateGenericEx(
- () -> Response.status(Response.Status.OK)
- .entity(PolicyControllerConstants.getFactory().get(controllerName)).build(),
+ () -> Response.status(OK).entity(PolicyControllerConstants.getFactory().get(controllerName)).build(),
e -> {
logger.debug(FETCH_POLICY_BY_NAME_FAILED, this, controllerName, e.getMessage(), e);
return (controllerName);
try {
controller = PolicyControllerConstants.getFactory().get(controllerName);
if (controller == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + DOES_NOT_EXIST_MSG)).build();
+ return errorResponse(BAD_REQUEST, controllerName + DOES_NOT_EXIST_MSG);
}
} catch (final IllegalArgumentException e) {
logger.debug(FETCH_POLICY_BY_NAME_FAILED, this, controllerName, e.getMessage(), e);
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + NOT_FOUND + e.getMessage())).build();
+ return errorResponse(BAD_REQUEST, controllerName + NOT_FOUND_MSG + ": " + e.getMessage());
} catch (final IllegalStateException e) {
logger.debug(FETCH_POLICY_BY_NAME_FAILED, this, controllerName, e.getMessage(), e);
- return Response.status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error(controllerName + NOT_ACCEPTABLE_MSG)).build();
+ return errorResponse(NOT_ACCEPTABLE, controllerName + NOT_ACCEPTABLE_MSG);
}
try {
PolicyEngineConstants.getManager().removePolicyController(controllerName);
} catch (IllegalArgumentException | IllegalStateException e) {
- logger.debug("{}: cannot remove policy-controller {} because of {}", this, controllerName, e.getMessage(),
- e);
- return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(new Error(e.getMessage())).build();
+ logger.debug("{}: cannot remove policy-controller {} because of {}",
+ this, controllerName, e.getMessage(), e);
+ return errorResponse(INTERNAL_SERVER_ERROR, e.getMessage());
}
- return Response.status(Response.Status.OK).entity(controller).build();
+ return Response.status(OK).entity(controller).build();
}
/**
public Response controllerProperties(@PathParam("controller") String controllerName) {
return catchArgStateGenericEx(() -> {
- final PolicyController controller = PolicyControllerConstants.getFactory().get(controllerName);
- return Response.status(Response.Status.OK).entity(controller.getProperties()).build();
+ var controller = PolicyControllerConstants.getFactory().get(controllerName);
+ return Response.status(OK).entity(controller.getProperties()).build();
}, e -> {
logger.debug(FETCH_POLICY_BY_NAME_FAILED, this, controllerName, e.getMessage(), e);
@GET
@Path("engine/controllers/{controller}/inputs")
public Response controllerInputs(@PathParam("controller") String controllerName) {
- return Response.status(Response.Status.OK).entity(INPUTS).build();
+ return Response.status(OK).entity(INPUTS).build();
}
/**
@POST
@Path("engine/controllers/{controller}/inputs/configuration")
public Response controllerUpdate(ControllerConfiguration controllerConfiguration,
- @PathParam("controller") String controllerName) {
+ @PathParam("controller") String controllerName) {
- if (controllerName == null || controllerName.isEmpty() || controllerConfiguration == null
+ if (StringUtils.isBlank(controllerName) || controllerConfiguration == null
|| !controllerName.equals(controllerConfiguration.getName())) {
- return Response.status(Response.Status.BAD_REQUEST)
+ return Response.status(BAD_REQUEST)
.entity("A valid or matching controller names must be provided").build();
}
return catchArgStateGenericEx(() -> {
- var controller =
- PolicyEngineConstants.getManager().updatePolicyController(controllerConfiguration);
+ var controller = PolicyEngineConstants.getManager().updatePolicyController(controllerConfiguration);
if (controller == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + DOES_NOT_EXIST_MSG)).build();
+ return errorResponse(BAD_REQUEST, controllerName + DOES_NOT_EXIST_MSG);
}
- return Response.status(Response.Status.OK).entity(controller).build();
+ return Response.status(OK).entity(controller).build();
}, e -> {
- logger.info("{}: cannot update policy-controller {} because of {}", this, controllerName,
- e.getMessage(), e);
+ logger.info("{}: cannot update policy-controller {} because of {}",
+ this, controllerName, e.getMessage(), e);
return (controllerName);
});
}
@GET
@Path("engine/controllers/{controller}/switches")
public Response controllerSwitches(@PathParam("controller") String controllerName) {
- return Response.status(Response.Status.OK).entity(SWITCHES).build();
+ return Response.status(OK).entity(SWITCHES).build();
}
/**
@Path("engine/controllers/{controller}/switches/lock")
public Response controllerLock(@PathParam("controller") String controllerName) {
var policyController = PolicyControllerConstants.getFactory().get(controllerName);
- final boolean success = policyController.lock();
- if (success) {
- return Response.status(Status.OK).entity(policyController).build();
+ if (policyController.lock()) {
+ return Response.status(OK).entity(policyController).build();
} else {
- return Response.status(Status.NOT_ACCEPTABLE)
- .entity(new Error("Controller " + controllerName + " cannot be locked")).build();
+ return errorResponse(NOT_ACCEPTABLE, "Controller " + controllerName + " cannot be locked");
}
}
var policyController = PolicyControllerConstants.getFactory().get(controllerName);
final boolean success = policyController.unlock();
if (success) {
- return Response.status(Status.OK).entity(policyController).build();
+ return Response.status(OK).entity(policyController).build();
} else {
- return Response.status(Status.NOT_ACCEPTABLE)
- .entity(new Error("Controller " + controllerName + " cannot be unlocked")).build();
+ return errorResponse(NOT_ACCEPTABLE, "Controller " + controllerName + " cannot be unlocked");
}
}
return catchArgStateGenericEx(() -> {
var drools = this.getDroolsController(controllerName);
- return Response.status(Response.Status.OK).entity(drools).build();
+ return Response.status(OK).entity(drools).build();
}, e -> {
logger.debug(FETCH_DROOLS_FAILED, this, controllerName, e.getMessage(), e);
@GET
@Path("engine/controllers/{controller}/drools/facts/{session}")
public Response droolsFacts1(@PathParam("controller") String controllerName,
- @PathParam("session") String sessionName) {
+ @PathParam("session") String sessionName) {
return catchArgStateGenericEx(() -> {
var drools = this.getDroolsController(controllerName);
}, e -> {
logger.debug(FETCH_DROOLS_BY_PARAMS_FAILED,
- this, controllerName, sessionName, queryName, queriedEntity, e.getMessage(), e);
- return (controllerName + ":" + sessionName + ":" + queryName + queriedEntity);
+ this, controllerName, sessionName, queryName, queriedEntity, e.getMessage(), e.toString());
+ return (controllerName + ":" + sessionName + ":" + queryName + ":" + queriedEntity);
});
}
@POST
@Path("engine/controllers/tools/coders/decoders/filters/rule")
public Response rules(String expression) {
- return Response.status(Status.OK).entity(new JsonProtocolFilter(expression)).build();
+ return Response.status(OK).entity(new JsonProtocolFilter(expression)).build();
}
/**
return EventProtocolCoderConstants.getManager().getDecoders(drools.getGroupId(), drools.getArtifactId());
}, e -> {
- logger.debug(FETCH_DECODERS_BY_POLICY_FAILED, this, controllerName,
- e.getMessage(), e);
+ logger.debug(FETCH_DECODERS_BY_POLICY_FAILED, this, controllerName, e.getMessage(), e);
return (controllerName);
});
}
return catchArgStateGenericEx(() -> {
var drools = this.getDroolsController(controllerName);
- final ProtocolCoderToolset decoder = EventProtocolCoderConstants.getManager()
+ var decoder = EventProtocolCoderConstants.getManager()
.getDecoders(drools.getGroupId(), drools.getArtifactId(), topic);
if (decoder == null) {
- return Response.status(Response.Status.BAD_REQUEST).entity(new Error(topic + DOES_NOT_EXIST_MSG))
- .build();
+ return errorResponse(BAD_REQUEST, topic + DOES_NOT_EXIST_MSG);
} else {
return decoder.getCoders();
}
return catchArgStateGenericEx(() -> {
var drools = this.getDroolsController(controllerName);
- final ProtocolCoderToolset decoder = EventProtocolCoderConstants.getManager()
+ var decoder = EventProtocolCoderConstants.getManager()
.getDecoders(drools.getGroupId(), drools.getArtifactId(), topic);
- final CoderFilters filters = decoder.getCoder(factClass);
+ var filters = decoder.getCoder(factClass);
if (filters == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(topic + ":" + factClass + DOES_NOT_EXIST_MSG)).build();
+ return errorResponse(BAD_REQUEST, topic + ":" + factClass + DOES_NOT_EXIST_MSG);
} else {
return filters;
}
}, e -> {
- logger.debug(FETCH_DECODER_BY_TYPE_FAILED, this,
- controllerName, topic, factClass, e.getMessage(), e);
+ logger.debug(FETCH_DECODER_BY_TYPE_FAILED, this, controllerName, topic, factClass, e.getMessage(), e);
return (controllerName + ":" + topic + ":" + factClass);
});
}
@PUT
@Path("engine/controllers/{controller}/decoders/{topic}/filters/{factType}")
public Response decoderFilter(
- JsonProtocolFilter configFilters,
- @PathParam("controller") String controllerName,
- @PathParam("topic") String topic,
- @PathParam("factType") String factClass) {
+ JsonProtocolFilter configFilters,
+ @PathParam("controller") String controllerName,
+ @PathParam("topic") String topic,
+ @PathParam("factType") String factClass) {
if (configFilters == null) {
- return Response.status(Response.Status.BAD_REQUEST).entity(new Error("Configuration Filters not provided"))
- .build();
+ return errorResponse(BAD_REQUEST, "Configuration Filters not provided");
}
return catchArgStateGenericEx(() -> {
var drools = this.getDroolsController(controllerName);
- final ProtocolCoderToolset decoder = EventProtocolCoderConstants.getManager()
+ var decoder = EventProtocolCoderConstants.getManager()
.getDecoders(drools.getGroupId(), drools.getArtifactId(), topic);
- final CoderFilters filters = decoder.getCoder(factClass);
+ var filters = decoder.getCoder(factClass);
if (filters == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(topic + ":" + factClass + DOES_NOT_EXIST_MSG)).build();
+ return errorResponse(BAD_REQUEST, topic + ":" + factClass + DOES_NOT_EXIST_MSG);
}
filters.setFilter(configFilters);
return filters;
@PathParam("factType") String factClass) {
return catchArgStateGenericEx(() -> {
- var drools = this.getDroolsController(controllerName);
- final ProtocolCoderToolset decoder = EventProtocolCoderConstants.getManager()
- .getDecoders(drools.getGroupId(), drools.getArtifactId(), topic);
-
- final CoderFilters filters = decoder.getCoder(factClass);
- if (filters == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + ":" + topic + ":" + factClass + DOES_NOT_EXIST_MSG)).build();
- }
+ var result = this.checkControllerDecoderAndFilter(controllerName, topic, factClass);
- final JsonProtocolFilter filter = filters.getFilter();
- if (filter == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + ":" + topic + ":" + factClass + NO_FILTERS)).build();
+ if (result instanceof Response) {
+ return result;
+ } else {
+ var filter = (JsonProtocolFilter) result;
+ return filter.getRule();
}
-
- return filter.getRule();
-
}, e -> {
logger.debug(FETCH_DECODER_BY_TYPE_FAILED, this,
controllerName, topic, factClass, e.getMessage(), e);
@PathParam("factType") String factClass) {
return catchArgStateGenericEx(() -> {
- var drools = this.getDroolsController(controllerName);
- final ProtocolCoderToolset decoder = EventProtocolCoderConstants.getManager()
- .getDecoders(drools.getGroupId(), drools.getArtifactId(), topic);
+ var result = this.checkControllerDecoderAndFilter(controllerName, topic, factClass);
- final CoderFilters filters = decoder.getCoder(factClass);
- if (filters == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + ":" + topic + ":" + factClass + DOES_NOT_EXIST_MSG)).build();
- }
+ if (result instanceof Response) {
+ return result;
+ } else {
+ var filter = (JsonProtocolFilter) result;
- final JsonProtocolFilter filter = filters.getFilter();
- if (filter == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + ":" + topic + ":" + factClass + NO_FILTERS)).build();
+ filter.setRule(null);
+ return filter.getRule();
}
- filter.setRule(null);
- return filter.getRule();
-
}, e -> {
logger.debug(FETCH_DECODER_BY_TYPE_FAILED,
this, controllerName, topic, factClass, e.getMessage(), e);
return catchArgStateGenericEx(() -> decoderFilterRule2(controllerName, topic, factClass, rule), e -> {
logger.debug("{}: cannot access decoder filter rules for policy-controller {} "
- + "topic {} type {} because of {}",
+ + "topic {} type {} because of {}",
this, controllerName, topic, factClass, e.getMessage(), e);
return (controllerName + ":" + topic + ":" + factClass);
});
}
- private Object decoderFilterRule2(String controllerName, String topic, String factClass, String rule) {
- var drools = this.getDroolsController(controllerName);
- final ProtocolCoderToolset decoder = EventProtocolCoderConstants.getManager()
- .getDecoders(drools.getGroupId(), drools.getArtifactId(), topic);
-
- final CoderFilters filters = decoder.getCoder(factClass);
- if (filters == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + ":" + topic + ":" + factClass + DOES_NOT_EXIST_MSG)).build();
- }
-
- final JsonProtocolFilter filter = filters.getFilter();
- if (filter == null) {
- return Response.status(Response.Status.BAD_REQUEST)
- .entity(new Error(controllerName + ":" + topic + ":" + factClass + NO_FILTERS)).build();
- }
-
- if (rule == null || rule.isEmpty()) {
- return Response.status(Response.Status.BAD_REQUEST).entity(new Error(controllerName + ":" + topic + ":"
- + factClass + " no filter rule provided")).build();
- }
-
- filter.setRule(rule);
- return filter.getRule();
- }
-
/**
* POST.
*
@PathParam("topic") String topic,
String json) {
- if (!checkValidNameInput(controllerName)) {
- return Response.status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error("controllerName contains whitespaces " + NOT_ACCEPTABLE_MSG)).build();
+ if (StringUtils.isBlank(controllerName)) {
+ return errorResponse(NOT_ACCEPTABLE, "controllerName contains whitespaces " + NOT_ACCEPTABLE_MSG);
}
- if (!checkValidNameInput(topic)) {
- return Response.status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error("topic contains whitespaces " + NOT_ACCEPTABLE_MSG)).build();
+ if (StringUtils.isBlank(topic)) {
+ return errorResponse(NOT_ACCEPTABLE, "topic contains whitespaces " + NOT_ACCEPTABLE_MSG);
}
- PolicyController policyController;
- try {
- policyController = PolicyControllerConstants.getFactory().get(controllerName);
- } catch (final IllegalArgumentException e) {
- logger.debug(FETCH_DECODERS_BY_TOPIC_FAILED, this,
- controllerName, topic, e.getMessage(), e);
- return Response.status(Response.Status.NOT_FOUND)
- .entity(new Error(controllerName + ":" + topic + ":" + NOT_FOUND_MSG)).build();
- } catch (final IllegalStateException e) {
- logger.debug(FETCH_DECODERS_BY_TOPIC_FAILED, this,
- controllerName, topic, e.getMessage(), e);
- return Response.status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error(controllerName + ":" + topic + ":" + NOT_ACCEPTABLE_MSG)).build();
- }
+ var drools = getDroolsController(controllerName);
var result = new CodingResult();
result.setDecoding(false);
Object event;
try {
- event = EventProtocolCoderConstants.getManager().decode(policyController.getDrools().getGroupId(),
- policyController.getDrools().getArtifactId(), topic, json);
+ event = EventProtocolCoderConstants.getManager()
+ .decode(drools.getGroupId(), drools.getArtifactId(), topic, json);
result.setDecoding(true);
} catch (final Exception e) {
- logger.debug(FETCH_POLICY_BY_TOPIC_FAILED, this, controllerName, topic,
- e.getMessage(), e);
- return Response.status(Response.Status.BAD_REQUEST).entity(new Error(e.getMessage())).build();
+ logger.debug(FETCH_POLICY_BY_TOPIC_FAILED, this, controllerName, topic, e.getMessage(), e);
+ return errorResponse(BAD_REQUEST, e.getMessage());
}
try {
result.setJsonEncoding(EventProtocolCoderConstants.getManager().encode(topic, event));
result.setEncoding(true);
} catch (final Exception e) {
- // continue so to propagate decoding results ..
- logger.debug("{}: cannot encode for policy-controller {} topic {} because of {}", this, controllerName,
- topic, e.getMessage(), e);
+ // continue so to propagate decoding results ...
+ logger.debug("{}: cannot encode for policy-controller {} topic {} because of {}",
+ this, controllerName, topic, e.getMessage(), e);
}
- return Response.status(Response.Status.OK).entity(result).build();
+ return Response.status(OK).entity(result).build();
}
/**
public Response encoderFilters(@PathParam("controller") String controllerName) {
return catchArgStateGenericEx(() -> {
- final PolicyController controller = PolicyControllerConstants.getFactory().get(controllerName);
- var drools = controller.getDrools();
+ var drools = getDroolsController(controllerName);
return EventProtocolCoderConstants.getManager()
.getEncoderFilters(drools.getGroupId(), drools.getArtifactId());
}, e -> {
- logger.debug(FETCH_ENCODER_BY_FILTER_FAILED, this, controllerName,
- e.getMessage(), e);
+ logger.debug(FETCH_ENCODER_BY_FILTER_FAILED, this, controllerName, e.getMessage(), e);
return (controllerName);
});
}
@GET
@Path("engine/topics")
public Response topics() {
- return Response.status(Response.Status.OK).entity(TopicEndpointManager.getManager()).build();
+ return Response.status(OK).entity(TopicEndpointManager.getManager()).build();
}
@Override
@GET
@Path("engine/topics/switches")
public Response topicSwitches() {
- return Response.status(Response.Status.OK).entity(SWITCHES).build();
+ return Response.status(OK).entity(SWITCHES).build();
}
/**
@PUT
@Path("engine/topics/switches/lock")
public Response topicsLock() {
- final boolean success = TopicEndpointManager.getManager().lock();
- if (success) {
- return Response.status(Status.OK).entity(TopicEndpointManager.getManager()).build();
+ if (TopicEndpointManager.getManager().lock()) {
+ return Response.status(OK).entity(TopicEndpointManager.getManager()).build();
} else {
- return Response.status(Status.NOT_ACCEPTABLE).entity(new Error(CANNOT_PERFORM_OPERATION)).build();
+ return errorResponse(NOT_ACCEPTABLE, CANNOT_PERFORM_OPERATION);
}
}
@DELETE
@Path("engine/topics/switches/lock")
public Response topicsUnlock() {
- final boolean success = TopicEndpointManager.getManager().unlock();
- if (success) {
- return Response.status(Status.OK).entity(TopicEndpointManager.getManager()).build();
+ if (TopicEndpointManager.getManager().unlock()) {
+ return Response.status(OK).entity(TopicEndpointManager.getManager()).build();
} else {
- return Response.status(Status.NOT_ACCEPTABLE).entity(new Error(CANNOT_PERFORM_OPERATION)).build();
+ return errorResponse(NOT_ACCEPTABLE, CANNOT_PERFORM_OPERATION);
}
}
@GET
@Path("engine/topics/sources")
public Response sources() {
- return Response.status(Response.Status.OK).entity(TopicEndpointManager.getManager().getTopicSources()).build();
+ return Response.status(OK).entity(TopicEndpointManager.getManager().getTopicSources()).build();
}
/**
@GET
@Path("engine/topics/sinks")
public Response sinks() {
- return Response.status(Response.Status.OK).entity(TopicEndpointManager.getManager().getTopicSinks()).build();
+ return Response.status(OK).entity(TopicEndpointManager.getManager().getTopicSinks()).build();
}
/**
@Path("engine/topics/sources/{comm: kafka|noop}")
public Response commSources(
@PathParam("comm") String comm) {
- if (!checkValidNameInput(comm)) {
- return Response
- .status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error("source communication mechanism contains whitespaces " + NOT_ACCEPTABLE_MSG))
- .build();
+ if (StringUtils.isBlank(comm)) {
+ return errorResponse(NOT_ACCEPTABLE,
+ "source communication mechanism contains whitespaces " + NOT_ACCEPTABLE_MSG);
}
List<TopicSource> sources = new ArrayList<>();
- var status = Status.OK;
+ var status = OK;
switch (CommInfrastructure.valueOf(comm.toUpperCase())) {
case NOOP:
sources.addAll(TopicEndpointManager.getManager().getNoopTopicSources());
sources.addAll(TopicEndpointManager.getManager().getKafkaTopicSources());
break;
default:
- status = Status.BAD_REQUEST;
- logger.debug("Invalid communication mechanism");
+ status = BAD_REQUEST;
+ logger.debug("{} is invalid communication mechanism", comm);
break;
}
return Response.status(status).entity(sources).build();
@Path("engine/topics/sinks/{comm: kafka|noop}")
public Response commSinks(
@PathParam("comm") String comm) {
- if (!checkValidNameInput(comm)) {
- return Response
- .status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error("sink communication mechanism contains whitespaces " + NOT_ACCEPTABLE_MSG))
- .build();
+ if (StringUtils.isBlank(comm)) {
+ return errorResponse(NOT_ACCEPTABLE,
+ "sink communication mechanism contains whitespaces " + NOT_ACCEPTABLE_MSG);
}
List<TopicSink> sinks = new ArrayList<>();
- var status = Status.OK;
+ var status = OK;
switch (CommInfrastructure.valueOf(comm.toUpperCase())) {
case NOOP:
sinks.addAll(TopicEndpointManager.getManager().getNoopTopicSinks());
sinks.addAll(TopicEndpointManager.getManager().getKafkaTopicSinks());
break;
default:
- status = Status.BAD_REQUEST;
- logger.debug("Invalid communication mechanism");
+ status = BAD_REQUEST;
+ logger.debug("{} is invalid communication mechanism", comm);
break;
}
return Response.status(status).entity(sinks).build();
public Response sourceTopic(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- return Response
- .status(Response.Status.OK)
- .entity(TopicEndpointManager.getManager()
- .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic))
- .build();
+ var source = TopicEndpointManager.getManager()
+ .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ return Response.status(OK).entity(source).build();
}
/**
public Response sinkTopic(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- return Response
- .status(Response.Status.OK)
- .entity(TopicEndpointManager.getManager()
- .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic))
- .build();
+ var sink = TopicEndpointManager.getManager()
+ .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ return Response.status(OK).entity(sink).build();
}
/**
public Response sourceEvents(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- return Response.status(Status.OK)
- .entity(Arrays.asList(TopicEndpointManager.getManager()
- .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic)
- .getRecentEvents()))
- .build();
+ var source = TopicEndpointManager.getManager()
+ .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ return Response.status(OK).entity(Arrays.asList(source.getRecentEvents())).build();
}
/**
public Response sinkEvents(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- return Response.status(Status.OK)
- .entity(Arrays.asList(TopicEndpointManager.getManager()
- .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic)
- .getRecentEvents()))
- .build();
+ var sink = TopicEndpointManager.getManager()
+ .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ return Response.status(OK).entity(Arrays.asList(sink.getRecentEvents())).build();
}
/**
public Response commSourceTopicSwitches(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- return Response.status(Response.Status.OK).entity(SWITCHES).build();
+ return Response.status(OK).entity(SWITCHES).build();
}
/**
public Response commSinkTopicSwitches(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- return Response.status(Response.Status.OK).entity(SWITCHES).build();
+ return Response.status(OK).entity(SWITCHES).build();
}
/**
public Response commSourceTopicLock(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var source =
- TopicEndpointManager.getManager().getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var source = TopicEndpointManager.getManager()
+ .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, source.lock(), source);
}
/**
- * DELETEs the lock on a topic.
+ * Deletes the lock on a topic.
*/
@Override
@DELETE
public Response commSourceTopicUnlock(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var source =
- TopicEndpointManager.getManager().getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var source = TopicEndpointManager.getManager()
+ .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, source.unlock(), source);
}
public Response commSourceTopicActivation(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var source =
- TopicEndpointManager.getManager().getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var source = TopicEndpointManager.getManager()
+ .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, source.start(), source);
}
public Response commSourceTopicDeactivation(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var source =
- TopicEndpointManager.getManager().getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var source = TopicEndpointManager.getManager()
+ .getTopicSource(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, source.stop(), source);
}
public Response commSinkTopicLock(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var sink =
- TopicEndpointManager.getManager().getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var sink = TopicEndpointManager.getManager()
+ .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, sink.lock(), sink);
}
/**
- * DELETEs the lock on a topic.
+ * Deletes the lock on a topic.
*/
@Override
@DELETE
public Response commSinkTopicUnlock(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var sink =
- TopicEndpointManager.getManager().getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var sink = TopicEndpointManager.getManager()
+ .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, sink.unlock(), sink);
}
public Response commSinkTopicActivation(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var sink =
- TopicEndpointManager.getManager().getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var sink = TopicEndpointManager.getManager()
+ .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, sink.start(), sink);
}
public Response commSinkTopicDeactivation(
@PathParam("comm") String comm,
@PathParam("topic") String topic) {
- var sink =
- TopicEndpointManager.getManager().getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
+ var sink = TopicEndpointManager.getManager()
+ .getTopicSink(CommInfrastructure.valueOf(comm.toUpperCase()), topic);
return getResponse(topic, sink.stop(), sink);
}
- private Response getResponse(String topicName, boolean success, Topic topic) {
- if (success) {
- return Response.status(Status.OK).entity(topic).build();
- } else {
- return Response.status(Status.NOT_ACCEPTABLE).entity(makeTopicOperError(topicName)).build();
- }
- }
-
- private Error makeTopicOperError(String topic) {
- return new Error("cannot perform operation on " + topic);
- }
-
/**
* Offers an event to a topic in a communication infrastructure.
*
if (source.offer(json)) {
return Arrays.asList(source.getRecentEvents());
} else {
- return Response.status(Status.NOT_ACCEPTABLE).entity(new Error("Failure to inject event over " + topic))
- .build();
+ return errorResponse(NOT_ACCEPTABLE, "Failure to inject event over " + topic);
}
}, e -> {
@Path("engine/tools/uuid")
@Produces(MediaType.TEXT_PLAIN)
public Response uuid() {
- return Response.status(Status.OK).entity(UUID.randomUUID().toString()).build();
+ return Response.status(OK).entity(UUID.randomUUID().toString()).build();
}
/**
@Path("engine/tools/loggers")
public Response loggers() {
final List<String> names = new ArrayList<>();
- if (!(LoggerFactory.getILoggerFactory() instanceof LoggerContext)) {
- logger.warn("The SLF4J logger factory is not configured for logback");
- return Response.status(Status.INTERNAL_SERVER_ERROR).entity(names).build();
+ if (checkLoggerFactoryInstance()) {
+ return Response.status(INTERNAL_SERVER_ERROR).entity(names).build();
}
- final LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
+ var context = (LoggerContext) LoggerFactory.getILoggerFactory();
for (final Logger lgr : context.getLoggerList()) {
names.add(lgr.getName());
}
- return Response.status(Status.OK).entity(names).build();
+ return Response.status(OK).entity(names).build();
}
/**
@Path("engine/tools/loggers/{logger}")
@Produces(MediaType.TEXT_PLAIN)
public Response loggerName1(@PathParam("logger") String loggerName) {
- if (!(LoggerFactory.getILoggerFactory() instanceof LoggerContext)) {
- logger.warn("The SLF4J logger factory is not configured for logback");
- return Response.status(Status.INTERNAL_SERVER_ERROR).build();
+ if (checkLoggerFactoryInstance()) {
+ return Response.status(INTERNAL_SERVER_ERROR).build();
}
- final LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
+ var context = (LoggerContext) LoggerFactory.getILoggerFactory();
var lgr = context.getLogger(loggerName);
if (lgr == null) {
- return Response.status(Status.NOT_FOUND).build();
+ return Response.status(NOT_FOUND).build();
}
final String loggerLevel = (lgr.getLevel() != null) ? lgr.getLevel().toString() : "";
- return Response.status(Status.OK).entity(loggerLevel).build();
+ return Response.status(OK).entity(loggerLevel).build();
}
/**
String newLevel;
try {
- if (!checkValidNameInput(loggerName)) {
- return Response.status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error("logger name: " + NOT_ACCEPTABLE_MSG))
- .build();
+ if (StringUtils.isBlank(loggerName)) {
+ return errorResponse(NOT_ACCEPTABLE, "logger name:" + NOT_ACCEPTABLE_MSG);
}
if (!Pattern.matches("^[a-zA-Z]{3,5}$", loggerLevel)) {
- return Response.status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error("logger level: " + NOT_ACCEPTABLE_MSG))
- .build();
+ return errorResponse(NOT_ACCEPTABLE, "logger level:" + NOT_ACCEPTABLE_MSG);
}
newLevel = LoggerUtils.setLevel(loggerName, loggerLevel);
- } catch (final IllegalArgumentException e) {
- logger.warn("{}: invalid operation for logger {} and level {}", this, loggerName, loggerLevel, e);
- return Response.status(Status.NOT_FOUND).build();
- } catch (final IllegalStateException e) {
+ } catch (Exception e) {
logger.warn("{}: logging framework unavailable for {} / {}", this, loggerName, loggerLevel, e);
- return Response.status(Status.INTERNAL_SERVER_ERROR).build();
+ return Response.status(INTERNAL_SERVER_ERROR).build();
}
- return Response.status(Status.OK).entity(newLevel
+ return Response.status(OK).entity(newLevel).build();
+ }
- ).build();
+ protected String getSwaggerContents() {
+ try (InputStream inputStream = getClass().getResourceAsStream(SWAGGER);
+ BufferedReader reader = new BufferedReader(new InputStreamReader(Objects.requireNonNull(inputStream)))) {
+ return reader.lines().collect(Collectors.joining(System.lineSeparator()));
+ } catch (IOException e) {
+ throw new PolicyDroolsPdpRuntimeException("Cannot read swagger.json", e);
+ }
}
/**
* @throws IllegalArgumentException if an invalid controller name has been passed in
*/
protected DroolsController getDroolsController(String controllerName) {
- final PolicyController controller = PolicyControllerConstants.getFactory().get(controllerName);
+ var controller = PolicyControllerConstants.getFactory().get(controllerName);
if (controller == null) {
throw new IllegalArgumentException(controllerName + DOES_NOT_EXIST_MSG);
}
* illegal state, and generic runtime exceptions.
*
* @param responder function that will generate a response. If it returns a "Response"
- * object, then that object is returned as-is. Otherwise, this method will
- * return an "OK" Response, using the function's return value as the "entity"
- * @param errorMsg function that will generate an error message prefix to be included
- * in responses generated as a result of catching an exception
+ * object, then that object is returned as-is. Otherwise, this method will
+ * return an "OK" Response, using the function's return value as the "entity"
+ * @param errorMsg function that will generate an error message prefix to be included
+ * in responses generated as a result of catching an exception
* @return a response
*/
- private Response catchArgStateGenericEx(Supplier<Object> responder, Function<Exception, String> errorMsg) {
+ protected Response catchArgStateGenericEx(Supplier<Object> responder, Function<Exception, String> errorMsg) {
try {
Object result = responder.get();
if (result instanceof Response) {
return (Response) result;
}
- return Response.status(Response.Status.OK).entity(result).build();
+ return Response.status(OK).entity(result).build();
} catch (final IllegalArgumentException e) {
- return Response.status(Response.Status.NOT_FOUND).entity(new Error(errorMsg.apply(e) + NOT_FOUND_MSG))
- .build();
+ return errorResponse(NOT_FOUND, errorMsg.apply(e) + NOT_FOUND_MSG);
} catch (final IllegalStateException e) {
- return Response.status(Response.Status.NOT_ACCEPTABLE)
- .entity(new Error(errorMsg.apply(e) + NOT_ACCEPTABLE_MSG)).build();
+ return errorResponse(NOT_ACCEPTABLE, errorMsg.apply(e) + NOT_ACCEPTABLE_MSG);
} catch (final RuntimeException e) {
errorMsg.apply(e);
- return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(new Error(e.getMessage())).build();
+ return errorResponse(INTERNAL_SERVER_ERROR, e.getMessage());
+ }
+ }
+
+ protected Object decoderFilterRule2(String controllerName, String topic, String factClass, String rule) {
+ if (StringUtils.isBlank(rule)) {
+ var error = controllerName + ":" + topic + ":" + factClass + " no filter rule provided";
+ return errorResponse(BAD_REQUEST, error);
+ }
+
+ var result = this.checkControllerDecoderAndFilter(controllerName, topic, factClass);
+
+ if (result instanceof Response) {
+ return result;
+ } else {
+ var filter = (JsonProtocolFilter) result;
+ filter.setRule(rule);
+ return filter.getRule();
+ }
+ }
+
+ protected Object checkControllerDecoderAndFilter(String controllerName, String topic, String factClass) {
+ var drools = this.getDroolsController(controllerName);
+ var decoder = EventProtocolCoderConstants.getManager()
+ .getDecoders(drools.getGroupId(), drools.getArtifactId(), topic);
+
+ var filters = decoder.getCoder(factClass);
+ if (filters == null) {
+ var error = controllerName + ":" + topic + ":" + factClass + DOES_NOT_EXIST_MSG;
+ return errorResponse(BAD_REQUEST, error);
+ }
+
+ var filter = filters.getFilter();
+ if (filter == null) {
+ var error = controllerName + ":" + topic + ":" + factClass + NO_FILTERS;
+ return errorResponse(BAD_REQUEST, error);
+ }
+ return filter;
+ }
+
+ private Response getResponse(String topicName, boolean success, Topic topic) {
+ if (success) {
+ return Response.status(OK).entity(topic).build();
+ } else {
+ return errorResponse(NOT_ACCEPTABLE, "cannot perform operation on " + topicName);
+ }
+ }
+
+ private static boolean checkLoggerFactoryInstance() {
+ if (!(LoggerFactory.getILoggerFactory() instanceof LoggerContext)) {
+ logger.warn("The SLF4J logger factory is not configured for logback");
+ return true;
}
+ return false;
}
- public static boolean checkValidNameInput(String test) {
- return Pattern.matches("\\S+", test);
+ private Response errorResponse(Status status, String errorMessage) {
+ var error = new Error(errorMessage);
+ return Response.status(status).entity(error).build();
}
/*
* Policy Engine Manager Implementation.
*/
@ToString(onlyExplicitlyIncluded = true)
-class PolicyEngineManager implements PolicyEngine {
+public class PolicyEngineManager implements PolicyEngine {
/**
* String literals.
*/
public synchronized void shutdown() {
/*
- * shutdown activity even when underlying subcomponents (features, controllers, topics, etc
- * ..) are stuck
+ * shutdown activity even when underlying subcomponents (features, controllers, topics, etc) are stuck
*/
var exitThread = makeShutdownThread();
logger.warn("{}: cannot shutdown lock manager because of {}", this, e.getMessage(), e);
}
- executorService.shutdownNow();
+ getExecutorService().shutdownNow();
// Stop the JMX listener
policyController.unlock();
policyController.start();
} catch (final Exception e) {
- logger.error("{}: cannot activate of policy-controller {} because of {}", this, policyController,
- e.getMessage(), e);
+ logger.error("{}: cannot activate of policy-controller {} because of {}",
+ this, policyController, e.getMessage(), e);
} catch (final LinkageError e) {
- logger.error("{}: cannot activate (rules compilation) of policy-controller {} because of {}", this,
- policyController, e.getMessage(), e);
+ logger.error("{}: cannot activate (rules compilation) of policy-controller {} because of {}",
+ this, policyController, e.getMessage(), e);
}
}
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2024 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.server.restful;
+
+import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
+import static jakarta.ws.rs.core.Response.Status.CREATED;
+import static jakarta.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR;
+import static jakarta.ws.rs.core.Response.Status.NOT_ACCEPTABLE;
+import static jakarta.ws.rs.core.Response.Status.NOT_FOUND;
+import static jakarta.ws.rs.core.Response.Status.NOT_MODIFIED;
+import static jakarta.ws.rs.core.Response.Status.OK;
+import static jakarta.ws.rs.core.Response.Status.PARTIAL_CONTENT;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+import static org.onap.policy.drools.properties.DroolsPropertyConstants.PROPERTY_CONTROLLER_NAME;
+
+import jakarta.ws.rs.core.Response;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.MockitoAnnotations;
+import org.onap.policy.common.endpoints.event.comm.TopicEndpoint;
+import org.onap.policy.common.endpoints.event.comm.TopicEndpointManager;
+import org.onap.policy.drools.controller.DroolsController;
+import org.onap.policy.drools.controller.internal.NullDroolsController;
+import org.onap.policy.drools.features.PolicyControllerFeatureApi;
+import org.onap.policy.drools.features.PolicyEngineFeatureApi;
+import org.onap.policy.drools.protocol.coders.EventProtocolCoder;
+import org.onap.policy.drools.protocol.coders.EventProtocolCoderConstants;
+import org.onap.policy.drools.protocol.coders.JsonProtocolFilter;
+import org.onap.policy.drools.protocol.coders.ProtocolCoderToolset;
+import org.onap.policy.drools.protocol.configuration.ControllerConfiguration;
+import org.onap.policy.drools.protocol.configuration.PdpdConfiguration;
+import org.onap.policy.drools.system.PolicyController;
+import org.onap.policy.drools.system.PolicyControllerConstants;
+import org.onap.policy.drools.system.PolicyControllerFactory;
+import org.onap.policy.drools.system.PolicyDroolsPdpRuntimeException;
+import org.onap.policy.drools.system.PolicyEngineConstants;
+import org.onap.policy.drools.system.PolicyEngineManager;
+import org.onap.policy.drools.system.internal.AggregatedPolicyController;
+import org.onap.policy.drools.system.internal.LockManager;
+import org.slf4j.ILoggerFactory;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.util.ReflectionTestUtils;
+
+class RestManagerTest {
+
+ private static final String CONTROLLER_NAME = "myControllerName";
+ private static final String FACT_CLASS = "factClass";
+ private static final String TOPIC = "topic";
+ private static final String GROUP_ID = "group";
+ private static final String ARTIFACT_ID = "artifact";
+
+ @Mock
+ RestManager restApi;
+
+ @Mock
+ PolicyControllerFactory controllerFactory;
+
+ @Mock
+ EventProtocolCoder coderManager;
+
+ @Mock
+ TopicEndpoint topicManager;
+
+ @Mock
+ PolicyEngineManager policyEngineManager;
+
+ AutoCloseable closeable;
+
+ @BeforeEach
+ void setUp() {
+ closeable = MockitoAnnotations.openMocks(this);
+
+ try (MockedStatic<TopicEndpointManager> constants = mockStatic(TopicEndpointManager.class)) {
+ setupTopicEndpointManager(constants);
+ restApi = mock(RestManager.class);
+ }
+ }
+
+ @AfterEach
+ void tearDown() throws Exception {
+ closeable.close();
+ }
+
+ @Test
+ void swagger() {
+ when(restApi.swagger()).thenCallRealMethod();
+ var response = restApi.swagger();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ when(restApi.getSwaggerContents()).thenThrow(new PolicyDroolsPdpRuntimeException("exception"));
+
+ response = restApi.swagger();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void engineShutdown() {
+ try (MockedStatic<PolicyEngineConstants> constants = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+
+ doNothing().doThrow(new IllegalStateException("should throw exception"))
+ .when(policyEngineManager).shutdown();
+
+ setupPolicyEngineManager(constants);
+
+ restApi = mock(RestManager.class);
+
+ when(restApi.engineShutdown()).thenCallRealMethod();
+
+ var response = restApi.engineShutdown();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ response = restApi.engineShutdown();
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void engineFeature() {
+ try (MockedStatic<PolicyEngineConstants> constants = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+ when(policyEngineManager.getFeatureProvider("testFeature"))
+ .thenReturn(mock(PolicyEngineFeatureApi.class))
+ .thenThrow(new IllegalArgumentException("should throw exception"));
+
+ setupPolicyEngineManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.engineFeature("testFeature")).thenCallRealMethod();
+
+ var response = restApi.engineFeature("testFeature");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ response = restApi.engineFeature("testFeature");
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ assertEquals("should throw exception", ((RestManager.Error) response.getEntity()).getError());
+ }
+ }
+
+ @Test
+ void engineUpdate() {
+ try (MockedStatic<PolicyEngineConstants> constants = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+ var pdpdConfig = mock(PdpdConfiguration.class);
+ when(policyEngineManager.configure(pdpdConfig))
+ .thenReturn(true)
+ .thenReturn(false)
+ .thenThrow(new IllegalArgumentException("should throw exception"));
+
+ setupPolicyEngineManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.engineUpdate(pdpdConfig)).thenCallRealMethod();
+
+ var response = restApi.engineUpdate(pdpdConfig);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ response = restApi.engineUpdate(pdpdConfig);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+
+ // call again, should be going on exception
+ response = restApi.engineUpdate(pdpdConfig);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void engineActivation() {
+ try (MockedStatic<PolicyEngineConstants> constants = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+ doNothing().doThrow(new IllegalStateException("should throw exception"))
+ .when(policyEngineManager).activate();
+
+ setupPolicyEngineManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.engineActivation()).thenCallRealMethod();
+
+ var response = restApi.engineActivation();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ response = restApi.engineActivation();
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void engineDeactivation() {
+ try (MockedStatic<PolicyEngineConstants> constants = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+ doNothing().doThrow(new IllegalStateException("should throw exception"))
+ .when(policyEngineManager).deactivate();
+
+ setupPolicyEngineManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.engineDeactivation()).thenCallRealMethod();
+
+ var response = restApi.engineDeactivation();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ response = restApi.engineDeactivation();
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void controllerAdd() {
+ try (MockedStatic<PolicyControllerConstants> controllerConst = mockStatic(PolicyControllerConstants.class)) {
+ try (MockedStatic<PolicyEngineConstants> engConst = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+
+ when(controllerFactory.get(CONTROLLER_NAME))
+ .thenReturn(mock(AggregatedPolicyController.class))
+ .thenThrow(new IllegalStateException("exception to test fetch policy failed"))
+ .thenReturn(null);
+
+ setupPolicyControllerFactory(controllerConst);
+
+ var invalidProps = new Properties();
+ invalidProps.setProperty(PROPERTY_CONTROLLER_NAME, "");
+
+ var properties = new Properties();
+ properties.setProperty(PROPERTY_CONTROLLER_NAME, CONTROLLER_NAME);
+
+ var policyController = mock(PolicyController.class);
+ when(policyController.start())
+ .thenReturn(false)
+ .thenThrow(new IllegalStateException("exception when starting controller"))
+ .thenReturn(true);
+
+ when(policyEngineManager.createPolicyController(CONTROLLER_NAME, properties))
+ .thenThrow(new IllegalArgumentException("exception creating controller"))
+ .thenReturn(policyController);
+
+ setupPolicyEngineManager(engConst);
+
+ restApi = mock(RestManager.class);
+
+ when(restApi.controllerAdd(null)).thenCallRealMethod();
+ when(restApi.controllerAdd(invalidProps)).thenCallRealMethod();
+ when(restApi.controllerAdd(properties)).thenCallRealMethod();
+
+ // first test - null properties config
+ var response = restApi.controllerAdd(null);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // second test - controllerName is empty
+ response = restApi.controllerAdd(invalidProps);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("Configuration must have an entry for controller.name");
+
+ // third test - controller exists
+ response = restApi.controllerAdd(properties);
+ assertEquals(NOT_MODIFIED.getStatusCode(), response.getStatus());
+
+ // fourth test - IllegalStateException
+ response = restApi.controllerAdd(properties);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("myControllerName not found");
+
+ // fifth test - cannot create controller
+ response = restApi.controllerAdd(properties);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("exception creating controller");
+
+ // sixth test - cannot start controller
+ response = restApi.controllerAdd(properties);
+ assertEquals(PARTIAL_CONTENT.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("myControllerName can't be started");
+
+ // seventh test - cannot start controller but Exception
+ response = restApi.controllerAdd(properties);
+ assertEquals(PARTIAL_CONTENT.getStatusCode(), response.getStatus());
+ assertEquals(policyController, response.getEntity());
+
+ // final test - works
+ response = restApi.controllerAdd(properties);
+ assertEquals(CREATED.getStatusCode(), response.getStatus());
+ assertEquals(policyController, response.getEntity());
+ }
+ }
+ }
+
+ @Test
+ void controllerFeature() {
+ try (MockedStatic<PolicyControllerConstants> controllerConst = mockStatic(PolicyControllerConstants.class)) {
+ var myFeature = mock(PolicyControllerFeatureApi.class);
+ when(controllerFactory.getFeatureProvider("myFeature"))
+ .thenReturn(myFeature)
+ .thenThrow(new IllegalArgumentException("exception when getting feature"));
+ setupPolicyControllerFactory(controllerConst);
+
+ restApi = mock(RestManager.class);
+ when(restApi.controllerFeature("myFeature")).thenCallRealMethod();
+
+ var response = restApi.controllerFeature("myFeature");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertEquals(myFeature, response.getEntity());
+
+ response = restApi.controllerFeature("myFeature");
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("exception when getting feature");
+ }
+ }
+
+ @Test
+ void controllerDelete() {
+ try (MockedStatic<PolicyControllerConstants> controllerConst = mockStatic(PolicyControllerConstants.class)) {
+ try (MockedStatic<PolicyEngineConstants> engConst = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+
+ var policyController = mock(PolicyController.class);
+
+ when(controllerFactory.get("nullController"))
+ .thenReturn(null);
+ when(controllerFactory.get("exceptionController"))
+ .thenThrow(new IllegalArgumentException("can't find the controller"))
+ .thenThrow(new IllegalStateException("exception to test fetch policy controller"));
+ when(controllerFactory.get("myValidController")).thenReturn(policyController);
+
+ setupPolicyControllerFactory(controllerConst);
+
+ doThrow(new IllegalStateException("exception when deleting controller"))
+ .doNothing()
+ .when(policyEngineManager).removePolicyController("myValidController");
+
+ setupPolicyEngineManager(engConst);
+
+ restApi = mock(RestManager.class);
+ when(restApi.controllerDelete(anyString())).thenCallRealMethod();
+
+ // first test - controller returns null
+ var response = restApi.controllerDelete("nullController");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("nullController does not exist");
+
+ // second test - getController throws IllegalArgExc
+ response = restApi.controllerDelete("exceptionController");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("can't find the controller");
+
+ // third test - getController throws IllegalStateExc
+ response = restApi.controllerDelete("exceptionController");
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("exceptionController not acceptable");
+
+ // fourth test - gets controller but exception when removing
+ response = restApi.controllerDelete("myValidController");
+ assertEquals(INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("exception when deleting controller");
+
+ // fifth test - gets controller and removes it from engine manager
+ response = restApi.controllerDelete("myValidController");
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertEquals(policyController, response.getEntity());
+ }
+ }
+ }
+
+ @Test
+ void controllerUpdate() {
+ try (MockedStatic<PolicyEngineConstants> constants = mockStatic(PolicyEngineConstants.class)) {
+ setupLockManagerAndExecutorService();
+
+ var config = mock(ControllerConfiguration.class);
+ when(config.getName()).thenReturn(CONTROLLER_NAME);
+
+ var policyController = mock(PolicyController.class);
+ when(policyEngineManager.updatePolicyController(config))
+ .thenThrow(new IllegalArgumentException("exception to test fetch policy controller"))
+ .thenReturn(null)
+ .thenReturn(policyController);
+
+ setupPolicyEngineManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.controllerUpdate(config, "invalidName")).thenCallRealMethod();
+ when(restApi.controllerUpdate(config, CONTROLLER_NAME)).thenCallRealMethod();
+ when(restApi.controllerUpdate(null, CONTROLLER_NAME)).thenCallRealMethod();
+ when(restApi.controllerUpdate(config, "")).thenCallRealMethod();
+
+ // invalid controller name
+ var response = restApi.controllerUpdate(config, "");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // controller configuration is null
+ response = restApi.controllerUpdate(null, CONTROLLER_NAME);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // controller name doesn't match name in configuration
+ response = restApi.controllerUpdate(config, "invalidName");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // IllegalArgException
+ response = restApi.controllerUpdate(config, CONTROLLER_NAME);
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+
+ // return null controller
+ response = restApi.controllerUpdate(config, CONTROLLER_NAME);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // return valid controller
+ response = restApi.controllerUpdate(config, CONTROLLER_NAME);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertEquals(policyController, response.getEntity());
+ }
+ }
+
+ @Test
+ void controllerLock() {
+ try (MockedStatic<PolicyControllerConstants> controllerConst = mockStatic(PolicyControllerConstants.class)) {
+ var policyController = mock(PolicyController.class);
+ when(policyController.lock())
+ .thenReturn(true)
+ .thenReturn(false);
+
+ when(controllerFactory.get(CONTROLLER_NAME)).thenReturn(policyController);
+
+ setupPolicyControllerFactory(controllerConst);
+
+ restApi = mock(RestManager.class);
+
+ when(restApi.controllerLock(CONTROLLER_NAME)).thenCallRealMethod();
+
+ // controller lock
+ var response = restApi.controllerLock(CONTROLLER_NAME);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertEquals(policyController, response.getEntity());
+
+ // controller fails to lock
+ response = restApi.controllerLock(CONTROLLER_NAME);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("myControllerName cannot be locked");
+ }
+ }
+
+ @Test
+ void controllerUnlock() {
+ try (MockedStatic<PolicyControllerConstants> controllerConst = mockStatic(PolicyControllerConstants.class)) {
+ var policyController = mock(PolicyController.class);
+ when(policyController.unlock())
+ .thenReturn(true)
+ .thenReturn(false);
+
+ when(controllerFactory.get(CONTROLLER_NAME)).thenReturn(policyController);
+
+ setupPolicyControllerFactory(controllerConst);
+
+ restApi = mock(RestManager.class);
+
+ when(restApi.controllerUnlock(CONTROLLER_NAME)).thenCallRealMethod();
+
+ // controller unlock
+ var response = restApi.controllerUnlock(CONTROLLER_NAME);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertEquals(policyController, response.getEntity());
+
+ // controller fails to unlock
+ response = restApi.controllerUnlock(CONTROLLER_NAME);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("myControllerName cannot be unlocked");
+ }
+ }
+
+ @Test
+ void droolsFactsDelete() {
+ try (MockedStatic<PolicyControllerConstants> controllerConst = mockStatic(PolicyControllerConstants.class)) {
+ var sessionName = "sessionName";
+ var queryName = "queryName";
+ var queriedEntity = "queriedEntity";
+
+ var drools = mock(NullDroolsController.class);
+ when(drools.factQuery(sessionName, queryName, queriedEntity, true))
+ .thenReturn(new ArrayList<>(List.of()));
+ var policyController = mock(PolicyController.class);
+ when(policyController.getDrools()).thenReturn(drools);
+
+ var controllerWithoutDrools = mock(PolicyController.class);
+ when(controllerWithoutDrools.getDrools()).thenReturn(null);
+
+ when(controllerFactory.get("nullController")).thenReturn(null);
+ when(controllerFactory.get("controllerWithoutDrools")).thenReturn(controllerWithoutDrools);
+ when(controllerFactory.get(CONTROLLER_NAME)).thenReturn(policyController);
+
+ setupPolicyControllerFactory(controllerConst);
+
+ restApi = mock(RestManager.class);
+
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.getDroolsController(anyString())).thenCallRealMethod();
+ when(restApi.droolsFactsDelete("nullController", sessionName, queryName, queriedEntity))
+ .thenCallRealMethod();
+ when(restApi.droolsFactsDelete("controllerWithoutDrools", sessionName, queryName, queriedEntity))
+ .thenCallRealMethod();
+ when(restApi.droolsFactsDelete(CONTROLLER_NAME, sessionName, queryName, queriedEntity))
+ .thenCallRealMethod();
+
+ // controller is null
+ var response = restApi.droolsFactsDelete("nullController", sessionName, queryName, queriedEntity);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ assertEquals("nullController:sessionName:queryName:queriedEntity not found",
+ ((RestManager.Error) response.getEntity()).getError());
+
+ // controller has no drools
+ response = restApi.droolsFactsDelete("controllerWithoutDrools", sessionName, queryName, queriedEntity);
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ assertEquals("controllerWithoutDrools:sessionName:queryName:queriedEntity not found",
+ ((RestManager.Error) response.getEntity()).getError());
+
+ // delete works
+ response = restApi.droolsFactsDelete(CONTROLLER_NAME, sessionName, queryName, queriedEntity);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertInstanceOf(List.class, response.getEntity());
+ }
+ }
+
+ @Test
+ void rules() {
+ when(restApi.rules(anyString())).thenCallRealMethod();
+ var response = restApi.rules("expression");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void decoderFilter2() {
+ try (MockedStatic<EventProtocolCoderConstants> constants = mockStatic(EventProtocolCoderConstants.class)) {
+ var decoder = mock(ProtocolCoderToolset.class);
+ when(decoder.getCoders()).thenReturn(new ArrayList<>(List.of()));
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, TOPIC))
+ .thenReturn(decoder);
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, "invalidTopic"))
+ .thenReturn(null);
+
+ setupEventProtocolManager(constants);
+
+ var drools = getDroolsControllerWithGroupArtifact();
+ restApi = mock(RestManager.class);
+ when(restApi.getDroolsController(CONTROLLER_NAME)).thenReturn(drools);
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.decoderFilter2(anyString(), anyString())).thenCallRealMethod();
+ when(restApi.getDroolsController("noDecoderCtrl")).thenReturn(drools);
+ when(restApi.getDroolsController("exceptionCtrl"))
+ .thenThrow(new IllegalArgumentException("exceptionCtrl"));
+
+ // should be ok
+ var response = restApi.decoderFilter2(CONTROLLER_NAME, TOPIC);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertInstanceOf(List.class, response.getEntity());
+
+ // controller has no decoder
+ response = restApi.decoderFilter2("noDecoderCtrl", "invalidTopic");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // can't get a controller
+ response = restApi.decoderFilter2("exceptionCtrl", TOPIC);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void decoderFilter1() {
+ try (MockedStatic<EventProtocolCoderConstants> constants = mockStatic(EventProtocolCoderConstants.class)) {
+ var decoder = mock(ProtocolCoderToolset.class);
+ when(decoder.getCoder(FACT_CLASS)).thenReturn(mock(EventProtocolCoder.CoderFilters.class));
+ when(decoder.getCoder("invalidClass")).thenReturn(null);
+
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, TOPIC))
+ .thenReturn(decoder);
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, "invalidTopic"))
+ .thenThrow(new IllegalArgumentException("exception"));
+
+ setupEventProtocolManager(constants);
+
+ var drools = getDroolsControllerWithGroupArtifact();
+ restApi = mock(RestManager.class);
+ when(restApi.getDroolsController(CONTROLLER_NAME)).thenReturn(drools);
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.decoderFilter1(anyString(), anyString(), anyString())).thenCallRealMethod();
+
+ // should be ok
+ var response = restApi.decoderFilter1(CONTROLLER_NAME, TOPIC, FACT_CLASS);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertInstanceOf(EventProtocolCoder.CoderFilters.class, response.getEntity());
+
+ // controller has no decoder
+ response = restApi.decoderFilter1(CONTROLLER_NAME, TOPIC, "invalidClass");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // can't get a controller
+ response = restApi.decoderFilter1(CONTROLLER_NAME, "invalidTopic", FACT_CLASS);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void decoderFilter() {
+ try (MockedStatic<EventProtocolCoderConstants> constants = mockStatic(EventProtocolCoderConstants.class)) {
+ var coderFilter = new EventProtocolCoder.CoderFilters(FACT_CLASS, new JsonProtocolFilter(), 1);
+
+ var decoder = mock(ProtocolCoderToolset.class);
+ when(decoder.getCoder(FACT_CLASS)).thenReturn(coderFilter);
+ when(decoder.getCoder("invalidClass")).thenReturn(null);
+
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, TOPIC))
+ .thenReturn(decoder);
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, "invalidTopic"))
+ .thenThrow(new IllegalArgumentException("exception"));
+
+ setupEventProtocolManager(constants);
+
+
+ restApi = mock(RestManager.class);
+ var configFilters = new JsonProtocolFilter();
+ when(restApi.decoderFilter(eq(configFilters), eq(CONTROLLER_NAME), anyString(),
+ anyString())).thenCallRealMethod();
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.decoderFilter(isNull(), eq(CONTROLLER_NAME), anyString(), anyString())).thenCallRealMethod();
+ var drools = getDroolsControllerWithGroupArtifact();
+ when(restApi.getDroolsController(CONTROLLER_NAME)).thenReturn(drools);
+
+ // should be ok
+ var response = restApi.decoderFilter(configFilters, CONTROLLER_NAME, TOPIC, FACT_CLASS);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ if (response.getEntity() instanceof EventProtocolCoder.CoderFilters) {
+ var filters = (EventProtocolCoder.CoderFilters) response.getEntity();
+ assertEquals(configFilters, filters.getFilter());
+ }
+
+ // controller has no decoder
+ response = restApi.decoderFilter(configFilters, CONTROLLER_NAME, TOPIC, "invalidClass");
+ assertNotNull(response);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // can't get a controller
+ response = restApi.decoderFilter(configFilters, CONTROLLER_NAME, "invalidTopic", FACT_CLASS);
+ assertNotNull(response);
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+
+ // can't get a controller
+ response = restApi.decoderFilter(null, CONTROLLER_NAME, "invalidTopic", "invalidClass");
+ assertNotNull(response);
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void decoderFilterRules() {
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.decoderFilterRules(anyString(), anyString(), anyString())).thenCallRealMethod();
+
+ when(restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, TOPIC, FACT_CLASS))
+ .thenReturn(new JsonProtocolFilter());
+ when(restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, TOPIC, "invalidClass"))
+ .thenReturn(Response.status(BAD_REQUEST).build());
+ // trying to trigger RuntimeException for code coverage - normally it wouldn't happen here
+ when(restApi.checkControllerDecoderAndFilter("invalidController", TOPIC, FACT_CLASS))
+ .thenReturn(null);
+
+ // should return a string rule
+ var response = restApi.decoderFilterRules(CONTROLLER_NAME, TOPIC, FACT_CLASS);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertInstanceOf(String.class, response.getEntity());
+
+ // checkControllerEtc... returned error response, so it just returns it to function
+ response = restApi.decoderFilterRules(CONTROLLER_NAME, TOPIC, "invalidClass");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // the runtime exception
+ response = restApi.decoderFilterRules("invalidController", TOPIC, FACT_CLASS);
+ assertEquals(INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void decoderFilterRuleDelete() {
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.decoderFilterRuleDelete(anyString(), anyString(), anyString())).thenCallRealMethod();
+
+ when(restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, TOPIC, FACT_CLASS))
+ .thenReturn(new JsonProtocolFilter());
+ when(restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, TOPIC, "invalidClass"))
+ .thenReturn(Response.status(BAD_REQUEST).build());
+
+ // should return a string rule
+ var response = restApi.decoderFilterRuleDelete(CONTROLLER_NAME, TOPIC, FACT_CLASS);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertInstanceOf(String.class, response.getEntity());
+
+ // checkControllerEtc... returned error response, so it just returns it to function
+ response = restApi.decoderFilterRuleDelete(CONTROLLER_NAME, TOPIC, "invalidClass");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void decoderFilterRule() {
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.decoderFilterRule(anyString(), anyString(), anyString(), anyString())).thenCallRealMethod();
+
+ when(restApi.decoderFilterRule2(CONTROLLER_NAME, TOPIC, FACT_CLASS, "rule"))
+ .thenReturn(new JsonProtocolFilter().getRule());
+ when(restApi.decoderFilterRule2(CONTROLLER_NAME, TOPIC, FACT_CLASS, ""))
+ .thenCallRealMethod();
+ when(restApi.decoderFilterRule("invalidController", TOPIC, FACT_CLASS, "rule"))
+ .thenThrow(new IllegalArgumentException("invalid controller"));
+
+ var response = restApi.decoderFilterRule(CONTROLLER_NAME, TOPIC, FACT_CLASS, "rule");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertInstanceOf(String.class, response.getEntity());
+
+ response = restApi.decoderFilterRule(CONTROLLER_NAME, TOPIC, FACT_CLASS, "");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+ assertInstanceOf(RestManager.Error.class, response.getEntity());
+
+ response = restApi.decoderFilterRule("invalidController", TOPIC, FACT_CLASS, "rule");
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ assertInstanceOf(RestManager.Error.class, response.getEntity());
+ }
+
+ @Test
+ void decode_EmptyParams() {
+ when(restApi.decode(anyString(), anyString(), anyString())).thenCallRealMethod();
+
+ var response = restApi.decode(CONTROLLER_NAME, "", "json");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+
+ response = restApi.decode("", TOPIC, "json");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void decode() {
+ try (MockedStatic<EventProtocolCoderConstants> constants = mockStatic(EventProtocolCoderConstants.class)) {
+ var event = new Object();
+ when(coderManager.decode(GROUP_ID, ARTIFACT_ID, TOPIC, "json")).thenReturn(event);
+ when(coderManager.decode(GROUP_ID, ARTIFACT_ID, "otherTopic", "json")).thenReturn(event);
+ when(coderManager.decode(GROUP_ID, ARTIFACT_ID, TOPIC, "invalidJson"))
+ .thenThrow(new IllegalArgumentException("invalid json"));
+
+ when(coderManager.encode(TOPIC, event)).thenReturn("json");
+ when(coderManager.encode("otherTopic", event))
+ .thenThrow(new IllegalArgumentException("invalid topic"));
+
+ setupEventProtocolManager(constants);
+
+ var drools = getDroolsControllerWithGroupArtifact();
+
+ restApi = mock(RestManager.class);
+ when(restApi.getDroolsController(CONTROLLER_NAME)).thenReturn(drools);
+ when(restApi.decode(anyString(), anyString(), anyString())).thenCallRealMethod();
+
+ // should work
+ var response = restApi.decode(CONTROLLER_NAME, TOPIC, "json");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertNotNull(response.getEntity());
+ if (response.getEntity() instanceof RestManager.CodingResult) {
+ var codingResult = (RestManager.CodingResult) response.getEntity();
+ assertTrue(codingResult.getDecoding());
+ assertTrue(codingResult.getEncoding());
+ assertEquals("json", codingResult.getJsonEncoding());
+ }
+
+ // can't decode
+ response = restApi.decode(CONTROLLER_NAME, TOPIC, "invalidJson");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // can't encode, but return decoded result
+ response = restApi.decode(CONTROLLER_NAME, "otherTopic", "json");
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertNotNull(response.getEntity());
+ if (response.getEntity() instanceof RestManager.CodingResult) {
+ var codingResult = (RestManager.CodingResult) response.getEntity();
+ assertTrue(codingResult.getDecoding());
+ assertFalse(codingResult.getEncoding());
+ assertNull(codingResult.getJsonEncoding());
+ }
+ }
+ }
+
+ @Test
+ void encoderFilters() {
+ try (MockedStatic<EventProtocolCoderConstants> constants = mockStatic(EventProtocolCoderConstants.class)) {
+ when(coderManager.getEncoderFilters(GROUP_ID, ARTIFACT_ID))
+ .thenReturn(new ArrayList<>(List.of()));
+
+ setupEventProtocolManager(constants);
+
+ var drools = getDroolsControllerWithGroupArtifact();
+ when(restApi.getDroolsController(CONTROLLER_NAME)).thenReturn(drools);
+ when(restApi.getDroolsController("invalidController"))
+ .thenThrow(new IllegalArgumentException("invalid controller"));
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.encoderFilters(anyString())).thenCallRealMethod();
+
+ // should work
+ var response = restApi.encoderFilters(CONTROLLER_NAME);
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+ assertNotNull(response.getEntity());
+
+ // exceptions
+ response = restApi.encoderFilters("invalidController");
+ assertEquals(NOT_FOUND.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void topicsLock() {
+ try (MockedStatic<TopicEndpointManager> constants = mockStatic(TopicEndpointManager.class)) {
+ when(topicManager.lock())
+ .thenReturn(true)
+ .thenReturn(false);
+ setupTopicEndpointManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.topicsLock()).thenCallRealMethod();
+
+ // should work and return ok
+ var response = restApi.topicsLock();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ // lock fails, return false
+ response = restApi.topicsLock();
+ assertNotNull(response);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void topicsUnlock() {
+ try (MockedStatic<TopicEndpointManager> constants = mockStatic(TopicEndpointManager.class)) {
+ when(topicManager.unlock())
+ .thenReturn(true)
+ .thenReturn(false);
+ setupTopicEndpointManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.topicsUnlock()).thenCallRealMethod();
+
+ // should work and return ok
+ var response = restApi.topicsUnlock();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ // lock fails, return false
+ response = restApi.topicsUnlock();
+ assertNotNull(response);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void commSources() {
+ try (MockedStatic<TopicEndpointManager> constants = mockStatic(TopicEndpointManager.class)) {
+ when(topicManager.getNoopTopicSources()).thenReturn(new ArrayList<>(List.of()));
+ when(topicManager.getKafkaTopicSources()).thenReturn(new ArrayList<>(List.of()));
+ setupTopicEndpointManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.commSources(anyString())).thenCallRealMethod();
+
+ var response = restApi.commSources("noop");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ response = restApi.commSources("kafka");
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ // topic type rest valid not supported
+ response = restApi.commSources("rest");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // empty topic type
+ response = restApi.commSources("");
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void commSinks() {
+ try (MockedStatic<TopicEndpointManager> constants = mockStatic(TopicEndpointManager.class)) {
+ when(topicManager.getNoopTopicSinks()).thenReturn(new ArrayList<>(List.of()));
+ when(topicManager.getKafkaTopicSinks()).thenReturn(new ArrayList<>(List.of()));
+ setupTopicEndpointManager(constants);
+
+ restApi = mock(RestManager.class);
+ when(restApi.commSinks(anyString())).thenCallRealMethod();
+
+ var response = restApi.commSinks("noop");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ response = restApi.commSinks("kafka");
+ assertEquals(OK.getStatusCode(), response.getStatus());
+
+ // topic type rest valid but not supported
+ response = restApi.commSinks("rest");
+ assertEquals(BAD_REQUEST.getStatusCode(), response.getStatus());
+
+ // empty topic type
+ response = restApi.commSinks("");
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void loggers() {
+ try (MockedStatic<LoggerFactory> loggerFactory = mockStatic(LoggerFactory.class)) {
+ var mockFactory = mock(ILoggerFactory.class);
+ loggerFactory.when(LoggerFactory::getILoggerFactory).thenReturn(mockFactory);
+
+ restApi = mock(RestManager.class);
+ when(restApi.loggers()).thenCallRealMethod();
+
+ var response = restApi.loggers();
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void loggerName1() {
+ try (MockedStatic<LoggerFactory> loggerFactory = mockStatic(LoggerFactory.class)) {
+ var mockFactory = mock(ILoggerFactory.class);
+ loggerFactory.when(LoggerFactory::getILoggerFactory).thenReturn(mockFactory);
+
+ restApi = mock(RestManager.class);
+ when(restApi.loggerName1(anyString())).thenCallRealMethod();
+
+ var response = restApi.loggerName1("logger1");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ }
+ }
+
+ @Test
+ void loggerName_EmptyValues() {
+ when(restApi.loggerName(anyString(), anyString())).thenCallRealMethod();
+
+ var response = restApi.loggerName("", "info");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("logger name: not acceptable");
+
+ response = restApi.loggerName("logger1", "");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(NOT_ACCEPTABLE.getStatusCode(), response.getStatus());
+ assertThat(((RestManager.Error) response.getEntity()).getError())
+ .contains("logger level: not acceptable");
+ }
+
+ @Test
+ void testLoggerName_Exceptions() {
+ when(restApi.loggerName(anyString(), anyString())).thenCallRealMethod();
+
+ var response = restApi.loggerName("audit", "abc");
+ assertNotNull(response);
+ assertInstanceOf(Response.class, response);
+ assertEquals(INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void testCheckControllerDecoderAndFilter() {
+ try (MockedStatic<EventProtocolCoderConstants> constants = mockStatic(EventProtocolCoderConstants.class)) {
+ var coderFilter = new EventProtocolCoder.CoderFilters(FACT_CLASS, new JsonProtocolFilter(), 1);
+ var decoder = mock(ProtocolCoderToolset.class);
+ when(decoder.getCoder(FACT_CLASS)).thenReturn(coderFilter);
+
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, TOPIC))
+ .thenReturn(decoder);
+
+ var decoderWithoutFactClass = mock(ProtocolCoderToolset.class);
+ when(decoderWithoutFactClass.getCoder("noFactClass")).thenReturn(null);
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, "topic2"))
+ .thenReturn(decoderWithoutFactClass);
+
+ var coderFactClassWithoutFilter = mock(EventProtocolCoder.CoderFilters.class);
+ when(coderFactClassWithoutFilter.getFilter()).thenReturn(null);
+ var decoderWithoutFilter = mock(ProtocolCoderToolset.class);
+ when(decoderWithoutFilter.getCoder("noFilterClass")).thenReturn(coderFactClassWithoutFilter);
+ when(coderManager.getDecoders(GROUP_ID, ARTIFACT_ID, "topic3"))
+ .thenReturn(decoderWithoutFilter);
+
+ setupEventProtocolManager(constants);
+
+ restApi = mock(RestManager.class);
+
+ var drools = getDroolsControllerWithGroupArtifact();
+ when(restApi.getDroolsController(CONTROLLER_NAME)).thenReturn(drools);
+ when(restApi.getDroolsController("exceptionController"))
+ .thenThrow(new IllegalArgumentException("exception"));
+ when(restApi.catchArgStateGenericEx(any(), any())).thenCallRealMethod();
+ when(restApi.checkControllerDecoderAndFilter(anyString(), anyString(), anyString()))
+ .thenCallRealMethod();
+
+ // should work fine and get back JsonProtocolFilter object
+ var result = restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, TOPIC, FACT_CLASS);
+ assertNotNull(result);
+ assertInstanceOf(JsonProtocolFilter.class, result);
+
+ // decoder doesn't have coder based on noFactClass parameter
+ var response = restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, "topic2", "noFactClass");
+ assertNotNull(response);
+ if (response instanceof Response) {
+ var actualResponse = (Response) response;
+ assertEquals(BAD_REQUEST.getStatusCode(), actualResponse.getStatus());
+ assertThat(((RestManager.Error) actualResponse.getEntity()).getError())
+ .contains("noFactClass does not exist");
+ }
+
+ // decoder has factClass, but factClass has no filter
+ response = restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, "topic3", "noFilterClass");
+ assertNotNull(response);
+ if (response instanceof Response) {
+ var actualResponse = (Response) response;
+ assertEquals(BAD_REQUEST.getStatusCode(), actualResponse.getStatus());
+ assertThat(((RestManager.Error) actualResponse.getEntity()).getError())
+ .contains("noFilterClass has no filters");
+ }
+ }
+ }
+
+ @Test
+ void testDecoderFilterRule2() {
+ var filter = new JsonProtocolFilter();
+ when(restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, TOPIC, FACT_CLASS))
+ .thenReturn(filter);
+ when(restApi.checkControllerDecoderAndFilter(CONTROLLER_NAME, TOPIC, "invalidFactClass"))
+ .thenReturn(Response.status(BAD_REQUEST).build());
+
+ when(restApi.decoderFilterRule2(anyString(), anyString(), anyString(), anyString()))
+ .thenCallRealMethod();
+ when(restApi.decoderFilterRule2(anyString(), anyString(), anyString(), isNull()))
+ .thenCallRealMethod();
+
+ // should work
+ var result = restApi.decoderFilterRule2(CONTROLLER_NAME, TOPIC, FACT_CLASS, "rule");
+ assertNotNull(result);
+ assertInstanceOf(String.class, result);
+
+ // rule is null
+ var response = restApi.decoderFilterRule2(CONTROLLER_NAME, TOPIC, FACT_CLASS, null);
+ assertNotNull(response);
+ if (response instanceof Response) {
+ var actualResponse = (Response) response;
+ assertEquals(BAD_REQUEST.getStatusCode(), actualResponse.getStatus());
+ assertThat(((RestManager.Error) actualResponse.getEntity()).getError())
+ .contains("no filter rule provided");
+ }
+
+ // rule is empty string
+ response = restApi.decoderFilterRule2(CONTROLLER_NAME, TOPIC, FACT_CLASS, "");
+ assertNotNull(response);
+ if (response instanceof Response) {
+ var actualResponse = (Response) response;
+ assertEquals(BAD_REQUEST.getStatusCode(), actualResponse.getStatus());
+ assertThat(((RestManager.Error) actualResponse.getEntity()).getError())
+ .contains("no filter rule provided");
+ }
+
+ // checkControllerDecoderFilter returns error response
+ response = restApi.decoderFilterRule2(CONTROLLER_NAME, TOPIC, "invalidFactClass", "rule");
+ assertNotNull(response);
+ assertEquals(BAD_REQUEST.getStatusCode(), ((Response) response).getStatus());
+ }
+
+ private void setupPolicyEngineManager(MockedStatic<PolicyEngineConstants> constants) {
+ constants.when(PolicyEngineConstants::getManager).thenReturn(policyEngineManager);
+ assertEquals(policyEngineManager, PolicyEngineConstants.getManager());
+ }
+
+ private void setupLockManagerAndExecutorService() {
+ var executorService = mock(ScheduledExecutorService.class);
+ when(executorService.shutdownNow()).thenReturn(new ArrayList<>());
+ when(policyEngineManager.getExecutorService()).thenReturn(executorService);
+
+ var lockManager = mock(LockManager.class);
+ doNothing().when(lockManager).shutdown();
+ ReflectionTestUtils.setField(policyEngineManager, "lockManager", lockManager);
+ }
+
+ private void setupPolicyControllerFactory(MockedStatic<PolicyControllerConstants> constants) {
+ constants.when(PolicyControllerConstants::getFactory).thenReturn(controllerFactory);
+ assertEquals(controllerFactory, PolicyControllerConstants.getFactory());
+ }
+
+ private void setupEventProtocolManager(MockedStatic<EventProtocolCoderConstants> constants) {
+ constants.when(EventProtocolCoderConstants::getManager).thenReturn(coderManager);
+ assertEquals(coderManager, EventProtocolCoderConstants.getManager());
+ }
+
+ private void setupTopicEndpointManager(MockedStatic<TopicEndpointManager> constants) {
+ constants.when(TopicEndpointManager::getManager).thenReturn(topicManager);
+ assertEquals(topicManager, TopicEndpointManager.getManager());
+ }
+
+ private static DroolsController getDroolsControllerWithGroupArtifact() {
+ var drools = mock(DroolsController.class);
+ when(drools.getGroupId()).thenReturn(GROUP_ID);
+ when(drools.getArtifactId()).thenReturn(ARTIFACT_ID);
+ return drools;
+ }
+}
\ No newline at end of file
@Test
void test200Start() {
- logger.info("enter");
+ logger.info("enter test200Start");
PolicyEngineConstants.getManager().start();
@Test
void test300Lock() {
- logger.info("enter");
+ logger.info("enter test300Lock");
PolicyEngineConstants.getManager().lock();
@Test
void test301Unlock() {
- logger.info("enter");
+ logger.info("enter test301Unlock");
PolicyEngineConstants.getManager().unlock();
@Test
void test400ControllerAdd() {
- logger.info("enter");
+ logger.info("enter test400ControllerAdd");
final Properties controllerProperties = new Properties();
controllerProperties.put(DroolsPropertyConstants.PROPERTY_CONTROLLER_NAME, TEST_CONTROLLER_NAME);
@Test
void test401ControllerVerify() {
- logger.info("enter");
+ logger.info("enter test401ControllerVerify");
final PolicyController testController = PolicyControllerConstants.getFactory().get(TEST_CONTROLLER_NAME);
@Test
void test500Deactivate() {
- logger.info("enter");
+ logger.info("enter test500Deactivate");
PolicyEngineConstants.getManager().deactivate();
@Test
void test501Activate() {
- logger.info("enter");
+ logger.info("enter test501Activate");
PolicyEngineConstants.getManager().activate();
@Test
void test900ControllerRemove() {
- logger.info("enter");
+ logger.info("enter test900ControllerRemove");
PolicyEngineConstants.getManager().removePolicyController(TEST_CONTROLLER_NAME);
assertTrue(PolicyControllerConstants.getFactory().inventory().isEmpty());
@Test
void test901Stop() {
- logger.info("enter");
+ logger.info("enter test901Stop");
/* Shutdown managed resources */
PolicyControllerConstants.getFactory().shutdown();
Code Review / policy / drools-pdp.git / commitdiff