so-optimization-clients/src/test/java/org/onap/so/client/sniro/SniroValidatorTest.java

   1 package org.onap.so.client.sniro;
   2
   3 import static org.assertj.core.api.Assertions.assertThat;
   4 import java.util.LinkedHashMap;
   5 import java.util.Map;
   6 import org.junit.Test;
   7 import org.onap.so.client.exception.BadResponseException;
   8
   9 public class SniroValidatorTest {
  10
  11     @Test
  12     public void validateDemandsResponse_success() throws BadResponseException {
  13         Map<String, Object> testMap = new LinkedHashMap<>();
  14         testMap.put("requestStatus", "accepted");
  15         new SniroValidator().validateDemandsResponse(testMap);
  16     }
  17
  18     @Test
  19     public void validateDemandsResponse_emptyResponse() {
  20         try {
  21             new SniroValidator().validateDemandsResponse(new LinkedHashMap<>());
  22         } catch (BadResponseException e) {
  23             assertThat(e.getMessage()).contains("Sniro Managers synchronous response is empty");
  24         }
  25     }
  26
  27     @Test
  28     public void validateDemandsResponse_responseWithErrorMessage() {
  29         String message = "An error occurred";
  30         Map<String, Object> testMap = new LinkedHashMap<>();
  31         testMap.put("requestStatus", "not_accepted");
  32         testMap.put("statusMessage", message);
  33         try {
  34             new SniroValidator().validateDemandsResponse(testMap);
  35         } catch (BadResponseException e) {
  36             assertThat(e.getMessage()).contains("Sniro Managers synchronous response indicates failed: " + message);
  37         }
  38     }
  39
  40     @Test
  41     public void validateDemandsResponse_responseWithoutMessage() {
  42         Map<String, Object> testMap = new LinkedHashMap<>();
  43         testMap.put("requestStatus", "not_accepted");
  44         testMap.put("statusMessage", "");
  45         try {
  46             new SniroValidator().validateDemandsResponse(testMap);
  47         } catch (BadResponseException e) {
  48             assertThat(e.getMessage()).contains("error message not provided");
  49         }
  50     }
  51
  52     @Test
  53     public void validateDemandsResponse_responseWithoutRequestStatus() {
  54         Map<String, Object> testMap = new LinkedHashMap<>();
  55         testMap.put("statusMessage", "");
  56         try {
  57             new SniroValidator().validateDemandsResponse(testMap);
  58         } catch (BadResponseException e) {
  59             assertThat(e.getMessage()).contains("Sniro Managers synchronous response does not contain: request status");
  60         }
  61     }
  62
  63     @Test
  64     public void validateSolution_success() throws BadResponseException {
  65         SniroValidator.validateSolution("{statusMessage:key}");
  66     }
  67
  68     @Test
  69     public void validateSolution_emptyResponse() {
  70         try {
  71             SniroValidator.validateSolution("");
  72         } catch (BadResponseException e) {
  73             assertThat(e.getMessage()).contains("Sniro Managers asynchronous response is empty");
  74         }
  75     }
  76
  77     @Test
  78     public void validateSolution_errorResponseWithoutMessage() {
  79         try {
  80             SniroValidator.validateSolution("{\"serviceException\":{\"text\":\"\"}}");
  81         } catch (BadResponseException e) {
  82             assertThat(e.getMessage()).contains(
  83                     "Sniro Managers asynchronous response contains a service exception: error message not provided");
  84         }
  85     }
  86
  87     @Test
  88     public void validateSolution_errorResponseWithErrorMessage() {
  89         String message = "An error occurred";
  90         try {
  91             SniroValidator.validateSolution("{\"serviceException\":{\"text\":\"" + message + "\"}}");
  92         } catch (BadResponseException e) {
  93             assertThat(e.getMessage())
  94                     .contains("Sniro Managers asynchronous response contains a service exception: " + message);
  95         }
  96     }
  97
  98     @Test
  99     public void validateReleaseResponse_success() throws BadResponseException {
 100         Map<String, Object> testMap = new LinkedHashMap<>();
 101         testMap.put("status", "success");
 102         new SniroValidator().validateReleaseResponse(testMap);
 103     }
 104
 105     @Test
 106     public void validateReleaseResponse_emptyResponse() {
 107         try {
 108             new SniroValidator().validateReleaseResponse(new LinkedHashMap<>());
 109         } catch (BadResponseException e) {
 110             assertThat(e.getMessage()).contains("Sniro Conductors response is empty");
 111         }
 112     }
 113
 114     @Test
 115     public void validateReleaseResponse_errorResponseWithErrorMessage() {
 116         String message = "An error occurred";
 117         Map<String, Object> testMap = new LinkedHashMap<>();
 118         testMap.put("status", "failed");
 119         testMap.put("message", message);
 120         try {
 121             new SniroValidator().validateReleaseResponse(testMap);
 122         } catch (BadResponseException e) {
 123             assertThat(e.getMessage()).contains("Sniro Conductors synchronous response indicates failed: " + message);
 124         }
 125     }
 126
 127     @Test
 128     public void validateReleaseResponse_errorResponseWithNoMessage() {
 129         Map<String, Object> testMap = new LinkedHashMap<>();
 130         testMap.put("status", "failed");
 131         testMap.put("message", "");
 132         try {
 133             new SniroValidator().validateReleaseResponse(testMap);
 134         } catch (BadResponseException e) {
 135             assertThat(e.getMessage())
 136                     .contains("Sniro Conductors synchronous response indicates failed: error message not provided");
 137         }
 138     }
 139
 140     @Test
 141     public void validateReleaseResponse_responseWithoutStatus() {
 142         Map<String, Object> testMap = new LinkedHashMap<>();
 143         testMap.put("statusMessage", "");
 144         try {
 145             new SniroValidator().validateReleaseResponse(testMap);
 146         } catch (BadResponseException e) {
 147             assertThat(e.getMessage()).contains("Sniro Conductors synchronous response does not contain: status");
 148         }
 149     }
 150 }