diff --git a/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java b/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java index e8f964ebd..a7802e0b4 100644 --- a/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java +++ b/src/test/java/org/gridsuite/study/server/ShortCircuitTest.java @@ -9,16 +9,12 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.ObjectWriter; +import com.github.tomakehurst.wiremock.WireMockServer; +import com.github.tomakehurst.wiremock.client.WireMock; +import com.github.tomakehurst.wiremock.matching.RegexPattern; import com.powsybl.commons.exceptions.UncheckedInterruptedException; -import lombok.SneakyThrows; -import mockwebserver3.Dispatcher; -import mockwebserver3.MockResponse; import mockwebserver3.MockWebServer; -import mockwebserver3.RecordedRequest; import mockwebserver3.junit5.internal.MockWebServerExtension; -import okhttp3.Headers; -import okhttp3.HttpUrl; import org.assertj.core.api.WithAssertions; import org.gridsuite.study.server.dto.ComputationType; import org.gridsuite.study.server.dto.NodeReceiver; @@ -31,13 +27,12 @@ import org.gridsuite.study.server.service.*; import org.gridsuite.study.server.service.shortcircuit.ShortCircuitService; import org.gridsuite.study.server.service.shortcircuit.ShortcircuitAnalysisType; +import org.gridsuite.study.server.utils.SendInput; import org.gridsuite.study.server.utils.TestUtils; import org.gridsuite.study.server.utils.elasticsearch.DisableElasticsearch; -import org.jetbrains.annotations.NotNull; +import org.gridsuite.study.server.utils.wiremock.*; import org.json.JSONObject; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.*; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mockito; import org.slf4j.Logger; @@ -47,7 +42,6 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.cloud.stream.binder.test.InputDestination; import org.springframework.cloud.stream.binder.test.OutputDestination; -import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatusCode; import org.springframework.http.MediaType; @@ -58,15 +52,21 @@ import java.util.*; -import static org.gridsuite.study.server.StudyConstants.*; +import static com.github.tomakehurst.wiremock.client.WireMock.matching; +import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig; +import static org.gridsuite.study.server.StudyConstants.HEADER_RECEIVER; +import static org.gridsuite.study.server.StudyConstants.HEADER_USER_ID; +import static org.gridsuite.study.server.StudyConstants.QUERY_PARAM_DEBUG; import static org.gridsuite.study.server.notification.NotificationService.HEADER_UPDATE_TYPE; import static org.gridsuite.study.server.utils.TestUtils.USER_DEFAULT_PROFILE_JSON; -import static org.gridsuite.study.server.utils.TestUtils.getBinaryAsBuffer; import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.Mockito.doAnswer; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; @@ -95,8 +95,6 @@ class ShortCircuitTest implements WithAssertions { private static final String SHORT_CIRCUIT_ANALYSIS_ERROR_RESULT_UUID = "25222222-9994-4e55-8ec7-07ea965d24eb"; - private static final String SHORT_CIRCUIT_ANALYSIS_OTHER_NODE_RESULT_UUID = "11131111-8594-4e55-8ef7-07ea965d24eb"; - private static final String SHORT_CIRCUIT_ANALYSIS_RESULT_JSON = "{\"version\":\"1.0\",\"faults\":[]}"; private static final String CSV_HEADERS = "{csvHeaders}"; @@ -105,7 +103,6 @@ class ShortCircuitTest implements WithAssertions { private static final String SHORT_CIRCUIT_ANALYSIS_STATUS_JSON = "{\"status\":\"COMPLETED\"}"; - private static final String SHORT_CIRCUIT_ANALYSIS_PROFILE_PARAMETERS_JSON = "{\"withLimitViolations\":\"true\",\"withFortescueResult\":\"false\",\"withFeederResult\":\"true\"}"; private static final String SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING = "0c0f1efd-bd22-4a75-83d3-9e530245c7f4"; private static final UUID SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID = UUID.fromString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING); private static final String NO_PROFILE_USER_ID = "noProfileUser"; @@ -115,14 +112,11 @@ class ShortCircuitTest implements WithAssertions { private static final String VALID_PARAMS_IN_PROFILE_USER_ID = "validParamInProfileUser"; private static final String PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING = "1cec4a7b-ab7e-4d78-9dd7-ce73c5ef11d9"; private static final String PROFILE_SHORT_CIRCUIT_ANALYSIS_DUPLICATED_PARAMETERS_UUID_STRING = "a4ce25e1-59a7-401d-abb1-04425fe24587"; - private static final String USER_PROFILE_NO_PARAMS_JSON = "{\"id\":\"97bb1890-a90c-43c3-a004-e631246d42d6\",\"name\":\"Profile No params\"}"; private static final String USER_PROFILE_VALID_PARAMS_JSON = "{\"id\":\"97bb1890-a90c-43c3-a004-e631246d42d6\",\"name\":\"Profile with valid params\",\"shortcircuitParameterId\":\"" + PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING + "\",\"allParametersLinksValid\":true}"; private static final String USER_PROFILE_INVALID_PARAMS_JSON = "{\"id\":\"97bb1890-a90c-43c3-a004-e631246d42d6\",\"name\":\"Profile with broken params\",\"shortcircuitParameterId\":\"" + PROFILE_SHORT_CIRCUIT_ANALYSIS_INVALID_PARAMETERS_UUID_STRING + "\",\"allParametersLinksValid\":false}"; - private static final String DUPLICATED_PARAMS_JSON = "\"" + PROFILE_SHORT_CIRCUIT_ANALYSIS_DUPLICATED_PARAMETERS_UUID_STRING + "\""; private static final String VARIANT_ID = "variant_1"; private static final String VARIANT_ID_2 = "variant_2"; - private static final String VARIANT_ID_3 = "variant_3"; private static final String VARIANT_ID_4 = "variant_4"; private static final long TIMEOUT = 1000; @@ -139,8 +133,6 @@ class ShortCircuitTest implements WithAssertions { @Autowired private ObjectMapper objectMapper; - private ObjectWriter objectWriter; - @Autowired private NetworkModificationTreeService networkModificationTreeService; @@ -168,132 +160,52 @@ class ShortCircuitTest implements WithAssertions { //output destinations private final String studyUpdateDestination = "study.update"; private final String elementUpdateDestination = "element.update"; - private final String shortCircuitAnalysisDebugDestination = "shortcircuitanalysis.debug"; private final String shortCircuitAnalysisResultDestination = "shortcircuitanalysis.result"; private final String shortCircuitAnalysisStoppedDestination = "shortcircuitanalysis.stopped"; private final String shortCircuitAnalysisFailedDestination = "shortcircuitanalysis.run.dlx"; @Autowired - private StudyService studyService; - @Autowired private TestUtils studyTestUtils; + private static WireMockServer wireMockServer; + + private ShortcircuitServerStubs shortcircuitServerStubs; + private UserAdminServerStubs userAdminServerStubs; + private ReportServerStubs reportServerStubs; + private ComputationServerStubs computationServerStubs; + + @BeforeAll + static void initWireMock(@Autowired InputDestination input) { + wireMockServer = new WireMockServer(wireMockConfig().dynamicPort().extensions(new SendInput(input))); + wireMockServer.start(); + } + @BeforeEach - void setup(final MockWebServer server) throws Exception { - objectWriter = objectMapper.writer().withDefaultPrettyPrinter(); - - // Ask the server for its URL. You'll need this to make HTTP requests. - HttpUrl baseHttpUrl = server.url(""); - String baseUrl = baseHttpUrl.toString().substring(0, baseHttpUrl.toString().length() - 1); - shortCircuitService.setShortCircuitServerBaseUri(baseUrl); - reportService.setReportServerBaseUri(baseUrl); - userAdminService.setUserAdminServerBaseUri(baseUrl); - - String shortCircuitAnalysisResultUuidStr = objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); - String shortCircuitAnalysisResultNotFoundUuidStr = objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND); - String shortCircuitAnalysisErrorResultUuidStr = objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_ERROR_RESULT_UUID); - - final Dispatcher dispatcher = new Dispatcher() { - @SneakyThrows - @Override - @NotNull - public MockResponse dispatch(RecordedRequest request) { - String path = Objects.requireNonNull(request.getPath()); - String method = Objects.requireNonNull(request.getMethod()); - - if (path.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&busId=BUS_TEST_ID&variantId=" + VARIANT_ID_2)) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), shortCircuitAnalysisResultUuidStr); - } else if (path.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_2 + ".*")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), shortCircuitAnalysisResultUuidStr); - } else if (path.matches("/v1/networks/" + NETWORK_UUID_STRING_NOT_FOUND + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_4)) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), shortCircuitAnalysisResultNotFoundUuidStr); - } else if (path.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID)) { - input.send(MessageBuilder.withPayload("") - .setHeader("receiver", "%7B%22nodeUuid%22%3A%22" + request.getPath().split("%")[5].substring(4) + "%22%2C%20%22rootNetworkUuid%22%3A%20%22" + request.getPath().split("%")[11].substring(4) + "%22%2C%20%22userId%22%3A%22userId%22%7D") - .build(), shortCircuitAnalysisFailedDestination); - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), shortCircuitAnalysisErrorResultUuidStr); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "\\?mode=FULL")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), SHORT_CIRCUIT_ANALYSIS_RESULT_JSON); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/fault-types")) { - return new MockResponse(200); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/fault_results/paged" + "\\?networkUuid=" + NETWORK_UUID_STRING + "&variantId=" + VARIANT_ID_2 + "&mode=FULL&page=0&size=20&sort=id,DESC")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), SHORT_CIRCUIT_ANALYSIS_RESULT_JSON); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/csv(\\?networkUuid=" + NETWORK_UUID_STRING + "&variantId=" + VARIANT_ID_2 + ")?")) { - return new MockResponse.Builder().code(200).body(getBinaryAsBuffer(SHORT_CIRCUIT_ANALYSIS_CSV_RESULT)).addHeader("Content-Type", "application/json; charset=utf-8").build(); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND + "/csv(\\?networkUuid=" + NETWORK_UUID_STRING_NOT_FOUND + "&variantId=" + VARIANT_ID_4 + ")?")) { - return new MockResponse(404); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/feeder_results/paged" + "\\?networkUuid=" + NETWORK_UUID_STRING + "&variantId=" + VARIANT_ID_2 + "&mode=FULL&filters=fakeFilters&page=0&size=20&sort=id,DESC")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), SHORT_CIRCUIT_ANALYSIS_RESULT_JSON); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/status")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), SHORT_CIRCUIT_ANALYSIS_STATUS_JSON); - } else if (path.matches("/v1/results/invalidate-status\\?resultUuid=" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID)) { - return new MockResponse(200); - } else if (path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/stop.*") - || path.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_OTHER_NODE_RESULT_UUID + "/stop.*")) { - String resultUuid = path.matches(".*variantId=" + VARIANT_ID_2 + ".*") ? SHORT_CIRCUIT_ANALYSIS_OTHER_NODE_RESULT_UUID : SHORT_CIRCUIT_ANALYSIS_RESULT_UUID; - input.send(MessageBuilder.withPayload("") - .setHeader("resultUuid", resultUuid) - .setHeader("receiver", "%7B%22nodeUuid%22%3A%22" + request.getPath().split("%")[5].substring(4) + "%22%2C%20%22rootNetworkUuid%22%3A%20%22" + request.getPath().split("%")[11].substring(4) + "%22%2C%20%22userId%22%3A%22userId%22%7D") - .build(), shortCircuitAnalysisStoppedDestination); - return new MockResponse(200); - } else if (path.matches("/v1/results\\?resultsUuids.*")) { - return new MockResponse(200); - } else if (path.matches("/v1/reports")) { - return new MockResponse(200); - } else if (path.matches("/v1/supervision/results-count")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), "1"); - } else if (path.matches("/v1/parameters")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING)); - } else if (path.matches("/v1/users/" + NO_PROFILE_USER_ID + "/profile")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), USER_DEFAULT_PROFILE_JSON); - } else if (path.matches("/v1/users/" + NO_PARAMS_IN_PROFILE_USER_ID + "/profile")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), USER_PROFILE_NO_PARAMS_JSON); - } else if (path.matches("/v1/users/" + VALID_PARAMS_IN_PROFILE_USER_ID + "/profile")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), USER_PROFILE_VALID_PARAMS_JSON); - } else if (path.matches("/v1/users/" + INVALID_PARAMS_IN_PROFILE_USER_ID + "/profile")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), USER_PROFILE_INVALID_PARAMS_JSON); - } else if (path.matches("/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)) { - if (method.equals("GET")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), TestUtils.resourceToString("/short-circuit-parameters.json")); - } else { - //Method PUT - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); - } - } else if (path.matches("/v1/parameters\\?duplicateFrom=" + PROFILE_SHORT_CIRCUIT_ANALYSIS_INVALID_PARAMETERS_UUID_STRING) && method.equals("POST")) { - // params duplication request KO - return new MockResponse(404); - } else if (path.matches("/v1/parameters/" + PROFILE_SHORT_CIRCUIT_ANALYSIS_INVALID_PARAMETERS_UUID_STRING) && method.equals("GET")) { - return new MockResponse(404); - } else if (path.matches("/v1/parameters\\?duplicateFrom=" + PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING) && method.equals("POST")) { - // params duplication request OK - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), DUPLICATED_PARAMS_JSON); - } else if (path.matches("/v1/parameters/" + PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING) && method.equals("GET")) { - // profile params get request OK - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), SHORT_CIRCUIT_ANALYSIS_PROFILE_PARAMETERS_JSON); - } else if (path.matches("/v1/parameters") && method.equals("POST")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); - } else if (path.matches("/v1/parameters/default") && method.equals("POST")) { - return new MockResponse(200, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE), objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); - } else { - LOGGER.error("Unhandled method+path: {} {}", request.getMethod(), request.getPath()); - return new MockResponse(418, Headers.of(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN_VALUE), "Unhandled method+path: " + request.getMethod() + " " + request.getPath()); - } - } - }; - server.setDispatcher(dispatcher); + void setup() { + shortcircuitServerStubs = new ShortcircuitServerStubs(wireMockServer); + userAdminServerStubs = new UserAdminServerStubs(wireMockServer); + computationServerStubs = new ComputationServerStubs(wireMockServer); + reportServerStubs = new ReportServerStubs(wireMockServer); + + shortCircuitService.setShortCircuitServerBaseUri(wireMockServer.baseUrl()); + reportService.setReportServerBaseUri(wireMockServer.baseUrl()); + userAdminService.setUserAdminServerBaseUri(wireMockServer.baseUrl()); } @Test - void testShortCircuitAnalysisParameters(final MockWebServer server) throws Exception { + void testShortCircuitAnalysisParameters() throws Exception { //insert a study StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), UUID.fromString(CASE_SHORT_CIRCUIT_UUID_STRING), null); UUID studyNameUserIdUuid = studyEntity.getId(); + computationServerStubs.stubPostParametersDefault(objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING)); + computationServerStubs.stubParametersGet(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING, TestUtils.resourceToString("/short-circuit-parameters.json")); //get default ShortCircuitParameters mockMvc.perform(get("/v1/studies/{studyUuid}/short-circuit-analysis/parameters", studyNameUserIdUuid)) .andExpectAll(status().isOk(), content().string(TestUtils.resourceToString("/short-circuit-parameters.json"))); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.equals("/v1/parameters/default"))); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.equals("/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID))); + WireMockUtilsCriteria.verifyPostRequest(wireMockServer, "/v1/parameters/default", Map.of()); + WireMockUtilsCriteria.verifyGetRequest(wireMockServer, "/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING, Map.of()); + computationServerStubs.stubParameterPut(wireMockServer, SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING, objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); mockMvc.perform(post("/v1/studies/{studyUuid}/short-circuit-analysis/parameters", studyNameUserIdUuid) .header(HEADER_USER_ID, "testUserId") .content("{\"dumb\": \"json\"}").contentType(MediaType.APPLICATION_JSON)) @@ -302,12 +214,11 @@ void testShortCircuitAnalysisParameters(final MockWebServer server) throws Excep assertEquals(NotificationService.UPDATE_TYPE_ONE_BUS_SHORT_CIRCUIT_STATUS, output.receive(TIMEOUT, studyUpdateDestination).getHeaders().get(NotificationService.HEADER_UPDATE_TYPE)); assertEquals(NotificationService.UPDATE_TYPE_PCC_MIN_STATUS, output.receive(TIMEOUT, studyUpdateDestination).getHeaders().get(NotificationService.HEADER_UPDATE_TYPE)); assertEquals(NotificationService.UPDATE_TYPE_COMPUTATION_PARAMETERS, output.receive(TIMEOUT, studyUpdateDestination).getHeaders().get(NotificationService.HEADER_UPDATE_TYPE)); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.equals("/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID))); + WireMockUtilsCriteria.verifyPutRequest(wireMockServer, "/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING, Map.of(), null); } @Test - void testAllBusesShortCircuit(final MockWebServer server) throws Exception { + void testAllBusesShortCircuit() throws Exception { //insert a study StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, null); UUID studyNameUserIdUuid = studyEntity.getId(); @@ -324,10 +235,6 @@ void testAllBusesShortCircuit(final MockWebServer server) throws Exception { NetworkModificationNode modificationNode3 = createNetworkModificationNode(studyNameUserIdUuid, modificationNode2Uuid, UUID.randomUUID(), VARIANT_ID_2, "node 3"); UUID modificationNode3Uuid = modificationNode3.getId(); - - NetworkModificationNode modificationNode4 = createNetworkModificationNode(studyNameUserIdUuid, - modificationNode3Uuid, UUID.randomUUID(), VARIANT_ID_3, "node 4"); - UUID unknownModificationNodeUuid = UUID.randomUUID(); // run a short circuit analysis on root node (not allowed) @@ -336,86 +243,108 @@ void testAllBusesShortCircuit(final MockWebServer server) throws Exception { .andExpect(status().isForbidden()); //run in debug mode an all-buses short circuit analysis + computationServerStubs.stubComputationRun(NETWORK_UUID_STRING, VARIANT_ID_2, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param(QUERY_PARAM_DEBUG, "true") .header("userId", "userId")) .andExpect(status().isOk()); - + shortcircuitServerStubs.verifyShortcircuitRun(NETWORK_UUID_STRING, VARIANT_ID_2, true); consumeShortCircuitAnalysisResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, true); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_2 + "&debug=true"))); - // get short circuit result + computationServerStubs.stubGetResult(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_RESULT_JSON); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid)) - .andExpectAll( - status().isOk(), - content().string(SHORT_CIRCUIT_ANALYSIS_RESULT_JSON)); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "\\?mode=FULL"))); + .andExpectAll( + status().isOk(), + content().string(SHORT_CIRCUIT_ANALYSIS_RESULT_JSON)); + WireMockUtilsCriteria.verifyGetRequest(wireMockServer, "/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, Map.of("mode", WireMock.equalTo("FULL"))); // export short circuit analysis csv result + computationServerStubs.stubGetResultCsv(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_CSV_RESULT); mockMvc.perform(post("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result/csv", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("type", "ALL_BUSES") .content(CSV_HEADERS)).andExpectAll(status().isOk(), content().bytes(SHORT_CIRCUIT_ANALYSIS_CSV_RESULT)); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/csv\\?networkUuid=" + NETWORK_UUID_STRING + "&variantId=" + VARIANT_ID_2))); + WireMockUtilsCriteria.verifyPostRequest(wireMockServer, "/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/csv", Map.of("networkUuid", WireMock.equalTo(NETWORK_UUID_STRING), "variantId", WireMock.equalTo(VARIANT_ID_2))); // get short circuit result but with unknown node mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result", studyNameUserIdUuid, firstRootNetworkUuid, unknownModificationNodeUuid)).andExpect( status().isNoContent()); - assertTrue(TestUtils.getRequestsDone(0, server).isEmpty()); - // get short circuit status + computationServerStubs.stubGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/status", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid)).andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_STATUS_JSON)); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/status"))); + computationServerStubs.verifyGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); // stop short circuit analysis + shortcircuitServerStubs.stubShortCircuitStopWithPostAction(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, shortCircuitAnalysisStoppedDestination, modificationNode3Uuid, firstRootNetworkUuid); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/stop", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .header(HEADER_USER_ID, "userId")) .andExpect(status().isOk()); - + computationServerStubs.verifyComputationStop(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, Map.of( + "receiver", WireMock.matching(".*") + )); checkUpdateModelStatusMessagesReceived(studyNameUserIdUuid, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_STATUS, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_RESULT); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/stop\\?receiver=.*nodeUuid.*"))); - // short circuit analysis failed + shortcircuitServerStubs.stubShortCircuitRunWithPostAction(NETWORK_UUID_STRING, VARIANT_ID, SHORT_CIRCUIT_ANALYSIS_ERROR_RESULT_UUID, shortCircuitAnalysisFailedDestination, modificationNode2Uuid, firstRootNetworkUuid); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode2Uuid) .header(HEADER_USER_ID, "testUserId")) .andExpect(status().isOk()).andReturn(); - + checkUpdateModelStatusMessagesReceived(studyNameUserIdUuid, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_STATUS); checkUpdateModelStatusMessagesReceived(studyNameUserIdUuid, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_FAILED); + computationServerStubs.verifyComputationRun(NETWORK_UUID_STRING, + Map.of( + "receiver", WireMock.matching(".*"), + "reporterId", WireMock.matching(".*"), + "variantId", WireMock.equalTo(VARIANT_ID))); + } - checkUpdateModelStatusMessagesReceived(studyNameUserIdUuid, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_STATUS); + @Test + void testDeleteShortcircuitResult() throws Exception { + //insert a study + StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, null); + UUID studyNameUserIdUuid = studyEntity.getId(); + UUID firstRootNetworkUuid = studyTestUtils.getOneRootNetworkUuid(studyNameUserIdUuid); + UUID rootNodeUuid = getRootNode(studyNameUserIdUuid).getId(); + NetworkModificationNode modificationNode1 = createNetworkModificationNode(studyNameUserIdUuid, rootNodeUuid, + UUID.randomUUID(), VARIANT_ID, "node 1"); + UUID modificationNode1Uuid = modificationNode1.getId(); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID))); + //run in debug mode an all-buses short circuit analysis + computationServerStubs.stubComputationRun(NETWORK_UUID_STRING, VARIANT_ID, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); + mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid) + .param(QUERY_PARAM_DEBUG, "true") + .header("userId", "userId")) + .andExpect(status().isOk()); + shortcircuitServerStubs.verifyShortcircuitRun(NETWORK_UUID_STRING, VARIANT_ID, true); + consumeShortCircuitAnalysisResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, true); // Test result count // In short-circuit server there is no distinction between 1-bus and all-buses, so the count will return all kinds of short-circuit + computationServerStubs.stubResultsCount(1); mockMvc.perform(delete("/v1/supervision/computation/results") - .queryParam("type", ComputationType.SHORT_CIRCUIT.toString()) - .queryParam("dryRun", "true")) + .queryParam("type", ComputationType.SHORT_CIRCUIT.toString()) + .queryParam("dryRun", "true")) .andExpect(status().isOk()); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/supervision/results-count"))); + computationServerStubs.verifyResultsCountGet(); // Delete Shortcircuit results - // In short-circuit server there is no distinction between 1-bus and all-buses, so we remove all kinds of short-circuit assertEquals(1, rootNetworkNodeInfoRepository.findAllByShortCircuitAnalysisResultUuidNotNull().size()); + computationServerStubs.stubDeleteResults("/v1/results"); + reportServerStubs.stubDeleteReport(); mockMvc.perform(delete("/v1/supervision/computation/results") - .queryParam("type", ComputationType.SHORT_CIRCUIT.toString()) - .queryParam("dryRun", "false")) - .andExpect(status().isOk()); - - var requests = TestUtils.getRequestsDone(2, server); - assertTrue(requests.stream().anyMatch(r -> r.matches("/v1/results\\?resultsUuids"))); - assertTrue(requests.stream().anyMatch(r -> r.matches("/v1/reports"))); + .queryParam("type", ComputationType.SHORT_CIRCUIT.toString()) + .queryParam("dryRun", "false")) + .andExpect(status().isOk()); + WireMockUtilsCriteria.verifyDeleteRequest(wireMockServer, "/v1/results", Map.of("resultsUuids", matching(".*"))); + reportServerStubs.verifyDeleteReport(); assertEquals(0, rootNetworkNodeInfoRepository.findAllByShortCircuitAnalysisResultUuidNotNull().size()); } @Test - void testGetShortCircuitAnalysisCsvResultNotFound(final MockWebServer server) throws Exception { + void testGetShortCircuitAnalysisCsvResultNotFound() throws Exception { //insert a study StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING_NOT_FOUND), UUID.fromString(CASE_SHORT_CIRCUIT_UUID_STRING_NOT_FOUND), null); UUID studyNameUserIdUuid = studyEntity.getId(); @@ -429,28 +358,30 @@ void testGetShortCircuitAnalysisCsvResultNotFound(final MockWebServer server) th modificationNode1Uuid, UUID.randomUUID(), VARIANT_ID, "node 2"); UUID modificationNode2Uuid = modificationNode2.getId(); - NetworkModificationNode modificationNode4 = createNetworkModificationNode(studyNameUserIdUuid, - modificationNode2Uuid, UUID.randomUUID(), VARIANT_ID_4, "node 4"); - UUID modificationNode4Uuid = modificationNode4.getId(); + NetworkModificationNode modificationNode3 = createNetworkModificationNode(studyNameUserIdUuid, + modificationNode2Uuid, UUID.randomUUID(), VARIANT_ID_4, "node 3"); + UUID modificationNode3Uuid = modificationNode3.getId(); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, rootNodeUuid) .header("userId", "userId")) .andExpect(status().isForbidden()); - mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode4Uuid) + computationServerStubs.stubComputationRun(NETWORK_UUID_STRING_NOT_FOUND, VARIANT_ID_4, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND); + mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .header("userId", "userId")) .andExpect(status().isOk()); - - consumeShortCircuitAnalysisResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode4Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND, false); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/networks/" + NETWORK_UUID_STRING_NOT_FOUND + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_4))); + computationServerStubs.verifyComputationRun(NETWORK_UUID_STRING_NOT_FOUND, Map.of( + "receiver", WireMock.matching(".*"), + "reporterId", WireMock.matching(".*"), + "variantId", WireMock.equalTo(VARIANT_ID_4))); + consumeShortCircuitAnalysisResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND, false); // export short circuit analysis csv result not found - - mockMvc.perform(post("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result/csv", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode4Uuid) + computationServerStubs.stubGetResultCsvNotFound(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND); + mockMvc.perform(post("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result/csv", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("type", "ALL_BUSES") .content(CSV_HEADERS)).andExpectAll(status().isNotFound()); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND + "/csv\\?networkUuid=" + NETWORK_UUID_STRING_NOT_FOUND + "&variantId=" + VARIANT_ID_4))); + WireMockUtilsCriteria.verifyPostRequest(wireMockServer, "/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID_NOT_FOUND + "/csv", Map.of("networkUuid", WireMock.equalTo(NETWORK_UUID_STRING_NOT_FOUND), "variantId", WireMock.equalTo(VARIANT_ID_4))); } private void consumeShortCircuitAnalysisResult(UUID studyUuid, UUID rootNetworkUuid, UUID nodeUuid, String resultUuid, boolean debug) throws JsonProcessingException { @@ -487,7 +418,7 @@ private void consumeShortCircuitAnalysisOneBusResult(UUID studyUuid, UUID rootNe } @Test - void testPagedShortCircuit(final MockWebServer server) throws Exception { + void testPagedShortCircuit() throws Exception { //insert a study StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, null); UUID studyNameUserIdUuid = studyEntity.getId(); @@ -500,53 +431,55 @@ void testPagedShortCircuit(final MockWebServer server) throws Exception { UUID unknownModificationNodeUuid = UUID.randomUUID(); //run a short circuit analysis + computationServerStubs.stubComputationRun(NETWORK_UUID_STRING, VARIANT_ID_2, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid) .header(HEADER_USER_ID, "userId")) .andExpect(status().isOk()); - + computationServerStubs.verifyComputationRun(NETWORK_UUID_STRING, Map.of( + "receiver", WireMock.matching(".*"), + "reporterId", WireMock.matching(".*"), + "variantId", WireMock.equalTo(VARIANT_ID_2))); consumeShortCircuitAnalysisResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, false); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_2))); - // get fault types + shortcircuitServerStubs.stubGetFaultTypes(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/computation/result/enum-values?computingType={computingType}&enumName={enumName}", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid, ComputationType.SHORT_CIRCUIT, "fault-types")) .andExpectAll(status().isOk()); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/fault-types"))); + shortcircuitServerStubs.verifyGetFaultTypes(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); // get short circuit result with pagination + shortcircuitServerStubs.stubGetPagedFaultResults(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, + SHORT_CIRCUIT_ANALYSIS_RESULT_JSON, NETWORK_UUID_STRING, VARIANT_ID_2, "FULL", "0", "20", "id,DESC"); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result?paged=true&page=0&size=20&sort=id,DESC", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid)).andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_RESULT_JSON)); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/fault_results/paged\\?networkUuid=" + NETWORK_UUID_STRING + "&variantId=variant_2&mode=FULL&page=0&size=20&sort=id,DESC"))); + shortcircuitServerStubs.verifyGetPagedFaultResults(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, NETWORK_UUID_STRING, VARIANT_ID_2, + "FULL", "0", "20", "id,DESC"); // get short circuit result with pagination but with unknown node mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result?paged=true&page=0&size=20", studyNameUserIdUuid, firstRootNetworkUuid, unknownModificationNodeUuid)).andExpect( status().isNoContent()); - assertTrue(TestUtils.getRequestsDone(0, server).isEmpty()); - // get short circuit status + computationServerStubs.stubGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/status", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid)).andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_STATUS_JSON)); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/status"))); + computationServerStubs.verifyGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, 1); // stop short circuit analysis + shortcircuitServerStubs.stubShortCircuitStopWithPostAction(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, shortCircuitAnalysisStoppedDestination, modificationNode1Uuid, firstRootNetworkUuid); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/stop", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode1Uuid) .header(HEADER_USER_ID, "userId")) .andExpect(status().isOk()); - checkUpdateModelStatusMessagesReceived(studyNameUserIdUuid, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_STATUS, NotificationService.UPDATE_TYPE_SHORT_CIRCUIT_RESULT); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/stop\\?receiver=.*nodeUuid.*"))); + WireMockUtilsCriteria.verifyPutRequest(wireMockServer, "/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/stop", true, Map.of( + "receiver", WireMock.matching(".*")), null); } @Test - void testOneBusShortCircuit(final MockWebServer server) throws Exception { + void testOneBusShortCircuit() throws Exception { //insert a study StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, null); UUID studyNameUserIdUuid = studyEntity.getId(); @@ -564,9 +497,6 @@ void testOneBusShortCircuit(final MockWebServer server) throws Exception { modificationNode2Uuid, UUID.randomUUID(), VARIANT_ID_2, "node 3"); UUID modificationNode3Uuid = modificationNode3.getId(); - NetworkModificationNode modificationNode4 = createNetworkModificationNode(studyNameUserIdUuid, - modificationNode3Uuid, UUID.randomUUID(), VARIANT_ID_3, "node 4"); - // run a one bus short circuit analysis on root node (not allowed) mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, rootNodeUuid) .param("busId", "BUS_TEST_ID") @@ -574,63 +504,62 @@ void testOneBusShortCircuit(final MockWebServer server) throws Exception { .andExpect(status().isForbidden()); //run in debug mode a one bus short circuit analysis + computationServerStubs.stubComputationRun(NETWORK_UUID_STRING, VARIANT_ID_2, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("busId", "BUS_TEST_ID") .param(QUERY_PARAM_DEBUG, "true") .header("userId", "userId")) .andExpect(status().isOk()); - + shortcircuitServerStubs.verifyShortcircuitRun(NETWORK_UUID_STRING, VARIANT_ID_2, true); consumeShortCircuitAnalysisOneBusResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, true); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_2 + "&debug=true"))); - assertEquals(1, rootNetworkNodeInfoRepository.findAllByOneBusShortCircuitAnalysisResultUuidNotNull().size()); // get one bus short circuit result + computationServerStubs.stubGetResult(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_RESULT_JSON); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("type", ShortcircuitAnalysisType.ONE_BUS.name())) .andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_RESULT_JSON) ); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "\\?mode=FULL"))); + WireMockUtilsCriteria.verifyGetRequest(wireMockServer, "/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, Map.of("mode", WireMock.equalTo("FULL"))); // get short circuit result with pagination + shortcircuitServerStubs.stubGetPagedFeederResults(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_RESULT_JSON, NETWORK_UUID_STRING, VARIANT_ID_2, "fakeFilters", "FULL", "0", "20", "id,DESC"); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/result?paged=true&page=0&size=20&sort=id,DESC&filters=fakeFilters", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("type", ShortcircuitAnalysisType.ONE_BUS.name()) ).andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_RESULT_JSON)); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/feeder_results/paged\\?networkUuid=" + NETWORK_UUID_STRING + "&variantId=variant_2&mode=FULL&filters=fakeFilters&page=0&size=20&sort=id,DESC"))); + shortcircuitServerStubs.verifyGetPagedFeederResults(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, NETWORK_UUID_STRING, VARIANT_ID_2, "fakeFilters", "FULL", "0", "20", "id,DESC"); // get one bus short circuit status + computationServerStubs.stubGetResultStatus(SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, SHORT_CIRCUIT_ANALYSIS_STATUS_JSON); mockMvc.perform(get("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/status", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("type", ShortcircuitAnalysisType.ONE_BUS.name())) .andExpectAll( status().isOk(), content().string(SHORT_CIRCUIT_ANALYSIS_STATUS_JSON) ); - - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/status"))); + WireMockUtilsCriteria.verifyGetRequest(wireMockServer, "/v1/results/" + SHORT_CIRCUIT_ANALYSIS_RESULT_UUID + "/status", Map.of()); //Test result count + computationServerStubs.stubResultsCount(1); mockMvc.perform(delete("/v1/supervision/computation/results") .queryParam("type", ComputationType.SHORT_CIRCUIT.toString()) .queryParam("dryRun", "true")) .andExpect(status().isOk()); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/supervision/results-count"))); + WireMockUtilsCriteria.verifyGetRequest(wireMockServer, "/v1/supervision/results-count", Map.of()); // Delete Shortcircuit results + computationServerStubs.stubDeleteResults("/v1/results"); + reportServerStubs.stubDeleteReport(); mockMvc.perform(delete("/v1/supervision/computation/results") .queryParam("type", ComputationType.SHORT_CIRCUIT.toString()) .queryParam("dryRun", "false")) .andExpect(status().isOk()); - - var requests = TestUtils.getRequestsDone(2, server); - assertTrue(requests.stream().anyMatch(r -> r.matches("/v1/results\\?resultsUuids"))); - assertTrue(requests.stream().anyMatch(r -> r.matches("/v1/reports"))); + WireMockUtilsCriteria.verifyDeleteRequest(wireMockServer, "/v1/results", Map.of("resultsUuids", matching(".*"))); + reportServerStubs.verifyDeleteReport(); assertEquals(0, rootNetworkNodeInfoRepository.findAllByOneBusShortCircuitAnalysisResultUuidNotNull().size()); } @@ -715,7 +644,7 @@ void testNoResult() throws Exception { } @Test - void testSetParamInvalidateShortCircuitStatus(final MockWebServer server) throws Exception { + void testSetParamInvalidateShortCircuitStatus() throws Exception { //insert a study StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, null); UUID studyNameUserIdUuid = studyEntity.getId(); @@ -734,19 +663,26 @@ void testSetParamInvalidateShortCircuitStatus(final MockWebServer server) throws UUID modificationNode3Uuid = modificationNode3.getId(); //run a short circuit analysis + computationServerStubs.stubComputationRun(NETWORK_UUID_STRING, VARIANT_ID_2, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .header("userId", "userId")) .andExpect(status().isOk()) .andReturn(); + computationServerStubs.verifyComputationRun(NETWORK_UUID_STRING, Map.of( + "receiver", WireMock.matching(".*"), + "reporterId", WireMock.matching(".*"), + "variantId", WireMock.equalTo(VARIANT_ID_2))); consumeShortCircuitAnalysisResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, false); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_2))); // update parameters invalidate the status + computationServerStubs.stubGetParametersDefault(objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING)); + computationServerStubs.stubPostParametersDefault(objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); + userAdminServerStubs.stubGetUserProfile(NO_PROFILE_USER_ID, USER_DEFAULT_PROFILE_JSON); + computationServerStubs.stubInvalidateStatus(); createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", NO_PROFILE_USER_ID, HttpStatus.OK); - var requests = TestUtils.getRequestsDone(3, server); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/users/" + NO_PROFILE_USER_ID + "/profile"))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters/default"))); - assertTrue(requests.stream().anyMatch(r -> r.matches("/v1/results/invalidate-status\\?resultUuid=.*"))); + computationServerStubs.verifyParametersDefault(1); + userAdminServerStubs.verifyGetUserProfile(NO_PROFILE_USER_ID); + computationServerStubs.verifyInvalidateStatus(Map.of("resultUuid", new RegexPattern(".*"))); } @Test @@ -769,20 +705,27 @@ void testSetParamInvalidateOneBusShortCircuitStatus(final MockWebServer server) UUID modificationNode3Uuid = modificationNode3.getId(); //run a one bus short circuit analysis + computationServerStubs.stubComputationRun(NETWORK_UUID_STRING, VARIANT_ID_2, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID); mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/shortcircuit/run", studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid) .param("busId", "BUS_TEST_ID") .header("userId", "userId")) .andExpect(status().isOk()) .andReturn(); + computationServerStubs.verifyComputationRun(NETWORK_UUID_STRING, Map.of( + "receiver", WireMock.matching(".*"), + "reporterId", WireMock.matching(".*"), + "variantId", WireMock.equalTo(VARIANT_ID_2))); consumeShortCircuitAnalysisOneBusResult(studyNameUserIdUuid, firstRootNetworkUuid, modificationNode3Uuid, SHORT_CIRCUIT_ANALYSIS_RESULT_UUID, false); - assertTrue(TestUtils.getRequestsDone(1, server).stream().anyMatch(r -> r.matches("/v1/networks/" + NETWORK_UUID_STRING + "/run-and-save\\?receiver=.*&reportUuid=.*&reporterId=.*&variantId=" + VARIANT_ID_2))); // update parameters invalidate the status + computationServerStubs.stubGetParametersDefault(objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING)); + computationServerStubs.stubPostParametersDefault(objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); + userAdminServerStubs.stubGetUserProfile(NO_PROFILE_USER_ID, USER_DEFAULT_PROFILE_JSON); + computationServerStubs.stubInvalidateStatus(); createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", NO_PROFILE_USER_ID, HttpStatus.OK); - var requests = TestUtils.getRequestsDone(3, server); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/users/" + NO_PROFILE_USER_ID + "/profile"))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters/default"))); - assertTrue(requests.stream().anyMatch(r -> r.matches("/v1/results/invalidate-status\\?resultUuid=.*"))); + computationServerStubs.verifyParametersDefault(1); + userAdminServerStubs.verifyGetUserProfile(NO_PROFILE_USER_ID); + computationServerStubs.verifyInvalidateStatus(Map.of("resultUuid", new RegexPattern(".*"))); } private void createOrUpdateParametersAndDoChecks(UUID studyNameUserIdUuid, String parameters, String userId, HttpStatusCode status) throws Exception { @@ -811,60 +754,67 @@ private void createOrUpdateParametersAndDoChecks(UUID studyNameUserIdUuid, Strin } @Test - void testResetShortCircuitAnalysisParametersUserHasNoProfile(final MockWebServer server) throws Exception { + void testResetShortCircuitAnalysisParametersUserHasNoProfile() throws Exception { StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID); UUID studyNameUserIdUuid = studyEntity.getId(); - createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", NO_PROFILE_USER_ID, HttpStatus.OK); - var requests = TestUtils.getRequestsDone(2, server); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/users/" + NO_PROFILE_USER_ID + "/profile"))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING))); // update existing with dft + userAdminServerStubs.stubGetUserProfile(NO_PROFILE_USER_ID, USER_DEFAULT_PROFILE_JSON); + computationServerStubs.stubParameterPut(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING, objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); + createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", NO_PROFILE_USER_ID, HttpStatus.OK); + userAdminServerStubs.verifyGetUserProfile(NO_PROFILE_USER_ID); + computationServerStubs.verifyParameterPut(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING); } @Test void testResetShortCircuitAnalysisParametersUserHasNoParamsInProfile(final MockWebServer server) throws Exception { StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID); UUID studyNameUserIdUuid = studyEntity.getId(); - createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", NO_PARAMS_IN_PROFILE_USER_ID, HttpStatus.OK); - var requests = TestUtils.getRequestsDone(2, server); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/users/" + NO_PARAMS_IN_PROFILE_USER_ID + "/profile"))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING))); // update existing with dft + userAdminServerStubs.stubGetUserProfile(NO_PARAMS_IN_PROFILE_USER_ID, USER_DEFAULT_PROFILE_JSON); + computationServerStubs.stubParameterPut(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING, objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); + createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", NO_PARAMS_IN_PROFILE_USER_ID, HttpStatus.OK); + userAdminServerStubs.verifyGetUserProfile(NO_PARAMS_IN_PROFILE_USER_ID); + computationServerStubs.verifyParameterPut(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING); } @Test void testResetShortCircuitAnalysisParametersUserHasInvalidParamsInProfile(final MockWebServer server) throws Exception { StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID); UUID studyNameUserIdUuid = studyEntity.getId(); - createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", INVALID_PARAMS_IN_PROFILE_USER_ID, HttpStatus.NO_CONTENT); - var requests = TestUtils.getRequestsDone(3, server); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/users/" + INVALID_PARAMS_IN_PROFILE_USER_ID + "/profile"))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING))); // update existing with dft - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters?duplicateFrom=" + PROFILE_SHORT_CIRCUIT_ANALYSIS_INVALID_PARAMETERS_UUID_STRING))); // post duplicate ko + userAdminServerStubs.stubGetUserProfile(INVALID_PARAMS_IN_PROFILE_USER_ID, USER_PROFILE_INVALID_PARAMS_JSON); + computationServerStubs.stubParameterPut(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING, objectMapper.writeValueAsString(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID)); + computationServerStubs.stubParametersDuplicateFromNotFound(PROFILE_SHORT_CIRCUIT_ANALYSIS_INVALID_PARAMETERS_UUID_STRING); + createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", INVALID_PARAMS_IN_PROFILE_USER_ID, HttpStatus.NO_CONTENT); + userAdminServerStubs.verifyGetUserProfile(INVALID_PARAMS_IN_PROFILE_USER_ID); + computationServerStubs.verifyParameterPut(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING); + computationServerStubs.verifyParametersDuplicateFrom(PROFILE_SHORT_CIRCUIT_ANALYSIS_INVALID_PARAMETERS_UUID_STRING); } @Test void testResetShortCircuitAnalysisParametersUserHasValidParamsInProfile(final MockWebServer server) throws Exception { StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID); UUID studyNameUserIdUuid = studyEntity.getId(); - createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", VALID_PARAMS_IN_PROFILE_USER_ID, HttpStatus.OK); - var requests = TestUtils.getRequestsDone(3, server); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/users/" + VALID_PARAMS_IN_PROFILE_USER_ID + "/profile"))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters/" + SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters?duplicateFrom=" + PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING))); // post duplicate ok + userAdminServerStubs.stubGetUserProfile(VALID_PARAMS_IN_PROFILE_USER_ID, USER_PROFILE_VALID_PARAMS_JSON); + computationServerStubs.stubParametersDuplicateFrom(PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING, objectMapper.writeValueAsString(PROFILE_SHORT_CIRCUIT_ANALYSIS_DUPLICATED_PARAMETERS_UUID_STRING)); + computationServerStubs.stubDeleteParameters(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING); + createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", VALID_PARAMS_IN_PROFILE_USER_ID, HttpStatus.OK); + userAdminServerStubs.verifyGetUserProfile(VALID_PARAMS_IN_PROFILE_USER_ID); + computationServerStubs.verifyParametersDuplicateFrom(PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING); + computationServerStubs.verifyDeleteParameters(SHORT_CIRCUIT_ANALYSIS_PARAMETERS_UUID_STRING); } @Test void testResetShortCircuitAnalysisParametersUserHasValidParamsInProfileButNoExistingShortcircuitAnalysisParams(final MockWebServer server) throws Exception { StudyEntity studyEntity = insertDummyStudy(UUID.fromString(NETWORK_UUID_STRING), CASE_SHORT_CIRCUIT_UUID, null); UUID studyNameUserIdUuid = studyEntity.getId(); - createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", VALID_PARAMS_IN_PROFILE_USER_ID, HttpStatus.OK); - var requests = TestUtils.getRequestsDone(2, server); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/users/" + VALID_PARAMS_IN_PROFILE_USER_ID + "/profile"))); - assertTrue(requests.stream().anyMatch(r -> r.equals("/v1/parameters?duplicateFrom=" + PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING))); // post duplicate ok + userAdminServerStubs.stubGetUserProfile(VALID_PARAMS_IN_PROFILE_USER_ID, USER_PROFILE_VALID_PARAMS_JSON); + computationServerStubs.stubParametersDuplicateFrom(PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING, objectMapper.writeValueAsString(PROFILE_SHORT_CIRCUIT_ANALYSIS_DUPLICATED_PARAMETERS_UUID_STRING)); + createOrUpdateParametersAndDoChecks(studyNameUserIdUuid, "", VALID_PARAMS_IN_PROFILE_USER_ID, HttpStatus.OK); + userAdminServerStubs.verifyGetUserProfile(VALID_PARAMS_IN_PROFILE_USER_ID); + computationServerStubs.verifyParametersDuplicateFrom(PROFILE_SHORT_CIRCUIT_ANALYSIS_VALID_PARAMETERS_UUID_STRING); } private StudyEntity insertDummyStudy(UUID networkUuid, UUID caseUuid, UUID shortCircuitParametersUuid) { @@ -897,7 +847,7 @@ private NetworkModificationNode createNetworkModificationNode(UUID studyUuid, UU .children(Collections.emptyList()).build(); // Only for tests - String mnBodyJson = objectWriter.writeValueAsString(modificationNode); + String mnBodyJson = objectMapper.writeValueAsString(modificationNode); JSONObject jsonObject = new JSONObject(mnBodyJson); jsonObject.put("variantId", variantId); jsonObject.put("modificationGroupUuid", modificationGroupUuid); @@ -917,7 +867,7 @@ private NetworkModificationNode createNetworkModificationNode(UUID studyUuid, UU } @AfterEach - void tearDown(final MockWebServer server) { + void tearDown() { studyRepository.findAll().forEach(s -> networkModificationTreeService.doDeleteTree(s.getId())); studyRepository.deleteAll(); @@ -925,7 +875,7 @@ void tearDown(final MockWebServer server) { TestUtils.assertQueuesEmptyThenClear(destinations, output); try { - TestUtils.assertServerRequestsEmptyThenShutdown(server); + TestUtils.assertWiremockServerRequestsEmptyThenClear(wireMockServer); } catch (UncheckedInterruptedException e) { LOGGER.error("Error while attempting to get the request done : ", e); } diff --git a/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java b/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java index c8fc7d0ff..754b7f55c 100644 --- a/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java +++ b/src/test/java/org/gridsuite/study/server/rootnetworks/SecurityAnalysisTest.java @@ -697,7 +697,7 @@ void testSecurityAnalysisParameters() throws Exception { StudyEntity studyEntity = insertDummyStudy(UUID.randomUUID(), UUID.randomUUID(), null); UUID studyUuid = studyEntity.getId(); assertNotNull(studyUuid); - computationServerStubs.stubParametersDefault(SECURITY_ANALYSIS_DEFAULT_PARAMETERS_JSON); + computationServerStubs.stubGetParametersDefault(SECURITY_ANALYSIS_DEFAULT_PARAMETERS_JSON); wireMockServer.stubFor( post(urlEqualTo("/v1/parameters/default")) .willReturn( @@ -709,7 +709,7 @@ void testSecurityAnalysisParameters() throws Exception { ); computationServerStubs.stubParametersGet(SECURITY_ANALYSIS_PARAMETERS_UUID_STRING, SECURITY_ANALYSIS_DEFAULT_PARAMETERS_JSON); - computationServerStubs.stubParametersDefault(SECURITY_ANALYSIS_DEFAULT_PARAMETERS_JSON); + computationServerStubs.stubGetParametersDefault(SECURITY_ANALYSIS_DEFAULT_PARAMETERS_JSON); mockMvc.perform(get("/v1/studies/{studyUuid}/security-analysis/parameters", studyUuid)) .andExpect(status().isOk()) .andExpect(content().string(SECURITY_ANALYSIS_DEFAULT_PARAMETERS_JSON)); diff --git a/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java b/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java index 47e2b31fb..704c10fa7 100644 --- a/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java +++ b/src/test/java/org/gridsuite/study/server/utils/wiremock/ComputationServerStubs.java @@ -11,6 +11,7 @@ import com.github.tomakehurst.wiremock.client.WireMock; import com.github.tomakehurst.wiremock.matching.StringValuePattern; import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import java.util.Map; @@ -51,6 +52,13 @@ public UUID stubGetResultStatus(String resultUuid, String statusJson) { .withBody(statusJson))).getId(); } + public UUID stubGetResult(String resultUuid, String statusJson) { + return wireMock.stubFor(WireMock.get(WireMock.urlPathEqualTo("/v1/results/" + resultUuid)).withQueryParam("mode", WireMock.equalTo("FULL")) + .willReturn(WireMock.ok() + .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .withBody(statusJson))).getId(); + } + public void verifyComputationStop(String resultUuid, Map queryParams) { WireMockUtilsCriteria.verifyPutRequest(wireMock, "/v1/results/" + resultUuid + "/stop", true, queryParams, null); } @@ -87,18 +95,34 @@ public void verifyParametersDuplicateFrom(String duplicateFromUuid, int nbReques WireMockUtilsCriteria.verifyPostRequest(wireMock, "/v1/parameters", Map.of("duplicateFrom", WireMock.equalTo(duplicateFromUuid)), nbRequests); } + /** Preferably use function without WireMockServer in signature + * TODO remove after current usages have been fixed + **/ + @Deprecated public void stubParameterPut(WireMockServer wireMockServer, String paramUuid, String responseJson) { wireMockServer.stubFor(WireMock.put(WireMock.urlPathEqualTo("/v1/parameters/" + paramUuid)) - .willReturn(WireMock.okJson(responseJson)) - ); + .willReturn(WireMock.okJson(responseJson))); } + /** This function doesn't remove request after verifying it + * TODO remove after current usages have been fixed + **/ + @Deprecated public void verifyParameterPut(WireMockServer wireMockServer, String paramUuid) { wireMockServer.verify( putRequestedFor(urlEqualTo("/v1/parameters/" + paramUuid)) ); } + public void stubParameterPut(String paramUuid, String responseJson) { + wireMock.stubFor(WireMock.put(WireMock.urlPathEqualTo("/v1/parameters/" + paramUuid)) + .willReturn(WireMock.okJson(responseJson))); + } + + public void verifyParameterPut(String paramUuid) { + WireMockUtilsCriteria.verifyPutRequest(wireMock, "/v1/parameters/" + paramUuid, Map.of(), null); + } + public void stubParametersGet(String paramUuid, String responseBody) { wireMock.stubFor(WireMock.get(WireMock.urlPathEqualTo("/v1/parameters/" + paramUuid)) .willReturn(WireMock.ok().withBody(responseBody)) @@ -124,7 +148,12 @@ public void verifyParameters(int nbRequests) { WireMockUtilsCriteria.verifyPostRequest(wireMock, "/v1/parameters", Map.of(), nbRequests); } - public void stubParametersDefault(String statusJson) { + public void stubPostParametersDefault(String responseBody) { + wireMock.stubFor(WireMock.post(WireMock.urlPathEqualTo("/v1/parameters/default")) + .willReturn(WireMock.ok().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE).withBody(responseBody))).getId(); + } + + public void stubGetParametersDefault(String statusJson) { wireMock.stubFor(WireMock.get(WireMock.urlPathEqualTo("/v1/parameters/default")) .willReturn(WireMock.ok() .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) @@ -135,6 +164,16 @@ public void verifyParametersDefault(int nbRequests) { WireMockUtilsCriteria.verifyPostRequest(wireMock, "/v1/parameters/default", Map.of(), nbRequests); } + public void stubDeleteParameters(String parametersUuid) { + wireMock.stubFor(WireMock.delete(WireMock.urlPathEqualTo("/v1/parameters/" + parametersUuid)) + .willReturn(WireMock.ok())); + } + + public void verifyDeleteParameters(String parametersUuid) { + WireMockUtilsCriteria.verifyDeleteRequest(wireMock, + "/v1/parameters/" + parametersUuid, Map.of()); + } + /* Results */ public UUID stubDeleteResult(String resultUuid) { @@ -164,4 +203,36 @@ public void stubResultsCount(int count) { public void verifyResultsCountGet() { WireMockUtilsCriteria.verifyGetRequest(wireMock, "/v1/supervision/results-count", Map.of()); } + + public void stubGetResultCsv(String resultUuid, byte[] csvContent) { + wireMock.stubFor(WireMock.post(urlPathEqualTo("/v1/results/" + resultUuid + "/csv")) + .willReturn(WireMock.ok() + .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .withBody(csvContent))); + } + + public void stubGetResultCsvNotFound(String resultUuid) { + wireMock.stubFor(WireMock.post(urlPathEqualTo("/v1/results/" + resultUuid + "/csv")) + .willReturn(aResponse() + .withStatus(HttpStatus.NOT_FOUND.value()) + .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + )); + } + + public void verifyGetResultCsv(String resultUuid) { + WireMockUtilsCriteria.verifyPostRequest(wireMock, "/v1/results/" + resultUuid + "/csv", Map.of()); + } + + /* Status */ + + public void stubInvalidateStatus() { + wireMock.stubFor(WireMock.put(WireMock.urlMatching("/v1/results/invalidate-status\\?resultUuid=.*")) + .willReturn(ok())); + } + + public void verifyInvalidateStatus(Map queryParams) { + WireMockUtilsCriteria.verifyPutRequest(wireMock, "/v1/results/invalidate-status", + true, queryParams, null); + } + } diff --git a/src/test/java/org/gridsuite/study/server/utils/wiremock/ShortcircuitServerStubs.java b/src/test/java/org/gridsuite/study/server/utils/wiremock/ShortcircuitServerStubs.java new file mode 100644 index 000000000..31cbd38f7 --- /dev/null +++ b/src/test/java/org/gridsuite/study/server/utils/wiremock/ShortcircuitServerStubs.java @@ -0,0 +1,123 @@ +/** + * Copyright (c) 2026, RTE (http://www.rte-france.com) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +package org.gridsuite.study.server.utils.wiremock; + +import com.github.tomakehurst.wiremock.WireMockServer; +import com.github.tomakehurst.wiremock.client.WireMock; +import com.github.tomakehurst.wiremock.extension.Parameters; + +import java.util.Map; +import java.util.UUID; + +import static com.github.tomakehurst.wiremock.client.WireMock.ok; +import static org.gridsuite.study.server.utils.SendInput.POST_ACTION_SEND_INPUT; + +/** + * @author Hugo Marcellin + */ +public class ShortcircuitServerStubs { + private final WireMockServer wireMock; + + public ShortcircuitServerStubs(WireMockServer wireMock) { + this.wireMock = wireMock; + } + + public void stubShortCircuitRunWithPostAction(String networkUuid, String variantId, String resultUuid, + String destination, UUID modificationUuid, UUID rootNetworkUuid) { + wireMock.stubFor( + WireMock.post(WireMock.urlPathMatching("/v1/networks/" + networkUuid + "/run-and-save")) + .withQueryParam("receiver", WireMock.matching(".*")) + .withQueryParam("reportUuid", WireMock.matching(".*")) + .withQueryParam("reporterId", WireMock.matching(".*")) + .withQueryParam("variantId", WireMock.equalTo(variantId)) + .withPostServeAction(POST_ACTION_SEND_INPUT, + Parameters.from( + Map.of( + "payload", "", + "destination", destination, + "receiver", "%7B%22nodeUuid%22%3A%22" + modificationUuid + "%22%2C%20%22rootNetworkUuid%22%3A%20%22" + rootNetworkUuid + "%22%2C%20%22userId%22%3A%22userId%22%7D" + )) + ).willReturn(WireMock.okJson("\"" + resultUuid + "\""))); + } + + public void stubShortCircuitStopWithPostAction(String resultUuid, String destination, UUID modificationNodeUuid, UUID rootNetworkUuid) { + wireMock.stubFor( + WireMock.put(WireMock.urlPathEqualTo("/v1/results/" + resultUuid + "/stop")).withPostServeAction(POST_ACTION_SEND_INPUT, + Parameters.from( + Map.of( + "payload", "", + "destination", destination, + "receiver", "%7B%22nodeUuid%22%3A%22" + modificationNodeUuid + "%22%2C%20%22rootNetworkUuid%22%3A%20%22" + rootNetworkUuid + "%22%2C%20%22userId%22%3A%22userId%22%7D" + ))).willReturn(ok()) + ); + } + + public void stubGetFaultTypes(String resultUuid) { + wireMock.stubFor(WireMock.get("/v1/results/" + resultUuid + "/fault-types") + .willReturn(ok())); + } + + public void verifyGetFaultTypes(String resultUuid) { + WireMockUtilsCriteria.verifyGetRequest(wireMock, "/v1/results/" + resultUuid + "/fault-types", Map.of()); + } + + public void stubGetPagedFaultResults(String resultUuid, String result, String networkUuid, String variantId, String mode, String page, String size, String sort) { + wireMock.stubFor(WireMock.get(WireMock.urlPathMatching("/v1/results/" + resultUuid + "/fault_results/paged")) + .withQueryParam("networkUuid", WireMock.equalTo(networkUuid)) + .withQueryParam("variantId", WireMock.equalTo(variantId)) + .withQueryParam("mode", WireMock.equalTo(mode)) + .withQueryParam("page", WireMock.equalTo(page)) + .withQueryParam("size", WireMock.equalTo(size)) + .withQueryParam("sort", WireMock.equalTo(sort)) + .willReturn(WireMock.okJson(result))); + } + + public void verifyGetPagedFaultResults(String resultUuid, String networkUuid, String variantId, String mode, String page, String size, String sort) { + WireMockUtilsCriteria.verifyGetRequest(wireMock, "/v1/results/" + resultUuid + "/fault_results/paged", Map.of( + "networkUuid", WireMock.equalTo(networkUuid), + "variantId", WireMock.equalTo(variantId), + "mode", WireMock.equalTo(mode), + "page", WireMock.equalTo(page), + "size", WireMock.equalTo(size), + "sort", WireMock.equalTo(sort) + )); + } + + public void stubGetPagedFeederResults(String resultUuid, String result, String networkUuid, String variantId, String filters, String mode, String page, String size, String sort) { + wireMock.stubFor(WireMock.get(WireMock.urlPathMatching("/v1/results/" + resultUuid + "/feeder_results/paged")) + .withQueryParam("networkUuid", WireMock.equalTo(networkUuid)) + .withQueryParam("variantId", WireMock.equalTo(variantId)) + .withQueryParam("filters", WireMock.equalTo(filters)) + .withQueryParam("mode", WireMock.equalTo(mode)) + .withQueryParam("page", WireMock.equalTo(page)) + .withQueryParam("size", WireMock.equalTo(size)) + .withQueryParam("sort", WireMock.equalTo(sort)) + .willReturn(WireMock.okJson(result))); + } + + public void verifyGetPagedFeederResults(String resultUuid, String networkUuid, String variantId, String filters, String mode, String page, String size, String sort) { + WireMockUtilsCriteria.verifyGetRequest(wireMock, "/v1/results/" + resultUuid + "/feeder_results/paged", Map.of( + "networkUuid", WireMock.equalTo(networkUuid), + "variantId", WireMock.equalTo(variantId), + "filters", WireMock.equalTo(filters), + "mode", WireMock.equalTo(mode), + "page", WireMock.equalTo(page), + "size", WireMock.equalTo(size), + "sort", WireMock.equalTo(sort) + )); + } + + public void verifyShortcircuitRun(String networkUuid, String variantId, boolean debug) { + WireMockUtilsCriteria.verifyPostRequest(wireMock, "/v1/networks/" + networkUuid + "/run-and-save", true, + Map.of( + "receiver", WireMock.matching(".*"), + "reporterId", WireMock.matching(".*"), + "variantId", WireMock.equalTo(variantId), + "debug", WireMock.equalTo(String.valueOf(debug))), + null); + } +}