import org.oransc.policyagent.clients.AsyncRestClient;
import org.oransc.policyagent.configuration.ApplicationConfig;
import org.oransc.policyagent.configuration.ImmutableRicConfig;
+import org.oransc.policyagent.configuration.ImmutableWebClientConfig;
import org.oransc.policyagent.configuration.RicConfig;
+import org.oransc.policyagent.configuration.WebClientConfig;
import org.oransc.policyagent.controllers.PolicyInfo;
import org.oransc.policyagent.controllers.ServiceRegistrationInfo;
import org.oransc.policyagent.controllers.ServiceStatus;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.context.TestConfiguration;
+import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.LocalServerPort;
+import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
+import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.web.reactive.function.client.WebClientResponseException;
@ExtendWith(SpringExtension.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
-public class ApplicationTest {
+@TestPropertySource(
+ properties = { //
+ "server.ssl.key-store=./config/keystore.jks", //
+ "app.webclient.trust-store=./config/truststore.jks"})
+class ApplicationTest {
private static final Logger logger = LoggerFactory.getLogger(ApplicationTest.class);
@Autowired
@Autowired
RicSupervision supervision;
+ @Autowired
+ ApplicationConfig applicationConfig;
+
@Autowired
Services services;
Duration checkInterval = Duration.ofMillis(1);
return new ServiceSupervision(this.services, this.policies, this.getA1ClientFactory(), checkInterval);
}
+
+ @Bean
+ public ServletWebServerFactory servletContainer() {
+ return new TomcatServletWebServerFactory();
+ }
+
}
@LocalServerPort
private int port;
@BeforeEach
- public void reset() {
+ void reset() {
rics.clear();
policies.clear();
policyTypes.clear();
}
@AfterEach
- public void verifyNoRicLocks() {
+ void verifyNoRicLocks() {
for (Ric ric : this.rics.getRics()) {
ric.getLock().lockBlocking(LockType.EXCLUSIVE);
ric.getLock().unlockBlocking();
- assertThat(ric.getLock().getLockCounter()).isEqualTo(0);
+ assertThat(ric.getLock().getLockCounter()).isZero();
assertThat(ric.getState()).isEqualTo(Ric.RicState.AVAILABLE);
}
}
@Test
- public void testGetRics() throws Exception {
+ void testGetRics() throws Exception {
addRic("ric1");
this.addPolicyType("type1", "ric1");
String url = "/rics?policyType=type1";
addRic("ric2");
this.addPolicyType("", "ric2");
url = "/rics?policyType=";
- rsp = restClient().get(url).block();
- assertThat(rsp).contains("ric2");
- assertThat(rsp).doesNotContain("ric1");
- assertThat(rsp).contains("AVAILABLE");
+
+ // This tests also validation of trusted certs restClient(true)
+ rsp = restClient(true).get(url).block();
+ assertThat(rsp).contains("ric2") //
+ .doesNotContain("ric1") //
+ .contains("AVAILABLE");
// All RICs
rsp = restClient().get("/rics").block();
- assertThat(rsp).contains("ric2");
- assertThat(rsp).contains("ric1");
+ assertThat(rsp).contains("ric2") //
+ .contains("ric1");
// Non existing policy type
url = "/rics?policyType=XXXX";
}
@Test
- public void testSynchronization() throws Exception {
+ void testSynchronization() throws Exception {
// Two polictypes will be put in the NearRT RICs
PolicyTypes nearRtRicPolicyTypes = new PolicyTypes();
nearRtRicPolicyTypes.put(createPolicyType("typeName"));
assertThat(ricPolicy.json()).isEqualTo(policy.json());
// Both types should be in the agent storage after the synch
- assertThat(ric1.getSupportedPolicyTypes().size()).isEqualTo(2);
- assertThat(ric2.getSupportedPolicyTypes().size()).isEqualTo(2);
+ assertThat(ric1.getSupportedPolicyTypes()).hasSize(2);
+ assertThat(ric2.getSupportedPolicyTypes()).hasSize(2);
}
@Test
- public void testGetRicForManagedElement_thenReturnCorrectRic() throws Exception {
+ void testGetRicForManagedElement_thenReturnCorrectRic() throws Exception {
String ricName = "ric1";
String managedElementId = "kista_1";
addRic(ricName, managedElementId);
testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
- private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId) {
+ private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId,
+ boolean isTransient) {
+ String url;
if (policyTypeName.isEmpty()) {
- return "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
+ url = "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
} else {
- return "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ url = "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ policyTypeName;
}
+ if (isTransient) {
+ url += "&transient=true";
+ }
+ return url;
+ }
+
+ private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId) {
+ return putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId, false);
}
@Test
- public void testPutPolicy() throws Exception {
+ void testPutPolicy() throws Exception {
String serviceName = "service1";
String ricName = "ric1";
String policyTypeName = "type1";
putService(serviceName);
addPolicyType(policyTypeName, ricName);
- String url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
+ // PUT a transient policy
+ String url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId, true);
final String policyBody = jsonString();
this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
assertThat(policy.id()).isEqualTo(policyInstanceId);
assertThat(policy.ownerServiceName()).isEqualTo(serviceName);
assertThat(policy.ric().name()).isEqualTo("ric1");
+ assertThat(policy.isTransient()).isTrue();
+
+ // Put a non transient policy
+ url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
+ restClient().put(url, policyBody).block();
+ policy = policies.getPolicy(policyInstanceId);
+ assertThat(policy.isTransient()).isFalse();
url = "/policies";
String rsp = restClient().get(url).block();
- assertThat(rsp.contains(policyInstanceId)).isTrue();
+ assertThat(rsp).as("Response contains policy instance ID.").contains(policyInstanceId);
+
+ url = "/policy?id=" + policyInstanceId;
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(policyBody);
// Test of error codes
url = putPolicyUrl(serviceName, ricName + "XX", policyTypeName, policyInstanceId);
testErrorCode(restClient().put(url, policyBody), HttpStatus.NOT_FOUND);
url = putPolicyUrl(serviceName, ricName, policyTypeName + "XX", policyInstanceId);
+ addPolicyType(policyTypeName + "XX", "otherRic");
testErrorCode(restClient().put(url, policyBody), HttpStatus.NOT_FOUND);
url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
@Test
/**
- * Test that HttpStatus and body from failing REST call to A1 is passed on to
- * the caller.
+ * Test that HttpStatus and body from failing REST call to A1 is passed on to the caller.
*
* @throws ServiceException
*/
- public void testErrorFromRIC() throws ServiceException {
+ void testErrorFromRic() throws ServiceException {
putService("service1");
addPolicyType("type1", "ric1");
}
@Test
- public void testPutTypelessPolicy() throws Exception {
+ void testPutTypelessPolicy() throws Exception {
putService("service1");
addPolicyType("", "ric1");
String url = putPolicyUrl("service1", "ric1", "", "id1");
String rsp = restClient().get("/policies").block();
List<PolicyInfo> info = parseList(rsp, PolicyInfo.class);
- assertThat(info).size().isEqualTo(1);
+ assertThat(info).hasSize(1);
PolicyInfo policyInfo = info.get(0);
- assertThat(policyInfo.id.equals("id1")).isTrue();
- assertThat(policyInfo.type.equals("")).isTrue();
+ assertThat(policyInfo.id).isEqualTo("id1");
+ assertThat(policyInfo.type).isEmpty();
}
@Test
- public void testRefuseToUpdatePolicy() throws Exception {
+ void testRefuseToUpdatePolicy() throws Exception {
// Test that only the json can be changed for a already created policy
// In this case service is attempted to be changed
this.addRic("ric1");
}
@Test
- public void testGetPolicy() throws Exception {
+ void testGetPolicy() throws Exception {
String url = "/policy?id=id";
Policy policy = addPolicy("id", "typeName", "service1", "ric1");
{
}
@Test
- public void testDeletePolicy() throws Exception {
+ void testDeletePolicy() throws Exception {
addPolicy("id", "typeName", "service1", "ric1");
assertThat(policies.size()).isEqualTo(1);
ResponseEntity<String> entity = restClient().deleteForEntity(url).block();
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
- assertThat(policies.size()).isEqualTo(0);
+ assertThat(policies.size()).isZero();
// Delete a non existing policy
testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
@Test
- public void testGetPolicySchemas() throws Exception {
+ void testGetPolicySchemas() throws Exception {
addPolicyType("type1", "ric1");
addPolicyType("type2", "ric2");
String url = "/policy_schemas";
String rsp = this.restClient().get(url).block();
- assertThat(rsp).contains("type1");
- assertThat(rsp).contains("[{\"title\":\"type2\"}");
+ assertThat(rsp).contains("type1") //
+ .contains("[{\"title\":\"type2\"}");
List<String> info = parseSchemas(rsp);
- assertThat(info.size()).isEqualTo(2);
+ assertThat(info).hasSize(2);
url = "/policy_schemas?ric=ric1";
rsp = restClient().get(url).block();
assertThat(rsp).contains("type1");
info = parseSchemas(rsp);
- assertThat(info.size()).isEqualTo(1);
+ assertThat(info).hasSize(1);
// Get schema for non existing RIC
url = "/policy_schemas?ric=ric1XXX";
}
@Test
- public void testGetPolicySchema() throws Exception {
+ void testGetPolicySchema() throws Exception {
addPolicyType("type1", "ric1");
addPolicyType("type2", "ric2");
String url = "/policy_schema?id=type1";
String rsp = restClient().get(url).block();
logger.info(rsp);
- assertThat(rsp).contains("type1");
- assertThat(rsp).contains("title");
+ assertThat(rsp).contains("type1") //
+ .contains("title");
// Get non existing schema
url = "/policy_schema?id=type1XX";
}
@Test
- public void testGetPolicyTypes() throws Exception {
+ void testGetPolicyTypes() throws Exception {
addPolicyType("type1", "ric1");
addPolicyType("type2", "ric2");
}
@Test
- public void testGetPolicies() throws Exception {
+ void testGetPolicies() throws Exception {
addPolicy("id1", "type1", "service1");
String url = "/policies";
String rsp = restClient().get(url).block();
logger.info(rsp);
List<PolicyInfo> info = parseList(rsp, PolicyInfo.class);
- assertThat(info).size().isEqualTo(1);
+ assertThat(info).hasSize(1);
PolicyInfo policyInfo = info.get(0);
assert (policyInfo.validate());
assertThat(policyInfo.id).isEqualTo("id1");
}
@Test
- public void testGetPoliciesFilter() throws Exception {
+ void testGetPoliciesFilter() throws Exception {
addPolicy("id1", "type1", "service1");
addPolicy("id2", "type1", "service2");
addPolicy("id3", "type2", "service1");
String url = "/policies?type=type1";
String rsp = restClient().get(url).block();
logger.info(rsp);
- assertThat(rsp).contains("id1");
- assertThat(rsp).contains("id2");
- assertThat(rsp.contains("id3")).isFalse();
+ assertThat(rsp).contains("id1") //
+ .contains("id2") //
+ .doesNotContain("id3");
url = "/policies?type=type1&service=service2";
rsp = restClient().get(url).block();
logger.info(rsp);
- assertThat(rsp.contains("id1")).isFalse();
- assertThat(rsp).contains("id2");
- assertThat(rsp.contains("id3")).isFalse();
+ assertThat(rsp).doesNotContain("id1") //
+ .contains("id2") //
+ .doesNotContain("id3");
// Test get policies for non existing type
url = "/policies?type=type1XXX";
}
@Test
- public void testGetPolicyIdsFilter() throws Exception {
+ void testGetPolicyIdsFilter() throws Exception {
addPolicy("id1", "type1", "service1", "ric1");
addPolicy("id2", "type1", "service2", "ric1");
addPolicy("id3", "type2", "service1", "ric1");
String url = "/policy_ids?type=type1";
String rsp = restClient().get(url).block();
logger.info(rsp);
- assertThat(rsp).contains("id1");
- assertThat(rsp).contains("id2");
- assertThat(rsp.contains("id3")).isFalse();
+ assertThat(rsp).contains("id1") //
+ .contains("id2") //
+ .doesNotContain("id3");
url = "/policy_ids?type=type1&service=service1&ric=ric1";
rsp = restClient().get(url).block();
}
@Test
- public void testPutAndGetService() throws Exception {
+ void testPutAndGetService() throws Exception {
// PUT
- putService("name", 0, HttpStatus.CREATED);
- putService("name", 0, HttpStatus.OK);
+ String serviceName = "name";
+ putService(serviceName, 0, HttpStatus.CREATED);
+ putService(serviceName, 0, HttpStatus.OK);
// GET one service
String url = "/services?name=name";
String rsp = restClient().get(url).block();
List<ServiceStatus> info = parseList(rsp, ServiceStatus.class);
- assertThat(info.size()).isEqualTo(1);
+ assertThat(info).hasSize(1);
ServiceStatus status = info.iterator().next();
- assertThat(status.keepAliveIntervalSeconds).isEqualTo(0);
- assertThat(status.serviceName).isEqualTo("name");
+ assertThat(status.keepAliveIntervalSeconds).isZero();
+ assertThat(status.serviceName).isEqualTo(serviceName);
// GET (all)
url = "/services";
rsp = restClient().get(url).block();
- assertThat(rsp.contains("name")).isTrue();
+ assertThat(rsp).as("Response contains service name").contains(serviceName);
logger.info(rsp);
// Keep alive
assertThat(services.size()).isEqualTo(1);
url = "/services?name=name";
restClient().delete(url).block();
- assertThat(services.size()).isEqualTo(0);
+ assertThat(services.size()).isZero();
- // Keep alive, no registerred service
+ // Keep alive, no registered service
testErrorCode(restClient().put("/services/keepalive?name=name", ""), HttpStatus.NOT_FOUND);
// PUT servive with bad payload
testErrorCode(restClient().put("/service", "crap"), HttpStatus.BAD_REQUEST);
testErrorCode(restClient().put("/service", "{}"), HttpStatus.BAD_REQUEST);
- testErrorCode(restClient().put("/service", createServiceJson("name", -123)), HttpStatus.BAD_REQUEST);
- testErrorCode(restClient().put("/service", createServiceJson("name", 0, "missing.portandprotocol.com")),
+ testErrorCode(restClient().put("/service", createServiceJson(serviceName, -123)), HttpStatus.BAD_REQUEST);
+ testErrorCode(restClient().put("/service", createServiceJson(serviceName, 0, "missing.portandprotocol.com")),
HttpStatus.BAD_REQUEST);
- // GET non existing servive
+ // GET non existing service
testErrorCode(restClient().get("/services?name=XXX"), HttpStatus.NOT_FOUND);
}
@Test
- public void testServiceSupervision() throws Exception {
+ void testServiceSupervision() throws Exception {
putService("service1", 1, HttpStatus.CREATED);
addPolicyType("type1", "ric1");
assertThat(services.size()).isEqualTo(1);
// Timeout after ~1 second
- await().untilAsserted(() -> assertThat(policies.size()).isEqualTo(0));
- assertThat(services.size()).isEqualTo(0);
+ await().untilAsserted(() -> assertThat(policies.size()).isZero());
+ assertThat(services.size()).isZero();
}
@Test
- public void testGetPolicyStatus() throws Exception {
+ void testGetPolicyStatus() throws Exception {
addPolicy("id", "typeName", "service1", "ric1");
assertThat(policies.size()).isEqualTo(1);
String url = "/policy_status?id=id";
String rsp = restClient().get(url).block();
- assertThat(rsp.equals("OK")).isTrue();
+ assertThat(rsp).isEqualTo("OK");
// GET non existing policy status
url = "/policy_status?id=XXX";
private Policy addPolicy(String id, String typeName, String service, String ric) throws ServiceException {
addRic(ric);
- Policy p = ImmutablePolicy.builder().id(id) //
+ Policy policy = ImmutablePolicy.builder() //
+ .id(id) //
.json(jsonString()) //
.ownerServiceName(service) //
.ric(rics.getRic(ric)) //
.type(addPolicyType(typeName, ric)) //
- .lastModified("lastModified").build();
- policies.put(p);
- return p;
+ .lastModified("lastModified") //
+ .isTransient(false) //
+ .build();
+ policies.put(policy);
+ return policy;
}
private Policy addPolicy(String id, String typeName, String service) throws ServiceException {
}
private String baseUrl() {
- return "http://localhost:" + port;
+ return "https://localhost:" + port;
}
private String jsonString() {
- return "{\n \"servingCellNrcgi\": \"1\"\n }";
+ return "{\"servingCellNrcgi\":\"1\"}";
}
@Test
- public void testConcurrency() throws Exception {
+ void testConcurrency() throws Exception {
final Instant startTime = Instant.now();
List<Thread> threads = new ArrayList<>();
a1ClientFactory.setResponseDelay(Duration.ofMillis(1));
addPolicyType("type1", "ric");
addPolicyType("type2", "ric");
- for (int i = 0; i < 100; ++i) {
- Thread t =
+ for (int i = 0; i < 10; ++i) {
+ Thread thread =
new Thread(new ConcurrencyTestRunnable(baseUrl(), supervision, a1ClientFactory, rics, policyTypes),
"TestThread_" + i);
- t.start();
- threads.add(t);
+ thread.start();
+ threads.add(thread);
}
for (Thread t : threads) {
t.join();
}
- assertThat(policies.size()).isEqualTo(0);
+ assertThat(policies.size()).isZero();
logger.info("Concurrency test took " + Duration.between(startTime, Instant.now()));
}
+ private AsyncRestClient restClient(boolean useTrustValidation) {
+ WebClientConfig config = this.applicationConfig.getWebClientConfig();
+ config = ImmutableWebClientConfig.builder() //
+ .keyStoreType(config.keyStoreType()) //
+ .keyStorePassword(config.keyStorePassword()) //
+ .keyStore(config.keyStore()) //
+ .keyPassword(config.keyPassword()) //
+ .isTrustStoreUsed(useTrustValidation) //
+ .trustStore(config.trustStore()) //
+ .trustStorePassword(config.trustStorePassword()) //
+ .build();
+
+ return new AsyncRestClient(baseUrl(), config);
+ }
+
private AsyncRestClient restClient() {
- return new AsyncRestClient(baseUrl());
+ return restClient(false);
}
private void testErrorCode(Mono<?> request, HttpStatus expStatus) {
.verify();
}
- private boolean checkWebClientError(Throwable t, HttpStatus expStatus, String responseContains) {
- assertTrue(t instanceof WebClientResponseException);
- WebClientResponseException e = (WebClientResponseException) t;
- assertThat(e.getStatusCode()).isEqualTo(expStatus);
- assertThat(e.getResponseBodyAsString()).contains(responseContains);
+ private boolean checkWebClientError(Throwable throwable, HttpStatus expStatus, String responseContains) {
+ assertTrue(throwable instanceof WebClientResponseException);
+ WebClientResponseException responseException = (WebClientResponseException) throwable;
+ assertThat(responseException.getStatusCode()).isEqualTo(expStatus);
+ assertThat(responseException.getResponseBodyAsString()).contains(responseContains);
return true;
}
List<T> result = new ArrayList<>();
JsonArray jsonArr = JsonParser.parseString(jsonString).getAsJsonArray();
for (JsonElement jsonElement : jsonArr) {
- T o = gson.fromJson(jsonElement.toString(), clazz);
- result.add(o);
+ T json = gson.fromJson(jsonElement.toString(), clazz);
+ result.add(json);
}
return result;
}
Code Review / nonrtric.git / blobdiff