JUnit集成测试抛出SQLNonTransientConnectionException

问题是,我写了一个新的集成。 所有人都在docker环境下运行,但是在添加了这个新的测试用例之后,另一个因以下异常而失败

    Too many connections

    at org.flywaydb.core.internal.jdbc.JdbcUtils.openConnection(JdbcUtils.java:60)
    at org.flywaydb.core.internal.database.DatabaseFactory.createDatabase(DatabaseFactory.java:72)
    at org.flywaydb.core.Flyway.execute(Flyway.java:1670)
    at org.flywaydb.core.Flyway.migrate(Flyway.java:1356)
    at org.springframework.boot.autoconfigure.flyway.FlywayMigrationInitializer.afterPropertiesSet(FlywayMigrationInitializer.java:66)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1821)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1758)
    ... 66 more
Caused by: java.sql.SQLNonTransientConnectionException: Too many connections
    at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:110)

这是新添加的测试用例:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = FlywayConfig.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
@ActiveProfiles({"aws", "local"})
public class BoundaryValueDeltaControllerTest {

    private static final String API_V1 = "/api/v1/";

    @Autowired
    TestRestTemplate testRestTemplate;

    @Autowired
    private DomainBuilder domainBuilder;

    @Autowired
    private AppBuilder appBuilder;

    @Autowired
    private UserBuilder userBuilder;

    @Autowired
    private DomainAdminBuilder domainAdminBuilder;

    @Autowired
    private BoundarySetBuilder boundarySetBuilder;

    @MockBean
    private LoginUserProvider loginUserProvider;

    @MockBean
    private LoginTokenService loginTokenService;

    @MockBean
    private BoundaryServiceAdapter serviceAdapter;

    @LocalServerPort
    private int port;

    LoginUserInfo loggedInUser;

    @Before
    public void setUp() {
        clear();
    }

    @After
    public void tearDown() {
        clear();
    }

    @Test
    public void updateBoundaryValuesFromApi() throws UrsBusinessException {
        Domain domain = domainBuilder.persist();
        App app = appBuilder.persist(domain);
        BoundarySet boundarySet =  boundarySetBuilder.persist(domain);
        User user = userBuilder.persist(domain.getAuthor().getUsername());
        aLoggedInUser(domain.getAuthor().getUsername());
        domainAdminBuilder.persist(user, domain);

        mockUpdateBoundaryValuesFromApiData();

        ResponseEntity<String> response = callUpdateBoundaryValuesFromApi(domain, boundarySet, app);

        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertNotNull(response.getBody());
    }

    private void mockUpdateBoundaryValuesFromApiData() throws UrsBusinessException {
        BoundaryValueInfo boundaryValueInfo = new BoundaryValueInfo();
        boundaryValueInfo.setBoundaryValueId(10L);
        boundaryValueInfo.setBoundaryValueKey("boundaryValueKey");
        boundaryValueInfo.setBoundaryValueName("boundaryValuename");

        when(serviceAdapter.readInfoFromApiUsingApp(any(), any(), any())).thenReturn(new BoundaryValueInfo[]{boundaryValueInfo});
    }

    private ResponseEntity<String> callUpdateBoundaryValuesFromApi(Domain domain, BoundarySet boundarySet, App app) {
        String url = url(API_V1 + "domains/" + domain.getName() + "/boundarysets/" + boundarySet.getBoundarySetName() + "/app/" + app.getName()+ "/updatefromapi/");
        return testRestTemplate.exchange(url,HttpMethod.GET, null, String.class);
    }

    private String url(String url) {
        return "http://localhost:" + port + url;
    }

    private void aLoggedInUser(String username) {
        Claims claims = Jwts.claims();
        claims.put("username", username);
        loggedInUser = LoginUserInfo.parse(claims);

        when(loginUserProvider.getLoggedInUser()).thenReturn(loggedInUser);
        when(loginTokenService.parseToken(any())).thenReturn(loggedInUser);
    }

    private void clear() {
        appBuilder.deleteAll();
        boundarySetBuilder.deleteAll();
        domainAdminBuilder.deleteAll();
        domainBuilder.deleteAll();
        userBuilder.deleteAll();
    }
}

这是在以下情况下失败的测试用例:

