Merge "Added STD sim 2.0.0 tests"

[nonrtric.git] / policy-agent / src / test / java / org / oransc / policyagent / utils / MockA1Client.java

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 b765f57..fc0eba3 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,6 +20,8 @@
 
 package org.oransc.policyagent.utils;
 
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
 import java.util.List;
 import java.util.Vector;
 
@@ -28,45 +30,46 @@ 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 org.springframework.http.HttpStatus;
+import org.springframework.web.reactive.function.client.WebClientResponseException;
 
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import reactor.core.publisher.MonoSink;
 
 public class MockA1Client implements A1Client {
     Policies policies = new Policies();
     private final PolicyTypes policyTypes;
+    private final Duration asynchDelay;
 
-    public MockA1Client(PolicyTypes policyTypes) {
+    public MockA1Client(PolicyTypes policyTypes, Duration asynchDelay) {
         this.policyTypes = policyTypes;
+        this.asynchDelay = asynchDelay;
     }
 
     @Override
     public Mono<List<String>> getPolicyTypeIdentities() {
-        synchronized (this.policyTypes) {
-            List<String> result = new Vector<>();
-            for (PolicyType p : this.policyTypes.getAll()) {
-                result.add(p.name());
-            }
-            return Mono.just(result);
+        List<String> result = new Vector<>();
+        for (PolicyType p : this.policyTypes.getAll()) {
+            result.add(p.name());
         }
+        return mono(result);
     }
 
     @Override
     public Mono<List<String>> getPolicyIdentities() {
-        synchronized (this.policies) {
-            Vector<String> result = new Vector<>();
-            for (Policy policy : policies.getAll()) {
-                result.add(policy.id());
-            }
-
-            return Mono.just(result);
+        Vector<String> result = new Vector<>();
+        for (Policy policy : policies.getAll()) {
+            result.add(policy.id());
         }
+
+        return mono(result);
     }
 
     @Override
     public Mono<String> getPolicyTypeSchema(String policyTypeId) {
         try {
-            return Mono.just(this.policyTypes.getType(policyTypeId).schema());
+            return mono(this.policyTypes.getType(policyTypeId).schema());
         } catch (Exception e) {
             return Mono.error(e);
         }
@@ -75,13 +78,14 @@ public class MockA1Client implements A1Client {
     @Override
     public Mono<String> putPolicy(Policy p) {
         this.policies.put(p);
-        return Mono.just("OK");
+        return mono("OK");
+
     }
 
     @Override
     public Mono<String> deletePolicy(Policy policy) {
         this.policies.remove(policy);
-        return Mono.just("OK");
+        return mono("OK");
     }
 
     public Policies getPolicies() {
@@ -90,18 +94,51 @@ public class MockA1Client implements A1Client {
 
     @Override
     public Mono<A1ProtocolType> getProtocolVersion() {
-        return Mono.just(A1ProtocolType.STD_V1);
+        return mono(A1ProtocolType.STD_V1_1);
     }
 
     @Override
     public Flux<String> deleteAllPolicies() {
         this.policies.clear();
-        return Flux.empty();
+        return mono("OK") //
+            .flatMapMany(Flux::just);
     }
 
     @Override
     public Mono<String> getPolicyStatus(Policy policy) {
-        return Mono.just("OK");
+        return mono("OK");
+    }
+
+    private <T> Mono<T> mono(T value) {
+        if (this.asynchDelay.isZero()) {
+            return Mono.just(value);
+        } else {
+            return Mono.create(monoSink -> asynchResponse(monoSink, value));
+        }
+    }
+
+    Mono<String> monoError(String responseBody, HttpStatus status) {
+        byte[] responseBodyBytes = responseBody.getBytes(StandardCharsets.UTF_8);
+        WebClientResponseException a1Exception = new WebClientResponseException(status.value(),
+            status.getReasonPhrase(), null, responseBodyBytes, StandardCharsets.UTF_8, null);
+        return Mono.error(a1Exception);
+    }
+
+    @SuppressWarnings("squid:S2925") // "Thread.sleep" should not be used in tests.
+    private void sleep() {
+        try {
+            Thread.sleep(this.asynchDelay.toMillis());
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private <T> void asynchResponse(MonoSink<T> callback, T str) {
+        Thread thread = new Thread(() -> {
+            sleep(); // Simulate a network delay
+            callback.success(str);
+        });
+        thread.start();
     }
 
 }