com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors Java Examples

@SuppressWarnings("ConstantConditions")
public BackstopperSpringboot2ContainerErrorController(
    @NotNull ProjectApiErrors projectApiErrors,
    @NotNull UnhandledServletContainerErrorHelper unhandledServletContainerErrorHelper,
    @NotNull ServerProperties serverProperties
) {
    if (projectApiErrors == null) {
        throw new NullPointerException("ProjectApiErrors cannot be null.");
    }

    if (unhandledServletContainerErrorHelper == null) {
        throw new NullPointerException("UnhandledServletContainerErrorHelper cannot be null.");
    }

    if (serverProperties == null) {
        throw new NullPointerException("ServerProperties cannot be null.");
    }

    this.projectApiErrors = projectApiErrors;
    this.unhandledServletContainerErrorHelper = unhandledServletContainerErrorHelper;
    this.errorPath = serverProperties.getError().getPath();
}
 

@SuppressWarnings("ConstantConditions")
public BackstopperSpringboot1ContainerErrorController(
    @NotNull ProjectApiErrors projectApiErrors,
    @NotNull UnhandledServletContainerErrorHelper unhandledServletContainerErrorHelper,
    @NotNull ServerProperties serverProperties
) {
    if (projectApiErrors == null) {
        throw new NullPointerException("ProjectApiErrors cannot be null.");
    }

    if (unhandledServletContainerErrorHelper == null) {
        throw new NullPointerException("UnhandledServletContainerErrorHelper cannot be null.");
    }

    if (serverProperties == null) {
        throw new NullPointerException("ServerProperties cannot be null.");
    }

    this.projectApiErrors = projectApiErrors;
    this.unhandledServletContainerErrorHelper = unhandledServletContainerErrorHelper;
    this.errorPath = serverProperties.getError().getPath();
}
 

@Test
public void constructorWorksIfPassedValidValues() {
    // when
    RiposteApiExceptionHandler
        myAdapter = new RiposteApiExceptionHandler(projectApiErrors, validListenerList, utils);

    // then
    List<ApiExceptionHandlerListener> actualListeners =
        (List<ApiExceptionHandlerListener>) Whitebox.getInternalState(myAdapter, "apiExceptionHandlerListenerList");
    ProjectApiErrors actualProjectApiErrors =
        (ProjectApiErrors) Whitebox.getInternalState(myAdapter, "projectApiErrors");
    ApiExceptionHandlerUtils actualUtils = (ApiExceptionHandlerUtils) Whitebox.getInternalState(myAdapter, "utils");
    assertThat(actualListeners, is(validListenerList));
    assertThat(actualProjectApiErrors, is(projectApiErrors));
    assertThat(actualUtils, is(utils));
}
 

/**
 * Verifies that the given MvcResult's {@link org.springframework.test.web.servlet.MvcResult#getResponse()} has the
 * expected HTTP status code, that its contents can be converted to the appropriate {@link DefaultErrorContractDTO} with the
 * expected errors (as per the default error handling contract), and that the MvcResult's {@link
 * org.springframework.test.web.servlet.MvcResult#getResolvedException()} matches the given expectedExceptionType.
 */
@SuppressWarnings("ThrowableResultOfMethodCallIgnored")
protected void verifyErrorResponse(MvcResult result, ProjectApiErrors projectApiErrors,
                                   List<ApiError> expectedErrors, Class<? extends Exception> expectedExceptionType)
    throws IOException {
    Integer expectedStatusCode = projectApiErrors.determineHighestPriorityHttpStatusCode(expectedErrors);
    expectedErrors = projectApiErrors.getSublistContainingOnlyHttpStatusCode(expectedErrors, expectedStatusCode);
    MockHttpServletResponse response = result.getResponse();
    assertThat(response.getStatus(), is(expectedStatusCode));
    DefaultErrorContractDTO details =
        objectMapper.readValue(response.getContentAsString(), DefaultErrorContractDTO.class);
    assertNotNull(details);
    assertNotNull(details.error_id);
    assertNotNull(details.errors);
    assertThat(details.errors.size(), is(expectedErrors.size()));
    List<Pair<String, String>> expectedErrorsAsPairs = convertToCodeAndMessagePairs(expectedErrors);
    for (DefaultErrorDTO errorView : details.errors) {
        assertTrue(expectedErrorsAsPairs.contains(Pair.of(errorView.code, errorView.message)));
    }
    assertNotNull(result.getResolvedException());
    Assertions.assertThat(result.getResolvedException()).isInstanceOf(expectedExceptionType);
}
 

