/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021, 2024 Nordix Foundation.
+ * Copyright (C) 2021, 2024-2025 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 static final String LOCAL_NAME = "LocalName";
private static final String VERSION002 = "0.0.2";
private static final String VERSION001 = "0.0.1";
- private static final long timeStamp = 1613152081L;
+ private static final long TIME_STAMP = 1613152081L;
private static final Instant DEFAULT_TIMESTAMP = Instant.EPOCH;
@Test
assertNotNull(new PfReferenceTimestampKey(new PfReferenceTimestampKey()).getTimeStamp());
assertEquals(LOCAL_NAME,
- new PfReferenceTimestampKey(new PfReferenceKey(), LOCAL_NAME, Instant.ofEpochSecond(timeStamp))
+ new PfReferenceTimestampKey(new PfReferenceKey(), LOCAL_NAME, Instant.ofEpochSecond(TIME_STAMP))
.getReferenceKey().getLocalName());
- assertEquals(Date.from(Instant.ofEpochSecond(timeStamp)), new PfReferenceTimestampKey(new PfConceptKey(),
- PARENT_LOCAL_NAME, LOCAL_NAME, Instant.ofEpochSecond(timeStamp)).getTimeStamp());
+ assertEquals(Date.from(Instant.ofEpochSecond(TIME_STAMP)), new PfReferenceTimestampKey(new PfConceptKey(),
+ PARENT_LOCAL_NAME, LOCAL_NAME, Instant.ofEpochSecond(TIME_STAMP)).getTimeStamp());
assertThat(new PfReferenceTimestampKey("ParentKeyName", VERSION001, PARENT_LOCAL_NAME, LOCAL_NAME,
- Instant.ofEpochSecond(timeStamp))).isInstanceOf(PfReferenceTimestampKey.class);
+ Instant.ofEpochSecond(TIME_STAMP))).isInstanceOf(PfReferenceTimestampKey.class);
assertThat(
- new PfReferenceTimestampKey("ParentKeyName", VERSION001, LOCAL_NAME, Instant.ofEpochSecond(timeStamp))
+ new PfReferenceTimestampKey("ParentKeyName", VERSION001, LOCAL_NAME, Instant.ofEpochSecond(TIME_STAMP))
.getReferenceKey().getParentLocalName()).isEqualTo(PfKey.NULL_KEY_NAME);
assertEquals(PfReferenceTimestampKey.getNullKey().getKey(), PfReferenceTimestampKey.getNullKey());
PfReferenceTimestampKey testNullKey = new PfReferenceTimestampKey();
assertTrue(testNullKey.isNullKey());
- String id = "NULL:0.0.0:NULL:NULL:" + timeStamp;
- assertThat(new PfReferenceTimestampKey(id).getTimeStamp().getTime()).isEqualTo(timeStamp);
+ String id = "NULL:0.0.0:NULL:NULL:" + TIME_STAMP;
+ assertThat(new PfReferenceTimestampKey(id).getTimeStamp().getTime()).isEqualTo(TIME_STAMP);
}
@Test
assertEquals(testReferenceKey, clonedReferenceKey);
assertNotEquals(testReferenceKey, new PfReferenceTimestampKey("PKN", VERSION001, "PLN",
- "LN", Instant.ofEpochSecond(timeStamp)));
- testReferenceKey.setTimeStamp(Date.from(Instant.ofEpochSecond(timeStamp)));
+ "LN", Instant.ofEpochSecond(TIME_STAMP)));
+ testReferenceKey.setTimeStamp(Date.from(Instant.ofEpochSecond(TIME_STAMP)));
assertEquals(testReferenceKey, new PfReferenceTimestampKey("PKN", VERSION001, PARENT_LOCAL_NAME, "LN",
- Instant.ofEpochSecond(timeStamp)));
+ Instant.ofEpochSecond(TIME_STAMP)));
assertNotEquals(0, testReferenceKey.compareTo(new PfReferenceTimestampKey()));
assertNotEquals(0, testReferenceKey.compareTo(new PfReferenceTimestampKey("PKN", VERSION002,
- "PLN", "LN", Instant.ofEpochSecond(timeStamp))));
+ "PLN", "LN", Instant.ofEpochSecond(TIME_STAMP))));
assertEquals(0, testReferenceKey.compareTo(new PfReferenceTimestampKey("PKN", VERSION001, PARENT_LOCAL_NAME,
- "LN", Instant.ofEpochSecond(timeStamp))));
+ "LN", Instant.ofEpochSecond(TIME_STAMP))));
assertThatThrownBy(() -> new PfReferenceTimestampKey((PfReferenceTimestampKey) null))
.isInstanceOf(NullPointerException.class);
@Test
void testNewerKey() {
PfReferenceTimestampKey key1 = new PfReferenceTimestampKey("ParentKeyName", VERSION001, PARENT_LOCAL_NAME,
- LOCAL_NAME, Instant.ofEpochSecond(timeStamp));
+ LOCAL_NAME, Instant.ofEpochSecond(TIME_STAMP));
PfReferenceTimestampKey key2 = new PfReferenceTimestampKey(key1);
assertFalse(key2.isNewerThan(key1));
assertThatThrownBy(() -> key1.isNewerThan((PfKey) null)).isInstanceOf(NullPointerException.class)
.hasMessageMatching("^otherKey is marked .*on.*ull but is null$");
- key2.setTimeStamp(Date.from(Instant.ofEpochSecond(timeStamp).plusSeconds(80)));
+ key2.setTimeStamp(Date.from(Instant.ofEpochSecond(TIME_STAMP).plusSeconds(80)));
assertTrue(key2.isNewerThan(key1));
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2021, 2024 Nordix Foundation.
+ * Copyright (C) 2019-2021, 2024-2025 Nordix Foundation.
* Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
private static final String CONCEPT_IS_NULL = "^copyConcept is marked .*on.*ull but is null$";
private static final String NAME_IS_NULL = "^name is marked .*on.*ull but is null$";
private static final String VERSION_IS_NULL = "^version is marked .*on.*ull but is null$";
- private static final long timeStamp = 1574832537641L;
+ private static final long TIME_STAMP = 1574832537641L;
@Test
void testTimestampKey() {
assertEquals("PfTimestampKey(name=NULL, version=0.0.0, timeStamp=" + Date.from(Instant.EPOCH) + ")",
someKey0.toString());
- PfTimestampKey someKey1 = new PfTimestampKey("my-name", VERSION001, Instant.ofEpochSecond(timeStamp));
+ PfTimestampKey someKey1 = new PfTimestampKey("my-name", VERSION001, Instant.ofEpochSecond(TIME_STAMP));
PfTimestampKey someKey2 = new PfTimestampKey(someKey1);
PfTimestampKey someKey3 = new PfTimestampKey(someKey1.getId());
assertEquals(someKey1, someKey2);
assertEquals(someKey1, someKey3);
assertFalse(someKey1.isNullVersion());
assertEquals("PfTimestampKey(name=my-name, version=0.0.1, timeStamp="
- + Date.from(Instant.ofEpochSecond(timeStamp)) + ")", someKey1.toString());
+ + Date.from(Instant.ofEpochSecond(TIME_STAMP)) + ")", someKey1.toString());
assertEquals("my-name", someKey1.getName());
assertEquals(VERSION001, someKey1.getVersion());
assertFalse(someKey1.isNewerThan(someKey2));
assertThatThrownBy(() -> someKey1.isNewerThan((PfKey) null)).isInstanceOf(NullPointerException.class)
.hasMessageMatching("^otherKey is marked .*on.*ull but is null$");
- someKey2.setTimeStamp(Date.from(Instant.ofEpochSecond(timeStamp).plusMillis(90)));
+ someKey2.setTimeStamp(Date.from(Instant.ofEpochSecond(TIME_STAMP).plusMillis(90)));
assertTrue(someKey2.isNewerThan(someKey1));
someKey3.setName("my-name3");
assertTrue(someKey3.isNewerThan(someKey1));
assertThatThrownBy(() -> someKey1.compareTo((PfConcept) null)).isInstanceOf(NullPointerException.class)
.hasMessageMatching("^otherObj is marked .*on.*ull but is null$");
- PfTimestampKey someKey4 = new PfTimestampKey("NULL", "0.0.0", Instant.ofEpochSecond(timeStamp));
+ PfTimestampKey someKey4 = new PfTimestampKey("NULL", "0.0.0", Instant.ofEpochSecond(TIME_STAMP));
assertFalse(someKey4.isNullKey());
assertFalse(someKey1.isNullKey());
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019, 2023 Nordix Foundation.
+ * Copyright (C) 2019, 2023, 2025 Nordix Foundation.
* Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
this.description = source.description;
}
- public DummyConceptEntity(final Double doubleValue) {
- this.key = new PfConceptKey();
- }
-
- public DummyConceptEntity(final PfConceptKey key, final Double doubleValue) {
- this.key = key;
- }
-
/**
* Constructor.
*
}
@Override
- public int compareTo(final PfConcept otherObj) {
+ public int compareTo(final @NonNull PfConcept otherObj) {
Assertions.argumentNotNull(otherObj, "comparison object may not be null");
if (this == otherObj) {
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2021, 2023-2024 Nordix Foundation.
+ * Copyright (C) 2019-2021, 2023-2025 Nordix Foundation.
* Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2022 Bell Canada. All rights reserved.
* ================================================================================
@Test
void testEntityTestAllOpsJpa() throws PfModelException {
- final DaoParameters daoParameters = new DaoParameters();
- daoParameters.setPluginClass(DefaultPfDao.class.getName());
- daoParameters.setPersistenceUnit("DaoTest");
-
- Properties jdbcProperties = new Properties();
- jdbcProperties.setProperty("jakarta.persistence.jdbc.driver", "org.h2.Driver");
- jdbcProperties.setProperty("jakarta.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
- jdbcProperties.setProperty("jakarta.persistence.jdbc.user", "sa");
- jdbcProperties.setProperty("jakarta.persistence.jdbc.password", "");
-
- daoParameters.setJdbcProperties(jdbcProperties);
+ final DaoParameters daoParameters = getDaoParameters();
pfDao = new PfDaoFactory().createPfDao(daoParameters);
pfDao.init(daoParameters);
testVersionOps();
- testgetFilteredOps();
+ testGetFilteredOps();
testgetFilteredOps3();
}
@Test
void testEntityTestBadVals() throws PfModelException {
- final DaoParameters daoParameters = new DaoParameters();
- daoParameters.setPluginClass(DefaultPfDao.class.getName());
- daoParameters.setPersistenceUnit("DaoTest");
-
- Properties jdbcProperties = new Properties();
- jdbcProperties.setProperty("jakarta.persistence.jdbc.driver", "org.h2.Driver");
- jdbcProperties.setProperty("jakarta.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
- jdbcProperties.setProperty("jakarta.persistence.jdbc.user", "sa");
- jdbcProperties.setProperty("jakarta.persistence.jdbc.password", "");
-
- daoParameters.setJdbcProperties(jdbcProperties);
+ final DaoParameters daoParameters = getDaoParameters();
pfDao = new PfDaoFactory().createPfDao(daoParameters);
pfDao.init(daoParameters);
assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
}
+ private static DaoParameters getDaoParameters() {
+ final DaoParameters daoParameters = new DaoParameters();
+ daoParameters.setPluginClass(DefaultPfDao.class.getName());
+ daoParameters.setPersistenceUnit("DaoTest");
+
+ Properties jdbcProperties = new Properties();
+ jdbcProperties.setProperty("jakarta.persistence.jdbc.driver", "org.h2.Driver");
+ jdbcProperties.setProperty("jakarta.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
+ jdbcProperties.setProperty("jakarta.persistence.jdbc.user", "sa");
+ jdbcProperties.setProperty("jakarta.persistence.jdbc.password", "");
+
+ daoParameters.setJdbcProperties(jdbcProperties);
+ return daoParameters;
+ }
+
private void testAllOps() {
final PfConceptKey aKey0 = new PfConceptKey("A-KEY0", VERSION001);
final PfConceptKey aKey1 = new PfConceptKey("A-KEY1", VERSION001);
tkeyInfoSetIn.add(tkeyInfo2);
pfDao.createCollection(tkeyInfoSetIn);
- tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
assertEquals(keyInfoSetIn, keyInfoSetOut);
pfDao.delete(DummyTimestampEntity.class, atKey2);
- tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
assertEquals(3, keyInfoSetOut.size());
assertEquals(1, pfDao.size(DummyTimestampEntity.class));
final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
- final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
+ final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);
final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
assertEquals(0, pfDao.getAllVersions(DummyConceptEntity.class, null).size());
}
- private void testgetFilteredOps() {
+ private void testGetFilteredOps() {
final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
- final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
+ final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);
final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
* ONAP
* ================================================================================
* Copyright (C) 2022 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
-import java.util.function.BiConsumer;
import org.onap.policy.common.message.bus.event.TopicSink;
import org.onap.policy.common.message.bus.event.TopicSource;
-import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actor.test.BasicBidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
-import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.sdnr.PciBody;
import org.onap.policy.sdnr.PciMessage;
import org.onap.policy.sdnr.PciResponse;
/**
* Constructs the object.
*
- * @param actor actor name
+ * @param actor actor name
* @param operation operation name
*/
public BasicA1pOperation(String actor, String operation) {
* @param operation operation to run
*/
protected void verifyOperation(A1pOperation operation)
- throws InterruptedException, ExecutionException {
+ throws InterruptedException, ExecutionException {
CompletableFuture<OperationOutcome> future2 = operation.start();
executor.runAll(100);
assertEquals(OperationResult.SUCCESS, outcome.getResult());
}
- /**
- * Provides a response to the listener.
- *
- * @param listener listener to which to provide the response
- * @param code response code
- * @param description response description
- */
- protected void provideResponse(BiConsumer<String, StandardCoderObject> listener, int code, String description) {
- PciResponse response = new PciResponse();
-
- Status status = new Status();
- response.setStatus(status);
- status.setCode(code);
-
- provideResponse(listener, Util.translate("", response, String.class));
- }
}
* ONAP
* ================================================================================
* Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2023-2024 Nordix Foundation.
+ * Modifications Copyright (C) 2023-2025 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.util.TreeMap;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeoutException;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
* ONAP
* ================================================================================
* Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
assertFalse(future2.isDone());
verify(forwarder).register(any(), listenerCaptor.capture());
- provideResponse(listenerCaptor.getValue(), ResponseCode.SUCCESS.getValue(), MY_DESCRIPTION);
+ provideResponse(listenerCaptor.getValue(), ResponseCode.SUCCESS.getValue());
executor.runAll(100);
assertTrue(future2.isDone());
* Provides a response to the listener.
*
* @param listener listener to which to provide the response
- * @param code response code
- * @param description response description
+ * @param code response code
*/
- protected void provideResponse(BiConsumer<String, StandardCoderObject> listener, int code, String description) {
- Response response = new Response();
+ protected void provideResponse(BiConsumer<String, StandardCoderObject> listener, int code) {
+ Response response1 = new Response();
ResponseStatus status = new ResponseStatus();
- response.setStatus(status);
+ response1.setStatus(status);
status.setCode(code);
- status.setDescription(description);
+ status.setDescription(BasicAppcOperation.MY_DESCRIPTION);
- provideResponse(listener, Util.translate("", response, String.class));
+ provideResponse(listener, Util.translate("", response1, String.class));
}
@Override
* ONAP
* ================================================================================
* Copyright (C) 2020-2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2023-2024 Nordix Foundation.
+ * Modifications Copyright (C) 2023-2025 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import org.onap.policy.simulators.TopicServer;
@ExtendWith(MockitoExtension.class)
-
class AppcLcmOperationTest extends BasicBidirectionalTopicOperation<AppcLcmMessageWrapper> {
+class AppcLcmOperationTest extends BasicBidirectionalTopicOperation<AppcLcmMessageWrapper> {
private static final String EXPECTED_EXCEPTION = "expected exception";
private static final String PAYLOAD_KEY1 = "key-A";
private static final String PAYLOAD_VALUE1 = "value-A";
private static final String MY_MESSAGE = "my-message";
- protected static final String MY_VNF = "my-vnf";
protected static final String RESOURCE_ID = "my-resource";
private static final int SUCCESS_CODE = 400;
private AppcLcmOperation oper;
@BeforeAll
- static void setUpBeforeClass() throws Exception {
+ static void setUpBeforeClass() throws Exception {
initBeforeClass(MY_SINK, MY_SOURCE);
}
@AfterAll
- static void tearDownAfterClass() {
+ static void tearDownAfterClass() {
destroyAfterClass();
}
* Sets up.
*/
@BeforeEach
- void setUp() {
+ void setUp() {
super.setUpBasic();
response = makeResponse();
}
@AfterEach
- void tearDown() {
+ void tearDown() {
super.tearDownBasic();
}
* Tests "success" case with simulator.
*/
@Test
- void testSuccess() throws Exception {
+ void testSuccess() throws Exception {
BidirectionalTopicParams opParams =
- BidirectionalTopicParams.builder().sinkTopic(MY_SINK).sourceTopic(MY_SOURCE).build();
+ BidirectionalTopicParams.builder().sinkTopic(MY_SINK).sourceTopic(MY_SOURCE).build();
config = new BidirectionalTopicConfig(blockingExecutor, opParams, topicMgr, AppcLcmOperation.SELECTOR_KEYS);
params = params.toBuilder().retry(0).timeoutSec(5).executor(blockingExecutor).build();
}
@Test
- void testConstructor() {
+ void testConstructor() {
assertEquals(DEFAULT_ACTOR, oper.getActorName());
assertEquals(DEFAULT_OPERATION, oper.getName());
}
@Test
- void testGetPropertyNames() {
+ void testGetPropertyNames() {
assertThat(oper.getPropertyNames()).isEqualTo(List.of(OperationProperties.AAI_TARGET_ENTITY));
}
@Test
- void testMakeRequest() {
+ void testMakeRequest() {
oper.generateSubRequestId(2);
String subreq = oper.getSubRequestId();
assertNotNull(subreq);
* Tests makeRequest() when a property is missing.
*/
@Test
- void testMakeRequestMissingProperty() {
+ void testMakeRequestMissingProperty() {
oper = new AppcLcmOperation(params, config);
oper.generateSubRequestId(1);
assertThatIllegalStateException().isThrownBy(() -> oper.makeRequest(1))
- .withMessageContaining("missing target entity");
+ .withMessageContaining("missing target entity");
}
@Test
- void testConvertPayload() {
+ void testConvertPayload() {
// only builds a payload for ConfigModify
params = params.toBuilder().operation(AppcLcmConstants.OPERATION_CONFIG_MODIFY).build();
oper = new AppcLcmOperation(params, config);
oper.generateSubRequestId(2);
assertThatIllegalArgumentException().isThrownBy(() -> oper.makeRequest(2))
- .withMessageContaining("Cannot convert payload");
+ .withMessageContaining("Cannot convert payload");
}
@Test
- void testGetExpectedKeyValues() {
+ void testGetExpectedKeyValues() {
oper.generateSubRequestId(2);
AppcLcmMessageWrapper request = oper.makeRequest(2);
assertEquals(List.of(request.getBody().getInput().getCommonHeader().getSubRequestId()),
- oper.getExpectedKeyValues(50, request));
+ oper.getExpectedKeyValues(50, request));
}
@Test
- void testDetmStatus() {
+ void testDetmStatus() {
assertEquals(Status.SUCCESS, oper.detmStatus(null, response));
// failure
}
@Test
- void testSetOutcome() {
+ void testSetOutcome() {
oper.setOutcome(outcome, OperationResult.SUCCESS, response);
assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(MY_MESSAGE, outcome.getMessage());
}
@Test
- void testGetStatus() {
+ void testGetStatus() {
assertNotNull(oper.getStatus(response));
// null status
}
@Test
- void testOperationSupportsPayload() {
+ void testOperationSupportsPayload() {
// these should support a payload
Set<String> supported = Set.of(AppcLcmConstants.OPERATION_CONFIG_MODIFY);
// these should NOT support a payload
Set<String> unsupported = AppcLcmConstants.OPERATION_NAMES.stream().filter(name -> !supported.contains(name))
- .collect(Collectors.toSet());
+ .collect(Collectors.toSet());
for (String name : unsupported) {
params = params.toBuilder().operation(name).build();
}
private AppcLcmMessageWrapper makeResponse() {
- AppcLcmMessageWrapper response = new AppcLcmMessageWrapper();
+ AppcLcmMessageWrapper wrapper = new AppcLcmMessageWrapper();
AppcLcmBody body = new AppcLcmBody();
- response.setBody(body);
+ wrapper.setBody(body);
AppcLcmOutput output = new AppcLcmOutput();
body.setOutput(output);
status.setMessage(MY_MESSAGE);
status.setCode(SUCCESS_CODE);
- return response;
+ return wrapper;
}
}
* ============LICENSE_START=======================================================
* Copyright (C) 2020 Bell Canada. All rights reserved.
* Modifications Copyright (C) 2020-2022 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import org.onap.policy.simulators.Util;
@ExtendWith(MockitoExtension.class)
- class GrpcOperationTest {
+class GrpcOperationTest {
private static final String MY_VNF = "my-vnf";
private static final String MY_SVC_ID = "my-service-instance-id";
private static final String RESOURCE_ID = "my-resource-id";
private GrpcOperation operation;
@BeforeAll
- static void setUpBeforeClass() throws Exception {
+ static void setUpBeforeClass() throws Exception {
sim = Util.buildCdsSim();
}
@AfterAll
- static void tearDownAfterClass() {
+ static void tearDownAfterClass() {
sim.stop();
}
* Sets up the fields.
*/
@BeforeEach
- void setUp() {
+ void setUp() {
// Setup the CDS properties
cdsProps = new CdsServerProperties();
cdsProps.setHost("10.10.10.10");
targetEntityIds.put(ControlLoopOperationParams.PARAMS_ENTITY_RESOURCEID, RESOURCE_ID);
params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR).operation(GrpcOperation.NAME)
- .requestId(REQUEST_ID).actorService(new ActorService())
- .build();
+ .requestId(REQUEST_ID).actorService(new ActorService())
+ .build();
}
/**
* Tests "success" case with simulator.
*/
@Test
- void testSuccess() throws Exception {
+ void testSuccess() throws Exception {
Map<String, Object> payload = Map.of("artifact_name", "my_artifact", "artifact_version", "1.0");
params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR).operation("subscribe")
- .requestId(REQUEST_ID).actorService(new ActorService())
- .retry(0).timeoutSec(5).executor(blockingExecutor).payload(payload)
- .build();
+ .requestId(REQUEST_ID).actorService(new ActorService())
+ .retry(0).timeoutSec(5).executor(blockingExecutor).payload(payload)
+ .build();
cdsProps.setHost("localhost");
cdsProps.setPort(sim.getPort());
cdsProps.setTimeout(3);
- GrpcConfig config = new GrpcConfig(blockingExecutor, cdsProps);
+ GrpcConfig grpcConfig = new GrpcConfig(blockingExecutor, cdsProps);
- operation = new GrpcOperation(params, config);
+ operation = new GrpcOperation(params, grpcConfig);
// set the properties
operation.setProperty(OperationProperties.OPT_CDS_GRPC_AAI_PROPERTIES, Collections.emptyMap());
}
@Test
- void testGetPropertyNames() {
+ void testGetPropertyNames() {
/*
* check VNF case with target entities
*/
}
@Test
- void testGetServiceInstanceId() {
+ void testGetServiceInstanceId() {
params = params.toBuilder().targetType(TargetType.VNF).targetEntityIds(targetEntityIds).build();
operation = new GrpcOperation(params, config);
loadVnfData();
assertEquals(MY_SVC_ID,
operation.getOpProperties()
- .convertToAaiProperties(operation)
- .get(GrpcOperationProperties.AAI_SERVICE_INSTANCE_ID_KEY));
+ .convertToAaiProperties(operation)
+ .get(GrpcOperationProperties.AAI_SERVICE_INSTANCE_ID_KEY));
}
@Test
- void testGetVnfId() {
+ void testGetVnfId() {
params = params.toBuilder().targetType(TargetType.VNF).targetEntityIds(targetEntityIds).build();
operation = new GrpcOperation(params, config);
loadVnfData();
assertEquals(MY_VNF,
operation.getOpProperties()
- .convertToAaiProperties(operation)
- .get(GrpcOperationProperties.AAI_VNF_ID_KEY));
+ .convertToAaiProperties(operation)
+ .get(GrpcOperationProperties.AAI_VNF_ID_KEY));
params = params.toBuilder().targetEntityIds(null).build();
operation = new GrpcOperation(params, config);
assertThatIllegalStateException().isThrownBy(()
-> operation.getOpProperties()
- .convertToAaiProperties(operation)
- .get(GrpcOperationProperties.AAI_VNF_ID_KEY));
+ .convertToAaiProperties(operation)
+ .get(GrpcOperationProperties.AAI_VNF_ID_KEY));
operation.setProperty(OperationProperties.AAI_TARGET_ENTITY, MY_VNF);
assertEquals(MY_VNF,
- operation.getOpProperties()
- .convertToAaiProperties(operation)
- .get(GrpcOperationProperties.AAI_VNF_ID_KEY));
+ operation.getOpProperties()
+ .convertToAaiProperties(operation)
+ .get(GrpcOperationProperties.AAI_VNF_ID_KEY));
operation.setProperty(OperationProperties.AAI_TARGET_ENTITY, null);
}
@Test
- void testStartOperationAsync() {
+ void testStartOperationAsync() {
ControlLoopOperationParams clop =
- ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR)
- .operation(GrpcOperation.NAME)
- .requestId(REQUEST_ID)
- .actorService(new ActorService())
- .targetType(TargetType.VNF)
- .build();
+ ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR)
+ .operation(GrpcOperation.NAME)
+ .requestId(REQUEST_ID)
+ .actorService(new ActorService())
+ .targetType(TargetType.VNF)
+ .build();
verifyOperation(clop, () -> operation.setProperty(OperationProperties.AAI_TARGET_ENTITY, MY_VNF));
verifyOperation(clop.toBuilder().targetEntityIds(targetEntityIds).build(), this::loadVnfData);
* Tests startOperationAsync() when the target type is PNF.
*/
@Test
- void testStartOperationAsyncPnf() {
+ void testStartOperationAsyncPnf() {
ControlLoopOperationParams clop =
- ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR)
- .operation(GrpcOperation.NAME)
- .requestId(REQUEST_ID)
- .actorService(new ActorService())
- .targetType(TargetType.PNF)
- .build();
+ ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR)
+ .operation(GrpcOperation.NAME)
+ .requestId(REQUEST_ID)
+ .actorService(new ActorService())
+ .targetType(TargetType.PNF)
+ .build();
verifyOperation(clop, this::loadPnfData);
}
@Test
- void testStartOperationAsyncError() {
+ void testStartOperationAsyncError() {
operation = new GrpcOperation(params, config);
assertThatIllegalArgumentException()
- .isThrownBy(() -> operation.startOperationAsync(1, params.makeOutcome()));
+ .isThrownBy(() -> operation.startOperationAsync(1, params.makeOutcome()));
}
private void verifyOperation(ControlLoopOperationParams clop, Runnable loader) {
Map<String, Object> payloadMap = Map.of(CdsActorConstants.KEY_CBA_NAME, CDS_BLUEPRINT_NAME,
- CdsActorConstants.KEY_CBA_VERSION, CDS_BLUEPRINT_VERSION, "data",
- "{\"mapInfo\":{\"key\":\"val\"},\"arrayInfo\":[\"one\",\"two\"],\"paramInfo\":\"val\"}");
+ CdsActorConstants.KEY_CBA_VERSION, CDS_BLUEPRINT_VERSION, "data",
+ "{\"mapInfo\":{\"key\":\"val\"},\"arrayInfo\":[\"one\",\"two\"],\"paramInfo\":\"val\"}");
params = clop.toBuilder().payload(payloadMap).build();
- GrpcConfig config = new GrpcConfig(executor, cdsProps);
- operation = new GrpcOperation(params, config);
+ GrpcConfig grpcConfig = new GrpcConfig(executor, cdsProps);
+ operation = new GrpcOperation(params, grpcConfig);
assertEquals(1000, operation.getTimeoutMs(null));
assertEquals(1000, operation.getTimeoutMs(0));
assertEquals(2000, operation.getTimeoutMs(2));
* ONAP
* ================================================================================
* Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Consumer;
-import java.util.stream.Collectors;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.onap.policy.common.parameters.ObjectValidationResult;
service.getActors().stream()
.map(Actor::getName)
.sorted()
- .collect(Collectors.toList())
+ .toList()
.toString());
// @formatter:on
}
assertEquals("[actor A, actor B, actor C, actor D]",
service.getActorNames().stream()
.sorted()
- .collect(Collectors.toList())
+ .toList()
.toString());
// @formatter:on
}
/**
* Arranges for an actor to throw a validation exception when
- * {@link Actor#configure(Map)} is invoked.
+ * {@link Actor#configure(Object)} is invoked.
*
* @param actor actor of interest
*/
/**
* Arranges for an actor to throw a runtime exception when
- * {@link Actor#configure(Map)} is invoked.
+ * {@link Actor#configure(Object)} is invoked.
*
* @param actor actor of interest
*/
@Test
void testLoadActors() {
- ActorService service = new ActorService();
- assertFalse(service.getActors().isEmpty());
- assertNotNull(service.getActor(DummyActor.class.getSimpleName()));
+ ActorService actorService = new ActorService();
+ assertFalse(actorService.getActors().isEmpty());
+ assertNotNull(actorService.getActor(DummyActor.class.getSimpleName()));
}
/**
* ONAP
* ================================================================================
* Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
void testRunFunction() {
// no exception, no log
AtomicInteger count = new AtomicInteger();
- Util.runFunction(() -> count.incrementAndGet(), "no error");
+ Util.runFunction(count::incrementAndGet, "no error");
assertEquals(1, count.get());
assertEquals(0, appender.getExtracted().size());
* ONAP
* ================================================================================
* Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.util.Iterator;
import java.util.Map;
-import java.util.stream.Collectors;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.onap.policy.common.parameters.ObjectValidationResult;
* Initializes the fields, including a fully populated {@link #actor}.
*/
@BeforeEach
- void setUp() {
+ void setUp() {
oper1 = spy(new MyOper(OPER1));
oper2 = spy(new MyOper(OPER2));
oper3 = spy(new MyOper(OPER3));
}
@Test
- void testActorImpl_testGetName() {
+ void testActorImpl_testGetName() {
assertEquals(ACTOR_NAME, actor.getName());
assertEquals(4, actor.getOperationNames().size());
assertEquals(0, actor.getSequenceNumber());
}
@Test
- void testDoStart() {
+ void testDoStart() {
actor.configure(params);
assertEquals(4, actor.getOperationNames().size());
}
@Test
- void testDoStop() {
+ void testDoStop() {
actor.configure(params);
actor.start();
assertEquals(4, actor.getOperationNames().size());
}
@Test
- void testDoShutdown() {
+ void testDoShutdown() {
actor.configure(params);
actor.start();
assertEquals(4, actor.getOperationNames().size());
actor.getOperators().stream()
.map(Operator::getName)
.sorted()
- .collect(Collectors.toList())
+ .toList()
.toString());
// @formatter:on
}
assertEquals("[add, divide, multiply, subtract]",
actor.getOperationNames().stream()
.sorted()
- .collect(Collectors.toList())
+ .toList()
.toString());
// @formatter:on
}
/**
* Arranges for an operator to throw a validation exception when
- * {@link Operator#configure(Map)} is invoked.
+ * {@link Operator#configure(Object)} is invoked.
*
* @param oper operator of interest
*/
private void makeValidException(Operator oper) {
ParameterValidationRuntimeException ex = new ParameterValidationRuntimeException(
- new ObjectValidationResult(actor.getName(), null, ValidationStatus.INVALID, "null"));
+ new ObjectValidationResult(actor.getName(), null, ValidationStatus.INVALID, "null"));
doThrow(ex).when(oper).configure(any());
}
/**
* Arranges for an operator to throw a runtime exception when
- * {@link Operator#configure(Map)} is invoked.
+ * {@link Operator#configure(Object)} is invoked.
*
* @param oper operator of interest
*/
* @return a new actor
*/
private ActorImpl makeActor(Operator... operators) {
- ActorImpl actor = new ActorImpl(ACTOR_NAME);
+ ActorImpl actorImpl = new ActorImpl(ACTOR_NAME);
for (Operator oper : operators) {
- actor.addOperator(oper);
+ actorImpl.addOperator(oper);
}
- return actor;
+ return actorImpl;
}
private static class MyOper extends OperatorPartial {
* ONAP
* ================================================================================
* Copyright (C) 2020-2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertSame;
-import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
@Mock
private BidirectionalTopicOperation<String, Integer> operation;
- private List<SelectorKey> keys;
private BidirectionalTopicParams params;
private MyOperator oper;
*/
@BeforeEach
void setUp() {
- keys = List.of(new SelectorKey(""));
+ List<SelectorKey> keys = List.of(new SelectorKey(""));
Mockito.lenient().when(mgr.getTopicHandler(MY_SINK, MY_SOURCE)).thenReturn(handler);
Mockito.lenient().when(handler.addForwarder(keys)).thenReturn(forwarder);
// @formatter:off
OperationMaker<BidirectionalTopicConfig, BidirectionalTopicOperation<?, ?>> maker =
- (params, config) -> {
- paramsRef.set(params);
+ (operationParams, config) -> {
+ paramsRef.set(operationParams);
configRef.set(config);
return operation;
};
// with no operation-maker
BidirectionalTopicOperator oper3 =
- new BidirectionalTopicOperator(ACTOR, OPERATION, mgr, Arrays.asList(new SelectorKey("")));
+ new BidirectionalTopicOperator(ACTOR, OPERATION, mgr, List.of(new SelectorKey("")));
assertThatThrownBy(() -> oper3.buildOperation(params2)).isInstanceOf(UnsupportedOperationException.class);
}
* ONAP
* ================================================================================
* Copyright (C) 2020-2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation.
+ * Modifications Copyright (C) 2024-2025 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 PseudoExecutor executor;
private ControlLoopOperationParams params;
- private MyOper oper;
+ private MyOper myOperation;
private int numStart;
private int numEnd;
}
/**
- * Initializes the fields, including {@link #oper}.
+ * Initializes the fields, including {@link #myOperation}.
*/
@BeforeEach
void setUp() {
config = new OperatorConfig(executor);
- oper = new MyOper();
+ myOperation = new MyOper();
tstart = null;
@Test
void testOperatorPartial_testGetActorName_testGetName() {
- assertEquals(ACTOR, oper.getActorName());
- assertEquals(OPERATION, oper.getName());
- assertEquals(ACTOR + "." + OPERATION, oper.getFullName());
+ assertEquals(ACTOR, myOperation.getActorName());
+ assertEquals(OPERATION, myOperation.getName());
+ assertEquals(ACTOR + "." + OPERATION, myOperation.getFullName());
}
@Test
@Test
void testGetPropertyNames() {
- assertThat(oper.getPropertyNames()).isEqualTo(PROP_NAMES);
+ assertThat(myOperation.getPropertyNames()).isEqualTo(PROP_NAMES);
}
@Test
void testGetProperty_testSetProperty_testGetRequiredProperty() {
- oper.setProperty("propertyA", "valueA");
- oper.setProperty("propertyB", "valueB");
- oper.setProperty("propertyC", 20);
- oper.setProperty("propertyD", "valueD");
+ myOperation.setProperty("propertyA", "valueA");
+ myOperation.setProperty("propertyB", "valueB");
+ myOperation.setProperty("propertyC", 20);
+ myOperation.setProperty("propertyD", "valueD");
- assertEquals("valueA", oper.getProperty("propertyA"));
- assertEquals("valueB", oper.getProperty("propertyB"));
- assertEquals(Integer.valueOf(20), oper.getProperty("propertyC"));
+ assertEquals("valueA", myOperation.getProperty("propertyA"));
+ assertEquals("valueB", myOperation.getProperty("propertyB"));
+ assertEquals(Integer.valueOf(20), myOperation.getProperty("propertyC"));
- assertEquals("valueD", oper.getRequiredProperty("propertyD", "typeD"));
+ assertEquals("valueD", myOperation.getRequiredProperty("propertyD", "typeD"));
- assertThatIllegalStateException().isThrownBy(() -> oper.getRequiredProperty("propertyUnknown", "some type"))
- .withMessage("missing some type");
+ assertThatIllegalStateException().isThrownBy(() ->
+ myOperation.getRequiredProperty("propertyUnknown", "some type")).withMessage("missing some type");
}
@Test
@Test
void testStartMultiple() {
for (int count = 0; count < MAX_PARALLEL; ++count) {
- oper.start();
+ myOperation.start();
}
assertTrue(executor.runAll(MAX_REQUESTS * MAX_PARALLEL));
assertEquals(OperationResult.SUCCESS, opend.getResult());
assertEquals(MAX_PARALLEL, numStart);
- assertEquals(MAX_PARALLEL, oper.getCount());
+ assertEquals(MAX_PARALLEL, myOperation.getCount());
assertEquals(MAX_PARALLEL, numEnd);
}
@Test
void testStartOperationAsync() {
- oper.start();
+ myOperation.start();
assertTrue(executor.runAll(MAX_REQUESTS));
- assertEquals(1, oper.getCount());
+ assertEquals(1, myOperation.getCount());
}
@Test
void testIsSuccess() {
- assertFalse(oper.isSuccess(null));
+ assertFalse(myOperation.isSuccess(null));
OperationOutcome outcome = new OperationOutcome();
outcome.setResult(OperationResult.SUCCESS);
- assertTrue(oper.isSuccess(outcome));
+ assertTrue(myOperation.isSuccess(outcome));
for (OperationResult failure : FAILURE_RESULTS) {
outcome.setResult(failure);
- assertFalse(oper.isSuccess(outcome), "testIsSuccess-" + failure);
+ assertFalse(myOperation.isSuccess(outcome), "testIsSuccess-" + failure);
}
}
@Test
void testIsActorFailed() {
- assertFalse(oper.isActorFailed(null));
+ assertFalse(myOperation.isActorFailed(null));
OperationOutcome outcome = params.makeOutcome();
// incorrect outcome
outcome.setResult(OperationResult.SUCCESS);
- assertFalse(oper.isActorFailed(outcome));
+ assertFalse(myOperation.isActorFailed(outcome));
outcome.setResult(OperationResult.FAILURE_RETRIES);
- assertFalse(oper.isActorFailed(outcome));
+ assertFalse(myOperation.isActorFailed(outcome));
// correct outcome
outcome.setResult(OperationResult.FAILURE);
// incorrect actor
outcome.setActor(MY_SINK);
- assertFalse(oper.isActorFailed(outcome));
+ assertFalse(myOperation.isActorFailed(outcome));
outcome.setActor(null);
- assertFalse(oper.isActorFailed(outcome));
+ assertFalse(myOperation.isActorFailed(outcome));
outcome.setActor(ACTOR);
// incorrect operation
outcome.setOperation(MY_SINK);
- assertFalse(oper.isActorFailed(outcome));
+ assertFalse(myOperation.isActorFailed(outcome));
outcome.setOperation(null);
- assertFalse(oper.isActorFailed(outcome));
+ assertFalse(myOperation.isActorFailed(outcome));
outcome.setOperation(OPERATION);
// correct values
- assertTrue(oper.isActorFailed(outcome));
+ assertTrue(myOperation.isActorFailed(outcome));
}
@Test
params = params.toBuilder().executor(ForkJoinPool.commonPool()).build();
// trigger timeout very quickly
- oper = new MyOper() {
+ myOperation = new MyOper() {
@Override
protected long getTimeoutMs(Integer timeoutSec) {
return 1;
}
};
- assertEquals(OperationResult.FAILURE_TIMEOUT, oper.start().get().getResult());
+ assertEquals(OperationResult.FAILURE_TIMEOUT, myOperation.start().get().getResult());
}
/**
params = params.toBuilder().retry(0).build();
// new params, thus need a new operation
- oper = new MyOper();
+ myOperation = new MyOper();
- oper.setMaxFailures(10);
+ myOperation.setMaxFailures(10);
verifyRun("testSetRetryFlag_testRetryOnFailure_ZeroRetries", 1, 1, OperationResult.FAILURE);
}
params = params.toBuilder().retry(null).build();
// new params, thus need a new operation
- oper = new MyOper();
+ myOperation = new MyOper();
- oper.setMaxFailures(10);
+ myOperation.setMaxFailures(10);
verifyRun("testSetRetryFlag_testRetryOnFailure_NullRetries", 1, 1, OperationResult.FAILURE);
}
params = params.toBuilder().retry(maxRetries).build();
// new params, thus need a new operation
- oper = new MyOper();
+ myOperation = new MyOper();
- oper.setMaxFailures(10);
+ myOperation.setMaxFailures(10);
verifyRun("testSetRetryFlag_testRetryOnFailure_RetriesExhausted", maxRetries + 1, maxRetries + 1,
OperationResult.FAILURE_RETRIES);
params = params.toBuilder().retry(10).build();
// new params, thus need a new operation
- oper = new MyOper();
+ myOperation = new MyOper();
final int maxFailures = 3;
- oper.setMaxFailures(maxFailures);
+ myOperation.setMaxFailures(maxFailures);
verifyRun("testSetRetryFlag_testRetryOnFailure_SuccessAfterRetries", maxFailures + 1, maxFailures + 1,
OperationResult.SUCCESS);
void testSetRetryFlag_testRetryOnFailure_NullOutcome() {
// arrange to return null from doOperation()
- oper = new MyOper() {
+ myOperation = new MyOper() {
@Override
protected OperationOutcome doOperation(int attempt, OperationOutcome outcome) {
@Test
void testSleep() throws Exception {
- CompletableFuture<Void> future = oper.sleep(-1, TimeUnit.SECONDS);
+ CompletableFuture<Void> future = myOperation.sleep(-1, TimeUnit.SECONDS);
assertTrue(future.isDone());
assertNull(future.get());
// edge case
- future = oper.sleep(0, TimeUnit.SECONDS);
+ future = myOperation.sleep(0, TimeUnit.SECONDS);
assertTrue(future.isDone());
assertNull(future.get());
* Start a second sleep we can use to check the first while it's running.
*/
tstart = Instant.now();
- future = oper.sleep(100, TimeUnit.MILLISECONDS);
+ future = myOperation.sleep(100, TimeUnit.MILLISECONDS);
- CompletableFuture<Void> future2 = oper.sleep(10, TimeUnit.MILLISECONDS);
+ CompletableFuture<Void> future2 = myOperation.sleep(10, TimeUnit.MILLISECONDS);
// wait for second to complete and verify that the first has not completed
future2.get();
@Test
void testIsSameOperation() {
- assertFalse(oper.isSameOperation(null));
+ assertFalse(myOperation.isSameOperation(null));
OperationOutcome outcome = params.makeOutcome();
// wrong actor - should be false
outcome.setActor(null);
- assertFalse(oper.isSameOperation(outcome));
+ assertFalse(myOperation.isSameOperation(outcome));
outcome.setActor(MY_SINK);
- assertFalse(oper.isSameOperation(outcome));
+ assertFalse(myOperation.isSameOperation(outcome));
outcome.setActor(ACTOR);
// wrong operation - should be null
outcome.setOperation(null);
- assertFalse(oper.isSameOperation(outcome));
+ assertFalse(myOperation.isSameOperation(outcome));
outcome.setOperation(MY_SINK);
- assertFalse(oper.isSameOperation(outcome));
+ assertFalse(myOperation.isSameOperation(outcome));
outcome.setOperation(OPERATION);
- assertTrue(oper.isSameOperation(outcome));
+ assertTrue(myOperation.isSameOperation(outcome));
}
@Test
void testFromException() {
// arrange to generate an exception when operation runs
- oper.setGenException(true);
+ myOperation.setGenException(true);
verifyRun("testFromException", 1, 1, OperationResult.FAILURE_EXCEPTION);
}
final OperationOutcome outcome = params.makeOutcome();
tasks.add(() -> CompletableFuture.completedFuture(outcome));
- tasks.add(() -> new CompletableFuture<>());
+ tasks.add(CompletableFuture::new);
tasks.add(() -> null);
- tasks.add(() -> new CompletableFuture<>());
+ tasks.add(CompletableFuture::new);
- CompletableFuture<OperationOutcome> result = oper.anyOf(tasks);
+ CompletableFuture<OperationOutcome> result = myOperation.anyOf(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
assertSame(outcome, result.get());
// repeat using array form
@SuppressWarnings("unchecked")
Supplier<CompletableFuture<OperationOutcome>>[] taskArray = new Supplier[tasks.size()];
- result = oper.anyOf(tasks.toArray(taskArray));
+ result = myOperation.anyOf(tasks.toArray(taskArray));
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
assertSame(outcome, result.get());
// second task completes, others do not
tasks.clear();
- tasks.add(() -> new CompletableFuture<>());
+ tasks.add(CompletableFuture::new);
tasks.add(() -> CompletableFuture.completedFuture(outcome));
- tasks.add(() -> new CompletableFuture<>());
+ tasks.add(CompletableFuture::new);
- result = oper.anyOf(tasks);
+ result = myOperation.anyOf(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
assertSame(outcome, result.get());
// third task completes, others do not
tasks.clear();
- tasks.add(() -> new CompletableFuture<>());
- tasks.add(() -> new CompletableFuture<>());
+ tasks.add(CompletableFuture::new);
+ tasks.add(CompletableFuture::new);
tasks.add(() -> CompletableFuture.completedFuture(outcome));
- result = oper.anyOf(tasks);
+ result = myOperation.anyOf(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
assertSame(outcome, result.get());
List<Supplier<CompletableFuture<OperationOutcome>>> tasks = new LinkedList<>();
// zero items: check both using a list and using an array
- assertNull(oper.anyOf(tasks));
- assertNull(oper.anyOf());
+ assertNull(myOperation.anyOf(tasks));
+ assertNull(myOperation.anyOf());
// one item: : check both using a list and using an array
CompletableFuture<OperationOutcome> future1 = new CompletableFuture<>();
tasks.add(() -> future1);
- assertSame(future1, oper.anyOf(tasks));
- assertSame(future1, oper.anyOf(() -> future1));
+ assertSame(future1, myOperation.anyOf(tasks));
+ assertSame(future1, myOperation.anyOf(() -> future1));
}
@Test
@SuppressWarnings("unchecked")
CompletableFuture<OperationOutcome> result =
- oper.allOf(() -> future1, () -> future2, () -> null, () -> future3);
+ myOperation.allOf(() -> future1, () -> future2, () -> null, () -> future3);
assertTrue(executor.runAll(MAX_REQUESTS));
assertFalse(result.isDone());
tasks.add(() -> null);
tasks.add(() -> future3);
- CompletableFuture<OperationOutcome> result = oper.allOf(tasks);
+ CompletableFuture<OperationOutcome> result = myOperation.allOf(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertFalse(result.isDone());
List<Supplier<CompletableFuture<OperationOutcome>>> tasks = new LinkedList<>();
// zero items: check both using a list and using an array
- assertNull(oper.allOf(tasks));
- assertNull(oper.allOf());
+ assertNull(myOperation.allOf(tasks));
+ assertNull(myOperation.allOf());
// one item: : check both using a list and using an array
CompletableFuture<OperationOutcome> future1 = new CompletableFuture<>();
tasks.add(() -> future1);
- assertSame(future1, oper.allOf(tasks));
- assertSame(future1, oper.allOf(() -> future1));
+ assertSame(future1, myOperation.allOf(tasks));
+ assertSame(future1, myOperation.allOf(() -> future1));
}
@Test
});
tasks.add(() -> future3);
- assertThatIllegalStateException().isThrownBy(() -> oper.anyOf(tasks)).withMessage(EXPECTED_EXCEPTION);
+ assertThatIllegalStateException().isThrownBy(() -> myOperation.anyOf(tasks)).withMessage(EXPECTED_EXCEPTION);
// should have canceled the first two, but not the last
assertTrue(future1.isCancelled());
tasks.add(() -> CompletableFuture.completedFuture(params.makeOutcome()));
tasks.add(() -> CompletableFuture.completedFuture(null));
tasks.add(() -> CompletableFuture.completedFuture(params.makeOutcome()));
- CompletableFuture<OperationOutcome> result = oper.allOf(tasks);
+ CompletableFuture<OperationOutcome> result = myOperation.allOf(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
tasks.add(() -> CompletableFuture.completedFuture(params.makeOutcome()));
tasks.add(() -> CompletableFuture.failedFuture(except));
tasks.add(() -> CompletableFuture.completedFuture(params.makeOutcome()));
- result = oper.allOf(tasks);
+ result = myOperation.allOf(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isCompletedExceptionally());
tasks.add(() -> CompletableFuture.completedFuture(outcome));
tasks.add(() -> CompletableFuture.completedFuture(outcome));
- CompletableFuture<OperationOutcome> result = oper.sequence(tasks);
+ CompletableFuture<OperationOutcome> result = myOperation.sequence(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
assertSame(outcome, result.get());
// repeat using array form
@SuppressWarnings("unchecked")
Supplier<CompletableFuture<OperationOutcome>>[] taskArray = new Supplier[tasks.size()];
- result = oper.sequence(tasks.toArray(taskArray));
+ result = myOperation.sequence(tasks.toArray(taskArray));
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
assertSame(outcome, result.get());
tasks.add(() -> CompletableFuture.completedFuture(failure));
tasks.add(() -> CompletableFuture.completedFuture(outcome));
- result = oper.sequence(tasks);
+ result = myOperation.sequence(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
assertSame(failure, result.get());
List<Supplier<CompletableFuture<OperationOutcome>>> tasks = new LinkedList<>();
// zero items: check both using a list and using an array
- assertNull(oper.sequence(tasks));
- assertNull(oper.sequence());
+ assertNull(myOperation.sequence(tasks));
+ assertNull(myOperation.sequence());
// one item: : check both using a list and using an array
CompletableFuture<OperationOutcome> future1 = new CompletableFuture<>();
tasks.add(() -> future1);
- assertSame(future1, oper.sequence(tasks));
- assertSame(future1, oper.sequence(() -> future1));
+ assertSame(future1, myOperation.sequence(tasks));
+ assertSame(future1, myOperation.sequence(() -> future1));
}
private void verifyOutcomes(int expected, OperationResult... results) throws Exception {
}
}
- CompletableFuture<OperationOutcome> result = oper.allOf(tasks);
+ CompletableFuture<OperationOutcome> result = myOperation.allOf(tasks);
assertTrue(executor.runAll(MAX_REQUESTS));
assertTrue(result.isDone());
@Test
void testDetmPriority() throws CoderException {
- assertEquals(1, oper.detmPriority(null));
+ assertEquals(1, myOperation.detmPriority(null));
OperationOutcome outcome = params.makeOutcome();
for (Entry<OperationResult, Integer> ent : map.entrySet()) {
outcome.setResult(ent.getKey());
- assertEquals(ent.getValue().intValue(), oper.detmPriority(outcome), ent.getKey().toString());
+ assertEquals(ent.getValue().intValue(), myOperation.detmPriority(outcome), ent.getKey().toString());
}
/*
* won't allow it. Instead, we decode it from a structure.
*/
outcome = new StandardCoder().decode("{\"result\":null}", OperationOutcome.class);
- assertEquals(1, oper.detmPriority(outcome));
+ assertEquals(1, myOperation.detmPriority(outcome));
}
/**
* arrange to stop the controller when the start-callback is invoked, but capture
* the outcome
*/
- params = params.toBuilder().startCallback(oper -> {
- starter(oper);
+ params = params.toBuilder().startCallback(outcome -> {
+ starter(outcome);
future.get().cancel(false);
}).build();
// new params, thus need a new operation
- oper = new MyOper();
+ myOperation = new MyOper();
- future.set(oper.start());
+ future.set(myOperation.start());
assertTrue(executor.runAll(MAX_REQUESTS));
// should have only run once
AtomicReference<Future<OperationOutcome>> future = new AtomicReference<>();
// arrange to stop the controller when the start-callback is invoked
- params = params.toBuilder().startCallback(oper -> {
+ params = params.toBuilder().startCallback(outcome -> {
future.get().cancel(false);
}).build();
// new params, thus need a new operation
- oper = new MyOper();
+ myOperation = new MyOper();
- future.set(oper.start());
+ future.set(myOperation.start());
assertTrue(executor.runAll(MAX_REQUESTS));
// should not have been set
OperationOutcome outcome;
outcome = new OperationOutcome();
- oper.setOutcome(outcome, timex);
+ myOperation.setOutcome(outcome, timex);
assertEquals(ControlLoopOperation.FAILED_MSG, outcome.getMessage());
assertEquals(OperationResult.FAILURE_TIMEOUT, outcome.getResult());
outcome = new OperationOutcome();
- oper.setOutcome(outcome, new IllegalStateException(EXPECTED_EXCEPTION));
+ myOperation.setOutcome(outcome, new IllegalStateException(EXPECTED_EXCEPTION));
assertEquals(ControlLoopOperation.FAILED_MSG, outcome.getMessage());
assertEquals(OperationResult.FAILURE_EXCEPTION, outcome.getResult());
}
OperationOutcome outcome;
outcome = new OperationOutcome();
- oper.setOutcome(outcome, OperationResult.SUCCESS);
+ myOperation.setOutcome(outcome, OperationResult.SUCCESS);
assertEquals(ControlLoopOperation.SUCCESS_MSG, outcome.getMessage());
assertEquals(OperationResult.SUCCESS, outcome.getResult());
- oper.setOutcome(outcome, OperationResult.SUCCESS);
+ myOperation.setOutcome(outcome, OperationResult.SUCCESS);
assertEquals(ControlLoopOperation.SUCCESS_MSG, outcome.getMessage());
assertEquals(OperationResult.SUCCESS, outcome.getResult());
for (OperationResult result : FAILURE_RESULTS) {
outcome = new OperationOutcome();
- oper.setOutcome(outcome, result);
+ myOperation.setOutcome(outcome, result);
assertEquals(ControlLoopOperation.FAILED_MSG, outcome.getMessage(), result.toString());
assertEquals(result, outcome.getResult(), result.toString());
}
@Test
void testMakeOutcome() {
- oper.setProperty(OperationProperties.AAI_TARGET_ENTITY, MY_TARGET_ENTITY);
- assertEquals(MY_TARGET_ENTITY, oper.makeOutcome().getTarget());
+ myOperation.setProperty(OperationProperties.AAI_TARGET_ENTITY, MY_TARGET_ENTITY);
+ assertEquals(MY_TARGET_ENTITY, myOperation.makeOutcome().getTarget());
}
@Test
void testIsTimeout() {
final TimeoutException timex = new TimeoutException(EXPECTED_EXCEPTION);
- assertFalse(oper.isTimeout(new IllegalStateException(EXPECTED_EXCEPTION)));
- assertFalse(oper.isTimeout(new IllegalStateException(timex)));
- assertFalse(oper.isTimeout(new CompletionException(new IllegalStateException(timex))));
- assertFalse(oper.isTimeout(new CompletionException(null)));
- assertFalse(oper.isTimeout(new CompletionException(new CompletionException(timex))));
+ assertFalse(myOperation.isTimeout(new IllegalStateException(EXPECTED_EXCEPTION)));
+ assertFalse(myOperation.isTimeout(new IllegalStateException(timex)));
+ assertFalse(myOperation.isTimeout(new CompletionException(new IllegalStateException(timex))));
+ assertFalse(myOperation.isTimeout(new CompletionException(null)));
+ assertFalse(myOperation.isTimeout(new CompletionException(new CompletionException(timex))));
- assertTrue(oper.isTimeout(timex));
- assertTrue(oper.isTimeout(new CompletionException(timex)));
+ assertTrue(myOperation.isTimeout(timex));
+ assertTrue(myOperation.isTimeout(new CompletionException(timex)));
}
@Test
// log structured data
appender.clearExtractions();
- oper.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, new MyData());
+ myOperation.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, new MyData());
List<String> output = appender.getExtracted();
assertEquals(1, output.size());
// repeat with a response
appender.clearExtractions();
- oper.logMessage(EventType.IN, SOURCE_INFRA, MY_SOURCE, new MyData());
+ myOperation.logMessage(EventType.IN, SOURCE_INFRA, MY_SOURCE, new MyData());
output = appender.getExtracted();
assertEquals(1, output.size());
// log a plain string
appender.clearExtractions();
- oper.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, TEXT);
+ myOperation.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, TEXT);
output = appender.getExtracted();
assertEquals(1, output.size());
assertThat(output.get(0)).contains(infraStr).contains(MY_SINK).contains(TEXT);
// log a null request
appender.clearExtractions();
- oper.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, null);
+ myOperation.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, null);
output = appender.getExtracted();
assertEquals(1, output.size());
setOperCoderException();
appender.clearExtractions();
- oper.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, new MyData());
+ myOperation.logMessage(EventType.OUT, SINK_INFRA, MY_SINK, new MyData());
output = appender.getExtracted();
assertEquals(2, output.size());
assertThat(output.get(0)).contains("cannot pretty-print request");
// repeat with a response
appender.clearExtractions();
- oper.logMessage(EventType.IN, SOURCE_INFRA, MY_SOURCE, new MyData());
+ myOperation.logMessage(EventType.IN, SOURCE_INFRA, MY_SOURCE, new MyData());
output = appender.getExtracted();
assertEquals(2, output.size());
assertThat(output.get(0)).contains("cannot pretty-print response");
@Test
void testGetRetry() {
- assertEquals(0, oper.getRetry(null));
- assertEquals(10, oper.getRetry(10));
+ assertEquals(0, myOperation.getRetry(null));
+ assertEquals(10, myOperation.getRetry(10));
}
@Test
@Test
void testGetTimeOutMs() {
- assertEquals(TIMEOUT * 1000, oper.getTimeoutMs(params.getTimeoutSec()));
+ assertEquals(TIMEOUT * 1000, myOperation.getTimeoutMs(params.getTimeoutSec()));
params = params.toBuilder().timeoutSec(null).build();
// new params, thus need a new operation
- oper = new MyOper();
+ myOperation = new MyOper();
- assertEquals(0, oper.getTimeoutMs(params.getTimeoutSec()));
+ assertEquals(0, myOperation.getTimeoutMs(params.getTimeoutSec()));
}
private void starter(OperationOutcome oper) {
starts.clear();
ends.clear();
- CompletableFuture<OperationOutcome> future = oper.start();
+ CompletableFuture<OperationOutcome> future = myOperation.start();
manipulator.accept(future);
}
if (expectedOperations > 0) {
- assertNotNull(testName, oper.getSubRequestId());
- assertEquals(oper.getSubRequestId(), opstart.getSubRequestId(), testName + " op start");
- assertEquals(oper.getSubRequestId(), opend.getSubRequestId(), testName + " op end");
+ assertNotNull(testName, myOperation.getSubRequestId());
+ assertEquals(myOperation.getSubRequestId(), opstart.getSubRequestId(), testName + " op start");
+ assertEquals(myOperation.getSubRequestId(), opend.getSubRequestId(), testName + " op end");
}
}
- assertEquals(expectedOperations, oper.getCount(), testName);
+ assertEquals(expectedOperations, myOperation.getCount(), testName);
}
/**
- * Creates a new {@link #oper} whose coder will throw an exception.
+ * Creates a new {@link #myOperation} whose coder will throw an exception.
*/
private void setOperCoderException() {
- oper = new MyOper() {
+ myOperation = new MyOper() {
@Override
protected Coder getCoder() {
return new StandardCoder() {
@Getter
static class MyData {
- private String text = TEXT;
+ private final String text = TEXT;
}
* ONAP
* ================================================================================
* Copyright (C) 2020-2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
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.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
void testNewIncompleteFuture() {
PipelineControllerFuture<String> future = controller.newIncompleteFuture();
assertNotNull(future);
- assertTrue(future instanceof PipelineControllerFuture);
+ assertInstanceOf(PipelineControllerFuture.class, future);
assertNotSame(controller, future);
assertFalse(future.isDone());
}
verify(controller, never()).remove(compFuture);
compFuture.completeExceptionally(EXPECTED_EXCEPTION);
- assertThatThrownBy(() -> future.get()).hasCause(EXPECTED_EXCEPTION);
+ assertThatThrownBy(future::get).hasCause(EXPECTED_EXCEPTION);
verify(controller).remove(compFuture);
}
* ONAP
* ================================================================================
* Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
ControlLoopOperationParams params = ControlLoopOperationParams.builder().build();
PipelineUtil util = new PipelineUtil(params);
- assertThatThrownBy(() -> util.start()).isInstanceOf(UnsupportedOperationException.class);
+ assertThatThrownBy(util::start).isInstanceOf(UnsupportedOperationException.class);
}
}
* rest
* ================================================================================
* Copyright (C) 2017-2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2019-2020, 2023-2024 Nordix Foundation.
+ * Modifications Copyright (C) 2019-2020, 2023-2025 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
package org.onap.policy.rest;
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.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.DELETE;
/**
* Tear down server endpoint for the tests.
*
- * @throws Exception if there is a problem
*/
@AfterAll
public static void tearDown() {
}
@Test
- public void testGetUrlNull() {
+ void testGetUrlNull() {
RestManager mgr = new RestManager();
assertThrows(NullPointerException.class, () -> {
mgr.get(null, "user", null, null);
}
@Test
- public void testPutUrlNull() {
+ void testPutUrlNull() {
RestManager mgr = new RestManager();
assertThrows(NullPointerException.class, () -> {
mgr.put(null, "user", null, null, MediaType.TEXT_PLAIN, PAYLOAD);
}
@Test
- public void testPostUrlNull() {
+ void testPostUrlNull() {
RestManager mgr = new RestManager();
assertThrows(NullPointerException.class, () -> {
mgr.post(null, "user", null, null, MediaType.TEXT_PLAIN, PAYLOAD);
}
@Test
- public void testDeleteUrlNull() {
+ void testDeleteUrlNull() {
RestManager mgr = new RestManager();
assertThrows(NullPointerException.class, () -> {
mgr.delete(null, "user", null, null, null, null);
}
@Test
- public void testPatchUrlNull() {
+ void testPatchUrlNull() {
RestManager mgr = new RestManager();
assertThrows(NullPointerException.class, () -> {
mgr.patch(null, "user", null, null, PAYLOAD);
}
@Test
- public void testUsernameNull() {
+ void testUsernameNull() {
RestManager mgr = new RestManager();
Pair<Integer, String> result = mgr.get(getUri, null, null, null);
private void checkResult(Pair<Integer, String> result, String expectedText) {
assertEquals((Integer) 200, result.getLeft());
assertNotNull(result.getRight());
- assertTrue(result.getRight().length() > 0);
+ assertFalse(result.getRight().isEmpty());
assertEquals(expectedText, result.getRight());
}
@Test
- public void testUsernameEmpty() {
+ void testUsernameEmpty() {
RestManager mgr = new RestManager();
Pair<Integer, String> result = mgr.get(getUri, "", null, null);
}
@Test
- public void testGoodUrl() {
+ void testGoodUrl() {
RestManager mgr = new RestManager();
Pair<Integer, String> result = mgr.get(getUri, "user", null, null);
}
@Test
- public void testNoUrlParamUrl() {
+ void testNoUrlParamUrl() {
RestManager mgr = new RestManager();
Pair<Integer, String> result = mgr.get(baseUri + "RestTest/GetHello/", null, null, null);
}
@Test
- public void testNoQueryParamUrl() {
+ void testNoQueryParamUrl() {
RestManager mgr = new RestManager();
Pair<Integer, String> result = mgr.get(baseUri + "RestTest/GetHello/" + NAME_PARAM, null, null, null);
}
@Test
- public void testBadUrl() {
+ void testBadUrl() {
RestManager mgr = new RestManager();
Pair<Integer, String> result = mgr.get(baseUri + "NonExistant/URL/", null, null, null);
}
@Test
- public void testWrongUrl() {
+ void testWrongUrl() {
RestManager mgr = new RestManager();
Pair<Integer, String> result = mgr.get(deleteUri, null, null, null);
* sdnr
* ================================================================================
* Copyright (C) 2018 Wipro Limited Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2019, 2024 Nordix Foundation.
+ * Modifications Copyright (C) 2019, 2024-2025 Nordix Foundation.
* Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
*/
assertTrue(jsonRequest.contains("Action"));
- logger.debug("Request as JSON: " + jsonRequest + "\n\n");
+ logger.debug("Request as JSON: {} \n\n", jsonRequest);
}
@Test
assertNotNull(sdnrRequest.getAction());
assertEquals("ModifyConfig", sdnrRequest.getAction());
- logger.debug("Request as a Java Object: \n" + sdnrRequest.toString() + "\n\n");
+ logger.debug("Request as a Java Object:\n {} \n\n", sdnrRequest);
}
@Test
assertTrue(jsonResponse.contains("SubRequestID"));
assertTrue(jsonResponse.contains("Status"));
- logger.debug("Response as JSON: " + jsonResponse + "\n\n");
+ logger.debug("Response as JSON: {}\n\n", jsonResponse);
}
@Test
assertNotNull(sdnrResponse.getStatus());
assertEquals(400, sdnrResponse.getStatus().getCode());
- logger.debug("Response as a Java Object: \n" + sdnrResponse.toString() + "\n\n");
+ logger.debug("Response as a Java Object:\n {} \n\n", sdnrResponse);
}
}
* ================================================================================
* Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2020-2021 Bell Canada. All rights reserved.
- * Modifications Copyright (C) 2023-2024 Nordix Foundation.
+ * Modifications Copyright (C) 2023-2025 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import com.google.protobuf.TextFormat.ParseException;
import com.google.protobuf.util.JsonFormat;
import io.grpc.ManagedChannel;
import io.grpc.netty.NettyChannelBuilder;
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2024 Nordix Foundation.
+ * Copyright (C) 2021-2025 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
void testClean() {
audit.setUser(" user");
JpaPolicyAudit jpaAudit = new JpaPolicyAudit(audit);
- assertThatNoException().isThrownBy(() -> jpaAudit.clean());
+ assertThatNoException().isThrownBy(jpaAudit::clean);
assertEquals(USER, jpaAudit.getUserName());
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2023 Nordix Foundation.
+ * Copyright (C) 2019-2023, 2025 Nordix Foundation.
* Copyright (C) 2019, 2021 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2020, 2022 Bell Canada. All rights reserved.
* ================================================================================
* @author Chenfei Gao (cgao@research.att.com)
*/
public class DummyPolicyModelsProviderImpl implements PolicyModelsProvider {
+
+ private static final String TOSCA_POLICY_GET_RESPONSE_JSON = "dummyimpl/DummyToscaPolicyGetResponse.json";
+ private static final String POLICY_TYPE_DELETE_RESPONSE_JSON = "dummyimpl/DummyToscaPolicyTypeDeleteResponse.json";
+ private static final String SERVICE_TEMPLATE_DELETE_RESPONSE_JSON =
+ "dummyimpl/DummyToscaServiceTemplateDeleteResponse.json";
+ private static final String POLICY_TYPE_GET_RESPONSE_JSON = "dummyimpl/DummyToscaPolicyTypeGetResponse.json";
+ private static final String TOSCA_POLICY_DELETE_RESPONSE_JSON = "dummyimpl/DummyToscaPolicyDeleteResponse.json";
+ private static final String NODE_TEMPLATE_RESPONSE_JSON = "dummyimpl/DummyToscaNodeTemplateResponse.json";
+
/**
* Constructor that takes the parameters.
*
@Override
public ToscaServiceTemplate deleteServiceTemplate(@NonNull String name, @NonNull String version)
throws PfModelException {
- return getDummyResponse("dummyimpl/DummyToscaServiceTemplateDeleteResponse.json");
+ return getDummyResponse(SERVICE_TEMPLATE_DELETE_RESPONSE_JSON);
}
@Override
public ToscaServiceTemplate getPolicyTypes(final String name, final String version) {
- return getDummyResponse("dummyimpl/DummyToscaPolicyTypeGetResponse.json");
+ return getDummyResponse(POLICY_TYPE_GET_RESPONSE_JSON);
}
@Override
}
@Override
- public ToscaServiceTemplate getFilteredPolicyTypes(ToscaEntityFilter<ToscaPolicyType> filter) {
- return getDummyResponse("dummyimpl/DummyToscaPolicyTypeGetResponse.json");
+ public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull ToscaEntityFilter<ToscaPolicyType> filter) {
+ return getDummyResponse(POLICY_TYPE_GET_RESPONSE_JSON);
}
@Override
- public List<ToscaPolicyType> getFilteredPolicyTypeList(ToscaEntityFilter<ToscaPolicyType> filter) {
+ public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull ToscaEntityFilter<ToscaPolicyType> filter) {
return new ArrayList<>();
}
@Override
- public ToscaServiceTemplate createPolicyTypes(final ToscaServiceTemplate serviceTemplate) {
+ public ToscaServiceTemplate createPolicyTypes(final @NonNull ToscaServiceTemplate serviceTemplate) {
return serviceTemplate;
}
@Override
- public ToscaServiceTemplate updatePolicyTypes(final ToscaServiceTemplate serviceTemplate) {
+ public ToscaServiceTemplate updatePolicyTypes(final @NonNull ToscaServiceTemplate serviceTemplate) {
return serviceTemplate;
}
@Override
- public ToscaServiceTemplate deletePolicyType(final String name, final String version) {
- return getDummyResponse("dummyimpl/DummyToscaPolicyTypeDeleteResponse.json");
+ public ToscaServiceTemplate deletePolicyType(final @NonNull String name, final @NonNull String version) {
+ return getDummyResponse(POLICY_TYPE_DELETE_RESPONSE_JSON);
}
@Override
public ToscaServiceTemplate getPolicies(final String name, final String version) {
- return getDummyResponse("dummyimpl/DummyToscaPolicyGetResponse.json");
+ return getDummyResponse(TOSCA_POLICY_GET_RESPONSE_JSON);
}
@Override
}
@Override
- public ToscaServiceTemplate getFilteredPolicies(ToscaTypedEntityFilter<ToscaPolicy> filter) {
- return getDummyResponse("dummyimpl/DummyToscaPolicyGetResponse.json");
+ public ToscaServiceTemplate getFilteredPolicies(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter) {
+ return getDummyResponse(TOSCA_POLICY_GET_RESPONSE_JSON);
}
@Override
- public List<ToscaPolicy> getFilteredPolicyList(ToscaTypedEntityFilter<ToscaPolicy> filter) {
+ public List<ToscaPolicy> getFilteredPolicyList(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter) {
return new ArrayList<>();
}
@Override
- public ToscaServiceTemplate createPolicies(final ToscaServiceTemplate serviceTemplate) {
+ public ToscaServiceTemplate createPolicies(final @NonNull ToscaServiceTemplate serviceTemplate) {
return serviceTemplate;
}
@Override
- public ToscaServiceTemplate updatePolicies(final ToscaServiceTemplate serviceTemplate) {
+ public ToscaServiceTemplate updatePolicies(final @NonNull ToscaServiceTemplate serviceTemplate) {
return serviceTemplate;
}
@Override
- public ToscaServiceTemplate deletePolicy(final String name, final String version) {
- return getDummyResponse("dummyimpl/DummyToscaPolicyDeleteResponse.json");
+ public ToscaServiceTemplate deletePolicy(final @NonNull String name, final @NonNull String version) {
+ return getDummyResponse(TOSCA_POLICY_DELETE_RESPONSE_JSON);
}
@Override
public ToscaServiceTemplate createToscaNodeTemplates(@NonNull ToscaServiceTemplate serviceTemplate) {
- return getDummyNodeTemplateResponse("dummyimpl/DummyToscaNodeTemplateResponse.json");
+ return getDummyNodeTemplateResponse();
}
@Override
public ToscaServiceTemplate updateToscaNodeTemplates(@NonNull ToscaServiceTemplate serviceTemplate)
throws PfModelRuntimeException {
- return getDummyNodeTemplateResponse("dummyimpl/DummyToscaNodeTemplateResponse.json");
+ return getDummyNodeTemplateResponse();
}
@Override
public ToscaServiceTemplate deleteToscaNodeTemplate(@NonNull String name, @NonNull String version) {
- return getDummyNodeTemplateResponse("dummyimpl/DummyToscaNodeTemplateResponse.json");
+ return getDummyNodeTemplateResponse();
}
@Override
}
@Override
- public List<PdpGroup> getFilteredPdpGroups(PdpGroupFilter filter) {
+ public List<PdpGroup> getFilteredPdpGroups(@NonNull PdpGroupFilter filter) {
return new ArrayList<>();
}
@Override
- public List<PdpGroup> createPdpGroups(final List<PdpGroup> pdpGroups) {
+ public List<PdpGroup> createPdpGroups(final
@NonNull List<PdpGroup> pdpGroups) {
return new ArrayList<>();
}
@Override
- public List<PdpGroup> updatePdpGroups(final List<PdpGroup> pdpGroups) {
+ public List<PdpGroup> updatePdpGroups(final
@NonNull List<PdpGroup> pdpGroups) {
return new ArrayList<>();
}
@Override
- public void updatePdpSubGroup(final String pdpGroupName, final PdpSubGroup pdpSubGroup) {
+ public void updatePdpSubGroup(final @NonNull String pdpGroupName, final @NonNull PdpSubGroup pdpSubGroup) {
// Not implemented
}
@Override
- public void updatePdp(String pdpGroupName, String pdpSubGroup, Pdp pdp) {
+ public void updatePdp(@NonNull String pdpGroupName, @NonNull String pdpSubGroup, @NonNull Pdp pdp) {
// Not implemented
}
@Override
- public PdpGroup deletePdpGroup(final String name) {
+ public PdpGroup deletePdpGroup(final @NonNull String name) {
return null;
}
}
@Override
- public List<PdpPolicyStatus> getGroupPolicyStatus(String groupName) {
+ public List<PdpPolicyStatus> getGroupPolicyStatus(@NonNull String groupName) {
// Not implemented
return new ArrayList<>();
}
}
/**
- * Return a ToscaServicetemplate dummy response.
+ * Return a ToscaService template dummy response.
*
* @param fileName the file name containing the dummy response
* @return the ToscaServiceTemplate with the dummy response
/**
* Return a tosca node template dummy response.
*
- * @param fileName the file name containing the dummy response
* @return the service template with the dummy response
*/
- protected ToscaServiceTemplate getDummyNodeTemplateResponse(final String fileName) {
+ protected ToscaServiceTemplate getDummyNodeTemplateResponse() {
var standardCoder = new StandardCoder();
ToscaServiceTemplate serviceTemplate;
try {
serviceTemplate =
- standardCoder.decode(ResourceUtils.getResourceAsString(fileName), ToscaServiceTemplate.class);
+ standardCoder.decode(ResourceUtils.getResourceAsString(NODE_TEMPLATE_RESPONSE_JSON),
+ ToscaServiceTemplate.class);
if (serviceTemplate == null) {
throw new PfModelException(Response.Status.INTERNAL_SERVER_ERROR, "error reading specified file");
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2024 Nordix Foundation.
+ * Copyright (C) 2019-2025 Nordix Foundation.
* Modifications Copyright (C) 2019, 2021 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2020, 2022 Bell Canada. All rights reserved.
* ================================================================================
parameters.setDatabaseUrl("jdbc:dummy");
parameters.setPersistenceUnit("dummy");
- PolicyModelsProvider dummyProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
- return dummyProvider;
+ return new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2020-2021, 2023-2024 Nordix Foundation.
+ * Copyright (C) 2020-2021, 2023-2025 Nordix Foundation.
* Modifications Copyright (C) 2020 Bell Canada. All rights reserved.
* Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
.getTextFileAsString("src/test/resources/servicetemplates/MultipleRevisionServiceTemplate.yaml"),
ToscaServiceTemplate.class);
- assertThatCode(() -> {
- databaseProvider.createPolicies(serviceTemplate);
- }).doesNotThrowAnyException();
+ assertThatCode(() -> databaseProvider.createPolicies(serviceTemplate)).doesNotThrowAnyException();
ToscaServiceTemplate fetchedServiceTemplate = databaseProvider.getPolicies(null, null);
* ONAP Policy Model
* ================================================================================
* Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2019-2021, 2023 Nordix Foundation.
+ * Modifications Copyright (C) 2019-2021, 2023, 2025 Nordix Foundation.
* Modifications Copyright (C) 2022 Bell Canada. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
if (getMetadata().containsKey(METADATA_METADATA_SET_NAME_TAG)
&& getMetadata().containsKey(METADATA_METADATA_SET_VERSION_TAG)) {
getMetadata().put(METADATA_METADATA_SET_NAME_TAG, getMetadata().get(METADATA_METADATA_SET_NAME_TAG)
- .replaceAll("^\"|\"$", ""));
+ .replaceAll("^\"|\"$", "")); // NOSONAR operator precedence is explicit
getMetadata().put(METADATA_METADATA_SET_VERSION_TAG, getMetadata().get(METADATA_METADATA_SET_VERSION_TAG)
- .replaceAll("^\"|\"$", ""));
+ .replaceAll("^\"|\"$", "")); // NOSONAR operator precedence is explicit
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2021 Nordix Foundation.
+ * Copyright (C) 2019-2021, 2025 Nordix Foundation.
* Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2024 Nordix Foundation
* ================================================================================
};
// @formatter:on
- private static List<ToscaPolicyType> typeList = new ArrayList<>();
+ private static final List<ToscaPolicyType> typeList = new ArrayList<>();
/**
* Set up a Tosca Policy type list for filtering.
String yamlAsJsonString = new GsonBuilder().setPrettyPrinting().create().toJson(yamlObject);
ToscaServiceTemplate serviceTemplate =
- new StandardCoder().decode(yamlAsJsonString, ToscaServiceTemplate.class);
+ new StandardCoder().decode(yamlAsJsonString, ToscaServiceTemplate.class);
assertNotNull(serviceTemplate);
addPolicyTypes(serviceTemplate.getPolicyTypes());
}
for (ToscaPolicyType type : typeList) {
- LOGGER.info("using policy type-" + type.getName() + ":" + type.getVersion());
+ LOGGER.info("using policy type-{}:{}", type.getName(), type.getVersion());
}
}
@Test
void testFilterLatestVersion() {
ToscaEntityFilter<ToscaPolicyType> filter =
- ToscaEntityFilter.<ToscaPolicyType>builder().version(ToscaEntityFilter.LATEST_VERSION).build();
+ ToscaEntityFilter.<ToscaPolicyType>builder().version(ToscaEntityFilter.LATEST_VERSION).build();
List<ToscaPolicyType> filteredList = filter.filter(typeList);
assertEquals(19, filteredList.size());
@Test
void testFilterNameVersion() {
ToscaEntityFilter<ToscaPolicyType> filter =
- ToscaEntityFilter.<ToscaPolicyType>builder().name("onap.policies.Monitoring").build();
+ ToscaEntityFilter.<ToscaPolicyType>builder().name("onap.policies.Monitoring").build();
List<ToscaPolicyType> filteredList = filter.filter(typeList);
assertEquals(1, filteredList.size());
assertEquals(19, filteredList.size());
filter = ToscaEntityFilter.<ToscaPolicyType>builder().name("onap.policies.optimization.Vim_fit")
- .version(VERSION_000).build();
+ .version(VERSION_000).build();
filteredList = filter.filter(typeList);
assertEquals(0, filteredList.size());
filter = ToscaEntityFilter.<ToscaPolicyType>builder().name("onap.policies.optimization.Vim_fit")
- .version("0.0.1").build();
+ .version("0.0.1").build();
filteredList = filter.filter(typeList);
assertEquals(0, filteredList.size());
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2021 Nordix Foundation.
+ * Copyright (C) 2019-2021, 2025 Nordix Foundation.
* Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2024 Nordix Foundation
* ================================================================================
};
// @formatter:on
- private static List<ToscaPolicy> policyList = new ArrayList<>();
+ private static final List<ToscaPolicy> policyList = new ArrayList<>();
/**
* Set up a Tosca Policy type list for filtering.
}
for (ToscaPolicy policy : policyList) {
- LOGGER.info("using policy-" + policy.getName() + ":" + policy.getVersion() + ", type-" + policy.getType()
- + ":" + policy.getTypeVersion());
+ LOGGER.info("using policy-{}:{}, type-{}:{}", policy.getName(), policy.getVersion(),
+ policy.getType(), policy.getTypeVersion());
}
}
@Test
void testFilterLatestVersion() {
ToscaTypedEntityFilter<ToscaPolicy> filter =
- ToscaTypedEntityFilter.<ToscaPolicy>builder().version(ToscaTypedEntityFilter.LATEST_VERSION).build();
+ ToscaTypedEntityFilter.<ToscaPolicy>builder().version(ToscaTypedEntityFilter.LATEST_VERSION).build();
List<ToscaPolicy> filteredList = filter.filter(policyList);
assertEquals(22, filteredList.size());
// Change versions back
//
policyList.forEach(policy -> {
- if ("onap.vfirewall.tca".equals(policy.getName())) {
- policy.setVersion(VERSION_100);
- } else if ("operational.modifyconfig".equals(policy.getName())) {
+ if ("onap.vfirewall.tca".equals(policy.getName()) || "operational.modifyconfig".equals(policy.getName())) {
policy.setVersion(VERSION_100);
}
});
@Test
void testFilterNameVersion() {
ToscaTypedEntityFilter<ToscaPolicy> filter =
- ToscaTypedEntityFilter.<ToscaPolicy>builder().name("operational.modifyconfig").build();
+ ToscaTypedEntityFilter.<ToscaPolicy>builder().name("operational.modifyconfig").build();
List<ToscaPolicy> filteredList = filter.filter(policyList);
assertEquals(1, filteredList.size());
assertEquals(22, filteredList.size());
filter = ToscaTypedEntityFilter.<ToscaPolicy>builder().name("OSDF_CASABLANCA.SubscriberPolicy_v1")
- .version(VERSION_100).build();
+ .version(VERSION_100).build();
filteredList = filter.filter(policyList);
assertEquals(1, filteredList.size());
filter = ToscaTypedEntityFilter.<ToscaPolicy>builder().name("operational.modifyconfig").version(VERSION_100)
- .build();
+ .build();
filteredList = filter.filter(policyList);
assertEquals(1, filteredList.size());
}
void testFilterVersionPrefix() {
// null pattern
ToscaTypedEntityFilter<ToscaPolicy> filter =
- ToscaTypedEntityFilter.<ToscaPolicy>builder().versionPrefix(null).build();
+ ToscaTypedEntityFilter.<ToscaPolicy>builder().versionPrefix(null).build();
List<ToscaPolicy> filteredList = filter.filter(policyList);
assertEquals(22, filteredList.size());
@Test
void testFilterTypeVersion() {
ToscaTypedEntityFilter<ToscaPolicy> filter =
- ToscaTypedEntityFilter.<ToscaPolicy>builder().type("onap.policies.controlloop.Operational").build();
+ ToscaTypedEntityFilter.<ToscaPolicy>builder().type("onap.policies.controlloop.Operational").build();
List<ToscaPolicy> filteredList = filter.filter(policyList);
assertEquals(0, filteredList.size());
filter = ToscaTypedEntityFilter.<ToscaPolicy>builder().type("onap.policies.controlloop.operational.common.Apex")
- .build();
+ .build();
filteredList = filter.filter(policyList);
assertEquals(0, filteredList.size());
filter = ToscaTypedEntityFilter.<ToscaPolicy>builder()
- .type("onap.policies.controlloop.operational.common.Drools").build();
+ .type("onap.policies.controlloop.operational.common.Drools").build();
filteredList = filter.filter(policyList);
assertEquals(3, filteredList.size());
assertEquals(0, filteredList.size());
filter = ToscaTypedEntityFilter.<ToscaPolicy>builder().type("onap.policies.optimization.resource.HpaPolicy")
- .typeVersion(VERSION_100).build();
+ .typeVersion(VERSION_100).build();
filteredList = filter.filter(policyList);
assertEquals(2, filteredList.size());
filter = ToscaTypedEntityFilter.<ToscaPolicy>builder().type("onap.policies.controlloop.Operational")
- .typeVersion(VERSION_000).build();
+ .typeVersion(VERSION_000).build();
filteredList = filter.filter(policyList);
assertEquals(0, filteredList.size());
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2021, 2023-2024 Nordix Foundation.
+ * Copyright (C) 2019-2021, 2023-2025 Nordix Foundation.
* Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
ToscaDataType duplDataType = toscaServiceTemplatePolicyType.getDataTypes().values().iterator().next();
toscaServiceTemplatePolicyType.getDataTypes().put("DuplicateDataType", duplDataType);
- assertThatThrownBy(() -> {
- toscaServiceTemplatePolicyType.getDataTypesAsMap();
- }).hasMessageContaining("list of map of entities contains more than one entity with key");
+ assertThatThrownBy(toscaServiceTemplatePolicyType::getDataTypesAsMap)
+ .hasMessageContaining("list of map of entities contains more than one entity with key");
}
private void createPolicyTypes() throws CoderException, PfModelException {
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2021 Nordix Foundation.
+ * Copyright (C) 2019-2021, 2025 Nordix Foundation.
* Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2024 Nordix Foundation
* ================================================================================
private JpaToscaTimeInterval setUpJpaToscaTimeInterval(Instant startTime, Instant endTime) {
PfConceptKey ttiParentKey = new PfConceptKey("tParentKey", "0.0.1");
PfReferenceKey ttiKey = new PfReferenceKey(ttiParentKey, "trigger0");
- JpaToscaTimeInterval tti = new JpaToscaTimeInterval(ttiKey, startTime, endTime);
- return tti;
+ return new JpaToscaTimeInterval(ttiKey, startTime, endTime);
}
}
* ONAP
* ================================================================================
* Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2024 Nordix Foundation
+ * Modifications Copyright (C) 2024-2025 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import java.io.Serial;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
private static final PfReferenceKey REF_KEY2 = new PfReferenceKey(CONCEPT_KEY2);
private static final JpaToscaProperty JPA_PROP1 = new JpaToscaProperty(REF_KEY1);
private static final JpaToscaProperty JPA_PROP2 = new JpaToscaProperty(REF_KEY2);
- private static ToscaProperty PROP1;
- private static ToscaProperty PROP2;
+ private static ToscaProperty toscaPropertyOne;
+ private static ToscaProperty toscaPropertyTwo;
private static final String DESCRIPT1 = "description A";
private static final String DESCRIPT2 = "description B";
JPA_PROP1.setDescription(DESCRIPT1);
JPA_PROP2.setDescription(DESCRIPT2);
- PROP1 = JPA_PROP1.toAuthorative();
- PROP2 = JPA_PROP2.toAuthorative();
+ toscaPropertyOne = JPA_PROP1.toAuthorative();
+ toscaPropertyTwo = JPA_PROP2.toAuthorative();
}
@BeforeEach
MyTosca tosca = jpa.toAuthorative();
assertEquals(SOME_DESCRIPTION, tosca.getDescription());
- assertThat(tosca.getProperties()).isEqualTo(Map.of(KEY1, PROP1, KEY2, PROP2));
+ assertThat(tosca.getProperties()).isEqualTo(Map.of(KEY1, toscaPropertyOne, KEY2, toscaPropertyTwo));
}
@Test
assertEquals(SOME_DESCRIPTION, jpa.getDescription());
assertThat(jpa.getProperties()).isNull();
- tosca.setProperties(Map.of(KEY1, PROP1, KEY2, PROP2));
+ tosca.setProperties(Map.of(KEY1, toscaPropertyOne, KEY2, toscaPropertyTwo));
- JpaToscaProperty jpa1 = new JpaToscaProperty(PROP1);
+ JpaToscaProperty jpa1 = new JpaToscaProperty(toscaPropertyOne);
jpa1.setKey(new PfReferenceKey(jpa.getKey(), KEY1));
- JpaToscaProperty jpa2 = new JpaToscaProperty(PROP2);
+ JpaToscaProperty jpa2 = new JpaToscaProperty(toscaPropertyTwo);
jpa2.setKey(new PfReferenceKey(jpa.getKey(), KEY2));
jpa = new MyJpa();
tosca.setName("world");
tosca.setVersion("3.2.1");
tosca.setDescription(SOME_DESCRIPTION);
- tosca.setProperties(Map.of(KEY1, PROP1, KEY2, PROP2));
+ tosca.setProperties(Map.of(KEY1, toscaPropertyOne, KEY2, toscaPropertyTwo));
jpa = new MyJpa(tosca);
assertEquals(SOME_DESCRIPTION, jpa.getDescription());
- JpaToscaProperty jpa1 = new JpaToscaProperty(PROP1);
+ JpaToscaProperty jpa1 = new JpaToscaProperty(toscaPropertyOne);
jpa1.setKey(new PfReferenceKey(jpa.getKey(), KEY1));
- JpaToscaProperty jpa2 = new JpaToscaProperty(PROP2);
+ JpaToscaProperty jpa2 = new JpaToscaProperty(toscaPropertyTwo);
jpa2.setKey(new PfReferenceKey(jpa.getKey(), KEY2));
assertThat(jpa.getProperties()).isEqualTo(Map.of(KEY1, jpa1, KEY2, jpa2));
}
- private static class MyTosca extends ToscaWithToscaProperties {
+ protected static class MyTosca extends ToscaWithToscaProperties {
}
+ @Setter
+ @Getter
@NoArgsConstructor
protected static class MyJpa extends JpaToscaWithToscaProperties<MyTosca> {
+ @Serial
private static final long serialVersionUID = 1L;
@NotNull
- @Getter
- @Setter
private String text;
public MyJpa(MyJpa jpa) {
}
private static class MyJpa2 extends MyJpa {
+ @Serial
private static final long serialVersionUID = 1L;
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2021 Nordix Foundation.
+ * Copyright (C) 2019-2021, 2025 Nordix Foundation.
* Modifications Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2024 Nordix Foundation
* ================================================================================
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
jpaToscaServiceTemplate.getDataTypes().getConceptMap().put(new PfConceptKey(), null);
assertTrue(ToscaUtils.doDataTypesExist(jpaToscaServiceTemplate));
- assertEquals(null, ToscaUtils.checkDataTypesExist(jpaToscaServiceTemplate));
- assertThatCode(() -> {
- ToscaUtils.assertDataTypesExist(jpaToscaServiceTemplate);
- }).doesNotThrowAnyException();
+ assertNull(ToscaUtils.checkDataTypesExist(jpaToscaServiceTemplate));
+ assertThatCode(() -> ToscaUtils.assertDataTypesExist(jpaToscaServiceTemplate)).doesNotThrowAnyException();
}
jpaToscaServiceTemplate.getPolicyTypes().getConceptMap().put(new PfConceptKey(), null);
assertTrue(ToscaUtils.doPolicyTypesExist(jpaToscaServiceTemplate));
- assertEquals(null, ToscaUtils.checkPolicyTypesExist(jpaToscaServiceTemplate));
- assertThatCode(() -> {
- ToscaUtils.assertPolicyTypesExist(jpaToscaServiceTemplate);
- }).doesNotThrowAnyException();
+ assertNull(ToscaUtils.checkPolicyTypesExist(jpaToscaServiceTemplate));
+ assertThatCode(() -> ToscaUtils.assertPolicyTypesExist(jpaToscaServiceTemplate)).doesNotThrowAnyException();
}
@Test
jpaToscaServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().put(new PfConceptKey(), null);
assertTrue(ToscaUtils.doPoliciesExist(jpaToscaServiceTemplate));
- assertEquals(null, ToscaUtils.checkPoliciesExist(jpaToscaServiceTemplate));
- assertThatCode(() -> {
- ToscaUtils.assertPoliciesExist(jpaToscaServiceTemplate);
- }).doesNotThrowAnyException();
+ assertNull(ToscaUtils.checkPoliciesExist(jpaToscaServiceTemplate));
+ assertThatCode(() -> ToscaUtils.assertPoliciesExist(jpaToscaServiceTemplate)).doesNotThrowAnyException();
}
@Test
- void testGetentityTypeAncestors() {
+ void testGetEntityTypeAncestors() {
assertThatThrownBy(() -> {
ToscaUtils.getEntityTypeAncestors(null, null, null);
}).hasMessageMatching("entityTypes is marked .*on.*ull but is null");
dt1.setDerivedFrom(new PfConceptKey("tosca.datatyps.Root", PfKey.NULL_KEY_VERSION));
checkSingleEmptyEntityTypeAncestor(dataTypes, dt0, result);
- checkMultipleEmptyEntityTypeAncestors(dataTypes, dt1, dt2, result, 1, 0);
+ checkMultipleEmptyEntityTypeAncestors(dataTypes, dt1, dt2, result);
dataTypes.getConceptMap().remove(dt1.getKey());
assertThat(ToscaUtils.getEntityTypeAncestors(dataTypes, dt2, result)).isEmpty();
}
private void checkMultipleEmptyEntityTypeAncestors(JpaToscaDataTypes dataTypes, JpaToscaDataType emptydt,
- JpaToscaDataType notemptydt, BeanValidationResult result, int size1, int size2) {
+ JpaToscaDataType notemptydt, BeanValidationResult result) {
assertThat(ToscaUtils.getEntityTypeAncestors(dataTypes, emptydt, result)).isEmpty();
assertFalse(ToscaUtils.getEntityTypeAncestors(dataTypes, notemptydt, result).isEmpty());
- assertEquals(size1, ToscaUtils.getEntityTypeAncestors(dataTypes, notemptydt, result).size());
- assertEquals(size2, ToscaUtils.getEntityTypeAncestors(dataTypes, emptydt, result).size());
+ assertEquals(1, ToscaUtils.getEntityTypeAncestors(dataTypes, notemptydt, result).size());
+ assertEquals(0, ToscaUtils.getEntityTypeAncestors(dataTypes, emptydt, result).size());
assertTrue(result.isValid());
}
}
@Test
- void testgetEntityTree() {
+ void testGetEntityTree() {
assertThatThrownBy(() -> {
ToscaUtils.getEntityTree(null, null, null);
}).hasMessageMatching("entityTypes is marked .*on.*ull but is null");
assertEquals(3, filteredDataTypes.getConceptMap().size());
dt9.setDerivedFrom(new PfConceptKey("i.dont.Exist", "0.0.0"));
- filteredDataTypes = new JpaToscaDataTypes(dataTypes);
assertThatThrownBy(() -> {
final JpaToscaDataTypes badDataTypes = new JpaToscaDataTypes(dataTypes);
Code Review / policy / models.git / commitdiff