org.mockserver.client.MockServerClient Java Examples

@BeforeClass
public void setupMockServer() {
    mockServer = ClientAndServer.startClientAndServer(0);

    ConfigurationProperties.disableSystemOut(true);
    ConfigurationProperties.logLevel("WARNING");

    MockServerClient mockServerClient = new MockServerClient("localhost", mockServer.getLocalPort());

    mockServerClient
            .when(request().withPath("/sleep"))
            .respond(response()
                    .withStatusCode(200)
                    .withDelay(TimeUnit.SECONDS, 10));

    mockServerClient
            .when(request().withPath("/404"))
            .respond(response().withStatusCode(404));

    mockServerClient
            .when(request().withPath("/502"))
            .respond(response().withStatusCode(502));

}
 

@Test
public void testPublish() {
    new MockServerClient("localhost", 1080)
            .when(
                    request()
                            .withMethod("POST")
                            .withPath("/mychannel")
            )
            .respond(
                    response()
                            .withStatusCode(200)
                            .withHeader(HttpHeaders.CONTENT_TYPE, "application/json")
            );
    JsonObject config = Json.createObjectBuilder().add("destination", "http://localhost:1080/mychannel").build();
    Notification notification = new Notification();
    notification.setScope(NotificationScope.PORTFOLIO.name());
    notification.setGroup(NotificationGroup.NEW_VULNERABILITY.name());
    notification.setLevel(NotificationLevel.INFORMATIONAL);
    notification.setTitle("Test Notification");
    notification.setContent("This is only a test");
    MsTeamsPublisher publisher = new MsTeamsPublisher();
    publisher.inform(notification, config);
}
 

@Test
public void testPublish() {
    new MockServerClient("localhost", 1080)
            .when(
                    request()
                            .withMethod("POST")
                            .withPath("/mychannel")
            )
            .respond(
                    response()
                            .withStatusCode(200)
                            .withHeader(HttpHeaders.CONTENT_TYPE, "application/json")
            );
    JsonObject config = Json.createObjectBuilder().add("destination", "http://localhost:1080/mychannel").build();
    Notification notification = new Notification();
    notification.setScope(NotificationScope.PORTFOLIO.name());
    notification.setGroup(NotificationGroup.NEW_VULNERABILITY.name());
    notification.setLevel(NotificationLevel.INFORMATIONAL);
    notification.setTitle("Test Notification");
    notification.setContent("This is only a test");
    SlackPublisher publisher = new SlackPublisher();
    publisher.inform(notification, config);
}
 

public MockServerTestHelper(ClientType clientType) {
    clientAndServer = ClientAndServer.startClientAndServer(8080);
    mockServerClient = new MockServerClient("127.0.0.1", 8080);
    mockServerClient
            .when(
                    HttpRequest.request()
                            .withMethod("GET")
                            .withPath("/api/hello")
                            .withHeader("client-type", clientType.getValue()),
                    Times.unlimited(),
                    TimeToLive.unlimited())
            .respond(
                    HttpResponse.response()
                            .withBody("Hello")
                            .withStatusCode(200)
            );
}
 

@Test
public void shouldReturnQuoteOfTheDay() {

    var resultQuote = Json.createObjectBuilder()
            .add("contents",
                    Json.createObjectBuilder().add("quotes",
                            Json.createArrayBuilder().add(Json.createObjectBuilder()
                                    .add("quote", "Do not worry if you have built your castles in the air. " +
                                            "They are where they should be. Now put the foundations under them."))))
            .build();

    new MockServerClient(mockServer.getContainerIpAddress(), mockServer.getServerPort())
            .when(request("/qod"))
            .respond(response().withBody(resultQuote.toString(), com.google.common.net.MediaType.JSON_UTF_8));

    var result = sampleEndpoint.getQuotes();

    System.out.println("Quote of the day: " + result);

    assertNotNull(result);
    assertFalse(result.isEmpty());
}
 

