content: package me.alidg.errors;
  
  import junitparams.JUnitParamsRunner;
  import junitparams.Parameters;
  import me.alidg.errors.HttpError.CodedMessage;
  import me.alidg.errors.annotation.ExceptionMapping;
  import me.alidg.errors.annotation.ExposeAsArg;
  import me.alidg.errors.conf.ErrorsAutoConfiguration;
  import me.alidg.errors.handlers.LastResortWebErrorHandler;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.springframework.boot.autoconfigure.AutoConfigurations;
  import org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration;
  import org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration;
  import org.springframework.boot.test.context.TestConfiguration;
  import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.annotation.Bean;
  import org.springframework.core.MethodParameter;
  import org.springframework.http.HttpStatus;
  import org.springframework.validation.BeanPropertyBindingResult;
  import org.springframework.validation.BindException;
  import org.springframework.validation.BindingResult;
  import org.springframework.validation.Validator;
  import org.springframework.web.bind.MethodArgumentNotValidException;
  
  import javax.validation.ConstraintViolationException;
  import javax.validation.constraints.Max;
  import javax.validation.constraints.Min;
  import javax.validation.constraints.NotBlank;
  import javax.validation.constraints.Size;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.List;
  import java.util.Locale;
  
  import static java.util.Collections.emptyList;
  import static me.alidg.Params.p;
  import static me.alidg.errors.Argument.arg;
  import static me.alidg.errors.WebErrorHandlersIT.Pojo.pojo;
  import static org.assertj.core.api.Assertions.assertThat;
  import static org.mockito.ArgumentMatchers.any;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.verify;
  
  /**
   * Integration tests for {@link WebErrorHandlers}.
   *
   * @author Ali Dehghani
   */
  @RunWith(JUnitParamsRunner.class)
  public class WebErrorHandlersIT {
  
      private static final Locale IRAN_LOCALE = new Locale("fa", "IR");
      private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
          .withPropertyValues("spring.messages.basename=test_messages")
          .withConfiguration(AutoConfigurations.of(
              MessageSourceAutoConfiguration.class,
              ValidationAutoConfiguration.class,
              ErrorsAutoConfiguration.class
  
          ));
  
      @Test
      @Parameters(method = "provideValidationParams")
      public void validationException_ShouldBeHandledProperly(Object pojo, Locale locale, CodedMessage... codedMessages) {
          contextRunner.run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
              Validator validator = ctx.getBean(Validator.class);
  
              BindingResult result = new BeanPropertyBindingResult(pojo, "pojo");
              validator.validate(pojo, result);
  
              // Assertions for BindException
              HttpError bindError = errorHandlers.handle(new BindException(result), null, locale);
              assertThat(bindError.getHttpStatus()).isEqualTo(HttpStatus.BAD_REQUEST);
              assertThat(bindError.getErrors()).containsOnly(codedMessages);
  
              // Assertions for MethodArgumentNotValidException
              HttpError argumentError = errorHandlers.handle(new MethodArgumentNotValidException(mock(MethodParameter.class), result), null, locale);
              assertThat(argumentError.getHttpStatus()).isEqualTo(HttpStatus.BAD_REQUEST);
              assertThat(argumentError.getErrors()).containsOnly(codedMessages);
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      public void annotatedException_ShouldBeHandledProperly() {
          contextRunner.run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
  
              SomeException exception = new SomeException(10, 12);
  
              // Without locale
              HttpError error = errorHandlers.handle(exception, null, null);
              assertThat(error.getHttpStatus()).isEqualTo(HttpStatus.UNPROCESSABLE_ENTITY);
              assertThat(error.getErrors()).containsOnly(cm("invalid_params", "Params are: 10, 12 and 42",
                  arg("min", 10), arg("max", 12), arg("theAnswer", "42"), arg("notUsed", "123")));
  
              // With locale
              error = errorHandlers.handle(exception, null, Locale.CANADA);
              assertThat(error.getHttpStatus()).isEqualTo(HttpStatus.UNPROCESSABLE_ENTITY);
              assertThat(error.getErrors()).containsOnly(cm("invalid_params", "Params are: 10, 12 and 42",
                  arg("min", 10), arg("max", 12), arg("theAnswer", "42"), arg("notUsed", "123")));
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      @Parameters(method = "provideParamsForUnknownErrors")
      public void unknownErrors_ShouldBeHandledProperly(Throwable exception) {
          contextRunner.run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
  
              HttpError error = errorHandlers.handle(exception, null, null);
              assertThat(error.getHttpStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
              assertThat(error.getErrors()).containsOnly(cm(LastResortWebErrorHandler.UNKNOWN_ERROR_CODE, null));
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      @Parameters(method = "provideParamsForRefined")
      public void refiner_ShouldRefineExceptionsBeforeHandlingThem(Throwable exception,
                                                                   HttpStatus expectedStatus,
                                                                   CodedMessage... codedMessages) {
          contextRunner.withUserConfiguration(RefinerConfig.class).run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
  
              HttpError httpError = errorHandlers.handle(exception, null, null);
  
              assertThat(httpError.getHttpStatus()).isEqualTo(expectedStatus);
              assertThat(httpError.getErrors()).containsOnly(codedMessages);
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      @Parameters(method = "provideEmptyViolations")
      public void constraintViolation_WithNoViolation_ShouldBeHandledByTheDefaultHandler(Exception exception) {
          contextRunner.run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
  
              HttpError httpError = errorHandlers.handle(exception, null, null);
  
              assertThat(httpError.getHttpStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
              assertThat(httpError.getErrors()).containsOnly(cm("unknown_error", null));
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      @Parameters(method = "provideValidationParams")
      public void constraintViolationException_ShouldBeHandledProperly(Object pojo, Locale locale, CodedMessage... codedMessages) {
          contextRunner.run(ctx -> {
              HttpError error;
  
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
              javax.validation.Validator validator = ctx.getBean(javax.validation.Validator.class);
  
              ConstraintViolationException exception = new ConstraintViolationException(validator.validate(pojo));
  
              error = errorHandlers.handle(exception, null, locale);
              assertThat(error.getHttpStatus()).isEqualTo(HttpStatus.BAD_REQUEST);
              assertThat(error.getErrors()).containsOnly(codedMessages);
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      public void errorFingerprint_ShouldNotBeCalculatedByDefault() {
          contextRunner.run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
  
              HttpError error = errorHandlers.handle(new SomeException(10, 12), null, null);
              assertThat(error.getFingerprint()).isNull();
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      public void errorFingerprint_ShouldBeCalculatedWhenConfigured() {
          contextRunner.withPropertyValues("errors.add-fingerprint=true").run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
  
              HttpError error = errorHandlers.handle(new SomeException(10, 12), null, null);
              assertThat(error.getFingerprint()).isNotNull();
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      @Test
      public void errorFingerprint_ShouldBeUnique() {
          contextRunner.withPropertyValues("errors.add-fingerprint=true").run(ctx -> {
              WebErrorHandlers errorHandlers = ctx.getBean(WebErrorHandlers.class);
  
              Exception e1 = new SomeException(1, 2);
              Exception e2 = new RuntimeException();
  
              HttpError error1 = errorHandlers.handle(e1, null, null);
              HttpError error2 = errorHandlers.handle(e2, null, null);
  
              assertThat(error1.getFingerprint()).isNotEqualTo(error2.getFingerprint());
  
              verifyPostProcessorsHasBeenCalled(ctx);
          });
      }
  
      private void verifyPostProcessorsHasBeenCalled(ApplicationContext ctx) {
          ctx.getBeansOfType(WebErrorHandlerPostProcessor.class).values().forEach(p -> verify(p).process(any()));
      }
  
      private Object[] provideParamsForUnknownErrors() {
          return p(null, new IllegalArgumentException(), new OutOfMemoryError());
      }
  
      private Object[] provideValidationParams() {
          return p(
              // Invalid text
              p(
                  pojo("", 10, "a"), null,
                  cm("text.required", "The text is required",
                      arg("invalid", ""), arg("property", "text"))
              ),
              p(
                  pojo("", 10, "a"), Locale.CANADA,
                  cm("text.required", "The text is required",
                      arg("invalid", ""), arg("property", "text"))
              ),
              p(
                  pojo("", 10, "a"), IRAN_LOCALE,
                  cm("text.required", "متن اجباری است",
                      arg("invalid", ""), arg("property", "text"))
              ),
  
              // Invalid number: min
              p(
                  pojo("t", -1, "a"), null,
                  cm("number.min", "The min is 0",
                      arg("value", 0L), arg("invalid", -1), arg("property", "number"))
              ),
              p(
                  pojo("t", -1, "a"), Locale.GERMANY,
                  cm("number.min", "The min is 0",
                      arg("value", 0L), arg("invalid", -1), arg("property", "number"))
              ),
  
              // Invalid number: max
              p(
                  pojo("t", 11, "a"), null,
                  cm("number.max", null,
                      arg("value", 10L), arg("invalid", 11), arg("property", "number"))
              ),
              p(
                  pojo("t", 11, "a"), Locale.GERMANY,
                  cm("number.max", null,
                      arg("value", 10L), arg("invalid", 11), arg("property", "number"))
              ),
              p(
                  pojo("t", 11, "a"), IRAN_LOCALE,
                  cm("number.max", null,
                      arg("value", 10L), arg("invalid", 11), arg("property", "number"))
              ),
  
              // Invalid range
              p(
                  pojo("t", 0), null,
                  cm("range.limit", "Between 1 and 3",
                      arg("max", 3), arg("min", 1), arg("invalid", emptyList()), arg("property", "range"))
              ),
              p(
                  pojo("t", 0), Locale.GERMANY,
                  cm("range.limit", "Between 1 and 3",
                      arg("max", 3), arg("min", 1), arg("invalid", emptyList()), arg("property", "range"))
              ),
  
              // Mixed
              p(
                  pojo("", 11), null,
                  cm("range.limit", "Between 1 and 3",
                      arg("max", 3), arg("min", 1), arg("invalid", emptyList()), arg("property", "range")),
                  cm("number.max", null,
                      arg("value", 10L), arg("invalid", 11), arg("property", "number")),
                  cm("text.required", "The text is required",
                      arg("invalid", ""), arg("property", "text"))
              ),
              p(
                  pojo("", 11), Locale.CANADA,
                  cm("range.limit", "Between 1 and 3",
                      arg("max", 3), arg("min", 1), arg("invalid", emptyList()), arg("property", "range")),
                  cm("number.max", null,
                      arg("value", 10L), arg("invalid", 11), arg("property", "number")),
                  cm("text.required", "The text is required",
                      arg("invalid", ""), arg("property", "text"))
              )
          );
      }
  
      private Object[] provideParamsForRefined() {
          return p(
              p(
                  new SymptomException(new SomeException(10, 11)),
                  HttpStatus.UNPROCESSABLE_ENTITY,
                  cm("invalid_params", "Params are: 10, 11 and 42",
                      arg("min", 10), arg("max", 11), arg("theAnswer", "42"), arg("notUsed", "123"))
              ),
              p(
                  new SymptomException(null), HttpStatus.INTERNAL_SERVER_ERROR, cm("unknown_error", null)
              ),
              p(
                  new IllegalArgumentException(), HttpStatus.INTERNAL_SERVER_ERROR, cm("unknown_error", null)
              )
          );
      }
  
      private Object[] provideEmptyViolations() {
          return p(
              new ConstraintViolationException(null),
              new ConstraintViolationException(Collections.emptySet())
          );
      }
  
      private CodedMessage cm(String code, String message, Argument... arguments) {
          return new CodedMessage(code, message, Arrays.asList(arguments));
      }
  
      static class Pojo {
  
          @NotBlank(message = "{text.required}")
          private String text;
  
          @Min(value = 0, message = "number.min")
          @Max(value = 10, message = "number.max")
          private int number;
  
          @Size(min = 1, max = 3, message = "range.limit")
          private List<String> range;
  
          Pojo(String text, int number, String... range) {
              this.text = text;
              this.number = number;
              this.range = Arrays.asList(range);
          }
  
          static Pojo pojo(String text, int number, String... range) {
              return new Pojo(text, number, range);
          }
  
          public String getText() {
              return text;
          }
  
          public void setText(String text) {
              this.text = text;
          }
  
          public int getNumber() {
              return number;
          }
  
          public void setNumber(int number) {
              this.number = number;
          }
  
          public List<String> getRange() {
              return range;
          }
  
          public void setRange(List<String> range) {
              this.range = range;
          }
      }
  
      private static class SymptomException extends RuntimeException {
  
          SymptomException(Throwable cause) {
              super(cause);
          }
      }
  
      @TestConfiguration
      protected static class RefinerConfig {
  
          @Bean
          public ExceptionRefiner exceptionRefiner() {
              return exception -> exception instanceof SymptomException ? exception.getCause() : exception;
          }
      }
  
      @TestConfiguration
      static class ErrorActionExecutorConfig {
  
          @Bean
          public WebErrorHandlerPostProcessor first() {
              return mock(WebErrorHandlerPostProcessor.class);
          }
  
          @Bean
          public WebErrorHandlerPostProcessor second() {
              return mock(WebErrorHandlerPostProcessor.class);
          }
      }
  
      @ExceptionMapping(errorCode = "invalid_params", statusCode = HttpStatus.UNPROCESSABLE_ENTITY)
      private class SomeException extends RuntimeException {
  
          @ExposeAsArg(100)
          private final int min;
          @ExposeAsArg(101)
          private final int max;
  
          SomeException(int min, int max) {
              this.min = min;
              this.max = max;
          }
  
          @ExposeAsArg(1000)
          public String theAnswer() {
              return "42";
          }
  
          @ExposeAsArg(2000)
          public String notUsed() {
              return "123";
          }
      }
  }
  