@Bean
@Primary
public SpringWebfluxApiExceptionHandler springWebfluxApiExceptionHandler(
    ProjectApiErrors projectApiErrors,
    SpringWebFluxApiExceptionHandlerListenerList apiExceptionHandlerListeners,
    ApiExceptionHandlerUtils generalUtils,
    SpringWebfluxApiExceptionHandlerUtils springUtils,
    ObjectProvider<ViewResolver> viewResolversProvider,
    ServerCodecConfigurer serverCodecConfigurer
) {
    return new SpringWebfluxApiExceptionHandler(
        projectApiErrors, apiExceptionHandlerListeners, generalUtils, springUtils, viewResolversProvider,
        serverCodecConfigurer
    ) {
        @Override
        protected ApiExceptionHandlerListenerResult shouldHandleApiException(
            Throwable ex
        ) {
            exceptionSeenByNormalBackstopperHandler = ex;
            normalBackstopperHandlingResult = super.shouldHandleApiException(ex);
            return normalBackstopperHandlingResult;
        }
    };
}
 

/**
 * Creates a new instance with the given arguments.
 *
 * @param projectApiErrors The {@link ProjectApiErrors} used for this project - cannot be null.
 * @param apiExceptionHandlerListenerList
 *          The list of {@link ApiExceptionHandlerListener}s that will be used for this project to analyze
 *          exceptions and see if they should be handled (and how they should be handled if so). These will be
 *          executed in list order. This cannot be null (pass in an empty list if you really don't have any
 *          listeners for your project, however this should never be the case in practice - you should always
 *          include {@link com.nike.backstopper.handler.listener.impl.GenericApiExceptionHandlerListener}
 *          at the very least).
 * @param utils The {@link ApiExceptionHandlerUtils} that should be used by this instance. You can pass in
 *              {@link ApiExceptionHandlerUtils#DEFAULT_IMPL} if you don't need custom logic. Cannot be null.
 */
public ApiExceptionHandlerBase(ProjectApiErrors projectApiErrors,
                               List<ApiExceptionHandlerListener> apiExceptionHandlerListenerList,
                               ApiExceptionHandlerUtils utils) {
    if (projectApiErrors == null)
        throw new IllegalArgumentException("projectApiErrors cannot be null.");

    if (apiExceptionHandlerListenerList == null)
        throw new IllegalArgumentException("apiExceptionHandlerListenerList cannot be null.");

    if (utils == null)
        throw new IllegalArgumentException("apiExceptionHandlerUtils cannot be null.");

    this.projectApiErrors = projectApiErrors;
    this.apiExceptionHandlerListenerList = apiExceptionHandlerListenerList;
    this.utils = utils;
}
 

/**
 * @return The error handler that should be used for this application for handling unknown/unexpected/unhandled
 * errors. Known/handled errors will be processed by {@link #riposteErrorHandler()}.
 *
 * <p>NOTE: The default implementation returned if you don't override this method is a very basic Backstopper impl -
 * it will not know about your application's {@link ProjectApiErrors} and will instead create a dummy {@link
 * ProjectApiErrors} that only supports the {@link com.nike.backstopper.apierror.sample.SampleCoreApiError} values.
 * This method should be overridden for most real applications to return a real implementation tailored for your
 * app. In practice this usually means copy/pasting this method and simply supplying the correct {@link
 * ProjectApiErrors} for the app. The rest is usually fine for defaults.
 */