@Test
public void testPublish() {
    new MockServerClient("localhost", 1080)
            .when(
                    request()
                            .withMethod("POST")
                            .withPath("/mychannel")
            )
            .respond(
                    response()
                            .withStatusCode(200)
                            .withHeader(HttpHeaders.CONTENT_TYPE, "application/json")
            );
    JsonObject config = Json.createObjectBuilder().add("destination", "http://localhost:1080/mychannel").build();
    Notification notification = new Notification();
    notification.setScope(NotificationScope.PORTFOLIO.name());
    notification.setGroup(NotificationGroup.NEW_VULNERABILITY.name());
    notification.setLevel(NotificationLevel.INFORMATIONAL);
    notification.setTitle("Test Notification");
    notification.setContent("This is only a test");
    WebhookPublisher publisher = new WebhookPublisher();
    publisher.inform(notification, config);
}
 

@Test
public void testUploadFindingsNegativeCase() throws Exception {
    String token = "db975c97-98b1-4988-8d6a-9c3e044dfff3";
    String applicationVersion = "";
    new MockServerClient("localhost", 1080)
            .when(
                    request()
                            .withMethod("POST")
                            .withHeader(HttpHeaders.ACCEPT, "application/xml")
                            .withPath("/ssc/upload/resultFileUpload.html?mat=" + token + "&engineType=DEPENDENCY_TRACK&entityId=" + applicationVersion)
                            .withQueryStringParameter("engineType", "DEPENDENCY_TRACK")
                            .withQueryStringParameter("mat", token)
                            .withQueryStringParameter("entityId", applicationVersion)
            )
            .respond(
                    response()
                            .withStatusCode(400)
                            .withHeader(HttpHeaders.CONTENT_TYPE, "application/xml")
            );
    FortifySscUploader uploader = new FortifySscUploader();
    FortifySscClient client = new FortifySscClient(uploader, new URL("https://localhost/ssc"));
    client.uploadDependencyTrackFindings(token, applicationVersion, new NullInputStream(16));
}
 

@Test
public void testUploadFindingsPositiveCase() throws Exception {
    String token = "db975c97-98b1-4988-8d6a-9c3e044dfff3";
    String applicationVersion = "12345";
    new MockServerClient("localhost", 1080)
            .when(
                    request()
                            .withMethod("POST")
                            .withHeader(HttpHeaders.ACCEPT, "application/xml")
                            .withPath("/ssc/upload/resultFileUpload.html?mat=" + token + "&engineType=DEPENDENCY_TRACK&entityId=" + applicationVersion)
                            .withQueryStringParameter("engineType", "DEPENDENCY_TRACK")
                            .withQueryStringParameter("mat", token)
                            .withQueryStringParameter("entityId", applicationVersion)
            )
            .respond(
                    response()
                            .withStatusCode(200)
                            .withHeader(HttpHeaders.CONTENT_TYPE, "application/xml")
            );
    FortifySscUploader uploader = new FortifySscUploader();
    FortifySscClient client = new FortifySscClient(uploader, new URL("https://localhost/ssc"));
    client.uploadDependencyTrackFindings(token, applicationVersion, new NullInputStream(0));
}
 

@Test
public void shouldReturnExpectation() throws Exception {
    // testSimpleExpectation {
    new MockServerClient(mockServer.getHost(), mockServer.getServerPort())
        .when(request()
            .withPath("/person")
            .withQueryStringParameter("name", "peter"))
        .respond(response()
            .withBody("Peter the person!"));

    // ...a GET request to '/person?name=peter' returns "Peter the person!"
    // }

    assertThat("Expectation returns expected response body",
        responseFromMockserver(mockServer, "/person?name=peter"),
        containsString("Peter the person")
    );
}
 

@Test
public void shouldCallActualMockserverVersion() throws Exception {
    String actualVersion = MockServerClient.class.getPackage().getImplementationVersion();
    try (MockServerContainer mockServer = new MockServerContainer(actualVersion)) {
        mockServer.start();

        String expectedBody = "Hello World!";

        new MockServerClient(mockServer.getHost(), mockServer.getServerPort())
            .when(request().withPath("/hello"))
            .respond(response().withBody(expectedBody));

        assertThat("MockServer returns correct result",
            responseFromMockserver(mockServer, "/hello"),
            equalTo(expectedBody)
        );
    }
}
 

