wiremock | A tool for mocking HTTP services | Mock library

by wiremock Java Version: 2.33.1 License: Apache-2.0

Download this library from

kandi X-RAY | wiremock Summary

wiremock is a Java library typically used in Testing, Mock applications. wiremock has no bugs, it has no vulnerabilities, it has build file available, it has a Permissive License and it has medium support. You can download it from GitHub.

WireMock only uses log4j in its test dependencies. Neither the thin nor standalone JAR depends on or embeds log4j, so you can continue to use WireMock 2.32.0 without any risk of exposue to the recently discovered vulnerability.

Support

Quality

Security

License

Reuse

kandi-support Support

wiremock has a medium active ecosystem.
It has 4980 star(s) with 1241 fork(s). There are 139 watchers for this library.
There were 2 major release(s) in the last 6 months.
There are 194 open issues and 936 have been closed. On average issues are closed in 316 days. There are 30 open pull requests and 0 closed requests.
It has a neutral sentiment in the developer community.
The latest version of wiremock is 2.33.1

wiremock Support

Best in #Mock

Average in #Mock

wiremock Support

Best in #Mock

Average in #Mock

quality kandi Quality

wiremock has 0 bugs and 0 code smells.

wiremock Quality

Best in #Mock

Average in #Mock

wiremock Quality

Best in #Mock

Average in #Mock

security Security

wiremock has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
wiremock code analysis shows 0 unresolved vulnerabilities.
There are 0 security hotspots that need review.

wiremock Security

Best in #Mock

Average in #Mock

wiremock Security

Best in #Mock

Average in #Mock

license License

wiremock is licensed under the Apache-2.0 License. This license is Permissive.
Permissive licenses have the least restrictions, and you can use them in most projects.

wiremock License

Best in #Mock

Average in #Mock

wiremock License

Best in #Mock

Average in #Mock

build Reuse

wiremock releases are available to install and integrate.
Build file is available. You can build the component from source.
Installation instructions are not available. Examples and code snippets are available.
It has 68112 lines of code, 5958 functions and 887 files.
It has medium code complexity. Code complexity directly impacts maintainability of the code.

wiremock Reuse

Best in #Mock

Average in #Mock

wiremock Reuse

Best in #Mock

Average in #Mock

Top functions reviewed by kandi - BETA

kandi has reviewed wiremock and discovered the below as its top functions. This is intended to give you an instant insight into wiremock implemented functionality, and help decide if they suit your requirements.

Applies the given parameters to the response .
Add mock service context handler .
Add default routes .
Main method .
Adds body section to the builder .
Deserialize a date - time value pattern .
Handle webhook event .
Renders a single event .
Chunks the given number of chunks into a byte array .
Apply additional additional configuration if enabled .

wiremock Key Features

HTTP response stubbing, matchable on URL, header and body content patterns

Request verification

Runs in unit tests, as a standalone process or as a WAR app

Configurable via a fluent Java API, JSON files and JSON over HTTP

Record/playback of stubs

Fault injection

Per-request conditional proxying

Browser proxying for request inspection and replacement

Stateful behaviour simulation

Configurable response delays

wiremock Examples and Code Snippets

See all related Code Snippets

Building WireMock locally

Copy

Download

./gradlew clean test

How to write response in wiremock as a template with list?

Copy

Download

testImplementation 'com.github.jknack:handlebars-jackson2:4.3.0'

<!-- https://mvnrepository.com/artifact/com.github.jknack/handlebars-jackson2 -->
<dependency>
    <groupId>com.github.jknack</groupId>
    <artifactId>handlebars-jackson2</artifactId>
    <version>4.3.0</version>
    <scope>test</scope>
</dependency>

WireMockServer wireMockServer = new WireMockServer(wireMockConfig().dynamicPort()
                .extensions(new ResponseTemplateTransformer(false, "json", Jackson2Helper.INSTANCE)))

{
  "place": "{{parameters.place}}",
  "users": {{json parameters.users}}
}

{
  "place": "New York",
  "users": [{"name":"John","age":24},{"name":"Merry","age":31}]
}

-----------------------

testImplementation 'com.github.jknack:handlebars-jackson2:4.3.0'

<!-- https://mvnrepository.com/artifact/com.github.jknack/handlebars-jackson2 -->
<dependency>
    <groupId>com.github.jknack</groupId>
    <artifactId>handlebars-jackson2</artifactId>
    <version>4.3.0</version>
    <scope>test</scope>
</dependency>

WireMockServer wireMockServer = new WireMockServer(wireMockConfig().dynamicPort()
                .extensions(new ResponseTemplateTransformer(false, "json", Jackson2Helper.INSTANCE)))

{
  "place": "{{parameters.place}}",
  "users": {{json parameters.users}}
}

{
  "place": "New York",
  "users": [{"name":"John","age":24},{"name":"Merry","age":31}]
}

-----------------------

testImplementation 'com.github.jknack:handlebars-jackson2:4.3.0'

<!-- https://mvnrepository.com/artifact/com.github.jknack/handlebars-jackson2 -->
<dependency>
    <groupId>com.github.jknack</groupId>
    <artifactId>handlebars-jackson2</artifactId>
    <version>4.3.0</version>
    <scope>test</scope>
</dependency>

WireMockServer wireMockServer = new WireMockServer(wireMockConfig().dynamicPort()
                .extensions(new ResponseTemplateTransformer(false, "json", Jackson2Helper.INSTANCE)))

{
  "place": "{{parameters.place}}",
  "users": {{json parameters.users}}
}

{
  "place": "New York",
  "users": [{"name":"John","age":24},{"name":"Merry","age":31}]
}

-----------------------

testImplementation 'com.github.jknack:handlebars-jackson2:4.3.0'

<!-- https://mvnrepository.com/artifact/com.github.jknack/handlebars-jackson2 -->
<dependency>
    <groupId>com.github.jknack</groupId>
    <artifactId>handlebars-jackson2</artifactId>
    <version>4.3.0</version>
    <scope>test</scope>
</dependency>

WireMockServer wireMockServer = new WireMockServer(wireMockConfig().dynamicPort()
                .extensions(new ResponseTemplateTransformer(false, "json", Jackson2Helper.INSTANCE)))

{
  "place": "{{parameters.place}}",
  "users": {{json parameters.users}}
}

{
  "place": "New York",
  "users": [{"name":"John","age":24},{"name":"Merry","age":31}]
}

-----------------------

testImplementation 'com.github.jknack:handlebars-jackson2:4.3.0'

<!-- https://mvnrepository.com/artifact/com.github.jknack/handlebars-jackson2 -->
<dependency>
    <groupId>com.github.jknack</groupId>
    <artifactId>handlebars-jackson2</artifactId>
    <version>4.3.0</version>
    <scope>test</scope>
</dependency>

WireMockServer wireMockServer = new WireMockServer(wireMockConfig().dynamicPort()
                .extensions(new ResponseTemplateTransformer(false, "json", Jackson2Helper.INSTANCE)))

{
  "place": "{{parameters.place}}",
  "users": {{json parameters.users}}
}

{
  "place": "New York",
  "users": [{"name":"John","age":24},{"name":"Merry","age":31}]
}

Docker Container with Wiremock could not find stub mappings

Copy

Download

{
  "mappings": [
    {
      "id": "679dd3ce-55e5-45ee-b270-01dcf1b371ca",
      "request": {
        "urlPattern": "^/hello",
        "method": "GET"
      },
      "response": {
        "status": 200,
        "jsonBody": {
          "status": "success",
          "message": "Hello"
        },
        "headers": {
          "Content-Type": "text/plain"
        }
      },
      "uuid": "679dd3ce-55e5-45ee-b270-01dcf1b371ca"
    },
    {
      "id": "679dd3ce-55e5-45ee-b270-01dcf1b371c2",
      "request": {
        "urlPattern": "^/hello-2",
        "method": "GET"
      },
      "response": {
        "status": 200,
        "jsonBody": {
          "status": "success",
          "message": "Hello-2"
        },
        "headers": {
          "Content-Type": "text/plain"
        }
      },
      "uuid": "679dd3ce-55e5-45ee-b270-01dcf1b371c2"
    }
  ]
}

docker run -it --rm \
  -p 8090:8080 \
  -v $PWD/samples/hello/stubs:/home/wiremock \
  wiremock/wiremock

-----------------------

