com.github.tomakehurst.wiremock.junit.WireMockRule Java Examples

@Before
public void setup() throws Exception {
    super.setup();
    this.authenticatedUser = login();
    WireMockRule bitbucketApi = getWireMockRule();

    String files = wireMockFileSystemPath()+"__files";
    String mappings = wireMockFileSystemPath()+"mappings";
    String proxyUrl = wireMockProxyUrl();

    new File(mappings).mkdirs();
    new File(files).mkdirs();
    bitbucketApi.enableRecordMappings(new SingleRootFileSource(mappings),
            new SingleRootFileSource(files));

    if (useProxy) {
        bitbucketApi.stubFor(
            WireMock.get(urlMatching(".*")).atPriority(10).willReturn(aResponse()
                .proxiedFrom(proxyUrl)));
    }

    this.apiUrl = String.format("http://localhost:%s",bitbucketApi.port());
}
 

public TestRealm(WireMockRule wireMockRule, String userInfoServerUrl, String emailFieldName, String groupFieldName) throws IOException {
    super(
         CLIENT_ID,
        "secret",
        null,
        "http://localhost:" + wireMockRule.port() + "/token",
        "http://localhost:" + wireMockRule.port() + "/authorization",
         userInfoServerUrl,
        null,
        null,
        null,
         FULL_NAME_FIELD,
         emailFieldName,
        null,
         groupFieldName,
        false,
        false,
        null,
        null,
        false,
        null,
        null,
        null,
        "manual"
    );
}
 

private static WireMockRule createWireMockServerRule(String resourceFolder) {
    final WireMockRule rule = new WireMockRule(
        wireMockConfig()
            .dynamicPort()
            .usingFilesUnderClasspath(resourceFolder)
    );

    String mappingsPath = String.format("src/test/resources/%s/mappings", resourceFolder);
    String filesPath = String.format("src/test/resources/%s/__files", resourceFolder);

    new File(mappingsPath).mkdirs();
    new File(filesPath).mkdirs();

    rule.enableRecordMappings(
        new SingleRootFileSource(mappingsPath),
        new SingleRootFileSource(filesPath)
    );

    return rule;
}
 

private void initializeServiceQueryStubs(WireMockRule rule,
		List<Integer> persistencePorts, List<Integer> recommenderPorts)
		throws JsonProcessingException {
	List<String> persistences = new LinkedList<String>();
	for (int persistencePort: persistencePorts) {
		persistences.add("localhost:" + persistencePort);
	}
	String json = new ObjectMapper().writeValueAsString(persistences);
	rule.stubFor(WireMock.get(WireMock.urlEqualTo(
			"/tools.descartes.teastore.registry/rest/services/" + Service.PERSISTENCE.getServiceName() + "/"))
					.willReturn(WireMock.okJson(json)));
	List<String> recommenders = new LinkedList<String>();
	for (int recommenderPort: recommenderPorts) {
		recommenders.add("localhost:" + recommenderPort);
	}
	json = new ObjectMapper().writeValueAsString(recommenders);
	rule.stubFor(WireMock.get(WireMock.urlEqualTo(
			"/tools.descartes.teastore.registry/rest/services/" + Service.RECOMMENDER.getServiceName() + "/"))
					.willReturn(WireMock.okJson(json)));
}
 

@Override
protected WireMockRule getWiremockRule() {
    return new WireMockRule(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .needClientAuth(true)
            .trustStorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/truststore01.jks"))
            .trustStorePassword("password")
            .keystorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/keystore01.jks"))
            .keystorePassword("password"));
}
 

@Override
protected WireMockRule getWiremockRule() {
    return new WireMockRule(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .keystorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/keystore01.jks"))
            .keystorePassword("password"));
}
 

private void initializeMockRegistry(WireMockRule wireMockRule, int count, int startport)
		throws JsonProcessingException {
	List<String> strings = new LinkedList<String>();
	for (int i = 0; i < count; i++) {
		strings.add("localhost:" + (startport + i));
	}
	String json = new ObjectMapper().writeValueAsString(strings);
	wireMockRule.stubFor(WireMock.get(WireMock.urlEqualTo(
			"/tools.descartes.teastore.registry/rest/services/" + Service.PERSISTENCE.getServiceName()))
					.willReturn(WireMock.okJson(json)));
	wireMockRule.stubFor(WireMock.post(WireMock.urlEqualTo(
			"/tools.descartes.teastore.registry/rest/services/"
					+ Service.PERSISTENCE.getServiceName() + "/*"))
	.willReturn(WireMock.ok()));
}
 

@Override
protected WireMockRule getWiremockRule() {
    return new WireMockRule(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .needClientAuth(true)
            .trustStorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/truststore01.jks"))
            .trustStorePassword("password")
            .keystorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/keystore01.jks"))
            .keystorePassword("password"));
}
 

private void initializeUpdateAndHeartbeatStubs(WireMockRule rule) {
	rule.stubFor(WireMock.put(WireMock.urlMatching(
			"/tools.descartes.teastore.registry/rest/services/.*"))
					.willReturn(WireMock.ok()));
	rule.stubFor(WireMock.delete(WireMock.urlMatching(
			"/tools.descartes.teastore.registry/rest/services/.*"))
					.willReturn(WireMock.ok()));
}
 