default @NotNull RiposteUnhandledErrorHandler riposteUnhandledErrorHandler() {
    ProjectApiErrors projectApiErrors = new SampleProjectApiErrorsBase() {
        @Override
        protected List<ApiError> getProjectSpecificApiErrors() {
            return null;
        }

        @Override
        protected ProjectSpecificErrorCodeRange getProjectSpecificErrorCodeRange() {
            return null;
        }
    };
    return BackstopperRiposteConfigHelper
        .defaultUnhandledErrorHandler(projectApiErrors, ApiExceptionHandlerUtils.DEFAULT_IMPL);
}
 

@Inject
public SpringWebfluxUnhandledExceptionHandler(
    @NotNull ProjectApiErrors projectApiErrors,
    @NotNull ApiExceptionHandlerUtils generalUtils,
    @NotNull SpringWebfluxApiExceptionHandlerUtils springUtils,
    @NotNull ObjectProvider<ViewResolver> viewResolversProvider,
    @NotNull ServerCodecConfigurer serverCodecConfigurer
) {
    super(projectApiErrors, generalUtils);

    //noinspection ConstantConditions
    if (springUtils == null) {
        throw new NullPointerException("springUtils cannot be null.");
    }
    
    //noinspection ConstantConditions
    if (viewResolversProvider == null) {
        throw new NullPointerException("viewResolversProvider cannot be null.");
    }

    //noinspection ConstantConditions
    if (serverCodecConfigurer == null) {
        throw new NullPointerException("serverCodecConfigurer cannot be null.");
    }

    this.singletonGenericServiceError = Collections.singleton(projectApiErrors.getGenericServiceError());
    this.genericServiceErrorHttpStatusCode = projectApiErrors.getGenericServiceError().getHttpStatusCode();

    this.springUtils = springUtils;
    this.viewResolvers = viewResolversProvider.orderedStream().collect(Collectors.toList());
    this.messageReaders = serverCodecConfigurer.getReaders();
    this.messageWriters = serverCodecConfigurer.getWriters();
}
 

@Test
public void projectApiErrors_returns_ProjectApiErrorsImpl() {
    ProjectApiErrors projectApiErrors = injector.getInstance(ProjectApiErrors.class);
    assertThat(projectApiErrors)
        .isNotNull()
        .isInstanceOf(ProjectApiErrorsImpl.class);
}
 

@Before
public void beforeMethod() {
      instanceSpy = spy(new ApiExceptionHandlerServletApiBase<Object>(mock(ProjectApiErrors.class),
                                                                      Collections.<ApiExceptionHandlerListener>emptyList(),
                                                                      ApiExceptionHandlerUtils.DEFAULT_IMPL) {
          @Override
          protected Object prepareFrameworkRepresentation(DefaultErrorContractDTO errorContractDTO, int httpStatusCode, Collection<ApiError> filteredClientErrors,
                                                          Throwable originalException, RequestInfoForLogging request) {
              return null;
          }
      });
    servletRequestMock = mock(HttpServletRequest.class);
    servletResponseMock = mock(HttpServletResponse.class);
}
 

@Before
public void beforeMethod() {
    projectApiErrorsMock = mock(ProjectApiErrors.class);
    listenerList = new SpringWebFluxApiExceptionHandlerListenerList(
        Arrays.asList(mock(ApiExceptionHandlerListener.class), mock(ApiExceptionHandlerListener.class))
    );
    generalUtils = ApiExceptionHandlerUtils.DEFAULT_IMPL;
    springUtilsMock = mock(SpringWebfluxApiExceptionHandlerUtils.class);
    viewResolversProviderMock = mock(ObjectProvider.class);
    serverCodecConfigurerMock = mock(ServerCodecConfigurer.class);
    messageReaders = Arrays.asList(mock(HttpMessageReader.class), mock(HttpMessageReader.class));
    messageWriters = Arrays.asList(mock(HttpMessageWriter.class), mock(HttpMessageWriter.class));
    viewResolvers = Arrays.asList(mock(ViewResolver.class), mock(ViewResolver.class));
    serverWebExchangeMock = mock(ServerWebExchange.class);
    serverHttpRequestMock = mock(ServerHttpRequest.class);
    serverHttpResponseMock = mock(ServerHttpResponse.class);
    serverHttpResponseHeadersMock = mock(HttpHeaders.class);
    uri = URI.create("http://localhost:8080/foo/bar?someQuery=someValue");
    exMock = mock(Throwable.class);

    doAnswer(invocation -> viewResolvers.stream()).when(viewResolversProviderMock).orderedStream();
    doReturn(messageReaders).when(serverCodecConfigurerMock).getReaders();
    doReturn(messageWriters).when(serverCodecConfigurerMock).getWriters();

    doReturn(serverHttpRequestMock).when(serverWebExchangeMock).getRequest();
    doReturn(uri).when(serverHttpRequestMock).getURI();

    doReturn(serverHttpResponseMock).when(serverWebExchangeMock).getResponse();
    doReturn(serverHttpResponseHeadersMock).when(serverHttpResponseMock).getHeaders();

    handlerSpy = spy(new SpringWebfluxApiExceptionHandler(
        projectApiErrorsMock, listenerList, generalUtils, springUtilsMock, viewResolversProviderMock,
        serverCodecConfigurerMock
    ));
}
 

