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

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