@ActiveProfiles({"aws", "local"})
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UnauthorizedControllerTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(UnauthorizedControllerTest.class);

    @Autowired
    private TestRestTemplate testRestTemplate;

    @LocalServerPort
    private int port;

    @Autowired
    private ApplicationContext context;

    private Map<Class<?>, List<String>> excludedMethodsPerController;

    @Before
    public void setUp() {
        excludedMethodsPerController = excludedMethodsPerController();
    }

    @Test
    public void contextStarts() {
        assertNotNull(context);
    }

    /**
     * If this test fails it probably means you forget to add the LoggedInUser annotation on a controller method.<br>
     * If you are 100% sure there is no annotation required, add the method to the list of excluded methods.
     */
    @Test
    public void controllerCall_WithoutAuthorization_ReturnsUnauthorized() {
        Map<String, Object> controllerBeans = context.getBeansWithAnnotation(Controller.class);

        for (Object controllerInstance : controllerBeans.values()) {
            LOGGER.info("Checking controller {}", controllerInstance);
            checkController(controllerInstance);
        }
    }

    public void checkController(Object controllerInstance) {
        // Use AopUtils for the case that spring wraps the controller in a proxy
        Class<?> controllerClass = AopProxyUtils.ultimateTargetClass(controllerInstance);
        Method[] allMethods = controllerClass.getDeclaredMethods();


        for (Method method : allMethods) {
            LOGGER.info("Checking method: {}", method.getName());
            if (!isCallable(controllerClass, method)) {
                continue;
            }

            String urlPrefix = urlPrefix(controllerClass);

            Mapping mapping = Mapping.of(method.getAnnotations());

            for (String url : mapping.urls) {
                for (RequestMethod requestMethod : mapping.requestMethods) {
                    ResponseEntity<String> exchange = exchange(urlPrefix + url, requestMethod);

                    String message = String.format("Failing %s.%s", controllerClass.getName(), method.getName());
                    assertEquals(message, HttpStatus.UNAUTHORIZED, exchange.getStatusCode());
                }
            }
        }
    }

    private ResponseEntity<String> exchange(String apiEndpoint, RequestMethod requestMethod) {
        return testRestTemplate.exchange(url(replacePathVariables(apiEndpoint)), HttpMethod.resolve(requestMethod.name()), null, String.class);
    }

    private String urlPrefix(Class<?> aClass) {
        if (!aClass.isAnnotationPresent(RequestMapping.class)) {
            return "";
        }

        RequestMapping annotation = aClass.getAnnotation(RequestMapping.class);
        return annotation.value()[0];
    }

    private String url(String url) {
        return "http://localhost:" + port + url;
    }

    private boolean isCallable(Class<?> controller, Method method) {
        return Modifier.isPublic(method.getModifiers())
                && !isExcluded(controller, method)
                && !isExternal(controller);
    }

    private boolean isExcluded(Class<?> controller, Method method) {
        List<String> excludedMethodsPerController = this.excludedMethodsPerController.getOrDefault(controller, new ArrayList<>());
        return excludedMethodsPerController.contains(method.getName());
    }

    private boolean isExternal(Class<?> controller) {
        return controller.getName().startsWith("org.spring");
    }

    private String replacePathVariables(String url) {
        return url.replaceAll("\\{[^\\/]+}", "someValue");
    }

    /**
     * There must be a really good reason to exclude the method from being checked.
     *
     * @return The list of urls that must not be checked by the security
     */
    private static Map<Class<?>, List<String>> excludedMethodsPerController() {
        Map<Class<?>, List<String>> methodPerController = new HashMap<>();

        methodPerController.put(AuthenticationController.class, Collections.singletonList("generateAuthorizationToken"));
        methodPerController.put(SystemUserLoginController.class, Arrays.asList("systemUserLogin", "handleException"));
        methodPerController.put(ValidationController.class, Collections.singletonList("isValid"));

        return methodPerController;
    }

    private static class Mapping {

        String[] urls;
        RequestMethod[] requestMethods;

        Mapping(String[] urls, RequestMethod[] requestMethods) {
            this.urls = urls;
            this.requestMethods = requestMethods;
        }

        Mapping(String[] urls, RequestMethod method) {
            this(urls, new RequestMethod[]{method});
        }

        static Mapping of(Annotation[] annotations) {
            for (Annotation annotation : annotations) {
                Mapping mapping = of(annotation);
                if (null != mapping) {
                    return mapping;
                }
            }

            throw new IllegalStateException("expected annotation not present");
        }

        static Mapping of(Annotation annotation) {
            if (annotation instanceof RequestMapping) {
                RequestMapping mapping = (RequestMapping) annotation;
                return new Mapping(mapping.value(), mapping.method());
            }
            if (annotation instanceof GetMapping) {
                GetMapping mapping = (GetMapping) annotation;
                return new Mapping(mapping.value(), RequestMethod.GET);
            }
            if (annotation instanceof PostMapping) {
                PostMapping mapping = (PostMapping) annotation;
                return new Mapping(mapping.value(), RequestMethod.POST);
            }
            if (annotation instanceof PutMapping) {
                PutMapping mapping = (PutMapping) annotation;
                return new Mapping(mapping.value(), RequestMethod.PUT);
            }
            if (annotation instanceof DeleteMapping) {
                DeleteMapping mapping = (DeleteMapping) annotation;
                return new Mapping(mapping.value(), RequestMethod.DELETE);
            }
            return null;
        }
    }
}

其他测试用例之前运行良好,但是我很困惑在添加新测试用例之后发生了什么。有人能帮我吗 ?