@Test
public void testOneTimeTokenInvalidCredentials() throws Exception {
    new MockServerClient("localhost", 1080)
            .when(
                    request()
                            .withMethod("POST")
                            .withHeader(HttpHeaders.AUTHORIZATION, HttpUtil.basicAuthHeaderValue("admin", "wrong"))
                            .withPath("/ssc/api/v1/fileTokens")
                            .withBody("{\"fileTokenType\":\"UPLOAD\"}")
            )
            .respond(
                    response()
                            .withStatusCode(401)
            );
    FortifySscUploader uploader = new FortifySscUploader();
    FortifySscClient client = new FortifySscClient(uploader, new URL("https://localhost/ssc"));
    String token = client.generateOneTimeUploadToken("admin", "wrong");
    Assert.assertNull(token);
}
 

@Test
public void testOneTimeTokenPositiveCase() throws Exception {
    new MockServerClient("localhost", 1080)
            .when(
                    request()
                            .withMethod("POST")
                            .withHeader(HttpHeaders.AUTHORIZATION, HttpUtil.basicAuthHeaderValue("admin", "admin"))
                            .withPath("/ssc/api/v1/fileTokens")
                            .withBody("{\"fileTokenType\":\"UPLOAD\"}")
            )
            .respond(
                    response()
                            .withStatusCode(201)
                            .withHeader(HttpHeaders.CONTENT_TYPE, "application/json")
                            .withBody("{ \"data\": { \"token\": \"db975c97-98b1-4988-8d6a-9c3e044dfff3\" }}")
            );
    FortifySscUploader uploader = new FortifySscUploader();
    FortifySscClient client = new FortifySscClient(uploader, new URL("https://localhost/ssc"));
    String token = client.generateOneTimeUploadToken("admin", "admin");
    Assert.assertEquals("db975c97-98b1-4988-8d6a-9c3e044dfff3", token);
}
 

@Test
public void example() throws Exception {
    setEnvs();
    String endpoint = "/service/";
    endpoint = endpoint.concat(ThreadProperty.get("deploy_api_id")).concat("/deployments");

    String responsePath = baseResponsePath.concat("getAppsResponseOK.json");
    String response = new String(Files.readAllBytes(Paths.get(getClass().getClassLoader().getResource(responsePath).getFile())));

    new MockServerClient("localhost", port)
        .when(
            request()
                .withMethod("GET")
                .withPath(endpoint)
        )
        .respond(
            response()
                .withStatusCode(200)
                .withBody(response)
        );

    BaseResponseList<DeployedApp> responseList = deployApiClient.getDeployedApps();
    assertThat(responseList.getList()).as("List should not be empty").isNotEmpty();
    assertThat(responseList.getList().size()).as("Response elements do not match").isEqualTo(16);
}
 

@Inject
public MockClientServerFacade(GlobalWorldFacade worldFacade) {
    this.worldFacade = worldFacade;

    services = new ConcurrentHashMap<>();
    servers = new ConcurrentHashMap<>();

    String servicesProperty = worldFacade.get("http.mock.services")
        .or(
            () -> {
                throw new CukesRuntimeException("No mocks defined in cukes.properties file. please add cukes.http.mock.services value");
            }
        );
    for (String serviceName : servicesProperty.split(",")) {
        MockServerClient client = new MockServerClient(
            worldFacade.get("http.mock.services." + serviceName + ".host", "localhost"),
            Integer.parseInt(worldFacade.get("http.mock.services." + serviceName + ".port")
                .or(
                    () -> {
                        throw new CukesRuntimeException("No port provided for mock service " + serviceName + ". Please provide property cukes.http.mock.services." + serviceName + ".port");
                    })
            )
        );
        services.put(serviceName, client);
    }

}
 

public MockServerClient getMockServerClient(String serviceName) {
    return services.computeIfAbsent(serviceName, key -> {
        String availableMockServices = services.keySet().stream().collect(Collectors.joining(", "));
        throw new CukesRuntimeException("Unable to find http mock service by name:" + key + ". " +
            "Available mock services are: {" + availableMockServices + "}");
    });
}
 

@Test
public void testCreatePerson() {
    Person expectedPerson = new Person("Hank", 42, 5L);
    new MockServerClient(mockServer.getContainerIpAddress(), mockServer.getServerPort())
                    .when(request("/mock-passthrough/person/5"))
                    .respond(response().withBody(jsonb.toJson(expectedPerson), MediaType.JSON_UTF_8));

    Person actualPerson = personSvc.getPersonFromExternalService(5);
    assertEquals("Hank", actualPerson.name);
    assertEquals(42, actualPerson.age);
    assertEquals(5, actualPerson.id);
}
 

