import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * 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;
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * 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);
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * @return The error handler that should be used for this application for handling known errors. For things that
 * fall through the cracks they will be handled by {@link #riposteUnhandledErrorHandler()}.
 *
 * <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 RiposteErrorHandler riposteErrorHandler() {
    ProjectApiErrors projectApiErrors = new SampleProjectApiErrorsBase() {
        @Override
        protected List<ApiError> getProjectSpecificApiErrors() {
            return null;
        }

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

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * @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 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);
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@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));
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * Creates a new instance with the given arguments.
 *
 * @param projectApiErrors The {@link ProjectApiErrors} used for this project - cannot be null.
 * @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.
 */
public UnhandledExceptionHandlerBase(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;
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * @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. You can pass in
 *              {@link ApiExceptionHandlerUtils#DEFAULT_IMPL} if you don't need custom logic.
 */
@Inject
public ClientDataValidationErrorHandlerListener(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;
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * @param projectApiErrors The {@link ProjectApiErrors} that should be used by this instance when finding
 *                          {@link ApiError}s. Cannot be null.
 */
@Inject
public DownstreamNetworkExceptionHandlerListener(ProjectApiErrors projectApiErrors) {
    if (projectApiErrors == null)
        throw new IllegalArgumentException("ProjectApiErrors cannot be null");

    this.projectApiErrors = projectApiErrors;
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * @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. You can pass in
 *              {@link ApiExceptionHandlerUtils#DEFAULT_IMPL} if you don't need custom logic.
 */
@Inject
public ServersideValidationErrorHandlerListener(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;
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test
public void constructor_sets_projectApiErrors_and_utils_to_passed_in_args() {
    // given
    ProjectApiErrors projectErrorsMock = mock(ProjectApiErrors.class);
    ApiExceptionHandlerUtils utilsMock = mock(ApiExceptionHandlerUtils.class);

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

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

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test
public void constructor_throws_IllegalArgumentException_if_passed_null_utils() {
    // when
    Throwable ex = Assertions.catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            new ClientDataValidationErrorHandlerListener(mock(ProjectApiErrors.class), null);
        }
    });

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

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test
public void constructor_sets_projectApiErrors_and_utils_to_passed_in_args() {
    // given
    ProjectApiErrors projectErrorsMock = mock(ProjectApiErrors.class);
    ApiExceptionHandlerUtils utilsMock = mock(ApiExceptionHandlerUtils.class);

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

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

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test
public void constructor_throws_IllegalArgumentException_if_passed_null_utils() {
    // when
    Throwable ex = Assertions.catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            new ServersideValidationErrorHandlerListener(mock(ProjectApiErrors.class), null);
        }
    });

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

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test
public void constructor_sets_projectApiErrors_to_passed_in_arg() {
    // given
    ProjectApiErrors projectErrorsMock = mock(ProjectApiErrors.class);

    // when
    DownstreamNetworkExceptionHandlerListener impl = new DownstreamNetworkExceptionHandlerListener(projectErrorsMock);

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

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void constructor_throws_IllegalArgumentException_if_passed_null_listener_list() {
    // expect
    new ApiExceptionHandlerBase(mock(ProjectApiErrors.class), null, ApiExceptionHandlerUtils.DEFAULT_IMPL) {
        @Override
        protected Object prepareFrameworkRepresentation(
            DefaultErrorContractDTO errorContractDTO, int httpStatusCode, Collection rawFilteredApiErrors,
            Throwable originalException, RequestInfoForLogging request) {
            return null;
        }
    };
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void constructor_throws_IllegalArgumentException_if_passed_null_apiExceptionHandlerUtils() {
    // expect
    new ApiExceptionHandlerBase(mock(ProjectApiErrors.class), singletonList(new GenericApiExceptionHandlerListener()), null) {
        @Override
        protected Object prepareFrameworkRepresentation(
            DefaultErrorContractDTO errorContractDTO, int httpStatusCode, Collection rawFilteredApiErrors,
            Throwable originalException, RequestInfoForLogging request) {
            return null;
        }
    };
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Test
public void handleExceptionShouldUseGenericServiceErrorIfProjectApiErrorsDotGetSublistContainingOnlyHttpStatusCodeSomehowReturnsNull() {
    ProjectApiErrors mockProjectApiErrors = mock(ProjectApiErrors.class);
    doReturn(42).when(mockProjectApiErrors).determineHighestPriorityHttpStatusCode(anyCollection());
    doReturn(null).when(mockProjectApiErrors).getSublistContainingOnlyHttpStatusCode(anyCollection(), anyInt());
    doReturn(BarebonesCoreApiErrorForTesting.GENERIC_SERVICE_ERROR).when(mockProjectApiErrors).getGenericServiceError();

    ApiExceptionHandlerBase<TestDTO> handler = spy(new TestApiExceptionHandler(mockProjectApiErrors));

    List<Pair<String, String>> extraDetailsForLogging = new ArrayList<>();
    ErrorResponseInfo<TestDTO> testDto = handler.doHandleApiException(singletonSortedSetOf(CUSTOM_API_ERROR), extraDetailsForLogging,
                                                                      null, new Exception(), reqMock);
    assertThat(testDto.frameworkRepresentationObj.erv.errors.size(), is(1));
    assertThat(testDto.frameworkRepresentationObj.erv.errors.get(0).code, is(mockProjectApiErrors.getGenericServiceError().getErrorCode()));
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
private TestApiExceptionHandler(ProjectApiErrors projectApiErrorsToUse) {
    super(projectApiErrorsToUse,
        Arrays.asList(
            new GenericApiExceptionHandlerListener(),
            new ServersideValidationErrorHandlerListener(testProjectApiErrors, ApiExceptionHandlerUtils.DEFAULT_IMPL),
            new DownstreamNetworkExceptionHandlerListener(testProjectApiErrors),
            new CustomExceptionOfDoomHandlerListener()),
        ApiExceptionHandlerUtils.DEFAULT_IMPL);
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
/**
 * @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 Jersey2WebApplicationExceptionHandlerListener(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;
}
 

import com.nike.backstopper.apierror.projectspecificinfo.ProjectApiErrors; //导入依赖的package包/类
@Inject
public Jersey2ApiExceptionHandler(ProjectApiErrors projectApiErrors,
                                  Jersey2ApiExceptionHandlerListenerList apiExceptionHandlerListenerList,
                                  ApiExceptionHandlerUtils apiExceptionHandlerUtils,
                                  JaxRsUnhandledExceptionHandler jaxRsUnhandledExceptionHandler) {

    super(projectApiErrors, apiExceptionHandlerListenerList.listeners, apiExceptionHandlerUtils, jaxRsUnhandledExceptionHandler);
}