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 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.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.springframework.boot.web.server.LocalServerPort;
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)
policies.clear();
policyTypes.clear();
services.clear();
+ a1ClientFactory.reset();
}
@AfterEach
@Test
public void testGetRics() throws Exception {
- addRic("kista_1");
- this.addPolicyType("type1", "kista_1");
+ addRic("ric1");
+ this.addPolicyType("type1", "ric1");
String url = "/rics?policyType=type1";
String rsp = restClient().get(url).block();
- assertThat(rsp).contains("kista_1");
+ assertThat(rsp).contains("ric1");
+
+ // nameless type for ORAN A1 1.1
+ addRic("ric2");
+ this.addPolicyType("", "ric2");
+ url = "/rics?policyType=";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).contains("ric2");
+ assertThat(rsp).doesNotContain("ric1");
// Non existing policy type
url = "/rics?policyType=XXXX";
}
@Test
- public void testRecovery() throws Exception {
+ public void testSynchronization() throws Exception {
addRic("ric").setState(Ric.RicState.UNDEFINED);
String ricName = "ric";
Policy policy2 = addPolicy("policyId2", "typeName", "service", ricName);
}
private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId) {
- String url = "/policy?type=" + policyTypeName + "&instance=" + policyInstanceId + "&ric=" + ricName
- + "&service=" + serviceName;
- return url;
+ if (policyTypeName.isEmpty()) {
+ return "/policy?instance=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
+ } else {
+ return "/policy?instance=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ + policyTypeName;
+ }
}
@Test
this.rics.getRic(ricName).setState(Ric.RicState.IDLE);
}
+ @Test
+ /**
+ * Test that HttpStatus and body from failing REST call to A1 is passed on to
+ * the caller.
+ *
+ * @throws ServiceException
+ */
+ public void testErrorFromRIC() throws ServiceException {
+ putService("service1");
+ addPolicyType("type1", "ric1");
+
+ 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?instance=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);
+
+ // 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);
+ }
+
+ @Test
+ public 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).size().isEqualTo(1);
+ PolicyInfo policyInfo = info.get(0);
+ assertThat(policyInfo.id.equals("id1")).isTrue();
+ assertThat(policyInfo.type.equals("")).isTrue();
+ }
+
@Test
public void testRefuseToUpdatePolicy() throws Exception {
// Test that only the json can be changed for a already created policy
// Try change ric1 -> ricXXX
String urlWrongRic = putPolicyUrl("service1", "ricXXX", "type1", "instance1");
- testErrorCode(restClient().put(urlWrongRic, jsonString()), HttpStatus.METHOD_NOT_ALLOWED);
+ testErrorCode(restClient().put(urlWrongRic, jsonString()), HttpStatus.CONFLICT);
}
@Test
@Test
public void testGetPolicies() throws Exception {
- reset();
addPolicy("id1", "type1", "service1");
String url = "/policies";
testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
+ @Test
+ public 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();
+
+ 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
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";
@Test
public void testServiceSupervision() throws Exception {
- putService("service1", 1);
+ putService("service1", 1, HttpStatus.CREATED);
addPolicyType("type1", "ric1");
String url = putPolicyUrl("service1", "ric1", "type1", "instance1");
}
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 "{\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);
- }
- }
-
@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);
}
}
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)) //
+ .expectErrorMatches(t -> checkWebClientError(t, expStatus, responseContains)) //
.verify();
}
- private boolean checkWebClientError(Throwable t, HttpStatus expStatus) {
+ 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);
return true;
}
.name(ricName) //
.baseUrl(ricName) //
.managedElementIds(mes) //
+ .controllerName("") //
.build();
Ric ric = new Ric(conf);
ric.setState(Ric.RicState.IDLE);
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();
Code Review / nonrtric.git / blobdiff