@Bean
public ProjectApiErrors projectApiErrors() {
    return ProjectApiErrorsForTesting.withProjectSpecificData(
        Arrays.asList(INVALID_COUNT_VALUE, INVALID_OFFSET_VALUE),
        ProjectSpecificErrorCodeRange.ALLOW_ALL_ERROR_CODES
    );
}
 

@Before
public void beforeMethod() {
    projectApiErrorsMock = mock(ProjectApiErrors.class);
    listenerList = new ApiExceptionHandlerListenerList(Collections.<ApiExceptionHandlerListener>emptyList());
    generalUtils = ApiExceptionHandlerUtils.DEFAULT_IMPL;
    springUtils = SpringApiExceptionHandlerUtils.DEFAULT_IMPL;
    handlerSpy = spy(new SpringApiExceptionHandler(projectApiErrorsMock, listenerList, generalUtils, springUtils));
}
 

@Inject
public SpringUnhandledExceptionHandler(ProjectApiErrors projectApiErrors,
                                       ApiExceptionHandlerUtils generalUtils,
                                       SpringApiExceptionHandlerUtils springUtils) {
    super(projectApiErrors, generalUtils);
    this.springUtils = springUtils;
    this.singletonGenericServiceError = Collections.singleton(projectApiErrors.getGenericServiceError());
    this.genericServiceErrorHttpStatusCode = projectApiErrors.getGenericServiceError().getHttpStatusCode();
}
 

/**
 * @return The basic set of handler listeners that are appropriate for most applications.
 */
public static List<ApiExceptionHandlerListener> defaultApiExceptionHandlerListeners(
    ProjectApiErrors projectApiErrors, ApiExceptionHandlerUtils utils
) {
    return Arrays.asList(
        new GenericApiExceptionHandlerListener(),
        new ServersideValidationErrorHandlerListener(projectApiErrors, utils),
        new ClientDataValidationErrorHandlerListener(projectApiErrors, utils),
        new DownstreamNetworkExceptionHandlerListener(projectApiErrors),
        new Jersey1WebApplicationExceptionHandlerListener(projectApiErrors, utils));
}
 

@Inject
public JaxRsApiExceptionHandler(ProjectApiErrors projectApiErrors,
                                JaxRsApiExceptionHandlerListenerList apiExceptionHandlerListeners,
                                ApiExceptionHandlerUtils apiExceptionHandlerUtils,
                                JaxRsUnhandledExceptionHandler jerseyUnhandledExceptionHandler) {

    this(projectApiErrors, apiExceptionHandlerListeners.listeners, apiExceptionHandlerUtils, jerseyUnhandledExceptionHandler);
}
 

/**
 * @param projectApiErrors The {@link ProjectApiErrors} that should be used by this instance when finding {@link
 *                         ApiError}s. Cannot be null.
 * @param utils The {@link ApiExceptionHandlerUtils} that should be used by this instance.
 */