@Override
protected WireMockRule getWiremockRule() {
    return new WireMockRule(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .needClientAuth(true)
            .trustStorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/truststore01.jks"))
            .trustStorePassword("password")
            .keystorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/keystore01.jks"))
            .keystorePassword("password"));
}
 

@Override
protected WireMockRule getWiremockRule() {
    return new WireMockRule(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .keystorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/keystore01.jks"))
            .keystorePassword("password"));
}
 

/**
 * Create a mock persistence using a wire mock rule.
 * Recommended: Use {@link #DEFAULT_MOCK_PERSISTENCE_PORT} as port.
 * @param rule The wire mock rule to create the mocking stubs for.
 */
public MockPersistenceProvider(WireMockRule rule) {
	this.port = rule.port();
	rule.stubFor(WireMock.get(WireMock.urlEqualTo(
			"/" + Service.PERSISTENCE.getServiceName() + "/rest/orders"))
					.willReturn(WireMock.okJson(getOrders())));
	rule.stubFor(WireMock.get(WireMock.urlEqualTo(
			"/" + Service.PERSISTENCE.getServiceName() + "/rest/orderitems"))
					.willReturn(WireMock.okJson(getOrderItems())));
	rule.stubFor(WireMock.get(WireMock.urlEqualTo(
			"/" + Service.PERSISTENCE.getServiceName() + "/rest/generatedb/finished"))
					.willReturn(WireMock.ok("true")));
}
 

@Override
protected WireMockRule getWiremockRule() {
    return new WireMockRule(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .needClientAuth(true)
            .trustStorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/truststore01.jks"))
            .trustStorePassword("password")
            .keystorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/keystore01.jks"))
            .keystorePassword("password"));
}
 

@Override
protected WireMockRule getWiremockRule() {
    return new WireMockRule(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .keystorePath(ResourceUtils.toPath("io/gravitee/gateway/standalone/keystore01.jks"))
            .keystorePassword("password"));
}
 

public static void stubPublicAuthV1ApiAuth(WireMockRule wireMockRule, Account account, String token) throws JsonProcessingException {
    Map<String, String> entity = ImmutableMap.of("account_id", account.getAccountId(), "token_type", account.getPaymentType().name());
    String json = new ObjectMapper().writeValueAsString(entity);
    wireMockRule.stubFor(get(urlEqualTo("/v1/api/auth"))
            .withHeader(AUTHORIZATION, equalTo("Bearer " + token))
            .willReturn(aResponse()
                    .withStatus(200)
                    .withHeader("Content-Type", APPLICATION_JSON)
                    .withBody(json)));
}
 

public WireMockRule getRule(Options options) {
    if (urlToMock != null && !urlToMock.isEmpty()) {
        return new WireMockRecorderRule(options, urlToMock);
    } else {
        return new WireMockRule(options);
    }
}
 

protected static WireMockRule createWireMockServerRule(String resourceFolder, String baseUrl) {
    ReplaceUrlTransformer replaceUrlTransformer = new ReplaceUrlTransformer();

    final WireMockRule rule = new WireMockRule(
        wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .usingFilesUnderClasspath(resourceFolder)
            .extensions(
                new GzipDecompressTransformer(),
                replaceUrlTransformer
            )
    );

    String mappingsPath = String.format("src/test/resources/%s/mappings", resourceFolder);
    String filesPath = String.format("src/test/resources/%s/__files", resourceFolder);

    new File(mappingsPath).mkdirs();
    new File(filesPath).mkdirs();

    rule.enableRecordMappings(
        new SingleRootFileSource(mappingsPath),
        new SingleRootFileSource(filesPath)
    );

    if (useProxy) {
        rule.stubFor(
            WireMock.get(urlMatching(".*"))
                .atPriority(10)
                .willReturn(aResponse().proxiedFrom(baseUrl)));
    }

    replaceUrlTransformer.configure(baseUrl, rule);

    return rule;
}
 

/**
 * @deprecated use {@link #getWireMockServer()} method instead. Note that
 *             WireMockServer is the base class of WireMockRule.
 *
 */
@Nullable
@Deprecated
public WireMockRule getWireMockRule() {
	throw new UnsupportedOperationException(
			"Deprecated since version 2.6.0. Please use getWireMockServer instead. WireMockServer is the base class of WireMockRule.");
}
 

public TestRealm(WireMockRule wireMockRule) throws IOException {
    this(wireMockRule, null);
}
 

public TestRealm(WireMockRule wireMockRule, String userInfoServerUrl) throws IOException {
    this(wireMockRule, userInfoServerUrl, EMAIL_FIELD, GROUPS_FIELD);
}
 

@Override
protected WireMockRule getWireMockRule() {
    return bitbucketApi;
}
 

private URI testServer(WireMockRule wireMock) {
    return URI.create("http://127.0.0.1:" + wireMock.port());
}
 

