required:
- nearRtRicId
- policyObject
+ - policyTypeId
ErrorInformation:
description: Problem as defined in https://tools.ietf.org/html/rfc7807
properties:
@Override
public Mono<ResponseEntity<Void>> deletePolicy(String policyId, String accept, ServerWebExchange exchange) throws Exception {
- return null;
+ return policyService.deletePolicyService(policyId, exchange);
}
@Override
public Mono<ResponseEntity<Object>> getPolicy(String policyId, String accept, ServerWebExchange exchange) throws Exception {
- return null;
+ return policyService.getPolicyService(policyId, exchange);
}
@Override
public Mono<ResponseEntity<Flux<PolicyInformation>>> getPolicyIds(String policyTypeId, String nearRtRicId, String serviceId, String typeName, String accept, ServerWebExchange exchange) throws Exception {
- return null;
+ return policyService.getPolicyIdsService(policyTypeId, nearRtRicId, serviceId, typeName, exchange);
}
@Override
public Mono<ResponseEntity<Object>> getPolicyTypeDefinition(String policyTypeId, String accept, ServerWebExchange exchange) throws Exception {
- return null;
+ return policyService.getPolicyTypeDefinitionService(policyTypeId);
}
@Override
public Mono<ResponseEntity<Flux<PolicyTypeInformation>>> getPolicyTypes(String nearRtRicId, String typeName, String compatibleWithVersion, String accept, ServerWebExchange exchange) throws Exception {
- return null;
+ return policyService.getPolicyTypesService(nearRtRicId, typeName, compatibleWithVersion, exchange);
}
@Override
public Mono<ResponseEntity<Object>> putPolicy(String policyId, Mono<Object> body, ServerWebExchange exchange) throws Exception {
- return null;
+ return body.flatMap(payload -> policyService.putPolicyService(policyId, payload, exchange));
}
}
package org.onap.ccsdk.oran.a1policymanagementservice.service.v3;
+import com.google.gson.Gson;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
import org.onap.ccsdk.oran.a1policymanagementservice.controllers.authorization.PolicyAuthorizationRequest.Input.AccessType;
+import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.Consts;
+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.*;
import org.onap.ccsdk.oran.a1policymanagementservice.util.v3.Helper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
+import java.lang.invoke.MethodHandles;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+
@Service
public class PolicyService {
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Autowired
private Helper helper;
@Autowired
private ErrorHandlingService errorHandlingService;
+ @Autowired
+ private Gson gson;
+
public Mono<ResponseEntity<PolicyObjectInformation>> createPolicyService
(PolicyObjectInformation policyObjectInfo, ServerWebExchange serverWebExchange) {
try {
- if (!helper.jsonSchemaValidation(policyObjectInfo.getPolicyObject()))
+ if (!helper.jsonSchemaValidation(gson.toJson(policyObjectInfo.getPolicyObject(), Map.class)))
return Mono.error(new ServiceException("Schema validation failed", HttpStatus.BAD_REQUEST));
Ric ric = rics.getRic(policyObjectInfo.getNearRtRicId());
PolicyType policyType = policyTypes.getType(policyObjectInfo.getPolicyTypeId());
Policy policy = helper.buildPolicy(policyObjectInfo, policyType, ric, helper.policyIdGeneration());
return helper.isPolicyAlreadyCreated(policy,policies)
.doOnError(error -> errorHandlingService.handleError(error))
- .flatMap(policyBuilt -> authorizationService.authCheck(serverWebExchange, policy, AccessType.WRITE))
+ .flatMap(policyBuilt -> authorizationService.authCheck(serverWebExchange, policy, AccessType.WRITE)
.doOnError(error -> errorHandlingService.handleError(error))
.flatMap(policyNotUsed -> ric.getLock().lock(Lock.LockType.SHARED, "createPolicy"))
.flatMap(grant -> postPolicy(policy, grant))
.map(locationHeaderValue ->
new ResponseEntity<PolicyObjectInformation>(policyObjectInfo,helper.createHttpHeaders(
"location",helper.buildURI(policy.getId(), serverWebExchange)), HttpStatus.CREATED))
- .doOnError(error -> errorHandlingService.handleError(error));
+ .doOnError(error -> errorHandlingService.handleError(error)));
} catch (Exception ex) {
return Mono.error(ex);
}
.doFinally(releaseLock -> grant.unlockBlocking())
.doOnError(error -> errorHandlingService.handleError(error));
}
+
+ public Mono<ResponseEntity<Object>> putPolicyService(String policyId, Object body, ServerWebExchange exchange) {
+
+ try {
+ Policy existingPolicy = policies.getPolicy(policyId);
+ PolicyObjectInformation pos =
+ new PolicyObjectInformation(existingPolicy.getRic().getConfig().getRicId(), body, existingPolicy.getType().getId());
+ Policy updatedPolicy = helper.buildPolicy(pos, existingPolicy.getType(), existingPolicy.getRic(), policyId);
+ Ric ric = existingPolicy.getRic();
+ ric.getLock().lock(Lock.LockType.SHARED, "updatePolicy")
+ .flatMap(grant -> postPolicy(updatedPolicy, grant))
+ .doOnError(error -> errorHandlingService.handleError(error));
+ return Mono.just(new ResponseEntity<>(policies.getPolicy(policyId), HttpStatus.OK));
+ } catch(Exception ex) {
+ return Mono.error(ex);
+ }
+ }
+
+ public Mono<ResponseEntity<Flux<PolicyTypeInformation>>> getPolicyTypesService(String nearRtRicId, String typeName,
+ String compatibleWithVersion,
+ ServerWebExchange webExchange) throws Exception {
+ if (compatibleWithVersion != null && typeName == null) {
+ throw new ServiceException("Parameter " + Consts.COMPATIBLE_WITH_VERSION_PARAM + " can only be used when "
+ + Consts.TYPE_NAME_PARAM + " is given", HttpStatus.BAD_REQUEST);
+ }
+ Collection<PolicyTypeInformation> listOfPolicyTypes = new ArrayList<>();
+ if (nearRtRicId == null || nearRtRicId.isEmpty() || nearRtRicId.isBlank()) {
+ for(Ric ric : rics.getRics()) {
+ Collection<PolicyType> policyTypes = PolicyTypes.filterTypes(ric.getSupportedPolicyTypes(), typeName,
+ compatibleWithVersion);
+ listOfPolicyTypes.addAll(helper.toPolicyTypeInfoCollection(policyTypes, ric));
+ }
+ } else {
+ Ric ric = rics.get(nearRtRicId);
+ if (ric == null)
+ throw new EntityNotFoundException("Near-RT RIC not Found using ID: " +nearRtRicId);
+ Collection<PolicyType> policyTypes = PolicyTypes.filterTypes(ric.getSupportedPolicyTypes(), typeName,
+ compatibleWithVersion);
+ listOfPolicyTypes.addAll(helper.toPolicyTypeInfoCollection(policyTypes, ric));
+ }
+ return Mono.just(new ResponseEntity<>(Flux.fromIterable(listOfPolicyTypes), HttpStatus.OK));
+ }
+
+ public Mono<ResponseEntity<Flux<PolicyInformation>>> getPolicyIdsService(String policyTypeId, String nearRtRicId,
+ String serviceId, String typeName,
+ ServerWebExchange exchange) throws EntityNotFoundException {
+ if ((policyTypeId != null && this.policyTypes.get(policyTypeId) == null))
+ throw new EntityNotFoundException("Policy type not found using ID: " +policyTypeId);
+ if ((nearRtRicId != null && this.rics.get(nearRtRicId) == null))
+ throw new EntityNotFoundException("Near-RT RIC not found using ID: " +nearRtRicId);
+
+ Collection<Policy> filtered = policies.filterPolicies(policyTypeId, nearRtRicId, serviceId, typeName);
+ return Flux.fromIterable(filtered)
+ .flatMap(policy -> authorizationService.authCheck(exchange, policy, AccessType.READ))
+ .onErrorContinue((error,item) -> logger.warn("Error occurred during authorization check for " +
+ "policy {}: {}", item, error.getMessage()))
+ .collectList()
+ .map(authPolicies -> new ResponseEntity<>(helper.toFluxPolicyInformation(authPolicies), HttpStatus.OK))
+ .doOnError(error -> logger.error(error.getMessage()));
+ }
+
+ public Mono<ResponseEntity<Object>> getPolicyService(String policyId, ServerWebExchange serverWebExchange)
+ throws EntityNotFoundException{
+ Policy policy = policies.getPolicy(policyId);
+ return authorizationService.authCheck(serverWebExchange, policy, AccessType.READ)
+ .map(x -> new ResponseEntity<Object>(policy.getJson(), HttpStatus.OK))
+ .doOnError(error -> errorHandlingService.handleError(error));
+ }
+
+ public Mono<ResponseEntity<Object>> getPolicyTypeDefinitionService(String policyTypeId)
+ throws EntityNotFoundException{
+ PolicyType singlePolicyType = policyTypes.get(policyTypeId);
+ if (singlePolicyType == null)
+ throw new EntityNotFoundException("PolicyType not found with ID: " + policyTypeId);
+ return Mono.just(new ResponseEntity<Object>(singlePolicyType.getSchema(), HttpStatus.OK));
+ }
+
+ public Mono<ResponseEntity<Void>> deletePolicyService(String policyId, ServerWebExchange serverWebExchange)
+ throws EntityNotFoundException {
+ Policy singlePolicy = policies.getPolicy(policyId);
+ return authorizationService.authCheck(serverWebExchange, singlePolicy, AccessType.WRITE)
+ .doOnError(error -> errorHandlingService.handleError(error))
+ .flatMap(policy -> policy.getRic().getLock().lock(Lock.LockType.SHARED, "deletePolicy"))
+ .flatMap(grant -> deletePolicy(singlePolicy, grant))
+ .doOnError(error -> errorHandlingService.handleError(error));
+ }
+
+ private Mono<ResponseEntity<Void>> deletePolicy(Policy policy, Lock.Grant grant) {
+ System.out.println();
+ return helper.checkRicStateIdle(policy.getRic())
+ .doOnError(error -> errorHandlingService.handleError(error))
+ .flatMap(ric -> helper.checkSupportedType(ric, policy.getType()))
+ .doOnError(error -> errorHandlingService.handleError(error))
+ .flatMap(ric -> a1ClientFactory.createA1Client(ric))
+ .flatMap(a1Client -> a1Client.deletePolicy(policy))
+ .doOnError(error -> errorHandlingService.handleError(error))
+ .doOnNext(policyString -> policies.remove(policy))
+ .doFinally(releaseLock -> grant.unlockBlocking())
+ .map(successResponse -> new ResponseEntity<Void>(HttpStatus.NO_CONTENT))
+ .doOnError(error -> errorHandlingService.handleError(error));
+ }
}
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
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.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
+import reactor.core.publisher.Flux;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;
import java.lang.invoke.MethodHandles;
import java.time.Instant;
+import java.util.Collection;
import java.util.UUID;
+import java.util.stream.Collectors;
@Component
public class Helper {
}
return Mono.just(policy);
}
+
+ public Flux<PolicyInformation> toFluxPolicyInformation(Collection<Policy> policyCollection) {
+ return Flux.fromIterable(policyCollection.stream()
+ .map(singlePolicy -> new PolicyInformation(singlePolicy.getId(), singlePolicy.getRic().getConfig().getRicId()))
+ .collect(Collectors.toList()));
+ }
+
+ public Collection<PolicyTypeInformation> toPolicyTypeInfoCollection(Collection<PolicyType> policyTypeCollection, Ric ric) {
+ return policyTypeCollection.stream()
+ .map(type -> new PolicyTypeInformation(type.getId(), ric.getConfig().getRicId()))
+ .collect(Collectors.toList());
+ }
}
package org.onap.ccsdk.oran.a1policymanagementservice.controllers.v3;
import org.junit.jupiter.api.*;
-import org.mockito.Mockito;
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.repository.Rics;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Services;
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.onap.ccsdk.oran.a1policymanagementservice.utils.MockA1ClientFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import java.lang.invoke.MethodHandles;
import java.nio.file.Path;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@TestMethodOrder(MethodOrderer.MethodName.class)
@Autowired
private ApplicationConfig applicationConfig;
+
@Autowired
private TestHelper testHelper;
testHelper.addPolicyType(policyTypeName, nonRtRicId);
String policyBody = testHelper.postPolicyBody(nonRtRicId, policyTypeName);
Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
- testHelper.testSuccessResponse(responseMono, HttpStatus.CREATED, "{\"servingCellNrcgi\":\"1\"}");
+ testHelper.testSuccessResponse(responseMono, HttpStatus.CREATED, "{\"scope\":{\"ueId\":\"ue5100\",\"qosId\":\"qos5100\"},\"qosObjectives\":{\"priorityLevel\":5100.0}}");
}
@Test
String policyTypeName = "type1_1.2.3";
String url = "/policies";
testHelper.addPolicyType(policyTypeName, nonRtRicId);
-
- when(helper.jsonSchemaValidation(Mockito.any())).thenReturn(Boolean.FALSE);
+ when(helper.jsonSchemaValidation(any())).thenReturn(Boolean.FALSE);
String policyBody = testHelper.postPolicyBody(nonRtRicId, policyTypeName);
Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
testHelper.testErrorCode(responseMono, HttpStatus.BAD_REQUEST, " Schema validation failed");
String policyTypeName = "type1_1.2.3";
String url = "/policies";
testHelper.addPolicyType(policyTypeName, " ");
+ when(helper.jsonSchemaValidation(any())).thenReturn(Boolean.TRUE);
String policyBody = testHelper.postPolicyBody("noRic", policyTypeName);
Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
testHelper.testErrorCode(responseMono, HttpStatus.NOT_FOUND, " Could not find ric: noRic");
String nonRtRicId = "ricOne";
String url = "/policies";
testHelper.addPolicyType(policyTypeName, nonRtRicId);
+ when(helper.jsonSchemaValidation(any())).thenReturn(Boolean.TRUE);
String policyBody = testHelper.postPolicyBody(nonRtRicId, "noPolicyType");
Mono<ResponseEntity<String>> responseMono = testHelper.restClientV3().postForEntity(url, policyBody);
testHelper.testErrorCode(responseMono, HttpStatus.NOT_FOUND, "Could not find type: noPolicyType");
package org.onap.ccsdk.oran.a1policymanagementservice.service.v3;
-import org.junit.jupiter.api.MethodOrderer;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.*;
import org.mockito.Mockito;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyObjectInformation;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policy;
-import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyTypes;
-import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
+import org.onap.ccsdk.oran.a1policymanagementservice.service.v3.AuthorizationService;
+import org.onap.ccsdk.oran.a1policymanagementservice.service.v3.PolicyService;
import org.onap.ccsdk.oran.a1policymanagementservice.util.v3.Helper;
import org.onap.ccsdk.oran.a1policymanagementservice.utils.v3.TestHelper;
+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.mock.mockito.MockBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
+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.Mono;
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.nio.file.Path;
+
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@TestMethodOrder(MethodOrderer.MethodName.class)
@SpringBootTest()
+@TestPropertySource(properties = { //
+ "app.vardata-directory=/tmp/pmstestv3", //
+})
public class PolicyServiceTest {
- @Autowired
- private Rics rics;
-
- @Autowired
- private PolicyTypes policyTypes;
-
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Autowired
private Policies policies;
@MockBean
private AuthorizationService authorizationService;
+ @AfterEach
+ public void clear() {
+ policies.clear();
+ }
+
+ @AfterAll
+ static void clearTestDir() {
+ try {
+ FileSystemUtils.deleteRecursively(Path.of("/tmp/pmstestv3"));
+ } catch (Exception e) {
+ logger.warn("Could test directory : {}", e.getMessage());
+ }
+ }
+
@Test
- public void testPolicyAlreadyCreatedFail() {
+ public void testPolicyAlreadyCreatedTrue() throws Exception{
String policyTypeName = "uri_type_123";
String nonRtRicId = "Ric_347";
testHelper.addPolicyType(policyTypeName, nonRtRicId);
ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
+ Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
when(helper.jsonSchemaValidation(any())).thenReturn(Boolean.TRUE);
+ when(helper.buildPolicy(any(),any(), any(), any())).thenReturn(policy);
when(helper.isPolicyAlreadyCreated(any(), any())).thenReturn(Mono.error(new ServiceException
- ("Policy already created", HttpStatus.CONFLICT)));
+ ("Same policy content already created with policy ID: 122344-5674", HttpStatus.BAD_REQUEST)));
Mono<ResponseEntity<PolicyObjectInformation>> responseMono = policyService.createPolicyService(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), serverWebExchange);
- testHelper.verifyMockError(responseMono, "Policy already created");
+ testHelper.verifyMockError(responseMono, "Same policy content already created with policy ID: 122344-5674");
}
@Test
- public void testPolicyNotAuthorizedFail() {
+ public void testPolicyNotAuthorizedFail() throws IOException {
String policyTypeName = "uri_type_123";
String nonRtRicId = "Ric_347";
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.io.CharStreams;
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClient;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClientFactory;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.SecurityContext;
import reactor.test.StepVerifier;
import reactor.util.annotation.Nullable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
import java.util.ArrayList;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;
@Autowired
private ObjectMapper objectMapper;
+ @Autowired
+ private Gson gson;
+
public int port;
public AsyncRestClient restClientV3() {
}
}
- public PolicyType createPolicyType(String policyTypeName) {
+ public PolicyType createPolicyType(String policyTypeName, String filePath) throws IOException {
+ InputStream in = getClass().getResourceAsStream(filePath);
+ assert in != null;
+ String schema = CharStreams.toString(new InputStreamReader(in, StandardCharsets.UTF_8));
return PolicyType.builder()
.id(policyTypeName)
- .schema("{\"title\":\"" + policyTypeName + "\"}")
+ .schema(schema)
.build();
}
this.rics.put(ric);
return ric;
}
- public PolicyType addPolicyType(String policyTypeName, String ricId) {
- PolicyType type = createPolicyType(policyTypeName);
+ public PolicyType addPolicyType(String policyTypeName, String ricId) throws IOException {
+ PolicyType type = createPolicyType(policyTypeName, "/policy_types/demo-policy-schema-3.json");
policyTypes.put(type);
addRic(ricId).addSupportedPolicyType(type);
return type;
}
- public Map<String,String> jsonString() {
- Map<String,String> policyDataInMap = new HashMap<>();
- policyDataInMap.put("servingCellNrcgi","1");
- return policyDataInMap;
+ public String postPolicyBody(String nearRtRicId, String policyTypeName) {
+ PolicyObjectInformation policyObjectInfo = new PolicyObjectInformation(nearRtRicId, dummyPolicyObject(), policyTypeName);
+ return gson.toJson(policyObjectInfo);
}
- public String postPolicyBody(String nearRtRicId, String policyTypeName) throws JsonProcessingException {
- PolicyObjectInformation policyObjectInfo = new PolicyObjectInformation(nearRtRicId, jsonString());
- policyObjectInfo.setPolicyTypeId(policyTypeName);
- policyObjectInfo.setPolicyObject(dummyPolicyObject());
- return objectMapper.writeValueAsString(policyObjectInfo);
+ public PolicyObjectInformation policyObjectInfo(String nearRtRicId, String policyTypeName) {
+ return gson.fromJson(postPolicyBody(nearRtRicId, policyTypeName), PolicyObjectInformation.class);
}
- public PolicyObjectInformation policyObjectInfo(String nearRtRicId, String policyTypeName) {
- PolicyObjectInformation policyObjectInfo = new PolicyObjectInformation(nearRtRicId, jsonString());
- policyObjectInfo.setPolicyTypeId(policyTypeName);
- policyObjectInfo.setPolicyObject(dummyPolicyObject());
- return policyObjectInfo;
+ public JsonObject dummyPolicyObject() {
+ return JsonParser.parseString("{\n" +
+ " \"scope\": {\n" +
+ " \"ueId\": \"ue5100\",\n" +
+ " \"qosId\": \"qos5100\"\n" +
+ " },\n" +
+ " \"qosObjectives\": {\n" +
+ " \"priorityLevel\": 5100.0\n" +
+ " }\n" +
+ " }").getAsJsonObject();
}
- private Map<String,String> dummyPolicyObject() {
- Map<String,String> policyDataInMap = new HashMap<>();
- policyDataInMap.put("servingCellNrcgi","1");
- return policyDataInMap;
+ public Policy buidTestPolicy(PolicyObjectInformation policyInfo, String id) throws Exception{
+ return Policy.builder().ric(rics.getRic(policyInfo.getNearRtRicId()))
+ .type(policyTypes.getType(policyInfo.getPolicyTypeId()))
+ .json(objectMapper.writeValueAsString(policyInfo.getPolicyObject()))
+ .lastModified(Instant.now())
+ .id(id).build();
}
public String createServiceJson(String name, long keepAliveIntervalSeconds) throws JsonProcessingException {
Code Review / ccsdk / oran.git / commitdiff