When we apply the Java plugin to our Gradle project we can configure which Java version we want to use for compiling our source code and running our tests using a toolchain configuration. The benefit of having a toolchain configuration is that we can use a different Java version for compiling and running our code than the Java version that is used by Gradle to execute the build. Gradle will look for that Java version on our local computer or download the correct version if it is not available. To search for a local Java installation Gradle will look for operating system specific locations, installations by package managers like SKDMAN! and Jabba, IntelliJ IDEA installations and Maven Toolchain specifications. Maven Toolchain specifications is an XML file describing the location of local Java installation. Each Java installation is described by a version and optional vendor it provides and the location of the installation. Maven uses this information to find the correct Java installation when the maven-toolchain-plugin
is used in a Maven project. But Gradle can also utilize Maven Toolchain specifications to find local Java installations. This can be useful when we have to work on multiple projects where some use Maven and others use Gradle. We can place the Maven Toolchain specification file in our Maven home directory. This is also the default place where Gradle will look, but we can use a project property to override this location.
Continue reading →
Spring Boot 3 requires at least Java 17, but that also means the Java version used by Gradle must also be at least 17. Otherwise we will get the following error message when we build our Spring Boot project in IntelliJ using Gradle:
The issue is that the Spring Boot Gradle plugin 3.1.5 requires Java 17, but our project is using Java 11. We can fix this by explicitly setting the Java version that Gradle uses in IntelliJ. Go to Settings > Build, Execution, Deployment > Build Tools > Gradle and change the JVM used for Gradle to a JDK version of at least version 17.
Continue reading →
Sometimes we want to send HTTP requests to servers that use HTTPS with self-signed certificates.
We then need to tell HTTP Client to not check the certificate of the server.
This is like running the curl command with the --insecure
or '-k' flag.
To disable the certificate verification for HTTP Client we need to adjust the http-client.private.env.json
file.
For the environment we want to disable the certificate verification we must add a SSLConfiguration
section.
In the SSLConfiguration
section we add the verifyHostCertificate
property with value 'true'.
Continue reading →
When we use the IntelliJ HTTP Client we can write Javascript for the pre-request and response handlers. The Javascript code must be in between {% … %}
delimeters. If we want to re-use Javascript functions in the pre-request or response handlers we can store them in an external Javascript file. Then we use the import
statement to import either the whole file or specify explicitly the code we want to import. This way we can reuse code for different pre-request and response handlers.
Continue reading →
The built-in IntelliJ HTTP Client is very useful for testing HTTP requests and responses. We can use it to test for example a REST API that works with JSON data. If an endpoint expects a JSON payload we can specify the payload in our HTTP Client request file. But if we have a lot of endpoints and large payload the request file can get big and messy. Instead of having the payload in the request file directly we can specify an external JSON file with the payload and use it for a request body. We must use the <
operator and give the name of the file with our JSON payload. The IntelliJ HTTP Client will read the contents of that file and use it as the request body. The payload may also contain (dynamic) variables and those variables will be replaced with correct values when the request is executed.
Continue reading →
jq
is a powerful tool to work with JSON from the command-line. The tool has a lot of functions that makes our live easier. One of the functions is add
which adds all elements in an array or values in an object. The function has no arguments. The elements in an array are added together if they are numbers and concatenated if they are strings. If the input is an object then the values are added together. When the input is an empty array or object then null is returned.
Continue reading →
jq
is a powerful tool to work with JSON from the command-line. The tool has a lot of functions that makes our live easier. With jq
we can use expressions in strings that will be evaluated and inserted into the string value. This is called string interpolation. The expression is enclosed by parentheses and the first parenthesis is prefixed with a backslash: \(<expression>)
. The expression can be any valid jq
expression and the result of the expression will be inserted into the string.
Continue reading →
jq
is a powerful tool to work with JSON from the command-line. The tool has a lot of functions that makes our live easier. For example we can use the keys
and keys_unsorted
functions to get the keys from an object. The function keys
will return the keys in sorted order while keys_unsorted
will return them in the original order from the object. With the same functions we can also get the indices of the elements in an array, but there is no sorting involved, so both functions return the same output.
Continue reading →
jq
is a powerful tool to work with JSON from the command-line. The tool has a lot of functions and operators that makes our live easier. One of the operators we can use is the alternative operator //
which allows us to specify default values. If the value on the left side of the operator //
is empty, null or false then the value on the right side is returned, otherwise the value itself is returned. The operator can be used multiple times if we want to have multiple fallbacks for a value we are checking.
Continue reading →
In Groovy we can apply the @NullCheck
annotation to a class, constructor or method. The annotation is an AST (Abstract Syntax Tree) transformation and will insert code that checks for null values in methods or constructors. If a null
value is passed to an annotated method or constructor, it will throw an IllegalArgumentException
. Without the annotation we could have a NullPointerException
if we try to invoke a method on the value we pass as argument. The annotation has an optional property includeGenerated
which by default is false
. If we set it to true
then the null checks are also applied to generated methods and constructors. This is very useful if we apply other AST transformations to our class that generates additional code.
Continue reading →
The assertion error messages from AssertJ will use the toString()
method of an object to give more insight about why the assertion could have failed. If an object doesn’t override the toString()
method the default implementation is Object#toString()
. The default implementation will print out the class name and an hexadecimal value of hashCode
separated by a @
. This doesn’t give much information about the actual object. For classes we have control over we can always implement a toString()
method, but for third party classes we may not be able to do that. In order to customize how an object is represented in assertion error messages, AssertJ allows us to provide a custom representation class for an object. The custom representation class must implement the org.assertj.core.presentation.Representation
interface. The interface has one method String toStringOf(Object)
that should return a String representation of the object. If we want to keep the default behavior for other classes and only override it for our own class, we can extend the StandardRepresentation
class and override the method String fallbackToStringOf(Object)
.
Continue reading →
Since Java 16 we can use the method mapMulti(BiConsumer)
of the Stream
API. This method allows us to map each element of the stream to multiple elements. We can also do that with the flatMap(Function)
method, but if we want to map a limited set of elements, mapMulti
is more convenient. Internally a shared stream is used and we don’t have the cost of creating a new stream for each element. Another use case is if the logic to map an element to multiple elements is complex and is hard to implement by returning a stream. Then mapMulti
allows us to write that logic in a BiConsumer
instead of a Function
.
Continue reading →