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

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