@Inject
public Jersey1WebApplicationExceptionHandlerListener(ProjectApiErrors projectApiErrors,
                                                     ApiExceptionHandlerUtils utils) {
    if (projectApiErrors == null)
        throw new IllegalArgumentException("ProjectApiErrors cannot be null");

    if (utils == null)
        throw new IllegalArgumentException("ApiExceptionHandlerUtils cannot be null");

    this.projectApiErrors = projectApiErrors;
    this.utils = utils;
}
 

@Inject
public RiposteUnhandledExceptionHandler(
    @NotNull ProjectApiErrors projectApiErrors,
    @NotNull ApiExceptionHandlerUtils utils
) {
    super(projectApiErrors, utils);
    singletonGenericServiceError = Collections.singleton(projectApiErrors.getGenericServiceError());
    genericServiceErrorHttpStatusCode = projectApiErrors.getGenericServiceError().getHttpStatusCode();
}
 

@Test
public void constructor_sets_projectApiErrors_and_utils_to_passed_in_args() {
    // given
    ProjectApiErrors projectErrorsMock = mock(ProjectApiErrors.class);
    ApiExceptionHandlerUtils utilsMock = mock(ApiExceptionHandlerUtils.class);

    // when
    OneOffSpringWebMvcFrameworkExceptionHandlerListener
        impl = new OneOffSpringWebMvcFrameworkExceptionHandlerListener(projectErrorsMock, utilsMock);

    // then
    assertThat(impl.projectApiErrors).isSameAs(projectErrorsMock);
    assertThat(impl.utils).isSameAs(utilsMock);
}
 

@Inject
public SpringWebfluxApiExceptionHandler(
    @NotNull ProjectApiErrors projectApiErrors,
    @NotNull SpringWebFluxApiExceptionHandlerListenerList apiExceptionHandlerListeners,
    @NotNull ApiExceptionHandlerUtils generalUtils,
    @NotNull SpringWebfluxApiExceptionHandlerUtils springUtils,
    @NotNull ObjectProvider<ViewResolver> viewResolversProvider,
    @NotNull ServerCodecConfigurer serverCodecConfigurer
) {
    super(projectApiErrors, apiExceptionHandlerListeners.listeners, generalUtils);

    //noinspection ConstantConditions
    if (springUtils == null) {
        throw new NullPointerException("springUtils cannot be null.");
    }

    //noinspection ConstantConditions
    if (viewResolversProvider == null) {
        throw new NullPointerException("viewResolversProvider cannot be null.");
    }

    //noinspection ConstantConditions
    if (serverCodecConfigurer == null) {
        throw new NullPointerException("serverCodecConfigurer cannot be null.");
    }

    this.springUtils = springUtils;
    this.viewResolvers = viewResolversProvider.orderedStream().collect(Collectors.toList());
    this.messageReaders = serverCodecConfigurer.getReaders();
    this.messageWriters = serverCodecConfigurer.getWriters();
}
 

@Test
public void constructor_throws_IllegalArgumentException_if_passed_null_utils() {
    // when
    Throwable ex = Assertions.catchThrowable(
        () -> new OneOffSpringWebMvcFrameworkExceptionHandlerListener(mock(ProjectApiErrors.class), null)
    );

    // then
    assertThat(ex).isInstanceOf(IllegalArgumentException.class);
}
 

/**
 * Returns a {@link RiposteUnhandledErrorHandler} that uses the given {@link ProjectApiErrors}.
 */
public static @NotNull RiposteUnhandledErrorHandler defaultUnhandledErrorHandler(
    @NotNull ProjectApiErrors projectApiErrors,
    @NotNull ApiExceptionHandlerUtils utils
) {
    return new RiposteUnhandledExceptionHandler(projectApiErrors, utils);
}
 

@Override
protected ProjectApiErrors getProjectApiErrors() {
    if (projectErrors == null) {
        projectErrors = new ProjectApiErrorsImpl();
    }

    return projectErrors;
}
 