{
  "mappings": [
    {
      "id": "679dd3ce-55e5-45ee-b270-01dcf1b371ca",
      "request": {
        "urlPattern": "^/hello",
        "method": "GET"
      },
      "response": {
        "status": 200,
        "jsonBody": {
          "status": "success",
          "message": "Hello"
        },
        "headers": {
          "Content-Type": "text/plain"
        }
      },
      "uuid": "679dd3ce-55e5-45ee-b270-01dcf1b371ca"
    },
    {
      "id": "679dd3ce-55e5-45ee-b270-01dcf1b371c2",
      "request": {
        "urlPattern": "^/hello-2",
        "method": "GET"
      },
      "response": {
        "status": 200,
        "jsonBody": {
          "status": "success",
          "message": "Hello-2"
        },
        "headers": {
          "Content-Type": "text/plain"
        }
      },
      "uuid": "679dd3ce-55e5-45ee-b270-01dcf1b371c2"
    }
  ]
}

docker run -it --rm \
  -p 8090:8080 \
  -v $PWD/samples/hello/stubs:/home/wiremock \
  wiremock/wiremock

Unable to run JUnit5 tests with Maven

Copy

Download

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M5</version>
                <dependencies>
                    <dependency>
                        <groupId>org.junit.jupiter</groupId>
                        <artifactId>junit-jupiter</artifactId>
                        <version>5.8.2</version>
                    </dependency>
                </dependencies>
            </plugin>

Implement different response with WireMock when no request(s) match

Copy

Download

try {
    fileSource.getBinaryFileNamed(bodyFileName).readContents();
} catch (FileNotFoundException e) {
    return WireMock.notFound().withBody("custom body");
}

// Otherwise return the unmodified response definition

-----------------------

{
  "mappings": [
    {
      "name": "Retrieve Items - Success",
      "priority": 1, // arbitrary number lower than the second priority
      "request": {
        "headers": {
          "accept": {
            "caseInsensitive": true,
            "equalTo": "application/json"
          }
        },
        "method": "GET",
        "urlPathPattern": "/api/items/(UUID1|UUID2|UUID3|UUID4)"
      },
      "response": {
        "bodyFileName": "items-api/responses/retrieve/{{ request.pathSegments.[2] }}.json",
        "headers": {
          "content-type": "application/json"
        },
        "status": 200
      }
    },
    {
      "name": "Retrieve Items - 404 Not Found",
      "priority": 5, // arbitrary number that is higher than 1
      "request": {
        "headers": {
          "accept": {
            "caseInsensitive": true,
            "equalTo": "application/json"
          }
        },
        "method": "GET",
        "urlPathPattern": "/api/items/[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}"
      },
      "response": {
        "status": 404
      }
    }
  ]
}

Wiremock stubs for an API client that has hardcoded urls

Copy

Download

JvmProxyConfigurer.configureFor(wireMockServer);

 wireMockServer.stubFor(get("/stuff")
    .withHost(equalTo("api.sandbox.braintreegateway.com"))
    .willReturn(okJson("{ ... }")));

// Test something that uses the Braintree client lib

Matching JSON request body based on JSON Path with logical operators in WireMock

Copy

Download

...
{
  "matchesJsonPath": "$[?(@.amnt < 20000)]"
}
...

{ 
  "amnt": 20000 // correct format
  "amnt": "20000" // incorrect format
}

-----------------------

...
{
  "matchesJsonPath": "$[?(@.amnt < 20000)]"
}
...

{ 
  "amnt": 20000 // correct format
  "amnt": "20000" // incorrect format
}

How to invoke JUnit5 test runner / Junit tag expressions using Maven Surefire plugin?

Copy

Download

pom.xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M5</version>
    <configuration>
        <groups>Demo1Test,Demo2Test,Demo3Test,Demo4Test</groups>
    </configuration>
</plugin>

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

@Tag("Demo1Test")
public class Demo1Test {

    @Test
    void name1(TestInfo info) {
        System.out.println(info.getDisplayName());
    }
}

-----------------------

pom.xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M5</version>
    <configuration>
        <groups>Demo1Test,Demo2Test,Demo3Test,Demo4Test</groups>
    </configuration>
</plugin>

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

@Tag("Demo1Test")
public class Demo1Test {

    @Test
    void name1(TestInfo info) {
        System.out.println(info.getDisplayName());
    }
}

quarkus.oidc.auth-server-url for both testing and localhost development

Copy

Download

src/test/resources/application.properties

Is there a way to block all external network access from a Java JUnit test?

Copy

Download

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M5</version>
    <configuration>
      <systemPropertyVariables>
        <socksProxyHost>localhost</socksProxyHost>
        <socksProxyPort>1080</socksProxyPort>
        [...]
      </systemPropertyVariables>
    </configuration>
  </plugin>

-----------------------

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.time.Duration;
import java.time.Instant;

public class BlockNetworkByProperty {

    public static void main(String[] args) throws Exception {

        System.setProperty("sun.net.spi.nameservice.nameservers", "192.168.0.254"); // Pick any dead IP.
        System.setProperty("sun.net.spi.nameservice.provider.1", "dns,sun");
        
        Instant start = Instant.now();
        System.out.println("Attempting connection.. ");

        try {
            
        URL oracle = new URL("https://www.cnet.com/");
        URLConnection yc = oracle.openConnection();
        BufferedReader in = new BufferedReader(new InputStreamReader(
            yc.getInputStream()));

        String inputLine;
        while ((inputLine = in.readLine()) != null)
            System.out.println(inputLine);
        in.close();

        System.out.println("Should not have gotten here.");
        } finally {
            long secondsPassed = Duration.between(start, Instant.now()).getSeconds();
            System.out.println(String.format("%s seconds have passed.", secondsPassed));
        }
        
    }

}

Attempting connection.. 
60 seconds have passed.
Exception in thread "main" java.net.UnknownHostException: www.cnet.com
at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:184)
...stack trace continues

-----------------------

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.time.Duration;
import java.time.Instant;

public class BlockNetworkByProperty {

    public static void main(String[] args) throws Exception {

        System.setProperty("sun.net.spi.nameservice.nameservers", "192.168.0.254"); // Pick any dead IP.
        System.setProperty("sun.net.spi.nameservice.provider.1", "dns,sun");
        
        Instant start = Instant.now();
        System.out.println("Attempting connection.. ");

        try {
            
        URL oracle = new URL("https://www.cnet.com/");
        URLConnection yc = oracle.openConnection();
        BufferedReader in = new BufferedReader(new InputStreamReader(
            yc.getInputStream()));

        String inputLine;
        while ((inputLine = in.readLine()) != null)
            System.out.println(inputLine);
        in.close();

        System.out.println("Should not have gotten here.");
        } finally {
            long secondsPassed = Duration.between(start, Instant.now()).getSeconds();
            System.out.println(String.format("%s seconds have passed.", secondsPassed));
        }
        
    }

}

Attempting connection.. 
60 seconds have passed.
Exception in thread "main" java.net.UnknownHostException: www.cnet.com
at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:184)
...stack trace continues

-----------------------

docker run --network none

-----------------------

    @Rule public SniffyRule sniffyRule = new SniffyRule();

    @Test
    @DisableSockets
    public void testDisableSockets() throws IOException {
        try {
            new Socket("google.com", 443);
            fail("Sniffy should have thrown ConnectException");
        } catch (ConnectException e) {
            assertNotNull(e);
        }
    }

-----------------------

public class DisableRemoteSocketsExtension implements BeforeAllCallback {
    private static final AtomicBoolean APPLIED = new AtomicBoolean(false);

    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        if (!APPLIED.get()) {
            System.out.println("Globally disabling non-loopback sockets");

            Socket.setSocketImplFactory(DisableRemoteSocketImpl::forSocket);
            ServerSocket.setSocketFactory(DisableRemoteSocketImpl::forServerSocket);

            APPLIED.set(true);
        }
    }
}

com.example.DisableRemoteSocketsExtension

junit.jupiter.extensions.autodetection.enabled=true

public class DisableRemoteSocketImpl extends SocketImpl {
    private static final Pattern LOOPBACK_PATTERN =
            Pattern.compile("^localhost$|^127(?:\\.[0-9]+){0,2}\\.[0-9]+$|^(?:0*:)*?:?0*1$");

    private final SocketImpl delegate;

    public DisableRemoteSocketImpl(SocketImpl delegate) {
        this.delegate = delegate;
    }

    public static DisableRemoteSocketImpl forSocket() {
        // Mimics implementation in Socket.setImpl()
        SocketImpl delegate = newSocksSocketImpl(getDefaultSocketImpl());
        return new DisableRemoteSocketImpl(delegate);
    }

    public static DisableRemoteSocketImpl forServerSocket() {
        // Mimics implementation in ServerSocket.setImpl()
        SocketImpl delegate = getDefaultSocketImpl();
        return new DisableRemoteSocketImpl(delegate);
    }

