package org.oransc.policyagent;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.awaitility.Awaitility.await;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
-import java.util.Vector;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.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.controllers.ImmutableServiceRegistrationInfo;
-import org.oransc.policyagent.controllers.ImmutableServiceStatus;
+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.oransc.policyagent.exceptions.ServiceException;
import org.oransc.policyagent.repository.ImmutablePolicy;
import org.oransc.policyagent.repository.ImmutablePolicyType;
+import org.oransc.policyagent.repository.Lock.LockType;
import org.oransc.policyagent.repository.Policies;
import org.oransc.policyagent.repository.Policy;
import org.oransc.policyagent.repository.PolicyType;
import org.oransc.policyagent.repository.PolicyTypes;
import org.oransc.policyagent.repository.Ric;
+import org.oransc.policyagent.repository.Ric.RicState;
import org.oransc.policyagent.repository.Rics;
import org.oransc.policyagent.repository.Services;
-import org.oransc.policyagent.tasks.RepositorySupervision;
+import org.oransc.policyagent.tasks.RicSupervision;
+import org.oransc.policyagent.tasks.ServiceSupervision;
import org.oransc.policyagent.utils.MockA1Client;
import org.oransc.policyagent.utils.MockA1ClientFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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.client.RestTemplate;
+import org.springframework.web.reactive.function.client.WebClientResponseException;
+
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+import reactor.util.annotation.Nullable;
@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
ApplicationContext context;
MockA1ClientFactory a1ClientFactory;
@Autowired
- RepositorySupervision supervision;
+ RicSupervision supervision;
+
+ @Autowired
+ ApplicationConfig applicationConfig;
@Autowired
Services services;
@TestConfiguration
static class TestBeanFactory {
private final PolicyTypes policyTypes = new PolicyTypes();
+ private final Services services = new Services();
+ private final Policies policies = new Policies();
+ MockA1ClientFactory a1ClientFactory = null;
@Bean
public ApplicationConfig getApplicationConfig() {
@Bean
MockA1ClientFactory getA1ClientFactory() {
- return new MockA1ClientFactory(this.policyTypes);
+ if (a1ClientFactory == null) {
+ this.a1ClientFactory = new MockA1ClientFactory(this.policyTypes);
+ }
+ return this.a1ClientFactory;
}
@Bean
- public Policies getPolicies() {
- return new Policies();
+ public PolicyTypes getPolicyTypes() {
+ return this.policyTypes;
}
@Bean
- public PolicyTypes getPolicyTypes() {
- return this.policyTypes;
+ Policies getPolicies() {
+ return this.policies;
+ }
+
+ @Bean
+ Services getServices() {
+ return this.services;
}
@Bean
- public Rics getRics() {
- return new Rics();
+ public ServiceSupervision getServiceSupervision() {
+ 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;
- private final RestTemplate restTemplate = new RestTemplate();
-
- private void reset() {
+ @BeforeEach
+ void reset() {
rics.clear();
policies.clear();
policyTypes.clear();
- assertThat(policies.size()).isEqualTo(0);
+ services.clear();
+ a1ClientFactory.reset();
}
- @Test
- public void testGetRics() throws Exception {
- reset();
- addRic("kista_1");
- String url = baseUrl() + "/rics";
- String rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println(rsp);
- assertThat(rsp).contains("kista_1");
-
- url = baseUrl() + "/rics?policyType=ANR";
- rsp = this.restTemplate.getForObject(url, String.class);
- assertThat(rsp).isEqualTo("[]");
+ @AfterEach
+ void verifyNoRicLocks() {
+ for (Ric ric : this.rics.getRics()) {
+ ric.getLock().lockBlocking(LockType.EXCLUSIVE);
+ ric.getLock().unlockBlocking();
+ assertThat(ric.getLock().getLockCounter()).isZero();
+ assertThat(ric.getState()).isEqualTo(Ric.RicState.AVAILABLE);
+ }
}
@Test
- public void testRecovery() throws Exception {
- reset();
- Policy policy = addPolicy("policyId", "typeName", "service", "ric"); // This should be created in the RIC
- Policy policy2 = addPolicy("policyId2", "typeName", "service", "ric");
+ void testGetRics() throws Exception {
+ addRic("ric1");
+ this.addPolicyType("type1", "ric1");
+ String url = "/rics?policyType=type1";
+ String rsp = restClient().get(url).block();
+ assertThat(rsp).contains("ric1");
+
+ // nameless type for ORAN A1 1.1
+ addRic("ric2");
+ this.addPolicyType("", "ric2");
+ url = "/rics?policyType=";
+
+ // 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") //
+ .contains("ric1");
+
+ // Non existing policy type
+ url = "/rics?policyType=XXXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
+ }
- getA1Client("ric").putPolicy(policy2); // put it in the RIC
+ @Test
+ void testSynchronization() throws Exception {
+ // Two polictypes will be put in the NearRT RICs
+ PolicyTypes nearRtRicPolicyTypes = new PolicyTypes();
+ nearRtRicPolicyTypes.put(createPolicyType("typeName"));
+ nearRtRicPolicyTypes.put(createPolicyType("typeName2"));
+ this.a1ClientFactory.setPolicyTypes(nearRtRicPolicyTypes);
+
+ // One type and one instance added to the agent storage
+ final String ric1Name = "ric1";
+ Ric ric1 = addRic(ric1Name);
+ Policy policy2 = addPolicy("policyId2", "typeName", "service", ric1Name);
+ Ric ric2 = addRic("ric2");
+
+ getA1Client(ric1Name).putPolicy(policy2); // put it in the RIC
policies.remove(policy2); // Remove it from the repo -> should be deleted in the RIC
+ String policyId = "policyId";
+ Policy policy = addPolicy(policyId, "typeName", "service", ric1Name); // This should be created in the RIC
supervision.checkAllRics(); // The created policy should be put in the RIC
- Policies ricPolicies = getA1Client("ric").getPolicies();
+
+ // Wait until synch is completed
+ await().untilAsserted(() -> RicState.SYNCHRONIZING.equals(rics.getRic(ric1Name).getState()));
+ await().untilAsserted(() -> RicState.AVAILABLE.equals(rics.getRic(ric1Name).getState()));
+ await().untilAsserted(() -> RicState.AVAILABLE.equals(rics.getRic("ric2").getState()));
+
+ Policies ricPolicies = getA1Client(ric1Name).getPolicies();
assertThat(ricPolicies.size()).isEqualTo(1);
- Policy ricPolicy = ricPolicies.get("policyId");
+ Policy ricPolicy = ricPolicies.get(policyId);
assertThat(ricPolicy.json()).isEqualTo(policy.json());
- }
- MockA1Client getA1Client(String ricName) throws ServiceException {
- return a1ClientFactory.getOrCreateA1Client(ricName);
+ // Both types should be in the agent storage after the synch
+ assertThat(ric1.getSupportedPolicyTypes()).hasSize(2);
+ assertThat(ric2.getSupportedPolicyTypes()).hasSize(2);
}
@Test
- public void testGetRic() throws Exception {
- reset();
- Ric ric = addRic("ric1");
- ric.addManagedElement("kista_1");
- String url = baseUrl() + "/ric?managedElementId=kista_1";
+ void testGetRicForManagedElement_thenReturnCorrectRic() throws Exception {
+ String ricName = "ric1";
+ String managedElementId = "kista_1";
+ addRic(ricName, managedElementId);
+
+ String url = "/ric?managedElementId=" + managedElementId;
+ String rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(ricName);
+
+ // test GET RIC for ManagedElement that does not exist
+ url = "/ric?managedElementId=" + "junk";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
+ }
- String rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println(rsp);
+ private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId,
+ boolean isTransient) {
+ String url;
+ if (policyTypeName.isEmpty()) {
+ url = "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
+ } else {
+ url = "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ + policyTypeName;
+ }
+ if (isTransient) {
+ url += "&transient=true";
+ }
+ return url;
+ }
- assertThat(rsp).isEqualTo("ric1");
+ private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId) {
+ return putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId, false);
}
@Test
- public void testPutPolicy() throws Exception {
- putService("service1");
+ void testPutPolicy() throws Exception {
+ String serviceName = "service1";
+ String ricName = "ric1";
+ String policyTypeName = "type1";
+ String policyInstanceId = "instance1";
- String url = baseUrl() + "/policy?type=type1&instance=instance1&ric=ric1&service=service1";
- String json = "{}";
- addPolicyType("type1", "ric1");
- this.rics.getRic("ric1").setState(Ric.RicState.IDLE);
+ putService(serviceName);
+ addPolicyType(policyTypeName, ricName);
- this.restTemplate.put(url, json);
+ // PUT a transient policy
+ String url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId, true);
+ final String policyBody = jsonString();
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
- Policy policy = policies.getPolicy("instance1");
+ restClient().put(url, policyBody).block();
+ Policy policy = policies.getPolicy(policyInstanceId);
assertThat(policy).isNotNull();
- assertThat(policy.id()).isEqualTo("instance1");
- assertThat(policy.ownerServiceName()).isEqualTo("service1");
-
- url = baseUrl() + "/policies";
- String rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println(rsp);
+ 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).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);
+ this.rics.getRic(ricName).setState(Ric.RicState.SYNCHRONIZING);
+ testErrorCode(restClient().put(url, policyBody), HttpStatus.LOCKED);
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
}
- private PolicyType addPolicyType(String policyTypeName, String ricName) {
- PolicyType type = ImmutablePolicyType.builder() //
- .name(policyTypeName) //
- .schema("{\"title\":\"" + policyTypeName + "\"}") //
- .build();
-
- policyTypes.put(type);
- addRic(ricName).addSupportedPolicyType(type);
- return type;
- }
-
- private Ric addRic(String ricName) {
- if (rics.get(ricName) != null) {
- return rics.get(ricName);
- }
- Vector<String> mes = new Vector<>();
- RicConfig conf = ImmutableRicConfig.builder() //
- .name(ricName) //
- .baseUrl(ricName) //
- .managedElementIds(mes) //
- .build();
- Ric ric = new Ric(conf);
- this.rics.put(ric);
- return ric;
- }
+ @Test
+ /**
+ * Test that HttpStatus and body from failing REST call to A1 is passed on to the caller.
+ *
+ * @throws ServiceException
+ */
+ void testErrorFromRic() throws ServiceException {
+ putService("service1");
+ addPolicyType("type1", "ric1");
- private Policy addPolicy(String id, String typeName, String service, String ric) throws ServiceException {
- addRic(ric);
- Policy p = ImmutablePolicy.builder().id(id) //
- .json("{}") //
- .ownerServiceName(service) //
- .ric(rics.getRic(ric)) //
- .type(addPolicyType(typeName, ric)) //
- .lastModified("lastModified").build();
- policies.put(p);
- return p;
+ String url = putPolicyUrl("service1", "ric1", "type1", "id1");
+ MockA1Client a1Client = a1ClientFactory.getOrCreateA1Client("ric1");
+ HttpStatus httpStatus = HttpStatus.INTERNAL_SERVER_ERROR;
+ String responseBody = "Refused";
+ byte[] responseBodyBytes = responseBody.getBytes(StandardCharsets.UTF_8);
+
+ WebClientResponseException a1Exception = new WebClientResponseException(httpStatus.value(), "statusText", null,
+ responseBodyBytes, StandardCharsets.UTF_8, null);
+ doReturn(Mono.error(a1Exception)).when(a1Client).putPolicy(any());
+
+ // PUT Policy
+ testErrorCode(restClient().put(url, "{}"), httpStatus, responseBody);
+
+ // DELETE POLICY
+ this.addPolicy("instance1", "type1", "service1", "ric1");
+ doReturn(Mono.error(a1Exception)).when(a1Client).deletePolicy(any());
+ testErrorCode(restClient().delete("/policy?id=instance1"), httpStatus, responseBody);
+
+ // GET STATUS
+ this.addPolicy("instance1", "type1", "service1", "ric1");
+ doReturn(Mono.error(a1Exception)).when(a1Client).getPolicyStatus(any());
+ testErrorCode(restClient().get("/policy_status?id=instance1"), httpStatus, responseBody);
+
+ // Check that empty response body is OK
+ a1Exception = new WebClientResponseException(httpStatus.value(), "", null, null, null, null);
+ doReturn(Mono.error(a1Exception)).when(a1Client).getPolicyStatus(any());
+ testErrorCode(restClient().get("/policy_status?id=instance1"), httpStatus);
}
- private Policy addPolicy(String id, String typeName, String service) throws ServiceException {
- return addPolicy(id, typeName, service, "ric");
+ @Test
+ void testPutTypelessPolicy() throws Exception {
+ putService("service1");
+ addPolicyType("", "ric1");
+ String url = putPolicyUrl("service1", "ric1", "", "id1");
+ restClient().put(url, jsonString()).block();
+
+ String rsp = restClient().get("/policies").block();
+ List<PolicyInfo> info = parseList(rsp, PolicyInfo.class);
+ assertThat(info).hasSize(1);
+ PolicyInfo policyInfo = info.get(0);
+ assertThat(policyInfo.id).isEqualTo("id1");
+ assertThat(policyInfo.type).isEmpty();
}
- private String baseUrl() {
- return "http://localhost:" + port;
+ @Test
+ 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");
+ this.addRic("ricXXX");
+ this.addPolicy("instance1", "type1", "service1", "ric1");
+ this.addPolicy("instance2", "type1", "service1", "ricXXX");
+
+ // Try change ric1 -> ricXXX
+ String urlWrongRic = putPolicyUrl("service1", "ricXXX", "type1", "instance1");
+ testErrorCode(restClient().put(urlWrongRic, jsonString()), HttpStatus.CONFLICT);
}
@Test
- public void testGetPolicy() throws Exception {
- String url = baseUrl() + "/policy?instance=id";
+ void testGetPolicy() throws Exception {
+ String url = "/policy?id=id";
Policy policy = addPolicy("id", "typeName", "service1", "ric1");
{
- String rsp = this.restTemplate.getForObject(url, String.class);
+ String rsp = restClient().get(url).block();
assertThat(rsp).isEqualTo(policy.json());
}
{
policies.remove(policy);
- ResponseEntity<String> rsp = this.restTemplate.getForEntity(url, String.class);
- assertThat(rsp.getStatusCodeValue()).isEqualTo(HttpStatus.NO_CONTENT.value());
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
}
@Test
- public void testDeletePolicy() throws Exception {
- reset();
- String url = baseUrl() + "/policy?instance=id";
- Policy policy = addPolicy("id", "typeName", "service1", "ric1");
- policy.ric().setState(Ric.RicState.IDLE);
+ void testDeletePolicy() throws Exception {
+ addPolicy("id", "typeName", "service1", "ric1");
assertThat(policies.size()).isEqualTo(1);
- this.restTemplate.delete(url);
+ String url = "/policy?id=id";
+ ResponseEntity<String> entity = restClient().deleteForEntity(url).block();
+
+ assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
+ assertThat(policies.size()).isZero();
- assertThat(policies.size()).isEqualTo(0);
+ // Delete a non existing policy
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
@Test
- public void testGetPolicySchemas() throws Exception {
- reset();
+ void testGetPolicySchemas() throws Exception {
addPolicyType("type1", "ric1");
addPolicyType("type2", "ric2");
- String url = baseUrl() + "/policy_schemas";
- String rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println("*** " + rsp);
- assertThat(rsp).contains("type1");
- assertThat(rsp).contains("type2");
- assertThat(rsp).contains("title");
+ String url = "/policy_schemas";
+ String rsp = this.restClient().get(url).block();
+ assertThat(rsp).contains("type1") //
+ .contains("[{\"title\":\"type2\"}");
List<String> info = parseSchemas(rsp);
- assertEquals(2, info.size());
+ assertThat(info).hasSize(2);
- url = baseUrl() + "/policy_schemas?ric=ric1";
- rsp = this.restTemplate.getForObject(url, String.class);
+ url = "/policy_schemas?ric=ric1";
+ rsp = restClient().get(url).block();
assertThat(rsp).contains("type1");
info = parseSchemas(rsp);
- assertEquals(1, info.size());
+ assertThat(info).hasSize(1);
+
+ // Get schema for non existing RIC
+ url = "/policy_schemas?ric=ric1XXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
@Test
- public void testGetPolicySchema() throws Exception {
- reset();
+ void testGetPolicySchema() throws Exception {
addPolicyType("type1", "ric1");
addPolicyType("type2", "ric2");
- String url = baseUrl() + "/policy_schema?id=type1";
- String rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println(rsp);
- assertThat(rsp).contains("type1");
- assertThat(rsp).contains("title");
+ String url = "/policy_schema?id=type1";
+ String rsp = restClient().get(url).block();
+ logger.info(rsp);
+ assertThat(rsp).contains("type1") //
+ .contains("title");
+
+ // Get non existing schema
+ url = "/policy_schema?id=type1XX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
@Test
- public void testGetPolicyTypes() throws Exception {
- reset();
+ void testGetPolicyTypes() throws Exception {
addPolicyType("type1", "ric1");
addPolicyType("type2", "ric2");
- String url = baseUrl() + "/policy_types";
- String rsp = this.restTemplate.getForObject(url, String.class);
+ String url = "/policy_types";
+ String rsp = restClient().get(url).block();
assertThat(rsp).isEqualTo("[\"type2\",\"type1\"]");
- url = baseUrl() + "/policy_types?ric=ric1";
- rsp = this.restTemplate.getForObject(url, String.class);
+ url = "/policy_types?ric=ric1";
+ rsp = restClient().get(url).block();
assertThat(rsp).isEqualTo("[\"type1\"]");
+
+ // Get policy types for non existing RIC
+ url = "/policy_types?ric=ric1XXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
@Test
- public void testGetPolicies() throws Exception {
- String url = baseUrl() + "/policies";
+ void testGetPolicies() throws Exception {
addPolicy("id1", "type1", "service1");
- addPolicy("id2", "type2", "service2");
- String rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println(rsp);
- assertThat(rsp).contains("id1");
- assertThat(rsp).contains("id2");
+ String url = "/policies";
+ String rsp = restClient().get(url).block();
+ logger.info(rsp);
+ List<PolicyInfo> info = parseList(rsp, PolicyInfo.class);
+ assertThat(info).hasSize(1);
+ PolicyInfo policyInfo = info.get(0);
+ assert (policyInfo.validate());
+ assertThat(policyInfo.id).isEqualTo("id1");
+ assertThat(policyInfo.type).isEqualTo("type1");
+ assertThat(policyInfo.service).isEqualTo("service1");
}
@Test
- public void testGetPoliciesFilter() throws Exception {
+ void testGetPoliciesFilter() throws Exception {
addPolicy("id1", "type1", "service1");
addPolicy("id2", "type1", "service2");
addPolicy("id3", "type2", "service1");
- String url = baseUrl() + "/policies?type=type1";
- String rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println(rsp);
- assertThat(rsp).contains("id1");
- assertThat(rsp).contains("id2");
- assertFalse(rsp.contains("id3"));
-
- url = baseUrl() + "/policies?type=type1&service=service2";
- rsp = this.restTemplate.getForObject(url, String.class);
- System.out.println(rsp);
- assertFalse(rsp.contains("id1"));
- assertThat(rsp).contains("id2");
- assertFalse(rsp.contains("id3"));
- }
-
- private String createServiceJson(String name) {
- ServiceRegistrationInfo service = ImmutableServiceRegistrationInfo.builder() //
- .keepAliveInterval(1) //
- .name(name) //
- .callbackUrl("callbackUrl") //
+ String url = "/policies?type=type1";
+ String rsp = restClient().get(url).block();
+ logger.info(rsp);
+ assertThat(rsp).contains("id1") //
+ .contains("id2") //
+ .doesNotContain("id3");
+
+ url = "/policies?type=type1&service=service2";
+ rsp = restClient().get(url).block();
+ logger.info(rsp);
+ assertThat(rsp).doesNotContain("id1") //
+ .contains("id2") //
+ .doesNotContain("id3");
+
+ // Test get policies for non existing type
+ url = "/policies?type=type1XXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
+
+ // Test get policies for non existing RIC
+ url = "/policies?ric=XXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
+ }
+
+ @Test
+ 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") //
+ .contains("id2") //
+ .doesNotContain("id3");
+
+ url = "/policy_ids?type=type1&service=service1&ric=ric1";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo("[\"id1\"]");
+
+ // Test get policy ids for non existing type
+ url = "/policy_ids?type=type1XXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
+
+ // Test get policy ids for non existing RIC
+ url = "/policy_ids?ric=XXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
+ }
+
+ @Test
+ void testPutAndGetService() throws Exception {
+ // PUT
+ 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).hasSize(1);
+ ServiceStatus status = info.iterator().next();
+ assertThat(status.keepAliveIntervalSeconds).isZero();
+ assertThat(status.serviceName).isEqualTo(serviceName);
+
+ // GET (all)
+ url = "/services";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).as("Response contains service name").contains(serviceName);
+ logger.info(rsp);
+
+ // Keep alive
+ url = "/services/keepalive?name=name";
+ ResponseEntity<String> entity = restClient().putForEntity(url).block();
+ assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+
+ // DELETE service
+ assertThat(services.size()).isEqualTo(1);
+ url = "/services?name=name";
+ restClient().delete(url).block();
+ assertThat(services.size()).isZero();
+
+ // 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(serviceName, -123)), HttpStatus.BAD_REQUEST);
+ testErrorCode(restClient().put("/service", createServiceJson(serviceName, 0, "missing.portandprotocol.com")),
+ HttpStatus.BAD_REQUEST);
+
+ // GET non existing service
+ testErrorCode(restClient().get("/services?name=XXX"), HttpStatus.NOT_FOUND);
+ }
+
+ @Test
+ void testServiceSupervision() throws Exception {
+ putService("service1", 1, HttpStatus.CREATED);
+ addPolicyType("type1", "ric1");
+
+ String url = putPolicyUrl("service1", "ric1", "type1", "instance1");
+ final String policyBody = jsonString();
+ restClient().put(url, policyBody).block();
+
+ assertThat(policies.size()).isEqualTo(1);
+ assertThat(services.size()).isEqualTo(1);
+
+ // Timeout after ~1 second
+ await().untilAsserted(() -> assertThat(policies.size()).isZero());
+ assertThat(services.size()).isZero();
+ }
+
+ @Test
+ 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).isEqualTo("OK");
+
+ // GET non existing policy status
+ url = "/policy_status?id=XXX";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
+ }
+
+ private Policy addPolicy(String id, String typeName, String service, String ric) throws ServiceException {
+ addRic(ric);
+ Policy policy = ImmutablePolicy.builder() //
+ .id(id) //
+ .json(jsonString()) //
+ .ownerServiceName(service) //
+ .ric(rics.getRic(ric)) //
+ .type(addPolicyType(typeName, ric)) //
+ .lastModified("lastModified") //
+ .isTransient(false) //
.build();
+ policies.put(policy);
+ return policy;
+ }
+
+ private Policy addPolicy(String id, String typeName, String service) throws ServiceException {
+ return addPolicy(id, typeName, service, "ric");
+ }
+
+ private String createServiceJson(String name, long keepAliveIntervalSeconds) {
+ return createServiceJson(name, keepAliveIntervalSeconds, "https://examples.javacodegeeks.com/core-java/");
+ }
+
+ private String createServiceJson(String name, long keepAliveIntervalSeconds, String url) {
+ ServiceRegistrationInfo service = new ServiceRegistrationInfo(name, keepAliveIntervalSeconds, url);
+
String json = gson.toJson(service);
return json;
}
private void putService(String name) {
- String url = baseUrl() + "/service";
- this.restTemplate.put(url, createServiceJson(name));
+ putService(name, 0, null);
+ }
+
+ private void putService(String name, long keepAliveIntervalSeconds, @Nullable HttpStatus expectedStatus) {
+ String url = "/service";
+ String body = createServiceJson(name, keepAliveIntervalSeconds);
+ ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
+ if (expectedStatus != null) {
+ assertEquals(expectedStatus, resp.getStatusCode(), "");
+ }
+ }
+
+ private String baseUrl() {
+ return "https://localhost:" + port;
+ }
+
+ private String jsonString() {
+ return "{\"servingCellNrcgi\":\"1\"}";
}
@Test
- public void testPutAndGetService() throws Exception {
- // PUT
- putService("name");
+ void testConcurrency() throws Exception {
+ final Instant startTime = Instant.now();
+ List<Thread> threads = new ArrayList<>();
+ a1ClientFactory.setResponseDelay(Duration.ofMillis(1));
+ addRic("ric");
+ addPolicyType("type1", "ric");
+ addPolicyType("type2", "ric");
+
+ for (int i = 0; i < 10; ++i) {
+ Thread thread =
+ new Thread(new ConcurrencyTestRunnable(baseUrl(), supervision, a1ClientFactory, rics, policyTypes),
+ "TestThread_" + i);
+ thread.start();
+ threads.add(thread);
+ }
+ for (Thread t : threads) {
+ t.join();
+ }
+ assertThat(policies.size()).isZero();
+ logger.info("Concurrency test took " + Duration.between(startTime, Instant.now()));
+ }
- // GET
- String url = baseUrl() + "/services?name=name";
- String rsp = this.restTemplate.getForObject(url, String.class);
- List<ImmutableServiceStatus> info = parseList(rsp, ImmutableServiceStatus.class);
- assertThat(info.size() == 1);
- ServiceStatus status = info.iterator().next();
- assertThat(status.keepAliveInterval() == 1);
- assertThat(status.name().equals("name"));
+ 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();
- // GET (all)
- url = baseUrl() + "/services";
- rsp = this.restTemplate.getForObject(url, String.class);
- assertThat(rsp.contains("name"));
- System.out.println(rsp);
+ return new AsyncRestClient(baseUrl(), config);
+ }
+
+ private AsyncRestClient restClient() {
+ return restClient(false);
+ }
+
+ private void testErrorCode(Mono<?> request, HttpStatus expStatus) {
+ testErrorCode(request, expStatus, "");
+ }
+
+ private void testErrorCode(Mono<?> request, HttpStatus expStatus, String responseContains) {
+ StepVerifier.create(request) //
+ .expectSubscription() //
+ .expectErrorMatches(t -> checkWebClientError(t, expStatus, responseContains)) //
+ .verify();
+ }
- // DELETE
- assertThat(services.size() == 1);
- url = baseUrl() + "/services?name=name";
- this.restTemplate.delete(url);
- assertThat(services.size() == 0);
+ 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;
+ }
+
+ private MockA1Client getA1Client(String ricName) throws ServiceException {
+ return a1ClientFactory.getOrCreateA1Client(ricName);
+ }
+
+ private PolicyType createPolicyType(String policyTypeName) {
+ return ImmutablePolicyType.builder() //
+ .name(policyTypeName) //
+ .schema("{\"title\":\"" + policyTypeName + "\"}") //
+ .build();
+ }
+
+ private PolicyType addPolicyType(String policyTypeName, String ricName) {
+ PolicyType type = createPolicyType(policyTypeName);
+ policyTypes.put(type);
+ addRic(ricName).addSupportedPolicyType(type);
+ return type;
+ }
+
+ private Ric addRic(String ricName) {
+ return addRic(ricName, null);
+ }
+
+ private Ric addRic(String ricName, String managedElement) {
+ if (rics.get(ricName) != null) {
+ return rics.get(ricName);
+ }
+ List<String> mes = new ArrayList<>();
+ if (managedElement != null) {
+ mes.add(managedElement);
+ }
+ RicConfig conf = ImmutableRicConfig.builder() //
+ .name(ricName) //
+ .baseUrl(ricName) //
+ .managedElementIds(mes) //
+ .controllerName("") //
+ .build();
+ Ric ric = new Ric(conf);
+ ric.setState(Ric.RicState.AVAILABLE);
+ this.rics.put(ric);
+ return ric;
}
private static <T> List<T> parseList(String jsonString, Class<T> clazz) {
List<T> result = new ArrayList<>();
- JsonArray jsonArr = new JsonParser().parse(jsonString).getAsJsonArray();
+ 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;
}
private static List<String> parseSchemas(String jsonString) {
- JsonArray arrayOfSchema = new JsonParser().parse(jsonString).getAsJsonArray();
+ JsonArray arrayOfSchema = JsonParser.parseString(jsonString).getAsJsonArray();
List<String> result = new ArrayList<>();
for (JsonElement schemaObject : arrayOfSchema) {
result.add(schemaObject.toString());
}
return result;
}
-
}
Code Review / nonrtric.git / blobdiff