package org.onap.ccsdk.oran.a1policymanagementservice.controllers.v3;
+import com.google.gson.Gson;
import org.junit.jupiter.api.*;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.SecurityContext;
import org.onap.ccsdk.oran.a1policymanagementservice.config.TestConfig;
import org.onap.ccsdk.oran.a1policymanagementservice.configuration.ApplicationConfig;
import org.onap.ccsdk.oran.a1policymanagementservice.controllers.OpenPolicyAgentSimulatorController;
import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.RappSimulatorController;
+import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyObjectInformation;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyTypes;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
import java.lang.invoke.MethodHandles;
import java.nio.file.Path;
+import java.util.Objects;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@Autowired
private OpenPolicyAgentSimulatorController openPolicyAgentSimulatorController;
+ @Autowired
+ private Gson gson;
+
@LocalServerPort
private int port;
testHelper.addPolicyType(policyTypeName, nonRtRicId);
String policyBody = testHelper.postPolicyBody(nonRtRicId, policyTypeName);
Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
- testHelper.testSuccessResponse(responseMono, HttpStatus.CREATED, "{\"scope\":{\"ueId\":\"ue5100\",\"qosId\":\"qos5100\"},\"qosObjectives\":{\"priorityLevel\":5100.0}}");
+ testHelper.testSuccessResponse(responseMono, HttpStatus.CREATED, responseBody ->
+ responseBody.contains("{\"scope\":{\"ueId\":\"ue5100\",\"qosId\":\"qos5100\"},\"qosObjectives\":{\"priorityLevel\":5100.0}}"));
+ testHelper.testSuccessHeader(responseMono, "location", headerValue -> headerValue.contains("https://localhost:" + port + "/a1policymanagement/v1/policies/"));
+ }
+
+ @Test
+ @DisplayName("test delete Policy")
+ void testDeletePolicy() throws Exception {
+ String nonRtRicId = "ric.1";
+ String policyTypeName = "type1_1.2.3";
+ String url = "/policies";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ String policyBody = testHelper.postPolicyBody(nonRtRicId, policyTypeName);
+ Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
+ String []locationHeader = Objects.requireNonNull(Objects.requireNonNull(responseMono.block()).getHeaders()
+ .get("location")).get(0).split("/");
+ String policyID = locationHeader[(locationHeader.length) - 1];
+ Mono<ResponseEntity<String>> responseMonoDelete = testHelper.restClientV3().deleteForEntity(url+"/" +policyID);
+ testHelper.testSuccessResponse(responseMonoDelete, HttpStatus.NO_CONTENT, responseBody -> true);
}
@Test
Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
testHelper.testErrorCode(responseMono, HttpStatus.NOT_FOUND, "Could not find type: noPolicyType");
}
+
+ @Test
+ public void testGetPolicyTypesNoRicFound() throws Exception{
+ String policyTypeName = "type1_1.2.3";
+ String nonRtRicId = "ricOne";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().getForEntity("/policyTypes" + "?nearRtRicId=\"noRic\"");
+ testHelper.testErrorCode(responseMono, HttpStatus.NOT_FOUND, "Near-RT RIC not Found using ID:");
+ }
+
+ @Test
+ @DisplayName("test get Policy")
+ void testGetPolicy() throws Exception {
+ String nonRtRicId = "ric.1";
+ String policyTypeName = "type1_1.2.3";
+ String url = "/policies";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ String policyBody = testHelper.postPolicyBody(nonRtRicId, policyTypeName);
+ Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
+ String []locationHeader = Objects.requireNonNull(Objects.requireNonNull(responseMono.block()).getHeaders()
+ .get("location")).get(0).split("/");
+ String policyID = locationHeader[(locationHeader.length) - 1];
+ Mono<ResponseEntity<String>> responseMonoGet = testHelper.restClientV3().getForEntity(url+"/" +policyID);
+ testHelper.testSuccessResponse(responseMonoGet, HttpStatus.OK, responseBody ->
+ responseBody.contains("{\"scope\":{\"ueId\":\"ue5100\",\"qosId\":\"qos5100\"},\"qosObjectives\":{\"priorityLevel\":5100.0}}"));
+ }
}
package org.onap.ccsdk.oran.a1policymanagementservice.service.v3;
+import com.google.gson.Gson;
+import com.google.gson.JsonParser;
import org.junit.jupiter.api.*;
import org.mockito.Mockito;
-import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
+import org.onap.ccsdk.oran.a1policymanagementservice.config.TestConfig;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
+import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyInformation;
import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyObjectInformation;
+import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyTypeInformation;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policy;
-import org.onap.ccsdk.oran.a1policymanagementservice.service.v3.AuthorizationService;
-import org.onap.ccsdk.oran.a1policymanagementservice.service.v3.PolicyService;
+import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyType;
+import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
import org.onap.ccsdk.oran.a1policymanagementservice.util.v3.Helper;
+import org.onap.ccsdk.oran.a1policymanagementservice.utils.MockA1ClientFactory;
import org.onap.ccsdk.oran.a1policymanagementservice.utils.v3.TestHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
+import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.util.FileSystemUtils;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.adapter.DefaultServerWebExchange;
+import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.io.IOException;
import java.lang.invoke.MethodHandles;
import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@TestMethodOrder(MethodOrderer.MethodName.class)
-@SpringBootTest()
+@SpringBootTest
+@ContextConfiguration(classes = TestConfig.class)
@TestPropertySource(properties = { //
"app.vardata-directory=/tmp/pmstestv3", //
})
public class PolicyServiceTest {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
- @Autowired
- private Policies policies;
@Autowired
- private A1ClientFactory a1ClientFactory;
+ private Policies policies;
@Autowired
- private ErrorHandlingService errorHandlingService;
+ private Rics rics;
@Autowired
private PolicyService policyService;
@MockBean
private AuthorizationService authorizationService;
+ @Autowired
+ private MockA1ClientFactory a1ClientFactory;
+
+ @Autowired
+ private Gson gson;
+
@AfterEach
public void clear() {
policies.clear();
+ rics.clear();
}
@AfterAll
Mono<ResponseEntity<PolicyObjectInformation>> responseMono = policyService.createPolicyService(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), serverWebExchange);
testHelper.verifyMockError(responseMono, "Not authorized");
}
+
+ @Test
+ public void testDeletePolicySuccess() throws Exception {
+
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
+ policies.put(policy);
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ when(helper.checkRicStateIdle(any())).thenReturn(Mono.just(policy.getRic()));
+ when(helper.checkSupportedType(any(), any())).thenReturn(Mono.just(policy.getRic()));
+ when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(policy));
+ Mono<ResponseEntity<Void>> responseMonoDelete = policyService.deletePolicyService(policy.getId(), serverWebExchange);
+ assert(policies.size() == 1);
+ testHelper.testSuccessResponse(responseMonoDelete, HttpStatus.NO_CONTENT, responseBody -> policies.size() == 0);
+ }
+
+ @Test
+ public void testDeletePolicyThrowsException() throws Exception {
+
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ assertThrows(EntityNotFoundException.class, () -> policyService.deletePolicyService("dummyPolicyID", serverWebExchange));
+ }
+
+ @Test
+ public void testPutPolicy() throws Exception {
+
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
+ policies.put(policy);
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ PolicyObjectInformation updatedPolicyObjectInfo = testHelper.policyObjectInfo(nonRtRicId, policyTypeName);
+ updatedPolicyObjectInfo.setPolicyObject(gson.fromJson(JsonParser.parseString("{\n" +
+ " \"scope\": {\n" +
+ " \"ueId\": \"ue6100\",\n" +
+ " \"qosId\": \"qos6100\"\n" +
+ " },\n" +
+ " \"qosObjectives\": {\n" +
+ " \"priorityLevel\": 6100.0\n" +
+ " }\n" +
+ " }").getAsJsonObject().toString(), Map.class));
+ Policy updatedPolicy = testHelper.buidTestPolicy(updatedPolicyObjectInfo, "122344-5674");
+ when(helper.buildPolicy(any(),any(), any(), any())).thenReturn(updatedPolicy);
+ when(helper.checkRicStateIdle(any())).thenReturn(Mono.just(updatedPolicy.getRic()));
+ when(helper.checkSupportedType(any(), any())).thenReturn(Mono.just(updatedPolicy.getRic()));
+ when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(updatedPolicy));
+ Mono<ResponseEntity<Object>> responseMono = policyService.putPolicyService(policy.getId(), updatedPolicyObjectInfo.getPolicyObject(), serverWebExchange);
+ testHelper.testSuccessResponse(responseMono, HttpStatus.OK, responseBody -> {
+ if (responseBody instanceof String returnPolicy)
+ return returnPolicy.contains(updatedPolicy.getJson());
+ return false;
+ });
+ }
+
+ @Test
+ public void testGetPolicyTypes() throws Exception {
+
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
+ Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService(null, null,null, serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
+ }
+
+ @Test
+ public void testGetPolicyTypesEmpty() throws Exception {
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
+ Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService(null, null, null, serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 0);
+ }
+
+ @Test
+ public void testGetPolicyTypesNoRic() {
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ assertThrows(EntityNotFoundException.class, () -> policyService.getPolicyTypesService("NoRic", "","", serverWebExchange));
+ }
+
+ @Test
+ public void testGetPolicyTypesNoMatchedTypeName() throws Exception {
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService("", "noTypeName", null, serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().findAny().isEmpty());
+ }
+
+ @Test
+ public void testGetPolicyTypesNoMatchedTypeNameWithRic() throws Exception {
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService("Ric_347", "noTypeName", null, serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().findAny().isEmpty());
+ }
+
+ @Test
+ public void testGetPolicyTypesMatchedTypeName() throws Exception {
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService(null, "uri_type", null, serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
+ }
+
+ @Test
+ public void testGetPolicyTypesMatchedTypeNameWithRic() throws Exception {
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
+ Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService
+ .getPolicyTypesService("Ric_347", "uri_type", null, serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
+ }
+
+ @Test
+ public void testGetPolicyIds() throws Exception {
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
+ policies.put(policy);
+ when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(policy));
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ Policy singlePolicy = policies.filterPolicies(null, null, null, null).iterator().next();
+ Collection<PolicyInformation> mockPolicyInfoCollection = new ArrayList<>();
+ mockPolicyInfoCollection.add(new PolicyInformation(singlePolicy.getId(), singlePolicy.getRic().getConfig().getRicId()));
+ when(helper.toFluxPolicyInformation(any())).thenReturn(Flux.fromIterable(mockPolicyInfoCollection));
+ Mono<ResponseEntity<Flux<PolicyInformation>>> responseEntityMono = policyService
+ .getPolicyIdsService(null, null, null, null, serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
+ }
+
+ @Test
+ public void testGetPolicyIdsNoRic() throws Exception {
+ testHelper.addPolicyType("uri_type_123", "Ric_347");
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
+ .getPolicyIdsService("uri_type_123", "noRic", "", "", serverWebExchange));
+ assertEquals("Near-RT RIC not found using ID: noRic", exception.getMessage());
+ }
+
+ @Test
+ public void testGetPolicyIdsNoPolicyType() {
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
+ .getPolicyIdsService("noPolicyType", "noRic", "", "", serverWebExchange));
+ assertEquals("Policy type not found using ID: noPolicyType", exception.getMessage());
+ }
+
+ @Test
+ public void testGetPolicyService() throws Exception {
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
+ policies.put(policy);
+ when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(policy));
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ Mono<ResponseEntity<Object>> responseEntityMono = policyService.getPolicyService(policy.getId(), serverWebExchange);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> {
+ if (responseBody instanceof String returnPolicy)
+ return returnPolicy.contains(policy.getJson());
+ return false;
+ });
+ }
+
+ @Test
+ public void testGetPolicyServiceNoPolicy() throws Exception {
+ ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
+ .getPolicyService("NoPolicy", serverWebExchange));
+ assertEquals("Could not find policy: NoPolicy", exception.getMessage());
+ }
+
+ @Test
+ public void testGetPolicyTypeService() throws Exception {
+ String policyTypeName = "uri_type_123";
+ String nonRtRicId = "Ric_347";
+ PolicyType addedPolicyType = testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ Mono<ResponseEntity<Object>> responseEntityMono = policyService.getPolicyTypeDefinitionService(policyTypeName);
+ testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> {
+ if (responseBody instanceof String returnPolicyType)
+ return returnPolicyType.contains(addedPolicyType.getSchema());
+ return false;
+ });
+ }
+
+ @Test
+ public void testGetPolicyTypeServiceNoPolicyType() {
+ EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
+ .getPolicyTypeDefinitionService("NoPolicyType"));
+ assertEquals("PolicyType not found with ID: NoPolicyType", exception.getMessage());
+ }
}
package org.onap.ccsdk.oran.a1policymanagementservice.utils.v3;
-import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.io.CharStreams;
import com.google.gson.Gson;
import org.onap.ccsdk.oran.a1policymanagementservice.configuration.RicConfig;
import org.onap.ccsdk.oran.a1policymanagementservice.configuration.WebClientConfig;
import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.Consts;
-import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.RappSimulatorController;
import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyObjectInformation;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
-import reactor.util.annotation.Nullable;
import java.io.IOException;
import java.io.InputStream;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
+import java.util.Objects;
+import java.util.function.Predicate;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
@Component
public class TestHelper {
return restClientV3(false);
}
- public AsyncRestClient restClient() {
- return restClient(false);
- }
-
public AsyncRestClient restClient(String baseUrl, boolean useTrustValidation) {
WebClientConfig config = this.applicationConfig.getWebClientConfig();
config = WebClientConfig.builder()
return restClient(baseUrl() + Consts.V2_API_ROOT, useTrustValidation);
}
- public void putService(String name) throws JsonProcessingException {
- putService(name, 0, null);
- }
-
- public void putService(String name, long keepAliveIntervalSeconds, @Nullable HttpStatus expectedStatus) throws JsonProcessingException {
- String url = "/services";
- String body = createServiceJson(name, keepAliveIntervalSeconds);
- ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
- if (expectedStatus != null) {
- assertNotNull(resp);
- assertEquals(expectedStatus, resp.getStatusCode(), "");
- }
- }
-
public PolicyType createPolicyType(String policyTypeName, String filePath) throws IOException {
InputStream in = getClass().getResourceAsStream(filePath);
assert in != null;
.id(id).build();
}
- public String createServiceJson(String name, long keepAliveIntervalSeconds) throws JsonProcessingException {
- String callbackUrl = baseUrl() + RappSimulatorController.SERVICE_CALLBACK_URL;
- return createServiceJson(name, keepAliveIntervalSeconds, callbackUrl);
- }
-
- public String createServiceJson(String name, long keepAliveIntervalSeconds, String url) throws JsonProcessingException {
- org.onap.ccsdk.oran.a1policymanagementservice.models.v2.ServiceRegistrationInfo service = new org.onap.ccsdk.oran.a1policymanagementservice.models.v2.ServiceRegistrationInfo(name)
- .keepAliveIntervalSeconds(keepAliveIntervalSeconds)
- .callbackUrl(url);
-
- return objectMapper.writeValueAsString(service);
- }
-
- public void testSuccessResponse(Mono<ResponseEntity<String>> responseEntityMono, HttpStatus httpStatusCode,
- String responseContains) {
+ public <T> void testSuccessResponse(Mono<ResponseEntity<T>> responseEntityMono, HttpStatus httpStatusCode,
+ Predicate<T> responsePredicate) {
StepVerifier.create(responseEntityMono)
.expectNextMatches(responseEntity -> {
// Assert status code
HttpStatusCode status = responseEntity.getStatusCode();
- String res = responseEntity.getBody();
- assertThat(res).contains(responseContains);
+ T responseBody = responseEntity.getBody();
+ assert responsePredicate.test(responseBody);
return status.value() == httpStatusCode.value();
})
.expectComplete()
.verify();
}
- public void testErrorCode(Mono<?> request, HttpStatus expStatus) {
- testErrorCode(request, expStatus, "", true);
- }
-
- public void testErrorCode(Mono<?> request, HttpStatus expStatus, boolean expectApplicationProblemJsonMediaType) {
- testErrorCode(request, expStatus, "", expectApplicationProblemJsonMediaType);
+ public void testSuccessHeader(Mono<ResponseEntity<String>> responseEntityMono, String headerKey,
+ Predicate<String> responsePredicate) {
+ StepVerifier.create(responseEntityMono)
+ .expectNextMatches(responseEntity -> {
+ String headerValue = Objects.requireNonNull(responseEntity.getHeaders().get(headerKey)).get(0);
+ return responsePredicate.test(headerValue);
+ })
+ .expectComplete()
+ .verify();
}
public void testErrorCode(Mono<?> request, HttpStatus expStatus, String responseContains) {
Code Review / ccsdk / oran.git / commitdiff