@Test
public void testCreatePerson() {
    Person expectedPerson = new Person("Hank", 42, 5L);
    new MockServerClient(mockServer.getContainerIpAddress(), mockServer.getServerPort())
                    .when(request("/mock-passthrough/person/5"))
                    .respond(response().withBody(jsonb.toJson(expectedPerson), MediaType.JSON_UTF_8));

    Person actualPerson = personSvc.getPersonFromExternalService(5);
    assertEquals("Hank", actualPerson.name);
    assertEquals(42, actualPerson.age);
    assertEquals(5, actualPerson.id);
}
 

@Before
public void setup() throws IOException {
  client = new MockServerClient("localhost", 5000);
  client.when(
                  request()
                  .withMethod("GET")
                  .withPath("/robots.txt")
          )
          .respond(
                  response()
                  .withStatusCode(200)
                  .withBody(readAndClose(getClass().getResourceAsStream("/robots.txt")))
          );
  client.when(
                  request()
                  .withMethod("GET")
                  .withQueryStringParameter("request", "GetCapabilities")
                  .withQueryStringParameter("service", "CSW")
                  .withPath("/csw")
          )
          .respond(
                  response()
                  .withStatusCode(200)
                  .withHeaders(
                    new Header("Content-Type", "application/xml; charset=utf-8")
                  )
                  .withBody(readAndClose(getClass().getResourceAsStream("/GetCapabilitiesResponse.xml")))
          );
  client.when(
                  request()
                  .withMethod("POST")
                  .withPath("/csw")
          )
          .respond(
                  response()
                  .withStatusCode(200)
                  .withHeaders(
                    new Header("Content-Type", "application/xml; charset=utf-8")
                  )
                  .withBody(readAndClose(getClass().getResourceAsStream("/GetRecordsResponse.xml")))
          );
  client.when(
                  request()
                  .withMethod("GET")
                  .withQueryStringParameter("request", "GetRecordById")
                  .withQueryStringParameter("service", "CSW")
                  .withPath("/csw")
          )
          .respond(
                  response()
                  .withStatusCode(200)
                  .withHeaders(
                    new Header("Content-Type", "application/xml; charset=utf-8")
                  )
                  .withBody(readAndClose(getClass().getResourceAsStream("/GetRecordByIdResponse.xml")))
          );
}
 

/**
 * This function will read all json files from getAllMockRequestsFromJson method
 * and create expectations from the given Paths and Response in the individual
 * tool's json.
 */
public void startMockServerWithExpectations() {
	// Starting mock server on port 1080.
	MockServerClient mockServer = startClientAndServer(1080);
	// Reading mock requests from multiple JSON files.
	List<MockRequest> mockRequests = getAllMockRequestsFromJson();
	String response = null;
	
	Iterator<MockRequest> mockIterator = mockRequests.iterator();
	while (mockIterator.hasNext()) {
		
		MockRequest request = mockIterator.next();
		List<Parameter> parameterList = new ArrayList<>();
		
		if(request.isResponseJson()) {
			response = request.getResponse().get(0).toString();
		} else {
			response = request.getResponse().toString();	
		}
		
		// checking if the request has any parameters.
		if(request.getParameters() != null) {
			for (Map.Entry<String,String> paramEntry : request.getParameters().entrySet()) {
				
				Parameter param = new Parameter(paramEntry.getKey(), paramEntry.getValue());
				parameterList.add(param);
			}
		}
		
		// Creating mock Expectation 
		mockServer
		.when(
				request()
				.withPath(request.getPath())
				.withQueryStringParameters(parameterList)
			)
		.respond(
				response()
				.withStatusCode(200)
				.withBody(response)
				);
		
		log.debug("Expectation created for the path {} with query string parmeters {}",request.getPath(),parameterList);
	}
	log.info("Mock Server Started");
 }
 

public MockServerClient getClient() {
    return client;
}
 

@Override
protected void containerIsStarted(InspectContainerResponse containerInfo) {
    super.containerIsStarted(containerInfo);
    client = new MockServerClient(getContainerIpAddress(), getFirstMappedPort());
}