import static org.assertj.core.api.Assertions.assertThat;
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 java.time.Instant;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
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.HttpEntity;
-import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
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)
Duration checkInterval = Duration.ofMillis(1);
return new ServiceSupervision(this.services, this.policies, this.getA1ClientFactory(), checkInterval);
}
+
+ @Bean
+ public ServletWebServerFactory servletContainer() {
+ return new TomcatServletWebServerFactory();
+ }
+
}
@LocalServerPort
policies.clear();
policyTypes.clear();
services.clear();
+ a1ClientFactory.reset();
}
@AfterEach
ric.getLock().lockBlocking(LockType.EXCLUSIVE);
ric.getLock().unlockBlocking();
assertThat(ric.getLock().getLockCounter()).isEqualTo(0);
- assertThat(ric.getState()).isEqualTo(Ric.RicState.IDLE);
+ assertThat(ric.getState()).isEqualTo(Ric.RicState.AVAILABLE);
}
}
rsp = restClient().get(url).block();
assertThat(rsp).contains("ric2");
assertThat(rsp).doesNotContain("ric1");
+ assertThat(rsp).contains("AVAILABLE");
+
+ // All RICs
+ rsp = restClient().get("/rics").block();
+ assertThat(rsp).contains("ric2");
+ assertThat(rsp).contains("ric1");
// Non existing policy type
url = "/rics?policyType=XXXX";
}
@Test
- public void testRecovery() throws Exception {
- addRic("ric").setState(Ric.RicState.UNDEFINED);
- String ricName = "ric";
- Policy policy2 = addPolicy("policyId2", "typeName", "service", ricName);
-
- getA1Client(ricName).putPolicy(policy2); // put it in the RIC
+ public 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", ricName); // This should be created in the RIC
+ 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
- await().untilAsserted(() -> RicState.SYNCHRONIZING.equals(rics.getRic(ricName).getState()));
- await().untilAsserted(() -> RicState.IDLE.equals(rics.getRic(ricName).getState()));
- Policies ricPolicies = getA1Client(ricName).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);
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);
}
@Test
private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId) {
if (policyTypeName.isEmpty()) {
- return "/policy?instance=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
+ return "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
} else {
- return "/policy?instance=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ return "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ policyTypeName;
}
}
String url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
final String policyBody = jsonString();
- this.rics.getRic(ricName).setState(Ric.RicState.IDLE);
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
restClient().put(url, policyBody).block();
String rsp = restClient().get(url).block();
assertThat(rsp.contains(policyInstanceId)).isTrue();
+ 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, policyInstanceId);
this.rics.getRic(ricName).setState(Ric.RicState.SYNCHRONIZING);
testErrorCode(restClient().put(url, policyBody), HttpStatus.LOCKED);
- this.rics.getRic(ricName).setState(Ric.RicState.IDLE);
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
}
@Test
// DELETE POLICY
this.addPolicy("instance1", "type1", "service1", "ric1");
doReturn(Mono.error(a1Exception)).when(a1Client).deletePolicy(any());
- testErrorCode(restClient().delete("/policy?instance=instance1"), httpStatus, responseBody);
+ 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?instance=instance1"), httpStatus, responseBody);
+ 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?instance=instance1"), httpStatus);
+ testErrorCode(restClient().get("/policy_status?id=instance1"), httpStatus);
}
@Test
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");
@Test
public void testGetPolicy() throws Exception {
- String url = "/policy?instance=id";
+ String url = "/policy?id=id";
Policy policy = addPolicy("id", "typeName", "service1", "ric1");
{
String rsp = restClient().get(url).block();
addPolicy("id", "typeName", "service1", "ric1");
assertThat(policies.size()).isEqualTo(1);
- String url = "/policy?instance=id";
+ String url = "/policy?id=id";
ResponseEntity<String> entity = restClient().deleteForEntity(url).block();
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
@Test
public void testGetPolicies() throws Exception {
- reset();
addPolicy("id1", "type1", "service1");
String url = "/policies";
@Test
public void testPutAndGetService() throws Exception {
// PUT
- putService("name", 0);
+ putService("name", 0, HttpStatus.CREATED);
+ putService("name", 0, HttpStatus.OK);
// GET one service
String url = "/services?name=name";
// Keep alive
url = "/services/keepalive?name=name";
- ResponseEntity<String> entity = restClient().postForEntity(url, null).block();
+ ResponseEntity<String> entity = restClient().putForEntity(url).block();
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
// DELETE service
assertThat(services.size()).isEqualTo(0);
// Keep alive, no registerred service
- testErrorCode(restClient().post("/services/keepalive?name=name", ""), HttpStatus.NOT_FOUND);
+ testErrorCode(restClient().put("/services/keepalive?name=name", ""), HttpStatus.NOT_FOUND);
- // PUT servive with crap payload
+ // 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")),
+ HttpStatus.BAD_REQUEST);
// GET non existing servive
testErrorCode(restClient().get("/services?name=XXX"), HttpStatus.NOT_FOUND);
@Test
public void testServiceSupervision() throws Exception {
- putService("service1", 1);
+ putService("service1", 1, HttpStatus.CREATED);
addPolicyType("type1", "ric1");
String url = putPolicyUrl("service1", "ric1", "type1", "instance1");
addPolicy("id", "typeName", "service1", "ric1");
assertThat(policies.size()).isEqualTo(1);
- String url = "/policy_status?instance=id";
+ String url = "/policy_status?id=id";
String rsp = restClient().get(url).block();
assertThat(rsp.equals("OK")).isTrue();
// GET non existing policy status
- url = "/policy_status?instance=XXX";
+ url = "/policy_status?id=XXX";
testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
}
private String createServiceJson(String name, long keepAliveIntervalSeconds) {
- ServiceRegistrationInfo service = new ServiceRegistrationInfo(name, keepAliveIntervalSeconds, "callbackUrl");
+ 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) {
- putService(name, 0);
+ putService(name, 0, null);
}
- private void putService(String name, long keepAliveIntervalSeconds) {
+ private void putService(String name, long keepAliveIntervalSeconds, @Nullable HttpStatus expectedStatus) {
String url = "/service";
String body = createServiceJson(name, keepAliveIntervalSeconds);
- restClient().put(url, body).block();
+ ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
+ if (expectedStatus != null) {
+ assertEquals(expectedStatus, resp.getStatusCode(), "");
+ }
}
private String baseUrl() {
- return "http://localhost:" + port;
+ return "https://localhost:" + port;
}
private String jsonString() {
- return "{\n \"servingCellNrcgi\": \"1\"\n }";
- }
-
- private static class ConcurrencyTestRunnable implements Runnable {
- private final RestTemplate restTemplate = new RestTemplate();
- private final String baseUrl;
- static AtomicInteger nextCount = new AtomicInteger(0);
- private final int count;
- private final RicSupervision supervision;
-
- ConcurrencyTestRunnable(String baseUrl, RicSupervision supervision) {
- this.baseUrl = baseUrl;
- this.count = nextCount.incrementAndGet();
- this.supervision = supervision;
- }
-
- @Override
- public void run() {
- for (int i = 0; i < 100; ++i) {
- if (i % 10 == 0) {
- this.supervision.checkAllRics();
- }
- String name = "policy:" + count + ":" + i;
- putPolicy(name);
- deletePolicy(name);
- }
- }
-
- private void putPolicy(String name) {
- String putUrl = baseUrl + "/policy?type=type1&instance=" + name + "&ric=ric1&service=service1";
- restTemplate.put(putUrl, createJsonHttpEntity("{}"));
- }
-
- private void deletePolicy(String name) {
- String deleteUrl = baseUrl + "/policy?instance=" + name;
- restTemplate.delete(deleteUrl);
- }
+ return "{\"servingCellNrcgi\":\"1\"}";
}
@Test
public void testConcurrency() throws Exception {
final Instant startTime = Instant.now();
List<Thread> threads = new ArrayList<>();
- addRic("ric1");
- addPolicyType("type1", "ric1");
+ a1ClientFactory.setResponseDelay(Duration.ofMillis(1));
+ addRic("ric");
+ addPolicyType("type1", "ric");
+ addPolicyType("type2", "ric");
for (int i = 0; i < 100; ++i) {
- Thread t = new Thread(new ConcurrencyTestRunnable(baseUrl(), this.supervision), "TestThread_" + i);
+ Thread t =
+ new Thread(new ConcurrencyTestRunnable(baseUrl(), supervision, a1ClientFactory, rics, policyTypes),
+ "TestThread_" + i);
t.start();
threads.add(t);
}
return a1ClientFactory.getOrCreateA1Client(ricName);
}
- private PolicyType addPolicyType(String policyTypeName, String ricName) {
- PolicyType type = ImmutablePolicyType.builder() //
+ 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;
.name(ricName) //
.baseUrl(ricName) //
.managedElementIds(mes) //
+ .controllerName("") //
.build();
Ric ric = new Ric(conf);
- ric.setState(Ric.RicState.IDLE);
+ ric.setState(Ric.RicState.AVAILABLE);
this.rics.put(ric);
return ric;
}
- private static HttpEntity<String> createJsonHttpEntity(String content) {
- HttpHeaders headers = new HttpHeaders();
- headers.setContentType(MediaType.APPLICATION_JSON);
- return new HttpEntity<String>(content, headers);
- }
-
private static <T> List<T> parseList(String jsonString, Class<T> clazz) {
List<T> result = new ArrayList<>();
JsonArray jsonArr = JsonParser.parseString(jsonString).getAsJsonArray();