Adapting to OSC A1 API

Implemented protocol adapter for the current OSC
A1 API implementation.

Change-Id: I2658a4340087a32f58bc9ab544bda740cbcbba99
Issue-ID: NONRTRIC-84
Signed-off-by: PatrikBuhr <patrik.buhr@est.tech>

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/clients/A1Client.java b/policy-agent/src/main/java/org/oransc/policyagent/clients/A1Client.java
index 31b5142..9814943 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/clients/A1Client.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/clients/A1Client.java
@@ -20,27 +20,31 @@
 
 package org.oransc.policyagent.clients;
 
-import java.util.Collection;
+import java.util.List;
 
 import org.oransc.policyagent.repository.Policy;
+
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public interface A1Client {
 
     public static enum A1ProtocolType {
-        UNKNOWN, STD_V1
+        UNKNOWN, STD_V1, OSC_V1
     }
 
     public Mono<A1ProtocolType> getProtocolVersion();
 
-    public Mono<Collection<String>> getPolicyTypeIdentities();
+    public Mono<List<String>> getPolicyTypeIdentities();
 
-    public Mono<Collection<String>> getPolicyIdentities();
+    public Mono<List<String>> getPolicyIdentities();
 
     public Mono<String> getPolicyTypeSchema(String policyTypeId);
 
     public Mono<String> putPolicy(Policy policy);
 
-    public Mono<String> deletePolicy(String policyId);
+    public Mono<String> deletePolicy(Policy policy);
+
+    public Flux<String> deleteAllPolicies();
 
 }

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/clients/A1ClientFactory.java b/policy-agent/src/main/java/org/oransc/policyagent/clients/A1ClientFactory.java
index a3d17bc..cb8f9dd 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/clients/A1ClientFactory.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/clients/A1ClientFactory.java
@@ -39,6 +39,8 @@ public class A1ClientFactory {
     private Mono<A1Client> createA1Client(Ric ric, A1ProtocolType version) {
         if (version == A1ProtocolType.STD_V1) {
             return Mono.just(createStdA1ClientImpl(ric));
+        } else if (version == A1ProtocolType.OSC_V1) {
+            return Mono.just(new OscA1Client(ric.getConfig()));
         }
         return Mono.error(new ServiceException("Not supported protocoltype: " + version));
     }

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/clients/AsyncRestClient.java b/policy-agent/src/main/java/org/oransc/policyagent/clients/AsyncRestClient.java
index 45c7afa..e2e5d64 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/clients/AsyncRestClient.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/clients/AsyncRestClient.java
@@ -19,12 +19,17 @@
  */
 package org.oransc.policyagent.clients;
 
+import java.lang.invoke.MethodHandles;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.web.reactive.function.client.WebClient;
 import reactor.core.publisher.Mono;
 
 public class AsyncRestClient {
+    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
     private final WebClient client;
 
     private static class AsyncRestClientException extends Exception {
@@ -41,6 +46,7 @@ public class AsyncRestClient {
     }
 
     public Mono<String> put(String uri, String body) {
+        logger.debug("PUT uri = '{}''", uri);
         return client.put() //
             .uri(uri) //
             .contentType(MediaType.APPLICATION_JSON) //
@@ -52,6 +58,7 @@ public class AsyncRestClient {
     }
 
     public Mono<String> get(String uri) {
+        logger.debug("GET uri = '{}''", uri);
         return client.get() //
             .uri(uri) //
             .retrieve() //
@@ -61,6 +68,7 @@ public class AsyncRestClient {
     }
 
     public Mono<String> delete(String uri) {
+        logger.debug("DELETE uri = '{}''", uri);
         return client.delete() //
             .uri(uri) //
             .retrieve() //

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/clients/OscA1Client.java b/policy-agent/src/main/java/org/oransc/policyagent/clients/OscA1Client.java
index 273f27b..dd77504 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/clients/OscA1Client.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/clients/OscA1Client.java
@@ -21,52 +21,113 @@
 package org.oransc.policyagent.clients;
 
 import java.lang.invoke.MethodHandles;
-import java.util.Collection;
+import java.util.ArrayList;
+import java.util.List;
 
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
 import org.oransc.policyagent.configuration.RicConfig;
 import org.oransc.policyagent.repository.Policy;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public class OscA1Client implements A1Client {
     private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
-    private final RicConfig ricConfig;
+    private final AsyncRestClient restClient;
 
     public OscA1Client(RicConfig ricConfig) {
-        this.ricConfig = ricConfig;
-        logger.debug("OscA1Client for ric: {}", this.ricConfig.name());
+        String baseUrl = ricConfig.baseUrl() + "/a1-p";
+        this.restClient = new AsyncRestClient(baseUrl);
+        logger.debug("OscA1Client for ric: {}", ricConfig.name());
     }
 
     @Override
-    public Mono<Collection<String>> getPolicyTypeIdentities() {
-        return Mono.error(new Exception("Not impl"));
+    public Mono<List<String>> getPolicyTypeIdentities() {
+        return restClient.get("/policytypes") //
+            .flatMap(this::parseJsonArrayOfString);
     }
 
     @Override
-    public Mono<Collection<String>> getPolicyIdentities() {
-        return Mono.error(new Exception("Not impl"));
+    public Mono<List<String>> getPolicyIdentities() {
+        return getPolicyTypeIdentities() //
+            .flatMapMany(types -> Flux.fromIterable(types)) //
+            .flatMap(type -> getPolicyIdentities(type)) //
+            .flatMap(policyIds -> Flux.fromIterable(policyIds)) //
+            .collectList();
+    }
+
+    private Mono<List<String>> getPolicyIdentities(String typeId) {
+        return restClient.get("/policytypes/" + typeId + "/policies") //
+            .flatMap(this::parseJsonArrayOfString);
     }
 
     @Override
     public Mono<String> getPolicyTypeSchema(String policyTypeId) {
-        return Mono.error(new Exception("Not impl"));
+        return restClient.get("/policytypes/" + policyTypeId) //
+            .flatMap(response -> getCreateSchema(response, policyTypeId));
+    }
+
+    private Mono<String> getCreateSchema(String policyTypeResponse, String policyTypeId) {
+        try {
+            JSONObject obj = new JSONObject(policyTypeResponse);
+            JSONObject schemaObj = obj.getJSONObject("create_schema");
+            schemaObj.put("title", policyTypeId);
+            return Mono.just(schemaObj.toString());
+        } catch (Exception e) {
+            logger.error("Unexcpected response for policy type: {}", policyTypeResponse, e);
+            return Mono.error(e);
+        }
     }
 
     @Override
     public Mono<String> putPolicy(Policy policy) {
-        return Mono.error(new Exception("Not impl"));
+        return restClient.put("/policytypes/" + policy.type().name() + "/policies/" + policy.id(), policy.json());
     }
 
     @Override
-    public Mono<String> deletePolicy(String policyId) {
-        return Mono.error(new Exception("Not impl"));
+    public Mono<String> deletePolicy(Policy policy) {
+        return deletePolicy(policy.type().name(), policy.id());
+    }
+
+    private Mono<String> deletePolicy(String typeId, String policyId) {
+        return restClient.delete("/policytypes/" + typeId + "/policies/" + policyId);
     }
 
     @Override
     public Mono<A1ProtocolType> getProtocolVersion() {
-        return Mono.error(new Exception("Not impl"));
+        return restClient.get("/healthcheck") //
+            .flatMap(resp -> Mono.just(A1ProtocolType.OSC_V1));
     }
 
+    @Override
+    public Flux<String> deleteAllPolicies() {
+        return getPolicyTypeIdentities() //
+            .flatMapMany(types -> Flux.fromIterable(types)) //
+            .flatMap(typeId -> deletePoliciesForType(typeId)); //
+    }
+
+    private Flux<String> deletePoliciesForType(String typeId) {
+        return getPolicyIdentities(typeId) //
+            .flatMapMany(policyIds -> Flux.fromIterable(policyIds)) //
+            .flatMap(policyId -> deletePolicy(typeId, policyId)); //
+    }
+
+    private Mono<List<String>> parseJsonArrayOfString(String inputString) {
+        try {
+            List<String> arrayList = new ArrayList<>();
+            JSONArray jsonArray = new JSONArray(inputString);
+            for (int i = 0; i < jsonArray.length(); i++) {
+                arrayList.add(jsonArray.getString(i));
+            }
+            logger.debug("A1 client: received list = {}", arrayList);
+            return Mono.just(arrayList);
+        } catch (JSONException ex) { // invalid json
+            return Mono.error(ex);
+        }
+    }
 }

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/clients/StdA1Client.java b/policy-agent/src/main/java/org/oransc/policyagent/clients/StdA1Client.java
index 4eb0c06..4c1d140 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/clients/StdA1Client.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/clients/StdA1Client.java
@@ -22,7 +22,6 @@ package org.oransc.policyagent.clients;
 
 import java.lang.invoke.MethodHandles;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 
 import org.json.JSONArray;
@@ -32,49 +31,44 @@ import org.oransc.policyagent.configuration.RicConfig;
 import org.oransc.policyagent.repository.Policy;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public class StdA1Client implements A1Client {
     private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
-    private final RicConfig ricConfig;
     private final AsyncRestClient restClient;
 
     public StdA1Client(RicConfig ricConfig) {
-        this.ricConfig = ricConfig;
-        this.restClient = new AsyncRestClient(getBaseUrl());
+        String baseUrl = ricConfig.baseUrl() + "/A1-P/v1";
+        this.restClient = new AsyncRestClient(baseUrl);
     }
 
     public StdA1Client(RicConfig ricConfig, AsyncRestClient restClient) {
-        this.ricConfig = ricConfig;
         this.restClient = restClient;
     }
 
     @Override
-    public Mono<Collection<String>> getPolicyTypeIdentities() {
-        logger.debug("getPolicyTypeIdentities nearRtRicUrl = {}", ricConfig.baseUrl());
+    public Mono<List<String>> getPolicyTypeIdentities() {
         return restClient.get("/policytypes/identities") //
             .flatMap(this::parseJsonArrayOfString);
     }
 
     @Override
-    public Mono<Collection<String>> getPolicyIdentities() {
-        logger.debug("getPolicyIdentities nearRtRicUrl = {}", ricConfig.baseUrl());
+    public Mono<List<String>> getPolicyIdentities() {
         return restClient.get("/policies/identities") //
             .flatMap(this::parseJsonArrayOfString);
     }
 
     @Override
     public Mono<String> getPolicyTypeSchema(String policyTypeId) {
-        logger.debug("getPolicyType nearRtRicUrl = {}, policyTypeId = {}", ricConfig.baseUrl(), policyTypeId);
         Mono<String> response = restClient.get("/policytypes/" + policyTypeId);
         return response.flatMap(this::createMono);
     }
 
     @Override
     public Mono<String> putPolicy(Policy policy) {
-        logger.debug("putPolicy nearRtRicUrl = {}, policyId = {}, policyString = {}", //
-            policy.ric().getConfig().baseUrl(), policy.id(), policy.json());
         // TODO update when simulator is updated to include policy type
         // Mono<String> response = client.put("/policies/" + policy.id() + "?policyTypeId=" + policy.type().name(),
         // policy.json());
@@ -84,9 +78,15 @@ public class StdA1Client implements A1Client {
     }
 
     @Override
-    public Mono<String> deletePolicy(String policyId) {
-        logger.debug("deletePolicy nearRtRicUrl = {}, policyId = {}", ricConfig.baseUrl(), policyId);
-        return restClient.delete("/policies/" + policyId);
+    public Mono<String> deletePolicy(Policy policy) {
+        return deletePolicy(policy.id());
+    }
+
+    @Override
+    public Flux<String> deleteAllPolicies() {
+        return getPolicyIdentities() //
+            .flatMapMany(policyIds -> Flux.fromIterable(policyIds)) // )
+            .flatMap(policyId -> deletePolicy(policyId)); //
     }
 
     @Override
@@ -95,11 +95,11 @@ public class StdA1Client implements A1Client {
             .flatMap(x -> Mono.just(A1ProtocolType.STD_V1));
     }
 
-    private String getBaseUrl() {
-        return ricConfig.baseUrl() + "/A1-P/v1";
+    private Mono<String> deletePolicy(String policyId) {
+        return restClient.delete("/policies/" + policyId);
     }
 
-    private Mono<Collection<String>> parseJsonArrayOfString(String inputString) {
+    private Mono<List<String>> parseJsonArrayOfString(String inputString) {
         try {
             List<String> arrayList = new ArrayList<>();
             JSONArray jsonArray = new JSONArray(inputString);

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/controllers/PolicyController.java b/policy-agent/src/main/java/org/oransc/policyagent/controllers/PolicyController.java
index 1b2ebb4..f794ab5 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/controllers/PolicyController.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/controllers/PolicyController.java
@@ -148,7 +148,7 @@ public class PolicyController {
         if (policy != null && policy.ric().state().equals(Ric.RicState.IDLE)) {
             policies.remove(policy);
             return a1ClientFactory.createA1Client(policy.ric()) //
-                .flatMap(client -> client.deletePolicy(id)) //
+                .flatMap(client -> client.deletePolicy(policy)) //
                 .flatMap(notUsed -> {
                     return Mono.just(new ResponseEntity<>(HttpStatus.NO_CONTENT));
                 });

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/tasks/RicRecoveryTask.java b/policy-agent/src/main/java/org/oransc/policyagent/tasks/RicRecoveryTask.java
index d7e8551..543fdf8 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/tasks/RicRecoveryTask.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/tasks/RicRecoveryTask.java
@@ -82,7 +82,7 @@ public class RicRecoveryTask {
 
     private Flux<Object> startRecover(Ric ric, A1Client a1Client) {
         Flux<PolicyType> recoverTypes = recoverPolicyTypes(ric, a1Client);
-        Flux<?> deletePoliciesInRic = deleteAllPoliciesInRic(ric, a1Client);
+        Flux<?> deletePoliciesInRic = a1Client.deleteAllPolicies();
         Flux<?> recreatePoliciesInRic = recreateAllPoliciesInRic(ric, a1Client);
 
         return Flux.concat(recoverTypes, deletePoliciesInRic, recreatePoliciesInRic);
@@ -116,7 +116,7 @@ public class RicRecoveryTask {
         Flux<PolicyType> recoverTypes = this.a1ClientFactory.createA1Client(ric) //
             .flatMapMany(a1Client -> recoverPolicyTypes(ric, a1Client));
         Flux<?> deletePoliciesInRic = this.a1ClientFactory.createA1Client(ric) //
-            .flatMapMany(a1Client -> deleteAllPoliciesInRic(ric, a1Client));
+            .flatMapMany(a1Client -> a1Client.deleteAllPolicies());
 
         Flux.merge(recoverTypes, deletePoliciesInRic) //
             .subscribe(x -> logger.debug("Brute recover: " + x), //
@@ -168,13 +168,6 @@ public class RicRecoveryTask {
         }
     }
 
-    private Flux<String> deleteAllPoliciesInRic(Ric ric, A1Client a1Client) {
-        return a1Client.getPolicyIdentities() //
-            .flatMapMany(policyIds -> Flux.fromIterable(policyIds)) //
-            .doOnNext(policyId -> logger.debug("Deleting policy: {}, for ric: {}", policyId, ric.getConfig().name()))
-            .flatMap(policyId -> a1Client.deletePolicy(policyId)); //
-    }
-
     private Flux<String> recreateAllPoliciesInRic(Ric ric, A1Client a1Client) {
         synchronized (policies) {
             return Flux.fromIterable(new Vector<>(policies.getForRic(ric.name()))) //

diff --git a/policy-agent/src/main/java/org/oransc/policyagent/tasks/ServiceSupervision.java b/policy-agent/src/main/java/org/oransc/policyagent/tasks/ServiceSupervision.java
index d75ff4f..d4b32e0 100644 (file)
--- a/policy-agent/src/main/java/org/oransc/policyagent/tasks/ServiceSupervision.java
+++ b/policy-agent/src/main/java/org/oransc/policyagent/tasks/ServiceSupervision.java
@@ -87,7 +87,7 @@ public class ServiceSupervision {
 
     private Mono<Policy> deletePolicyInRic(Policy policy) {
         return a1ClientFactory.createA1Client(policy.ric()) //
-            .flatMap(client -> client.deletePolicy(policy.id()) //
+            .flatMap(client -> client.deletePolicy(policy) //
                 .onErrorResume(exception -> handleDeleteFromRicFailure(policy, exception)) //
                 .map((nothing) -> policy));
     }

diff --git a/policy-agent/src/test/java/org/oransc/policyagent/clients/StdA1ClientTest.java b/policy-agent/src/test/java/org/oransc/policyagent/clients/StdA1ClientTest.java
index ee1e8df..1454cca 100644 (file)
--- a/policy-agent/src/test/java/org/oransc/policyagent/clients/StdA1ClientTest.java
+++ b/policy-agent/src/test/java/org/oransc/policyagent/clients/StdA1ClientTest.java
@@ -163,7 +163,8 @@ public class StdA1ClientTest {
     public void testDeletePolicy() {
         when(asyncRestClientMock.delete(POLICIES_URL + POLICY_1_ID)).thenReturn(Mono.empty());
 
-        Mono<?> responseMono = a1Client.deletePolicy(POLICY_1_ID);
+        Policy policy = createPolicy(RIC_URL, POLICY_1_ID, POLICY_JSON_VALID, POLICY_TYPE);
+        Mono<?> responseMono = a1Client.deletePolicy(policy);
         verify(asyncRestClientMock).delete(POLICIES_URL + POLICY_1_ID);
         StepVerifier.create(responseMono).expectComplete().verify();
     }

diff --git a/policy-agent/src/test/java/org/oransc/policyagent/tasks/RepositorySupervisionTest.java b/policy-agent/src/test/java/org/oransc/policyagent/tasks/RepositorySupervisionTest.java
index 4bbe316..20e54f0 100644 (file)
--- a/policy-agent/src/test/java/org/oransc/policyagent/tasks/RepositorySupervisionTest.java
+++ b/policy-agent/src/test/java/org/oransc/policyagent/tasks/RepositorySupervisionTest.java
@@ -29,7 +29,7 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import java.util.Arrays;
-import java.util.Collection;
+import java.util.List;
 import java.util.Vector;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -52,6 +52,8 @@ 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 reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 @ExtendWith(MockitoExtension.class)
@@ -112,13 +114,13 @@ public class RepositorySupervisionTest {
         RepositorySupervision supervisorUnderTest =
             new RepositorySupervision(rics, policies, a1ClientFactory, types, services);
 
-        Mono<Collection<String>> policyIds = Mono.just(Arrays.asList("policyId1", "policyId2"));
+        Mono<List<String>> policyIds = Mono.just(Arrays.asList("policyId1", "policyId2"));
 
         doReturn(policyIds).when(a1ClientMock).getPolicyTypeIdentities();
         doReturn(policyIds).when(a1ClientMock).getPolicyIdentities();
-        doReturn(Mono.empty()).when(a1ClientMock).deletePolicy(anyString());
         doReturn(Mono.just("schema")).when(a1ClientMock).getPolicyTypeSchema(anyString());
         doReturn(Mono.just("OK")).when(a1ClientMock).putPolicy(any());
+        doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies();
 
         supervisorUnderTest.checkAllRics();
 
@@ -126,7 +128,7 @@ public class RepositorySupervisionTest {
         await().untilAsserted(() -> RicState.IDLE.equals(ric2.state()));
         await().untilAsserted(() -> RicState.IDLE.equals(ric3.state()));
 
-        verify(a1ClientMock, times(3)).deletePolicy("policyId2");
+        verify(a1ClientMock, times(3)).deleteAllPolicies();
         verifyNoMoreInteractions(a1ClientMock);
     }
 }

diff --git a/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java b/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java
index 9e4701d..bd1b058 100644 (file)
--- a/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java
+++ b/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java
@@ -35,7 +35,7 @@ import static org.mockito.Mockito.when;
 import static org.oransc.policyagent.repository.Ric.RicState.IDLE;
 
 import java.util.Arrays;
-import java.util.Collection;
+import java.util.List;
 import java.util.Vector;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -55,6 +55,8 @@ 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 reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 @ExtendWith(MockitoExtension.class)
@@ -90,13 +92,11 @@ public class StartupServiceTest {
 
     @Test
     public void startup_allOk() {
-        Mono<Collection<String>> policyTypes1 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
-        Mono<Collection<String>> policyTypes2 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME, POLICY_TYPE_2_NAME));
+        Mono<List<String>> policyTypes1 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
+        Mono<List<String>> policyTypes2 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME, POLICY_TYPE_2_NAME));
         doReturn(policyTypes1, policyTypes2).when(a1ClientMock).getPolicyTypeIdentities();
-        Mono<Collection<String>> policies = Mono.just(Arrays.asList(POLICY_ID_1, POLICY_ID_2));
-        doReturn(policies).when(a1ClientMock).getPolicyIdentities();
         doReturn(Mono.just("Schema")).when(a1ClientMock).getPolicyTypeSchema(anyString());
-        doReturn(Mono.just("OK")).when(a1ClientMock).deletePolicy(anyString());
+        doReturn(Flux.just("OK")).when(a1ClientMock).deleteAllPolicies();
 
         Rics rics = new Rics();
         PolicyTypes policyTypes = new PolicyTypes();
@@ -113,9 +113,7 @@ public class StartupServiceTest {
 
         await().untilAsserted(() -> assertThat(policyTypes.size()).isEqualTo(2));
 
-        verify(a1ClientMock, times(2)).getPolicyTypeIdentities();
-        verify(a1ClientMock, times(2)).deletePolicy(POLICY_ID_1);
-        verify(a1ClientMock, times(2)).deletePolicy(POLICY_ID_2);
+        verify(a1ClientMock, times(2)).deleteAllPolicies();
 
         assertTrue(policyTypes.contains(POLICY_TYPE_1_NAME), POLICY_TYPE_1_NAME + " not added to PolicyTypes.");
         assertTrue(policyTypes.contains(POLICY_TYPE_2_NAME), POLICY_TYPE_2_NAME + " not added to PolicyTypes.");
@@ -153,7 +151,6 @@ public class StartupServiceTest {
     public void startup_unableToConnectToGetTypes() {
         Mono<?> error = Mono.error(new Exception("Unable to contact ric."));
         doReturn(error, error).when(a1ClientMock).getPolicyTypeIdentities();
-        doReturn(error).when(a1ClientMock).getPolicyIdentities();
 
         Rics rics = new Rics();
         PolicyTypes policyTypes = new PolicyTypes();
@@ -168,13 +165,13 @@ public class StartupServiceTest {
     }
 
     @Test
-    public void startup_unableToConnectToGetPolicies() {
+    public void startup_unableToConnectToDeleteAllPolicies() {
 
-        Mono<Collection<String>> policyTypes = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
+        Mono<List<String>> policyTypes = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(policyTypes);
         when(a1ClientMock.getPolicyTypeSchema(anyString())).thenReturn(Mono.just("Schema"));
-        Mono<?> error = Mono.error(new Exception("Unable to contact ric."));
-        doReturn(error).when(a1ClientMock).getPolicyIdentities();
+        Flux<?> error = Flux.error(new Exception("Unable to contact ric."));
+        doReturn(error).when(a1ClientMock).deleteAllPolicies();
 
         Rics rics = new Rics();
         StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, new PolicyTypes(),

diff --git a/policy-agent/src/test/java/org/oransc/policyagent/utils/MockA1Client.java b/policy-agent/src/test/java/org/oransc/policyagent/utils/MockA1Client.java
index d6cd533..1151dd2 100644 (file)
--- a/policy-agent/src/test/java/org/oransc/policyagent/utils/MockA1Client.java
+++ b/policy-agent/src/test/java/org/oransc/policyagent/utils/MockA1Client.java
@@ -20,7 +20,7 @@
 
 package org.oransc.policyagent.utils;
 
-import java.util.Collection;
+import java.util.List;
 import java.util.Vector;
 
 import org.oransc.policyagent.clients.A1Client;
@@ -28,6 +28,8 @@ 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 reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public class MockA1Client implements A1Client {
@@ -39,9 +41,9 @@ public class MockA1Client implements A1Client {
     }
 
     @Override
-    public Mono<Collection<String>> getPolicyTypeIdentities() {
+    public Mono<List<String>> getPolicyTypeIdentities() {
         synchronized (this.policyTypes) {
-            Vector<String> result = new Vector<>();
+            List<String> result = new Vector<>();
             for (PolicyType p : this.policyTypes.getAll()) {
                 result.add(p.name());
             }
@@ -50,7 +52,7 @@ public class MockA1Client implements A1Client {
     }
 
     @Override
-    public Mono<Collection<String>> getPolicyIdentities() {
+    public Mono<List<String>> getPolicyIdentities() {
         synchronized (this.policies) {
             Vector<String> result = new Vector<>();
             for (Policy policy : policies.getAll()) {
@@ -77,8 +79,8 @@ public class MockA1Client implements A1Client {
     }
 
     @Override
-    public Mono<String> deletePolicy(String policyId) {
-        this.policies.removeId(policyId);
+    public Mono<String> deletePolicy(Policy policy) {
+        this.policies.remove(policy);
         return Mono.just("OK");
     }
 
@@ -91,4 +93,10 @@ public class MockA1Client implements A1Client {
         return Mono.just(A1ProtocolType.STD_V1);
     }
 
+    @Override
+    public Flux<String> deleteAllPolicies() {
+        this.policies.clear();
+        return Flux.empty();
+    }
+
 }