    @Override
    protected void create(boolean stream) throws IOException {
        callDelegate("create", new Class<?>[]{boolean.class}, new Object[]{stream});
    }

    @Override
    protected void connect(String host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("connect", new Class<?>[]{String.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void connect(InetAddress address, int port) throws IOException {
        requireLoopbackAddress(address);
        callDelegate("connect", new Class<?>[]{InetAddress.class, int.class}, new Object[]{address, port});
    }

    @Override
    protected void connect(SocketAddress address, int timeout) throws IOException {
        if (!(address instanceof InetSocketAddress)) {
            throw new UnsupportedOperationException("Unsupported address type: " + address);
        }
        requireLoopbackAddress(((InetSocketAddress) address).getHostString());
        callDelegate("connect", new Class<?>[]{SocketAddress.class, int.class}, new Object[]{address, timeout});
    }

    @Override
    protected void bind(InetAddress host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("bind", new Class<?>[]{InetAddress.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void listen(int backlog) throws IOException {
        callDelegate("listen", new Class<?>[]{int.class}, new Object[]{backlog});
    }

    @Override
    protected void accept(SocketImpl s) throws IOException {
        callDelegate("accept", new Class<?>[]{SocketImpl.class}, new Object[]{s});
    }

    @Override
    protected InputStream getInputStream() throws IOException {
        return callDelegate("getInputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected OutputStream getOutputStream() throws IOException {
        return callDelegate("getOutputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected int available() throws IOException {
        return callDelegate("available", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void close() throws IOException {
        callDelegate("close", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void sendUrgentData(int data) throws IOException {
        callDelegate("close", new Class<?>[]{int.class}, new Object[]{data});
    }

    @Override
    public void setOption(int optID, Object value) throws SocketException {
        delegate.setOption(optID, value);
    }

    @Override
    public Object getOption(int optID) throws SocketException {
        return delegate.getOption(optID);
    }

    private void requireLoopbackAddress(String host) {
        if (!LOOPBACK_PATTERN.matcher(host).matches()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + host);
        }
    }

    private void requireLoopbackAddress(InetAddress address) {
        if (!address.isLoopbackAddress()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + address);
        }
    }

    private static SocketImpl createDelegate() {
        // Mimics implementation in Socket.setImpl()
        return newSocksSocketImpl(getDefaultSocketImpl());
    }

    private static SocketImpl getDefaultSocketImpl() {
        try {
            Method factoryMethod = SocketImpl.class.getDeclaredMethod("createPlatformSocketImpl", Boolean.TYPE);
            factoryMethod.setAccessible(true);
            return (SocketImpl) factoryMethod.invoke(null, false);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    private static SocketImpl newSocksSocketImpl(SocketImpl delegate) {
        try {
            Constructor<? extends SocketImpl> constructor = Class.forName("java.net.SocksSocketImpl")
                    .asSubclass(SocketImpl.class).getDeclaredConstructor(SocketImpl.class);
            constructor.setAccessible(true);
            return constructor.newInstance(delegate);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T callDelegate(String methodName, Class<?>[] parameterTypes, Object[] args) throws IOException {
        try {
            Method method = SocketImpl.class.getDeclaredMethod(methodName, parameterTypes);
            method.setAccessible(true);
            return (T) method.invoke(delegate, args);
        } catch (InvocationTargetException invocationTargetException) {
            Throwable e = invocationTargetException.getCause();
            if (e instanceof IOException) {
                throw (IOException) e;
            } else if (e instanceof RuntimeException) {
                throw (RuntimeException) e;
            } else if (e instanceof Error) {
                throw (Error) e;
            } else {
                throw new AssertionError(invocationTargetException);
            }
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }
}

-----------------------

public class DisableRemoteSocketsExtension implements BeforeAllCallback {
    private static final AtomicBoolean APPLIED = new AtomicBoolean(false);

    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        if (!APPLIED.get()) {
            System.out.println("Globally disabling non-loopback sockets");

            Socket.setSocketImplFactory(DisableRemoteSocketImpl::forSocket);
            ServerSocket.setSocketFactory(DisableRemoteSocketImpl::forServerSocket);

            APPLIED.set(true);
        }
    }
}

com.example.DisableRemoteSocketsExtension

junit.jupiter.extensions.autodetection.enabled=true

public class DisableRemoteSocketImpl extends SocketImpl {
    private static final Pattern LOOPBACK_PATTERN =
            Pattern.compile("^localhost$|^127(?:\\.[0-9]+){0,2}\\.[0-9]+$|^(?:0*:)*?:?0*1$");

    private final SocketImpl delegate;

    public DisableRemoteSocketImpl(SocketImpl delegate) {
        this.delegate = delegate;
    }

    public static DisableRemoteSocketImpl forSocket() {
        // Mimics implementation in Socket.setImpl()
        SocketImpl delegate = newSocksSocketImpl(getDefaultSocketImpl());
        return new DisableRemoteSocketImpl(delegate);
    }

    public static DisableRemoteSocketImpl forServerSocket() {
        // Mimics implementation in ServerSocket.setImpl()
        SocketImpl delegate = getDefaultSocketImpl();
        return new DisableRemoteSocketImpl(delegate);
    }

    @Override
    protected void create(boolean stream) throws IOException {
        callDelegate("create", new Class<?>[]{boolean.class}, new Object[]{stream});
    }

    @Override
    protected void connect(String host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("connect", new Class<?>[]{String.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void connect(InetAddress address, int port) throws IOException {
        requireLoopbackAddress(address);
        callDelegate("connect", new Class<?>[]{InetAddress.class, int.class}, new Object[]{address, port});
    }

    @Override
    protected void connect(SocketAddress address, int timeout) throws IOException {
        if (!(address instanceof InetSocketAddress)) {
            throw new UnsupportedOperationException("Unsupported address type: " + address);
        }
        requireLoopbackAddress(((InetSocketAddress) address).getHostString());
        callDelegate("connect", new Class<?>[]{SocketAddress.class, int.class}, new Object[]{address, timeout});
    }

    @Override
    protected void bind(InetAddress host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("bind", new Class<?>[]{InetAddress.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void listen(int backlog) throws IOException {
        callDelegate("listen", new Class<?>[]{int.class}, new Object[]{backlog});
    }

    @Override
    protected void accept(SocketImpl s) throws IOException {
        callDelegate("accept", new Class<?>[]{SocketImpl.class}, new Object[]{s});
    }

    @Override
    protected InputStream getInputStream() throws IOException {
        return callDelegate("getInputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected OutputStream getOutputStream() throws IOException {
        return callDelegate("getOutputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected int available() throws IOException {
        return callDelegate("available", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void close() throws IOException {
        callDelegate("close", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void sendUrgentData(int data) throws IOException {
        callDelegate("close", new Class<?>[]{int.class}, new Object[]{data});
    }

    @Override
    public void setOption(int optID, Object value) throws SocketException {
        delegate.setOption(optID, value);
    }

    @Override
    public Object getOption(int optID) throws SocketException {
        return delegate.getOption(optID);
    }

    private void requireLoopbackAddress(String host) {
        if (!LOOPBACK_PATTERN.matcher(host).matches()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + host);
        }
    }

    private void requireLoopbackAddress(InetAddress address) {
        if (!address.isLoopbackAddress()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + address);
        }
    }

    private static SocketImpl createDelegate() {
        // Mimics implementation in Socket.setImpl()
        return newSocksSocketImpl(getDefaultSocketImpl());
    }

    private static SocketImpl getDefaultSocketImpl() {
        try {
            Method factoryMethod = SocketImpl.class.getDeclaredMethod("createPlatformSocketImpl", Boolean.TYPE);
            factoryMethod.setAccessible(true);
            return (SocketImpl) factoryMethod.invoke(null, false);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    private static SocketImpl newSocksSocketImpl(SocketImpl delegate) {
        try {
            Constructor<? extends SocketImpl> constructor = Class.forName("java.net.SocksSocketImpl")
                    .asSubclass(SocketImpl.class).getDeclaredConstructor(SocketImpl.class);
            constructor.setAccessible(true);
            return constructor.newInstance(delegate);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T callDelegate(String methodName, Class<?>[] parameterTypes, Object[] args) throws IOException {
        try {
            Method method = SocketImpl.class.getDeclaredMethod(methodName, parameterTypes);
            method.setAccessible(true);
            return (T) method.invoke(delegate, args);
        } catch (InvocationTargetException invocationTargetException) {
            Throwable e = invocationTargetException.getCause();
            if (e instanceof IOException) {
                throw (IOException) e;
            } else if (e instanceof RuntimeException) {
                throw (RuntimeException) e;
            } else if (e instanceof Error) {
                throw (Error) e;
            } else {
                throw new AssertionError(invocationTargetException);
            }
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }
}

-----------------------

public class DisableRemoteSocketsExtension implements BeforeAllCallback {
    private static final AtomicBoolean APPLIED = new AtomicBoolean(false);

    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        if (!APPLIED.get()) {
            System.out.println("Globally disabling non-loopback sockets");

            Socket.setSocketImplFactory(DisableRemoteSocketImpl::forSocket);
            ServerSocket.setSocketFactory(DisableRemoteSocketImpl::forServerSocket);

            APPLIED.set(true);
        }
    }
}

com.example.DisableRemoteSocketsExtension

junit.jupiter.extensions.autodetection.enabled=true

public class DisableRemoteSocketImpl extends SocketImpl {
    private static final Pattern LOOPBACK_PATTERN =
            Pattern.compile("^localhost$|^127(?:\\.[0-9]+){0,2}\\.[0-9]+$|^(?:0*:)*?:?0*1$");

    private final SocketImpl delegate;

    public DisableRemoteSocketImpl(SocketImpl delegate) {
        this.delegate = delegate;
    }

    public static DisableRemoteSocketImpl forSocket() {
        // Mimics implementation in Socket.setImpl()
        SocketImpl delegate = newSocksSocketImpl(getDefaultSocketImpl());
        return new DisableRemoteSocketImpl(delegate);
    }

    public static DisableRemoteSocketImpl forServerSocket() {
        // Mimics implementation in ServerSocket.setImpl()
        SocketImpl delegate = getDefaultSocketImpl();
        return new DisableRemoteSocketImpl(delegate);
    }

    @Override
    protected void create(boolean stream) throws IOException {
        callDelegate("create", new Class<?>[]{boolean.class}, new Object[]{stream});
    }

    @Override
    protected void connect(String host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("connect", new Class<?>[]{String.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void connect(InetAddress address, int port) throws IOException {
        requireLoopbackAddress(address);
        callDelegate("connect", new Class<?>[]{InetAddress.class, int.class}, new Object[]{address, port});
    }

    @Override
    protected void connect(SocketAddress address, int timeout) throws IOException {
        if (!(address instanceof InetSocketAddress)) {
            throw new UnsupportedOperationException("Unsupported address type: " + address);
        }
        requireLoopbackAddress(((InetSocketAddress) address).getHostString());
        callDelegate("connect", new Class<?>[]{SocketAddress.class, int.class}, new Object[]{address, timeout});
    }

    @Override
    protected void bind(InetAddress host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("bind", new Class<?>[]{InetAddress.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void listen(int backlog) throws IOException {
        callDelegate("listen", new Class<?>[]{int.class}, new Object[]{backlog});
    }

    @Override
    protected void accept(SocketImpl s) throws IOException {
        callDelegate("accept", new Class<?>[]{SocketImpl.class}, new Object[]{s});
    }

    @Override
    protected InputStream getInputStream() throws IOException {
        return callDelegate("getInputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected OutputStream getOutputStream() throws IOException {
        return callDelegate("getOutputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected int available() throws IOException {
        return callDelegate("available", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void close() throws IOException {
        callDelegate("close", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void sendUrgentData(int data) throws IOException {
        callDelegate("close", new Class<?>[]{int.class}, new Object[]{data});
    }

    @Override
    public void setOption(int optID, Object value) throws SocketException {
        delegate.setOption(optID, value);
    }

    @Override
    public Object getOption(int optID) throws SocketException {
        return delegate.getOption(optID);
    }

    private void requireLoopbackAddress(String host) {
        if (!LOOPBACK_PATTERN.matcher(host).matches()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + host);
        }
    }

    private void requireLoopbackAddress(InetAddress address) {
        if (!address.isLoopbackAddress()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + address);
        }
    }

    private static SocketImpl createDelegate() {
        // Mimics implementation in Socket.setImpl()
        return newSocksSocketImpl(getDefaultSocketImpl());
    }

    private static SocketImpl getDefaultSocketImpl() {
        try {
            Method factoryMethod = SocketImpl.class.getDeclaredMethod("createPlatformSocketImpl", Boolean.TYPE);
            factoryMethod.setAccessible(true);
            return (SocketImpl) factoryMethod.invoke(null, false);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    private static SocketImpl newSocksSocketImpl(SocketImpl delegate) {
        try {
            Constructor<? extends SocketImpl> constructor = Class.forName("java.net.SocksSocketImpl")
                    .asSubclass(SocketImpl.class).getDeclaredConstructor(SocketImpl.class);
            constructor.setAccessible(true);
            return constructor.newInstance(delegate);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T callDelegate(String methodName, Class<?>[] parameterTypes, Object[] args) throws IOException {
        try {
            Method method = SocketImpl.class.getDeclaredMethod(methodName, parameterTypes);
            method.setAccessible(true);
            return (T) method.invoke(delegate, args);
        } catch (InvocationTargetException invocationTargetException) {
            Throwable e = invocationTargetException.getCause();
            if (e instanceof IOException) {
                throw (IOException) e;
            } else if (e instanceof RuntimeException) {
                throw (RuntimeException) e;
            } else if (e instanceof Error) {
                throw (Error) e;
            } else {
                throw new AssertionError(invocationTargetException);
            }
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }
}

-----------------------

public class DisableRemoteSocketsExtension implements BeforeAllCallback {
    private static final AtomicBoolean APPLIED = new AtomicBoolean(false);

    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        if (!APPLIED.get()) {
            System.out.println("Globally disabling non-loopback sockets");

            Socket.setSocketImplFactory(DisableRemoteSocketImpl::forSocket);
            ServerSocket.setSocketFactory(DisableRemoteSocketImpl::forServerSocket);

            APPLIED.set(true);
        }
    }
}

com.example.DisableRemoteSocketsExtension

junit.jupiter.extensions.autodetection.enabled=true

public class DisableRemoteSocketImpl extends SocketImpl {
    private static final Pattern LOOPBACK_PATTERN =
            Pattern.compile("^localhost$|^127(?:\\.[0-9]+){0,2}\\.[0-9]+$|^(?:0*:)*?:?0*1$");

    private final SocketImpl delegate;

    public DisableRemoteSocketImpl(SocketImpl delegate) {
        this.delegate = delegate;
    }

    public static DisableRemoteSocketImpl forSocket() {
        // Mimics implementation in Socket.setImpl()
        SocketImpl delegate = newSocksSocketImpl(getDefaultSocketImpl());
        return new DisableRemoteSocketImpl(delegate);
    }

    public static DisableRemoteSocketImpl forServerSocket() {
        // Mimics implementation in ServerSocket.setImpl()
        SocketImpl delegate = getDefaultSocketImpl();
        return new DisableRemoteSocketImpl(delegate);
    }

    @Override
    protected void create(boolean stream) throws IOException {
        callDelegate("create", new Class<?>[]{boolean.class}, new Object[]{stream});
    }

    @Override
    protected void connect(String host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("connect", new Class<?>[]{String.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void connect(InetAddress address, int port) throws IOException {
        requireLoopbackAddress(address);
        callDelegate("connect", new Class<?>[]{InetAddress.class, int.class}, new Object[]{address, port});
    }

    @Override
    protected void connect(SocketAddress address, int timeout) throws IOException {
        if (!(address instanceof InetSocketAddress)) {
            throw new UnsupportedOperationException("Unsupported address type: " + address);
        }
        requireLoopbackAddress(((InetSocketAddress) address).getHostString());
        callDelegate("connect", new Class<?>[]{SocketAddress.class, int.class}, new Object[]{address, timeout});
    }

    @Override
    protected void bind(InetAddress host, int port) throws IOException {
        requireLoopbackAddress(host);
        callDelegate("bind", new Class<?>[]{InetAddress.class, int.class}, new Object[]{host, port});
    }

    @Override
    protected void listen(int backlog) throws IOException {
        callDelegate("listen", new Class<?>[]{int.class}, new Object[]{backlog});
    }

    @Override
    protected void accept(SocketImpl s) throws IOException {
        callDelegate("accept", new Class<?>[]{SocketImpl.class}, new Object[]{s});
    }

    @Override
    protected InputStream getInputStream() throws IOException {
        return callDelegate("getInputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected OutputStream getOutputStream() throws IOException {
        return callDelegate("getOutputStream", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected int available() throws IOException {
        return callDelegate("available", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void close() throws IOException {
        callDelegate("close", new Class<?>[]{}, new Object[]{});
    }

    @Override
    protected void sendUrgentData(int data) throws IOException {
        callDelegate("close", new Class<?>[]{int.class}, new Object[]{data});
    }

    @Override
    public void setOption(int optID, Object value) throws SocketException {
        delegate.setOption(optID, value);
    }

    @Override
    public Object getOption(int optID) throws SocketException {
        return delegate.getOption(optID);
    }

    private void requireLoopbackAddress(String host) {
        if (!LOOPBACK_PATTERN.matcher(host).matches()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + host);
        }
    }

    private void requireLoopbackAddress(InetAddress address) {
        if (!address.isLoopbackAddress()) {
            throw new UnsupportedOperationException("Attempted to connect to remote host: " + address);
        }
    }

    private static SocketImpl createDelegate() {
        // Mimics implementation in Socket.setImpl()
        return newSocksSocketImpl(getDefaultSocketImpl());
    }

    private static SocketImpl getDefaultSocketImpl() {
        try {
            Method factoryMethod = SocketImpl.class.getDeclaredMethod("createPlatformSocketImpl", Boolean.TYPE);
            factoryMethod.setAccessible(true);
            return (SocketImpl) factoryMethod.invoke(null, false);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    private static SocketImpl newSocksSocketImpl(SocketImpl delegate) {
        try {
            Constructor<? extends SocketImpl> constructor = Class.forName("java.net.SocksSocketImpl")
                    .asSubclass(SocketImpl.class).getDeclaredConstructor(SocketImpl.class);
            constructor.setAccessible(true);
            return constructor.newInstance(delegate);
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T callDelegate(String methodName, Class<?>[] parameterTypes, Object[] args) throws IOException {
        try {
            Method method = SocketImpl.class.getDeclaredMethod(methodName, parameterTypes);
            method.setAccessible(true);
            return (T) method.invoke(delegate, args);
        } catch (InvocationTargetException invocationTargetException) {
            Throwable e = invocationTargetException.getCause();
            if (e instanceof IOException) {
                throw (IOException) e;
            } else if (e instanceof RuntimeException) {
                throw (RuntimeException) e;
            } else if (e instanceof Error) {
                throw (Error) e;
            } else {
                throw new AssertionError(invocationTargetException);
            }
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }
}

Can I create a spring bean as part of my cucumber step definitions?

Copy

Download

@Profile("cucumber")
@TestConfiguration
public class ClockConfiguration {
    @Bean
    public Clock clock() {
        return Clock.fixed(Instant.parse(TestScope.getDateValue()), ZoneId.systemDefault());
    }
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    TestScope.setDateValue(dateTime);
}

-----------------------

@Profile("cucumber")
@TestConfiguration
public class ClockConfiguration {
    @Bean
    public Clock clock() {
        return Clock.fixed(Instant.parse(TestScope.getDateValue()), ZoneId.systemDefault());
    }
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    TestScope.setDateValue(dateTime);
}

-----------------------

public void setClock(String dateTime) {
    this.clock = Clock.fixed(Instant.parse(dateTime), ZoneId.systemDefault());
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    applicationContext.getBean(MyWrapperClock.class).setClock(dateTime);
}

@Bean 
public Clock clock() {
    return Mockito.mock(Clock.class);
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    when(this.clock.instant()).thenReturn(Instant.parse(dateTime));
    when(this.clock.getZone()).thenReturn(ZoneId.systemDefault());
}

-----------------------

public void setClock(String dateTime) {
    this.clock = Clock.fixed(Instant.parse(dateTime), ZoneId.systemDefault());
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    applicationContext.getBean(MyWrapperClock.class).setClock(dateTime);
}

@Bean 
public Clock clock() {
    return Mockito.mock(Clock.class);
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    when(this.clock.instant()).thenReturn(Instant.parse(dateTime));
    when(this.clock.getZone()).thenReturn(ZoneId.systemDefault());
}

-----------------------

public void setClock(String dateTime) {
    this.clock = Clock.fixed(Instant.parse(dateTime), ZoneId.systemDefault());
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    applicationContext.getBean(MyWrapperClock.class).setClock(dateTime);
}

@Bean 
public Clock clock() {
    return Mockito.mock(Clock.class);
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    when(this.clock.instant()).thenReturn(Instant.parse(dateTime));
    when(this.clock.getZone()).thenReturn(ZoneId.systemDefault());
}

-----------------------

public void setClock(String dateTime) {
    this.clock = Clock.fixed(Instant.parse(dateTime), ZoneId.systemDefault());
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    applicationContext.getBean(MyWrapperClock.class).setClock(dateTime);
}

@Bean 
public Clock clock() {
    return Mockito.mock(Clock.class);
}

@Given("now is {string})
public void setDateTime(String dateTime) {
    when(this.clock.instant()).thenReturn(Instant.parse(dateTime));
    when(this.clock.getZone()).thenReturn(ZoneId.systemDefault());
}

See all related Code Snippets

Community Discussions

Trending Discussions on wiremock

How to write response in wiremock as a template with list?
Docker Container with Wiremock could not find stub mappings
Unable to run JUnit5 tests with Maven
how to setup Wiremock dynamic port
Implement different response with WireMock when no request(s) match
Wiremock stubs for an API client that has hardcoded urls
SpringBoot2 Configuration JOOQ MariaDB: "required a bean of type 'javax.sql.DataSource' that could not be found"
Trying to update embedded database when mocked http response is returned using Wiremock of MockServer
Wiremock does not receive any requests
With wiremock how can I match against the wiremock server URL in the body of a POST?

Trending Discussions on wiremock

QUESTION

How to write response in wiremock as a template with list?

Asked 2022-Mar-18 at 20:10

I want to use template response in wiremock and set list as a parameter. How to do that?

I set up wiremock in Java:

wireMockServer.stubFor(get(urlPathEqualTo("/somePath"))
            .withQueryParam("place.id", equalTo(buildingId))
            .willReturn(aResponse()
                .withHeader("Content-Type", "application/json")
                .withBodyFile("wiremock/response-template.json") //how to set up this file
                .withTransformerParameters(Map.of(
                    "place", "New York",
                    "users", List.of(new User("John", 24), new User("Merry", 31)) //list to insert
                 ))
                .withTransformers("response-template")));

How to write file: response-template.json to have result like this:

{
  "place": "New York",
  "users": [
    {
      "name": "John",
      "age": 24
    },
    {
      "name": "Marry",
      "age": 31
    }
  ]
}

I know that it should start like this:

{
  "place": "{{parameters.place}}",
  "users": [
    ???
  ]
}

ANSWER

Answered 2022-Mar-18 at 20:10

The easiest solution would be to use Jackson2 Helper or any other helper that can serialize to jsons.

Add Handlebars jackson2 dependency to your project:

Gradle

testImplementation 'com.github.jknack:handlebars-jackson2:4.3.0'

Maven

<!-- https://mvnrepository.com/artifact/com.github.jknack/handlebars-jackson2 -->
<dependency>
    <groupId>com.github.jknack</groupId>
    <artifactId>handlebars-jackson2</artifactId>
    <version>4.3.0</version>
    <scope>test</scope>
</dependency>

WireMockServer wireMockServer = new WireMockServer(wireMockConfig().dynamicPort()
                .extensions(new ResponseTemplateTransformer(false, "json", Jackson2Helper.INSTANCE)))

The name of the helper will be json and that is how you will refer to it from your template.

In your template use it like :

{
  "place": "{{parameters.place}}",
  "users": {{json parameters.users}}
}

The output is :

{
  "place": "New York",
  "users": [{"name":"John","age":24},{"name":"Merry","age":31}]
}

Of course you can customize Jackson2Helper and create your own instance with own ObjectMapper instance - this is useful if you are using Spring and want to use same serialization options everywhere.

Source https://stackoverflow.com/questions/71529928

QUESTION

Unable to run JUnit5 tests with Maven

Asked 2022-Jan-15 at 16:05

I'm running into an issue where I can't run JUnit5 tests using Maven. Running them in the IDE works just fine but using "mvn test" produces the following output:

 T E S T S
[INFO] -------------------------------------------------------
[INFO] 
[INFO] Results:
[INFO] 
[INFO] Tests run: 0, Failures: 0, Errors: 0, Skipped: 0
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

Here are my test classes :

package com.example.spstream.controllers.events;

import com.example.spstream.entities.Event;
import com.example.spstream.repositories.EventRepository;
import com.example.spstream.repositories.UserRepository;
import com.example.spstream.util.Mapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.dao.DataAccessException;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import java.time.LocalDateTime;


import static org.hamcrest.Matchers.containsString;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
@EnableAutoConfiguration(exclude = SecurityAutoConfiguration.class)
public class EventsCreationTest {
    private static final String MISSING_TITLE_ERROR_MESSAGE = "title is missing";
    private static final String MISSING_ACTIVITY_ERROR_MESSAGE = "activity is missing";
    private static final String MISSING_LOCALISATION_ERROR_MESSAGE = "localisation is missing";
    private static final String INVALID_ORGANISER_ID_ERROR_MESSAGE = "user %s does not exist";
    private static final String MISSING_ORGANISER_ID_ERROR_MESSAGE = "organiser id is missing";
    @Autowired
    private MockMvc mockMvc;
    @MockBean
    private UserRepository userRepository;
    @SpyBean
    private EventRepository eventRepository;

    private static final String DATE_IN_PAST_ERROR_MESSAGE = "date is in the past";

    @BeforeEach
    public void reset(){
        Mockito.reset(userRepository);
        Mockito.when(userRepository.existsById("123456")).thenReturn(true);
    }

    //prevents hardcoded events from failing tests due to date in the past
    public void setEventDateToTomorrow(Event event) {
        event.setDateTime(LocalDateTime.now().plusDays(1));
    }

    public void setEventDateToYesterday(Event event) {
        event.setDateTime(LocalDateTime.now().minusDays(1));
    }

    public void testCorrectEventCreationWithEvent(Event event) throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/events")
                        .content(Mapper.writeObjectToJson(event))
                        .contentType(MediaType.APPLICATION_JSON)
                        .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.id").exists())
                .andExpect(jsonPath("$.id").isString());
    }

    public void testIncorrectEventCreationWithEvent(Event event, String errorMessagePattern) throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/events")
                        .content(Mapper.writeObjectToJson(event))
                        .contentType(MediaType.APPLICATION_JSON)
                        .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isBadRequest())
                .andExpect(content().string(containsString(String.format(errorMessagePattern, event.getOrganiserId()))));
    }

    /**
     * correct data
     **/
    @Test
    public void testMinimalCorrectEvent() throws Exception {
        Event minimalEvent = Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/minimal_event.json"), Event.class);
        setEventDateToTomorrow(minimalEvent);
        testCorrectEventCreationWithEvent(minimalEvent);
    }

    @Test
    public void testMaximalCorrectEvent() throws Exception {
        Event maximalEvent = Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/maximal_event.json"), Event.class);
        setEventDateToTomorrow(maximalEvent);
        testCorrectEventCreationWithEvent(maximalEvent);
    }

    /**
     * missing data
     **/
    @Test
    public void testIncorrectEventTitleMissing() throws Exception {
        Event eventTitleMissing = Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/minimal_event.json"), Event.class);
        setEventDateToTomorrow(eventTitleMissing);
        eventTitleMissing.setTitle(null);
        testIncorrectEventCreationWithEvent(eventTitleMissing, MISSING_TITLE_ERROR_MESSAGE);
    }

    @Test
    public void testIncorrectEventActivityMissing() throws Exception {
        Event eventActivityMissing =  Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/minimal_event.json"), Event.class);
        eventActivityMissing.setActivity(null);
        setEventDateToTomorrow(eventActivityMissing);
        testIncorrectEventCreationWithEvent(eventActivityMissing, MISSING_ACTIVITY_ERROR_MESSAGE);
    }

    @Test
    public void testIncorrectEventLocalisationMissing() throws Exception {
        Event eventLocalisationMissing =  Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/minimal_event.json"), Event.class);
        eventLocalisationMissing.setLocalisation(null);
        setEventDateToTomorrow(eventLocalisationMissing);
        testIncorrectEventCreationWithEvent(eventLocalisationMissing, MISSING_LOCALISATION_ERROR_MESSAGE);
    }

    @Test
    public void testIncorrectEventMissingUserId() throws Exception {
        Event eventOrganiserIdMissing = Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/incorrect/missing_user_id.json"), Event.class);
        setEventDateToTomorrow(eventOrganiserIdMissing);
        testIncorrectEventCreationWithEvent(eventOrganiserIdMissing, MISSING_ORGANISER_ID_ERROR_MESSAGE);
    }

    /**
     * invalid data
     **/
    @Test
    public void testIncorrectEventInvalidOrganiserId() throws Exception {
        Mockito.when(userRepository.existsById(Mockito.any())).thenReturn(false);
        Event eventInvalidOrganiserId = Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/minimal_event.json"), Event.class);
        setEventDateToTomorrow(eventInvalidOrganiserId);
        testIncorrectEventCreationWithEvent(eventInvalidOrganiserId, INVALID_ORGANISER_ID_ERROR_MESSAGE);
    }

    @Test
    public void testIncorrectEventDateInThePast() throws Exception {
        Event eventInPast = Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/minimal_event.json"), Event.class);
        setEventDateToYesterday(eventInPast);
        testIncorrectEventCreationWithEvent(eventInPast, DATE_IN_PAST_ERROR_MESSAGE);
    }

    /**
     * internal database issue
     **/
    @Test
    public void testCorrectEventServerError() throws Exception {

        Event eventInvalidOrganiserId = Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/create/correct/minimal_event.json"), Event.class);
        setEventDateToTomorrow(eventInvalidOrganiserId);
        Mockito.when(eventRepository.save(eventInvalidOrganiserId)).thenThrow(Mockito.mock(DataAccessException.class));
        mockMvc.perform(MockMvcRequestBuilders.post("/events")
                        .content(Mapper.writeObjectToJson(eventInvalidOrganiserId))
                        .contentType(MediaType.APPLICATION_JSON)
                        .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().is5xxServerError());
        System.out.println("whatever");
    }
}

package com.example.spstream.controllers.events;

import com.example.spstream.entities.Event;
import com.example.spstream.repositories.EventRepository;
import com.example.spstream.util.Mapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;

import org.springframework.dao.DataAccessException;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;


import java.util.List;
import java.util.Optional;

import static com.example.spstream.util.Mapper.readJsonFromFile;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
@EnableAutoConfiguration(exclude = SecurityAutoConfiguration.class)
public class EventsAccessTest {

    @MockBean
    EventRepository mockEventRepository;

    @Autowired
    MockMvc mockMvc;

    @BeforeEach
    public void reset(){
        Mockito.reset(mockEventRepository);
    }

    @Test
    public void testFindAll() throws Exception{
        List<Event> events = Mapper.readObjectListFromJson(readJsonFromFile("controllers/events/access/all_events.json"), Event.class);
        Mockito.when(mockEventRepository.findAll()).thenReturn(events);
        mockMvc.perform(MockMvcRequestBuilders.get("/events")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(content().json(Mapper.readJsonFromFile("controllers/events/access/all_events.json")));
    }

    @Test
    public void testFindEventWhichExists() throws Exception{
        Mockito.when(mockEventRepository.findById("123456")).thenReturn(Optional.of(Mapper.readObjectFromJson(Mapper.readJsonFromFile("controllers/events/access/final_event.json"),Event.class)));
        mockMvc.perform(MockMvcRequestBuilders.get("/events/123456")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(content().json(Mapper.readJsonFromFile("controllers/events/access/final_event.json")));
    }

     @Test
    public void testFindEventWhichDoesntExist() throws Exception {
         Mockito.when(mockEventRepository.findById("7891011")).thenReturn(Optional.empty());
        mockMvc.perform(MockMvcRequestBuilders.get("/events/7891011")
                        .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON));
    }

    @Test
    public void testFindEventDatabaseError() throws Exception {
        Mockito.when(mockEventRepository.findById("123456")).thenThrow(Mockito.mock(DataAccessException.class));
        mockMvc.perform(MockMvcRequestBuilders.get("/events/123456")
                        .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().is5xxServerError());

    }

}

The pom :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>spstream</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spstream</name>
    <description>spstream</description>
    <properties>
        <java.version>17</java.version>
        <testcontainers.version>1.16.2</testcontainers.version>

    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
            <exclusion>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
            </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>postgresql</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.github.tomakehurst</groupId>
            <artifactId>wiremock-jre8</artifactId>
            <version>2.32.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.8.2</version>
            <scope>test</scope>
        </dependency>

    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>testcontainers-bom</artifactId>
                <version>${testcontainers.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M5</version>
                <dependencies>
                    <dependency>
                        <groupId>org.apache.maven.surefire</groupId>
                        <artifactId>surefire-junit47</artifactId>
                        <version>3.0.0-M5</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

</project>

I have done some research and I figured it might have something to do mith mixing up JUnit4 and JUnit5 features which leads to maven surefire plugin not running tests. However I can't find where those leftover JUnit4 features might be. I'd appreciate any help.

ANSWER

Answered 2022-Jan-15 at 15:48

The Junit4 is available because of Testcontainer dependency. Testcontainers have a dependency on Junit4 and have it available by default. You might also encounter the following issue in few cases:

IDE's detects the test cases written in Junit4 format but in sometime in case you make the test classes and methods package-private, they don't detect it.

I am not sure if they would be removing it in further releases but they do have Junit5 support which should resolve the issue

https://www.testcontainers.org/test_framework_integration/junit_5/

Source https://stackoverflow.com/questions/70722701

QUESTION

Implement different response with WireMock when no request(s) match

Asked 2021-Sep-22 at 14:27

I'm trying to stub a RESTful API. One of the resources return the details when the resource is (indeed) found, or an HTTP 404 (Not Found) when, eventually, there is no resource for the given URL.

This is my simplified stub/mapping:

{
  "mappings": [
    {
      "name": "Retrieve Items",
      "request": {
        "headers": {
          "accept": {
            "caseInsensitive": true,
            "equalTo": "application/json"
          }
        },
        "method": "GET",
        "urlPathPattern": "/api/items/[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}"
      },
      "response": {
        "bodyFileName": "items-api/responses/retrieve/{{ request.pathSegments.[2] }}.json",
        "headers": {
          "content-type": "application/json"
        },
        "status": 200
      }
    }
  ]
}

Then I have several JSON files (in /home/wiremock/__files/items-api/responses/retrieve/ to match the requests against — but I can't find a way to implement the HTTP 404 (Not Found) scenario:

{
  "timestamp": {{ now }},
  "status": 404,
  "error": "Not Found",
  "message": null,
  "path": "{{ request.path }}"
}

With this config I get back (the expected, but not useful for my use case) response from WireMock that the file name uuid-sent-in-request.json is not found.

Is there a way to implement this behavior currently?

ANSWER

Answered 2021-Sep-21 at 12:42

Currently you would need to write a ResponseDefinitionTransformer to get the behaviour you're looking for.

It would need to check whether the ResponseDefinition passed in the parameter required a file, then if so check whether the file exists by doing something like:

try {
    fileSource.getBinaryFileNamed(bodyFileName).readContents();
} catch (FileNotFoundException e) {
    return WireMock.notFound().withBody("custom body");
}

// Otherwise return the unmodified response definition

Source https://stackoverflow.com/questions/69236509

QUESTION

SpringBoot2 Configuration JOOQ MariaDB: "required a bean of type 'javax.sql.DataSource' that could not be found"

Asked 2021-Sep-13 at 13:20

it's not the first time this question was asked and i read a lot of article about this topic, but I can't solve this problem:

Field dataSource in de.foo.MariaDbConfig required a bean of type 'javax.sql.DataSource' that could not be found.

All my configurations are like in this articles. Code generation worked properly with a given ddl sql file. The database is a MariaDB. Why does this error keep appearing?

Config

import org.jooq.SQLDialect;
import org.jooq.impl.DataSourceConnectionProvider;
import org.jooq.impl.DefaultConfiguration;
import org.jooq.impl.DefaultDSLContext;
import org.jooq.impl.DefaultExecuteListenerProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy;

import javax.sql.DataSource;

@Configuration
public class MariaDbConfig {

    @Autowired
    private DataSource dataSource;

    @Bean
    public DataSourceConnectionProvider connectionProvider() {

        return new DataSourceConnectionProvider(new TransactionAwareDataSourceProxy(dataSource));
    }

    @Bean
    public DefaultDSLContext dslContext(final DefaultConfiguration defaultConfiguration) {

        return new DefaultDSLContext(defaultConfiguration);
    }

    @Bean
    public DefaultConfiguration defaultConfiguration(final DataSourceConnectionProvider connectionProvider) {

        DefaultConfiguration jooqConfiguration = new DefaultConfiguration();

        jooqConfiguration.set(connectionProvider);
        jooqConfiguration.setSQLDialect(SQLDialect.MARIADB);
        jooqConfiguration.set(new DefaultExecuteListenerProvider(new ExceptionTranslator()));

        return jooqConfiguration;
    }
}

application.yml

spring:
  application:
    name:                         '@project.artifactId@'
  datasource:
    driverClassName:              org.mariadb.jdbc.Driver
    url:                          jdbc:mariadb://localhost:3306/foo
    username:                     root
    password:                     foo123

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>de.foo</groupId>
    <artifactId>foobar</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>foobarapp</name>
    <properties>
        <java.version>11</java.version>
        <testcontainers.version>1.15.3</testcontainers.version>
        <jooq.version>3.15.2</jooq.version>
    </properties>
    <dependencies>
        <!--WEB&IO-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <!-- openapi generator libs -->
        <!--
          The open-api maven plugin generates classes with swagger-annotation.
          Unfortunately, there is no feature toggle for it, therefore we have to live with generated stubs using swagger annotations
        -->
        <dependency>
            <groupId>io.swagger</groupId>
            <artifactId>swagger-annotations</artifactId>
            <version>1.6.2</version>
        </dependency>
        <!-- Required for model classes generated by openapi-generator-maven-plugin because of bug https://github.com/OpenAPITools/openapi-generator/issues/2901
     The config tag <openApiNullable> is fully supported from 5.0.0 onwards -->
        <dependency>
            <groupId>org.openapitools</groupId>
            <artifactId>jackson-databind-nullable</artifactId>
            <version>0.2.1</version>
        </dependency>
        <!-- Required by the generated API to add support for xml format-->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>2.12.5</version>
        </dependency>

        <!--DB-->
        <dependency>
            <groupId>org.mariadb.jdbc</groupId>
            <artifactId>mariadb-java-client</artifactId>
            <version>2.7.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jooq</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jooq</groupId>
            <artifactId>jooq-meta-extensions</artifactId>
            <version>${jooq.version}</version>
        </dependency>

        <!--TOOLS-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>


        <!--TEST-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>mariadb</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.github.tomakehurst</groupId>
            <artifactId>wiremock-jre8</artifactId>
            <version>2.27.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>testcontainers-bom</artifactId>
                <version>${testcontainers.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            <!--API CODE GEN-->
            <plugin>
                <groupId>org.openapitools</groupId>
                <artifactId>openapi-generator-maven-plugin</artifactId>
                <version>4.2.3</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                        <configuration>
                            <inputSpec>
                                ${project.basedir}/src/main/resources/foo.yaml
                            </inputSpec>
                            <generatorName>spring</generatorName>
                            <apiPackage>${project.groupId}.ui.api</apiPackage>
                            <modelPackage>${project.groupId}.ui.api.model</modelPackage>
                            <supportingFilesToGenerate>
                                ApiUtil.java
                            </supportingFilesToGenerate>
                            <configOptions>
                                <interfaceOnly>true</interfaceOnly>
                                <delegatePattern>true</delegatePattern>
                            </configOptions>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <!-- Run this profile to generate DB entities from schema ddl file. -->
    <profiles>
        <profile>
            <id>jooq</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.jooq</groupId>
                        <artifactId>jooq-codegen-maven</artifactId>
                        <version>${jooq.version}</version>
                        <executions>
                            <execution>
                                <id>generate-jooq-sources</id>
                                <phase>generate-sources</phase>
                                <goals>
                                    <goal>generate</goal>
                                </goals>
                                <configuration>
                                    <generator>
                                        <generate>
                                            <relations>true</relations>
                                            <deprecated>false</deprecated>
                                            <pojos>false</pojos>
                                            <daos>false</daos>
                                            <pojosEqualsAndHashCode>true</pojosEqualsAndHashCode>
                                            <javaTimeTypes>true</javaTimeTypes>
                                        </generate>
                                        <database>
                                            <name>org.jooq.meta.extensions.ddl.DDLDatabase</name>
                                            <inputCatalog></inputCatalog>
                                            <inputSchema>PUBLIC</inputSchema>
                                            <outputSchemaToDefault>true</outputSchemaToDefault>
                                            <outputCatalogToDefault>true</outputCatalogToDefault>
                                            <properties>
                                                <property>
                                                    <key>sort</key>
                                                    <value>semantic</value>
                                                </property>
                                                <property>
                                                    <key>parseIgnoreComments</key>
                                                    <value>true</value>
                                                </property>
                                                <property>
                                                    <key>parseDialect</key>
                                                    <value>SQLSERVER</value>
                                                </property>
                                                <property>
                                                    <key>scripts</key>
                                                    <value>src/main/resources/foo.sql</value>
                                                </property>
                                            </properties>
                                        </database>
                                        <target>
                                            <clean>true</clean>
                                            <packageName>de.foo</packageName>
                                            <directory>src/main/java</directory>
                                        </target>
                                    </generator>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>

</project>

I also defined my own DataSource like this but the error keeps coming up:

@Bean
    public DataSource datasource() {
        return DataSourceBuilder.create()
          .driverClassName("org.mariadb.jdbc.Driver")
          .url("jdbc:mariadb://localhost:3306/foo")
          .username("root")
          .password("foo123")
          .build(); 
    }

I hope some of you guys got an idea.

ANSWER

Answered 2021-Sep-13 at 13:20

So Simon Martinelli helped me by finding the solution inside stackoverflow. After removing the hole config class, i got this "DSLContext that could not be found" error. Then i found this question:

How to fix "Consider defining a bean of type 'org.jooq.DSLContext' in your configuration." after update to jOOQ 3.15.0

Which solved my problem completly. Sorry for asking a question that has already been solved, but nothing pointed into the direction of R2dbcAutoConfiguration.

So, as Simon already said, removing the config class and, as the answer in this question already pointed out, adding @SpringBootApplication(exclude = { R2dbcAutoConfiguration.class }) solved the problem.

Source https://stackoverflow.com/questions/69162928

QUESTION

Trying to update embedded database when mocked http response is returned using Wiremock of MockServer

Asked 2021-Sep-09 at 20:15

Working in a Spring Boot context, I am testing a service that queries a db, then makes a remote call that updates the db, then requeries the db to get the updated data.

I am trying to use Wiremock or MockServer to mock the remote call, but can't figure out how to update the embedded database as part of the mock server response generation process.

For example, using MockServer, I tried creating a callback class that had an autowired JdbcTemplate instance, but in the context of the callback that JdbcTemplate variable is null.

    public class ApprovalHappyPathCallback implements ExpectationResponseCallback {
    JdbcTemplate jdbcTemplate;

    @Autowired
    public void setDataSource(DataSource ds) {
        jdbcTemplate = new JdbcTemplate(ds);
    }

    public static final HttpResponse httpResponse = response()
            .withStatusCode(HttpStatusCode.ACCEPTED_202.code())
            .withHeaders(
                    header("x-callback", "test_callback_header"),
                    header("Content-Length", "a_callback_response".getBytes(UTF_8).length),
                    header("Connection", "keep-alive")
            )
            .withBody("a_callback_response");

    @Override
    public HttpResponse handle(HttpRequest httpRequest) {
        if (httpRequest.getMethod().equals("GET")) {
            jdbcTemplate.execute("update communications set status = 'APPROVED_SCHEDULED' where id = 153511");
            return httpResponse;
        } else {
            return notFoundResponse();
        }
    }
}

The call back executes, but the jdbcTemplate statement does not work.

The callback is referenced like this in the test:

mockServer.when(request().withMethod("GET"))
        .withBody("Approved")
        // );
        .respond(
            callback()
                .withCallbackClass(ApprovalHappyPathCallback.class)
        );

The service method that makes the remote call is essentially:

public CommunicationEntity approveCommunication(Long communicationId) {
    String approvalToken = commRepo.approvalTokenById(communicationId);
        if (approvalToken == null) {
            approvalToken = UUID.randomUUID().toString();
            communicationEntity.setApprovalToken(approvalToken);
            commRepo.save(communicationEntity);
        }
    String approvalResponse = remoteCommunicationApprover.approveCommunication(communicationId, approvalToken);
    CommunicationEntity communicationEntity = getCommunicationById(communicationId);

        if (communicationEntity.getStatus() != CommunicationStatus.Approved_Scheduled) {
            throw new BadRequestException(
                    "Approval request for communication " + communicationId + " and token " + approvalToken
                            + " failed with remote response: " + approvalResponse,
                    ErrorCodes.COMMUNICATION_SVC_REMOTE_APPROVAL_REQUEST_FAILED);
        }
        return communicationEntity;

ANSWER

Answered 2021-Sep-09 at 20:15

There were two issues causing problems: making sure the jdbcTemplate used in the callback method was configured with the correct DataSource, and making sure that the data in the embedded in memory DB was accessible from the MockServer response generation thread.

I solved the first problem by using a lambda or closure for the MockServer callback in which I use the JdbcTemplate instance created in the test class with the autowired DataSource (though solutions exist for the callback class approach as well).

The second problem was the result of the fact that the test method was within a transaction and so inserts to the DB made at the beginning of the test were not committed when the MockServer thread (note that the MockServer response generation happens in a different thread than the main thread where the test method is running) was executing the callback. Thus those inserts were not accessible to the callback.

The solution was to annotate the test method with @Transactional(propagation = Propagation.NOT_SUPPORTED) See h2 database access to test data from separate threads

Source https://stackoverflow.com/questions/69111134

QUESTION

Wiremock does not receive any requests

Asked 2021-Sep-09 at 12:04

I am writing an integrationtest for a resource (Jax-rs with resteasy) which invokes a thirdparty request to the Trustpilot Api to get a review link for a product. In my tests I wanted to mock this call by using Wiremock and invoke the request by using resteasy Dispatcher. The code below shows my Setup (names etc are changed).

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { MyResourceTestContext.class })
public class MyResourceIntegrationTest {


    @Rule
    public WireMockRule wireMockRule = new WireMockRule(wireMockConfig().dynamicPort().dynamicHttpsPort());

    @Autowired
    private MyResource myResource;

    private Dispatcher dispatcher;
    private MockHttpResponse response;

    @Before
    public void setUp() throws Exception {
        dispatcher = MockDispatcherFactory.createDispatcher();
        dispatcher.getRegistry().addSingletonResource(myResource);
        response = new MockHttpResponse();
    }

    @Test
    public void testResourceShouldReturnRedirectToTrustpilotreview() throws Exception {

        URI apiRequestURI = UriBuilder
                .fromUri("https://api.trustpilot.com/v1/private/product-reviews/business-units"
                        + "/{businessUnitId}}/invitation-links")
                .build(BUSINESS_UNIT_ID);

        URI expectedRedirectURI = UriBuilder.fromUri("https://products.trustpilot.com/#evaluate/{reviewLinkId}")
                .build(REVIEW_LINK_ID);

        stubFor(post(apiRequestURI.toString())
                .willReturn(okJson("{\"reviewLinkId\":\"" + REVIEW_LINK_ID + "\","
                        + "\"reviewUrl\":\"" + expectedRedirectURI.toString() + "\"}")));

        MockHttpRequest request = MockHttpRequest.get("/myResource");
        dispatcher.invoke(request, response);

        WireMock.verify(1, postRequestedFor(urlEqualTo(apiRequestURI.toString())));
        Assert.assertEquals(HttpStatus.TEMPORARY_REDIRECT.value(), response.getStatus());
        Assert.assertEquals(expectedRedirectURI.toString(), response.getOutputHeaders().getFirst("Location"));

    }

But what I'm getting is (with my actual bid in the url):

com.github.tomakehurst.wiremock.client.VerificationException: Expected at least one request matching: {
      "url" : "https://api.trustpilot.com/v1/private/product-reviews/business-units/<bid>/invitation-links",
      "method" : "POST"
    }
    Requests received: [ ]

Stepping into the request with the Debugger I can say this request and other requests are actually executed successfully. But they are not recognized/mocked by Wiremock.

Is there something wrong with my Wiremock setup? Any Ideas? Thank you!

ANSWER

Answered 2021-Sep-09 at 12:04

There are a couple of reasons why this isn't sending anything to WireMock at the moment:

WireMock only accepts relative URLs when stubbing so passing the full URL including protocol and domain won't work. Try something equivalent to stubFor(post(urlPathEqualTo("/v1/private/product-reviews/business-units/<bid>/invitation-links") instead.
There doesn't seem to be any way for your class under test to know which host/port WireMock is running on and no forward proxying set up so the code is presumably still trying to call the real Trustpilot API.

To solve 2. you have a couple of options:

Set up your class/code under test to use localhost as the destination host and the result of wireMockRule.port() as the port number, or wireMockRule.httpsPort() if you're on HTTPS.
Use the new auto JVM proxy setup feature to proxy your app's calls through WireMock. This assumes you're on WireMock 2.31.0+ and that your app's HTTP client respects the JVM proxy system properties.

Source https://stackoverflow.com/questions/69116881

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install wiremock

You can download it from GitHub.
You can use wiremock like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the wiremock component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

Support

If you have a question about WireMock, or are experiencing a problem you’re not sure is a bug please post a message to the [WireMock mailing list](https://groups.google.com/forum/#!forum/wiremock-user). On the other hand if you’re pretty certain you’ve found a bug please open an issue.