@Test
public void constructor_sets_fields_to_passed_in_args() {
    // given
    ProjectApiErrors projectErrorsMock = mock(ProjectApiErrors.class);
    ApiExceptionHandlerUtils utilsMock = mock(ApiExceptionHandlerUtils.class);

    // when
    JaxRsWebApplicationExceptionHandlerListener
        impl = new JaxRsWebApplicationExceptionHandlerListener(projectErrorsMock, utilsMock);

    // then
    assertThat(impl.projectApiErrors).isSameAs(projectErrorsMock);
    assertThat(impl.utils).isSameAs(utilsMock);
}
 

public JaxRsApiExceptionHandler(ProjectApiErrors projectApiErrors,
                               List<ApiExceptionHandlerListener> apiExceptionHandlerListeners,
                               ApiExceptionHandlerUtils apiExceptionHandlerUtils,
                               JaxRsUnhandledExceptionHandler jerseyUnhandledExceptionHandler) {

   super(projectApiErrors, apiExceptionHandlerListeners, apiExceptionHandlerUtils);

  if (jerseyUnhandledExceptionHandler == null)
    throw new IllegalArgumentException("jerseyUnhandledExceptionHandler cannot be null");

  this.jerseyUnhandledExceptionHandler = jerseyUnhandledExceptionHandler;
}
 

@Override
protected ProjectApiErrors getProjectApiErrors() {
    if (projectErrors == null) {
        projectErrors = new ProjectApiErrorsImpl();
    }

    return projectErrors;
}
 

/**
 * @return The basic set of handler listeners that are appropriate for most JAX-RS applications.
 */
public static List<ApiExceptionHandlerListener> defaultApiExceptionHandlerListeners(
    ProjectApiErrors projectApiErrors, ApiExceptionHandlerUtils utils
) {
    return Arrays.asList(
        new GenericApiExceptionHandlerListener(),
        new ServersideValidationErrorHandlerListener(projectApiErrors, utils),
        new ClientDataValidationErrorHandlerListener(projectApiErrors, utils),
        new DownstreamNetworkExceptionHandlerListener(projectApiErrors),
        new JaxRsWebApplicationExceptionHandlerListener(projectApiErrors, utils));
}
 

/**
 * @param projectApiErrors The {@link ProjectApiErrors} that should be used by this instance when finding {@link
 *                         ApiError}s. Cannot be null.
 * @param utils The {@link ApiExceptionHandlerUtils} that should be used by this instance.
 */
@Inject
public JaxRsWebApplicationExceptionHandlerListener(ProjectApiErrors projectApiErrors,
                                                   ApiExceptionHandlerUtils utils) {
    if (projectApiErrors == null)
        throw new IllegalArgumentException("ProjectApiErrors cannot be null");

    if (utils == null)
        throw new IllegalArgumentException("ApiExceptionHandlerUtils cannot be null");

    this.projectApiErrors = projectApiErrors;
    this.utils = utils;
}
 

@Test
public void constructor_sets_fields_to_passed_in_args() {
    // given
    ProjectApiErrors projectErrorsMock = mock(ProjectApiErrors.class);
    ApiExceptionHandlerUtils utilsMock = mock(ApiExceptionHandlerUtils.class);

    // when
    Jersey2WebApplicationExceptionHandlerListener
        impl = new Jersey2WebApplicationExceptionHandlerListener(projectErrorsMock, utilsMock);

    // then
    assertThat(impl.projectApiErrors).isSameAs(projectErrorsMock);
    assertThat(impl.utils).isSameAs(utilsMock);
}
 

/**
 * @return The basic set of handler listeners that are appropriate for most Jersey 2 applications.
 */
public static List<ApiExceptionHandlerListener> defaultApiExceptionHandlerListeners(
    ProjectApiErrors projectApiErrors, ApiExceptionHandlerUtils utils
) {
    return Arrays.asList(
        new GenericApiExceptionHandlerListener(),
        new ServersideValidationErrorHandlerListener(projectApiErrors, utils),
        new ClientDataValidationErrorHandlerListener(projectApiErrors, utils),
        new DownstreamNetworkExceptionHandlerListener(projectApiErrors),
        new Jersey2WebApplicationExceptionHandlerListener(projectApiErrors, utils),
        new JaxRsWebApplicationExceptionHandlerListener(projectApiErrors, utils));
}