vid-automation/src/main/java/vid/automation/test/services/SimulatorApi.java

   1 package vid.automation.test.services;
   2
   3 import static java.util.stream.Collectors.toList;
   4 import static org.testng.Assert.assertEquals;
   5 import static vid.automation.test.services.DropTestApiField.dropFieldCloudOwnerFromString;
   6 import static vid.automation.test.services.DropTestApiField.dropTestApiFieldFromString;
   7
   8 import com.fasterxml.jackson.databind.DeserializationFeature;
   9 import com.google.common.collect.ImmutableList;
  10 import com.google.common.collect.ImmutableMap;
  11 import java.net.URI;
  12 import java.util.Collection;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.function.Function;
  16 import java.util.function.UnaryOperator;
  17 import java.util.stream.Collectors;
  18 import javax.ws.rs.client.Client;
  19 import javax.ws.rs.client.ClientBuilder;
  20 import javax.ws.rs.client.Entity;
  21 import javax.ws.rs.client.WebTarget;
  22 import javax.ws.rs.core.GenericType;
  23 import javax.ws.rs.core.MediaType;
  24 import javax.ws.rs.core.Response;
  25 import org.glassfish.jersey.client.ClientProperties;
  26 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
  27 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
  28 import org.glassfish.jersey.uri.internal.JerseyUriBuilder;
  29 import org.onap.simulator.presetGenerator.presets.BasePresets.BasePreset;
  30 import org.onap.simulator.presetGenerator.presets.model.RegistrationRequest;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33 import org.springframework.http.HttpStatus;
  34 import vid.automation.test.utils.ReadFile;
  35
  36 public class SimulatorApi {
  37
  38     public enum RegistrationStrategy {
  39         APPEND, CLEAR_THEN_SET
  40     }
  41
  42     private static final Logger logger = LoggerFactory.getLogger(SimulatorApi.class);
  43
  44     /*
  45     these classes are partial representation of org.mockserver.model.HttpRequest.
  46     We can not use HttpRequest since it contains Map with NottableString and jackson throw the following error :
  47     com.fasterxml.jackson.databind.JsonMappingException: Can not find a (Map) Key deserializer for type
  48      [simple type, class org.mockserver.model.NottableString]
  49     */
  50     public static class StringWrapper {
  51         public String value;
  52     }
  53
  54     public static class RecordedHeaders {
  55         public StringWrapper name;
  56         public List<StringWrapper> values;
  57     }
  58
  59     public static class BodyWrapper {
  60         public String value;
  61     }
  62
  63     public static class HttpRequest {
  64         public StringWrapper path;
  65         public BodyWrapper body;
  66         public List<RecordedHeaders> headers;
  67     }
  68
  69     public static class RecordedRequests {
  70         public String path;
  71         public String body;
  72         public Map<String, List<String>> headers;
  73
  74         public RecordedRequests(String path,  String body, Map<String, List<String>> headers) {
  75             this.path = path;
  76             this.body = body;
  77             this.headers = headers;
  78         }
  79
  80         public RecordedRequests() {
  81         }
  82     }
  83
  84     private static final URI uri; //uri for registration
  85     private static final URI simulationUri; //uri for getting simulated responses
  86     private static final Client client;
  87
  88     private static final List<UnaryOperator<String>> presetStringPostProccessors =
  89             ImmutableList.of(dropTestApiFieldFromString(), dropFieldCloudOwnerFromString());
  90
  91     static {
  92         String host = getSimulatorHost();
  93         Integer port = Integer.valueOf(System.getProperty("SIM_PORT", System.getProperty("VID_PORT", "8080"))); //port for registration
  94         uri = new JerseyUriBuilder().host(host).port(port).scheme("http").path("vidSimulator").build();
  95         client = ClientBuilder.newClient();
  96         client.property(ClientProperties.SUPPRESS_HTTP_COMPLIANCE_VALIDATION, true);
  97         //registering jacksonJsonProvider for avoiding exceptions like :
  98         // org.glassfish.jersey.message.internal.MessageBodyProviderNotFoundException:
  99         // MessageBodyWriter not found for media type=application/json
 100         JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider();
 101         jacksonJsonProvider.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 102         client.register(jacksonJsonProvider);
 103
 104         Integer simulationPort = getSimulatedResponsesPort();
 105         simulationUri = new JerseyUriBuilder().host(host).port(simulationPort).scheme("http").build();
 106     }
 107
 108     public static String getSimulatorHost() {
 109         return System.getProperty("SIM_HOST", System.getProperty("VID_HOST", "127.0.0.1"));
 110     }
 111
 112     public static Integer getSimulatedResponsesPort() {
 113         return Integer.valueOf(System.getProperty("SIMULATION_PORT", "1080"));
 114     }
 115
 116     public static URI getSimulationUri() {
 117         return simulationUri;
 118     }
 119
 120     public static void registerExpectation(String expectationFilename, RegistrationStrategy registrationStrategy) {
 121         registerExpectation(expectationFilename, ImmutableMap.<String, Object>of(), registrationStrategy);
 122     }
 123
 124     public static void registerExpectation(RegistrationStrategy strategy, String... expectationTemplateFilenames) {
 125         registerExpectation(expectationTemplateFilenames, ImmutableMap.of(), strategy);
 126     }
 127
 128     public static void registerExpectation(String[] expectationTemplateFilenames, ImmutableMap<String, Object> templateParams, RegistrationStrategy strategy) {
 129         if (strategy.equals(RegistrationStrategy.CLEAR_THEN_SET)) {
 130             clearRegistrations();
 131         }
 132         for (String expectationTemplateFilename: expectationTemplateFilenames) {
 133             registerExpectation(expectationTemplateFilename, templateParams, RegistrationStrategy.APPEND);
 134         }
 135     }
 136
 137     public static void registerExpectation(String expectationTemplateFilename, ImmutableMap<String, Object> templateParams, RegistrationStrategy registrationStrategy) {
 138
 139         String content = ReadFile.loadResourceAsString("registration_to_simulator/" + expectationTemplateFilename);
 140
 141         for (Map.Entry<String, Object> templateParam : templateParams.entrySet()) {
 142             content = content.replaceAll(templateParam.getKey(), templateParam.getValue().toString());
 143         }
 144
 145         registerToSimulatorAndAssertSuccess(expectationTemplateFilename, content, registrationStrategy);
 146
 147     }
 148
 149     public static void registerExpectationFromPreset(BasePreset preset, RegistrationStrategy registrationStrategy) {
 150         RegistrationRequest content = preset.generateScenario();
 151         registerToSimulatorAndAssertSuccess(preset.getClass().getCanonicalName(), content, registrationStrategy);
 152     }
 153
 154     public static void registerExpectationFromPresetsCollections(Collection<Collection<BasePreset>> presets, RegistrationStrategy registrationStrategy) {
 155         registerExpectationFromPresets(presets.stream()
 156                 .flatMap(Collection::stream)
 157                 .collect(toList()), registrationStrategy);
 158     }
 159
 160     public static void registerExpectationFromPresets(Collection<BasePreset> presets, RegistrationStrategy registrationStrategy) {
 161         if (registrationStrategy == RegistrationStrategy.CLEAR_THEN_SET) {
 162             clearRegistrations();
 163         }
 164         presets.forEach(
 165                 preset-> {
 166                     try {registerToSimulatorAndAssertSuccess(preset.getClass().getCanonicalName(), preset.generateScenario());}
 167                     catch (Throwable e) {
 168                         throw new RuntimeException("Failed to register preset "+preset.getClass().getName(), e);
 169                     }
 170                 }
 171         );
 172     }
 173
 174 //    public static List<HttpRequest> retrieveRecordedRequests() {
 175 //        Response response = client.target(uri).path("retrieveRecordedRequests").request().get();
 176 //        return response.readEntity(new GenericType<List<HttpRequest>>(){});
 177 //    }
 178
 179     /*
 180         This method return counter of requests that has been sent to simulator.
 181         The key of the map is a path, and the value is counter
 182      */
 183     public static Map<String, Long> retrieveRecordedRequestsPathCounter() {
 184         List<HttpRequest> httpRequests =  retrieveRecordedHttpRequests();
 185         return httpRequests.stream().map(x->x.path.value).collect(
 186                 Collectors.groupingBy(Function.identity(), Collectors.counting()));
 187     }
 188
 189     private static List<HttpRequest> retrieveRecordedHttpRequests() {
 190         Response response = client.target(uri).path("retrieveRecordedRequests").request().get();
 191         return response.readEntity(new GenericType<List<HttpRequest>>(){});
 192     }
 193
 194     public static List<RecordedRequests> retrieveRecordedRequests() {
 195         List<HttpRequest> rawRequests =  retrieveRecordedHttpRequests();
 196         return rawRequests.stream().map(request->new RecordedRequests(
 197             request.path.value,
 198             request.body != null && request.body != null ?  request.body.value : "",
 199             request.headers.stream().collect(
 200                 Collectors.toMap(
 201                     x->x.name.value,
 202                     x->x.values.stream().map(y->y.value).collect(toList())))
 203         )).collect(toList());
 204     }
 205
 206     private static void registerToSimulatorAndAssertSuccess(String name, Object content, RegistrationStrategy registrationStrategy) {
 207         if (registrationStrategy == RegistrationStrategy.CLEAR_THEN_SET) {
 208             clearRegistrations();
 209         }
 210         registerToSimulatorAndAssertSuccess(name, content);
 211     }
 212
 213     private static void registerToSimulatorAndAssertSuccess(String name, Object content) {
 214         logger.info("Setting {}", name);
 215
 216         content = postProccessContent(content);
 217
 218         Response response = createSimulatorRegistrationWebTarget().request(MediaType.APPLICATION_JSON_TYPE).post(Entity.json(content));
 219         assertEquals(response.getStatus(), HttpStatus.OK.value());
 220     }
 221
 222     private static Object postProccessContent(Object content) {
 223         if (content instanceof String) {
 224             for (UnaryOperator<String> presetStringPostProccessor : presetStringPostProccessors) {
 225                 content = presetStringPostProccessor.apply((String) content);
 226             }
 227         }
 228
 229         return content;
 230     }
 231
 232     public static void clearExpectations() {
 233         clearRegistrations();
 234     }
 235
 236     private static void clearRegistrations() {
 237         logger.info("Clearing Registrations");
 238         Response response = createSimulatorRegistrationWebTarget().request().delete();
 239         assertEquals(response.getStatus(), HttpStatus.OK.value());
 240     }
 241
 242     private static WebTarget createSimulatorRegistrationWebTarget() {
 243         return client.target(uri).path("registerToVidSimulator");
 244     }
 245
 246     public static void clearAll() {
 247         WebTarget webTarget = createSimulatorRegistrationWebTarget();
 248         webTarget.request().delete();
 249     }
 250 }