juplo.de Git - facebook-errors/blob - src/test/java/de/juplo/facebook/errors/GraphApiExchangeFilterFunctionIntegrationTest.java

   1 package de.juplo.facebook.errors;
   2
   3
   4 import de.juplo.facebook.errors.GraphApiException.Type;
   5 import java.time.Duration;
   6 import okhttp3.mockwebserver.MockResponse;
   7 import okhttp3.mockwebserver.MockWebServer;
   8 import org.junit.After;
   9 import static org.junit.Assert.assertEquals;
  10 import org.junit.Before;
  11 import org.junit.Test;
  12 import org.slf4j.Logger;
  13 import org.slf4j.LoggerFactory;
  14 import org.springframework.http.HttpStatus;
  15 import org.springframework.http.client.reactive.JettyClientHttpConnector;
  16 import org.springframework.web.reactive.function.client.WebClient;
  17 import reactor.core.publisher.Mono;
  18 import reactor.test.StepVerifier;
  19
  20
  21 /**
  22  *
  23  * @author Kai Moritz
  24  */
  25 public class GraphApiExchangeFilterFunctionIntegrationTest
  26 {
  27   private static final Logger LOG =
  28       LoggerFactory.getLogger(GraphApiExchangeFilterFunctionIntegrationTest.class);
  29
  30   private MockWebServer server;
  31         private WebClient webClient;
  32
  33
  34         @Before
  35         public void setup()
  36   {
  37     server = new MockWebServer();
  38     webClient =
  39         WebClient
  40             .builder()
  41             .clientConnector(new JettyClientHttpConnector())
  42             .baseUrl(server.url("/").toString())
  43             .filter(new GraphApiExchangeFilterFunction())
  44             .build();
  45         }
  46
  47         @After
  48         public void shutdown() throws Exception
  49   {
  50     this.server.shutdown();
  51         }
  52
  53
  54   @Test
  55   public void testNoError()
  56   {
  57     //server
  58     //    .enqueue(new MockResponse()
  59     //        .setResponseCode(HttpStatus.CONTINUE.value())
  60     //        .setHeader("Content-Type", "application/json")
  61     //        .setBody("Hallo Welt!"));
  62     //
  63     //try
  64     //{
  65     //  String result = clientTemplate.getForObject(uri, String.class);
  66     //  assertEquals("Hallo Welt!", result);
  67     //}
  68     //catch(Exception e)
  69     //{
  70     //  LOG.debug("{}", e.toString());
  71     //  fail("Unexpected error: " + e);
  72     //}
  73
  74
  75     server
  76         .enqueue(new MockResponse()
  77             .setResponseCode(HttpStatus.OK.value())
  78             .setHeader("Content-Type", "text/plain")
  79             .setBody("Hallo Welt!"));
  80
  81     try
  82     {
  83       String result = clientTemplate.getForObject(uri, String.class);
  84       assertEquals("Hallo Welt!", result);
  85     }
  86     catch(Exception e)
  87     {
  88       LOG.debug("{}", e.toString());
  89       fail("Unexpected error: " + e);
  90     }
  91
  92
  93     server
  94         .enqueue(new MockResponse()
  95             .setResponseCode(HttpStatus.TEMPORARY_REDIRECT.value())
  96             .setHeader("Content-Type", "text/plain")
  97             .setBody("Hallo Welt!"));
  98
  99     try
 100     {
 101       String result = clientTemplate.getForObject(uri, String.class);
 102       assertEquals("Hallo Welt!", result);
 103     }
 104     catch(Exception e)
 105     {
 106       LOG.debug("{}", e.toString());
 107       fail("Unexpected error: " + e);
 108     }
 109
 110
 111     server
 112         .enqueue(new MockResponse()
 113             .setResponseCode(HttpStatus.INTERNAL_SERVER_ERROR.value())
 114             .setHeader("Content-Type", "text/plain")
 115             .setBody("Hallo Welt!"));
 116
 117     try
 118     {
 119       clientTemplate.getForObject(uri, String.class);
 120       fail("The parent handler should have raised an exception!");
 121     }
 122     catch(HttpServerErrorException e)
 123     {
 124       LOG.debug("Expexted error: {}", e.toString());
 125     }
 126     catch(Exception e)
 127     {
 128       LOG.debug("{}", e.toString());
 129       fail("Unexpected error: " + e);
 130     }
 131   }
 132
 133   @Test
 134   public void testValidError()
 135   {
 136     server
 137         .enqueue(new MockResponse()
 138             .setResponseCode(HttpStatus.BAD_REQUEST.value())
 139             .setHeader("Content-Type", "application/json")
 140             .setBody(
 141                 "{\n" +
 142                 "  \"error\":\n" +
 143                 "  {\n" +
 144                 "    \"message\": \"(#613) Calls to stream have exceeded the rate of 600 calls per 600 seconds.\",\n" +
 145                 "    \"type\": \"OAuthException\",\n" +
 146                 "    \"code\": 613\n" +
 147                 "  }\n" +
 148                 "}"));
 149
 150     try
 151     {
 152       clientTemplate.getForObject(uri, String.class);
 153       fail("The expected exception was not thrown");
 154     }
 155     catch(RateLimitExceededException e)
 156     {
 157       LOG.debug("{}", e.toString());
 158       assertEquals(new Integer(613), e.getCode());
 159       assertEquals("(#613) Calls to stream have exceeded the rate of 600 calls per 600 seconds.", e.getMessage());
 160       assertEquals(Type.OAuthException, e.getType());
 161     }
 162   }
 163
 164   @Test
 165   public void testUnmappedError()
 166   {
 167     server
 168         .enqueue(new MockResponse()
 169             .setResponseCode(HttpStatus.BAD_REQUEST.value())
 170             .setHeader("Content-Type", "application/json")
 171             .setBody(
 172                 "{\n" +
 173                 "  \"error\":\n" +
 174                 "  {\n" +
 175                 "    \"message\": \"This error does not exist.\",\n" +
 176                 "    \"type\": \"NonexistentTypeException\",\n" +
 177                 "    \"code\": 999999999\n" +
 178                 "  }\n" +
 179                 "}"));
 180
 181     try
 182     {
 183       clientTemplate.getForObject(uri, String.class);
 184       fail("The expected exception was not thrown");
 185     }
 186     catch(GraphApiException e)
 187     {
 188       LOG.debug("{}", e.toString());
 189       assertEquals(new Integer(999999999), e.getCode());
 190       assertEquals("This error does not exist.", e.getMessage());
 191       try
 192       {
 193         Type type = e.getType();
 194         LOG.error("unknown type: {}", type);
 195         fail("unmapped type was resolved by enum: " + type);
 196       }
 197       catch (IllegalArgumentException ee) {}
 198     }
 199   }
 200
 201   @Test
 202   public void testInvlalidError()
 203   {
 204     server
 205         .enqueue(new MockResponse()
 206             .setResponseCode(HttpStatus.BAD_REQUEST.value())
 207             .setHeader("Content-Type", "application/json")
 208             .setBody(
 209                 "{\n" +
 210                 "  \"error\":\n" +
 211                 "  {\n" +
 212                 "    \"message\": \"Not a Graph-Api-Exception.\",\n" +
 213                 "    \"type\": \"Whatever\",\n" +
 214                 "    \"code\": \"some string\"\n" +
 215                 "  }\n" +
 216                 "}"));
 217
 218     try
 219     {
 220       clientTemplate.getForObject(uri, String.class);
 221       fail("The parent handler should have raised an exception!");
 222     }
 223     catch(HttpClientErrorException e)
 224     {
 225       LOG.debug("Expexted error: {}", e.toString());
 226     }
 227     catch(Exception e)
 228     {
 229       LOG.debug("{}", e.toString());
 230       fail("Unexpected error: " + e);
 231     }
 232
 233
 234     server
 235         .enqueue(new MockResponse()
 236             .setResponseCode(HttpStatus.BAD_REQUEST.value())
 237             .setHeader("Content-Type", "text/plain")
 238             .setBody("Hallo Welt!"));
 239
 240     try
 241     {
 242       clientTemplate.getForObject(uri, String.class);
 243       fail("The parent handler should have raised an exception!");
 244     }
 245     catch(HttpClientErrorException e)
 246     {
 247       LOG.debug("Expexted error: {}", e.toString());
 248     }
 249     catch(Exception e)
 250     {
 251       LOG.debug("{}", e.toString());
 252       fail("Unexpected error: " + e);
 253     }
 254   }
 255
 256   @Test
 257   public void testValidError()
 258   {
 259     server
 260         .enqueue(new MockResponse()
 261             .setResponseCode(HttpStatus.BAD_REQUEST.value())
 262             .setHeader("Content-Type", "application/json")
 263             .setBody(
 264                 "{\n" +
 265                 "  \"error\":\n" +
 266                 "  {\n" +
 267                 "    \"message\": \"(#613) Calls to stream have exceeded the rate of 600 calls per 600 seconds.\",\n" +
 268                 "    \"type\": \"OAuthException\",\n" +
 269                 "    \"code\": 613\n" +
 270                 "  }\n" +
 271                 "}"));
 272
 273
 274     Mono<String> result =
 275         webClient
 276             .get()
 277             .uri("/egal")
 278             .retrieve()
 279             .bodyToMono(String.class);
 280
 281     StepVerifier
 282         .create(result)
 283         .expectErrorSatisfies(throwable ->
 284         {
 285           assertEquals(RateLimitExceededException.class, throwable.getClass());
 286           RateLimitExceededException e = (RateLimitExceededException)throwable;
 287           LOG.debug("{}", e.toString());
 288           assertEquals(new Integer(613), e.getCode());
 289           assertEquals("(#613) Calls to stream have exceeded the rate of 600 calls per 600 seconds.", e.getMessage());
 290           assertEquals(Type.OAuthException, e.getType());
 291         })
 292         .verify(Duration.ofSeconds(3));
 293   }
 294 }