protected WireMockRule getWiremockRule() {
    return new WireMockRule(
            wireMockConfig()
                    .dynamicPort()
                    .extensions(new ResponseTemplateTransformer(true)));
}
 

public WireMockRule getRule(int port) {
    return getRule(wireMockConfig().port(port));
}
 

public GHMockRule(WireMockRule mocked) {
    this.service = mocked;
}
 

/**
 * @return wiremock rule
 */
public WireMockRule service() {
    return service;
}
 

@Test
public void testMutualSSLEnabledBackend() {
    wireMockRule = new WireMockRule(wireMockConfig()
            .port(18082)
            .httpsPort(18081)
            .needClientAuth(true)
            .trustStoreType("JKS")
            .keystoreType("JKS")
            .keystorePath(KEYSTORE_FILE_PATH)
            .trustStorePath(TRUSTSTORE_FILE_PATH)
            .trustStorePassword("wso2carbon")
            .keystorePassword("wso2carbon"));
    wireMockRule.start();
    // Mock service for key manager token endpoint
    wireMockRule.stubFor(head(urlEqualTo("/test"))
            .willReturn(aResponse()
                    .withStatus(200)
                    .withBody("{success}")
                    .withHeader("Content-Type", "application/json")
            ));
    System.setProperty("javax.net.ssl.keyStoreType", "JKS");
    System.setProperty("javax.net.ssl.keyStore", KEYSTORE_FILE_PATH_CLIENT);
    System.setProperty("javax.net.ssl.keyStorePassword", "wso2carbon");
    System.setProperty("javax.net.ssl.trustStore", TRUSTSTORE_FILE_PATH_CLIENT);
    System.setProperty("javax.net.ssl.trustStorePassword", "wso2carbon");
    //Success case
    org.mozilla.javascript.NativeObject obj =
            HostObjectUtils.sendHttpHEADRequest("https://localhost:18081/test",
                    "404");
    Assert.assertEquals("success", obj.get("response"));
    //Non available path
    org.mozilla.javascript.NativeObject objError =
            HostObjectUtils.sendHttpHEADRequest("https://localhost:18081/best",
                    "404");
    Assert.assertNotEquals("success", objError.get("response"));
    //Error Port
    org.mozilla.javascript.NativeObject objErrorPort =
            HostObjectUtils.sendHttpHEADRequest("https://localhost:8082/best",
                    "404");
    Assert.assertNotEquals("success", objErrorPort.get("response"));
    //Invalid credentials
    System.setProperty("javax.net.ssl.trustStorePassword", "Wrong-Password");
    org.mozilla.javascript.NativeObject objErrorSSL =
            HostObjectUtils.sendHttpHEADRequest("https://localhost:18081/best",
                    "404");
    Assert.assertNotEquals("success", objErrorSSL.get("response"));
    //With Proxy host and port
    System.setProperty(APIConstants.HTTP_PROXY_HOST, "localhost");
    System.setProperty(APIConstants.HTTP_PROXY_PORT, "18081");
    obj = HostObjectUtils.sendHttpHEADRequest("https://localhost:18081/test",
                    "404");
    Assert.assertEquals("success", obj.get("response"));
    wireMockRule.resetAll();
    wireMockRule.stop();

}
 

public static void verifyRequestCount(int expectedCount, WireMockRule wireMock) {
    wireMock.verify(expectedCount, anyRequestedFor(anyUrl()));
}
 

@BeforeClass
public static void CucumberRestStepsTestCase() {
  wm = new WireMockRule(8080);
  wm.start();

  stubFor(
      get("/")
          .willReturn(ok())
  );

  stubFor(
      post("/withData")
          .withRequestBody(equalToJson("{\"test\": \"test\"}"))
          .willReturn(okJson("{\"foo\": \"bar\"}"))
  );

  stubFor(
      post("/withData")
          .withRequestBody(equalToJson("[{\"test\": \"test\"}]"))
          .willReturn(okJson("{\"foo\": \"bar\"}"))
  );

  stubFor(
      get(urlPathEqualTo("/withParams"))
          .withQueryParam("param", equalTo("paramValue"))
          .willReturn(okJson("[]"))
  );

  stubFor(
      get("/withHeaders")
          .withHeader("MyHeader", equalTo("MyHeaderValue"))
          .willReturn(
              aResponse()
                  .withHeader("MyHeader", "MyHeaderValue")
                  .withHeader("MultiHeader", "MultiHeaderValue1", "MultiHeaderValue2")
          )
  );

  stubFor(
      get("/withArray")
          .willReturn(okJson("[{\"foo\": \"bar\"}, {\"foo\": 3}, {\"foos\": [\"bar\", \"wee\"]}]"))
  );

  stubFor(
      get("/response")
          .willReturn(okJson("{\"foo\": \"bar\"}"))
  );

  stubFor(
      get("/response/bar")
          .willReturn(okJson("{\"bar\": \"wee\"}"))
  );

  stubFor(
      post("/withFile")
          .withMultipartRequestBody(
              aMultipart()
                  .withName("file")
          )
          .willReturn(ok())
  );
}
 

protected void verifyWireMock(WireMockRule wiremock) {
    // override in derived class for extra verification
}