java8
Used in:
components
- OverviewOverview
- VersionsVersions
- DependentsDependents
- DependenciesDependencies
<dependency>
<groupId>au.com.dius.pact.consumer</groupId>
<artifactId>java8</artifactId>
<version>4.1.28</version>
</dependency><?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<!-- This module was also published with a richer model, Gradle metadata, -->
<!-- which should be used instead. Do not delete the following line which -->
<!-- is to indicate to Gradle or any Gradle module metadata file consumer -->
<!-- that they should prefer consuming it instead. -->
<!-- do_not_remove: published-with-gradle-metadata -->
<modelVersion>4.0.0</modelVersion>
<groupId>au.com.dius.pact.consumer</groupId>
<artifactId>java8</artifactId>
<version>4.1.28</version>
<name>java8</name>
<description># pact-jvm-consumer-java8
Provides a Java8 lambda based DSL for use with Junit to build consumer tests.
## Dependency
The library is available on maven central using:
* group-id = `au.com.dius.pact.consumer`
* artifact-id = `java8`
* version-id = `4.1.x`
# A Lambda DSL for Pact
This is an extension for the pact DSL provided by [consumer](../consumer). The difference between
the default pact DSL and this lambda DSL is, as the name suggests, the usage of lambdas. The use of lambdas makes the code much cleaner.
## Why a new DSL implementation?
The lambda DSL solves the following two main issues. Both are visible in the following code sample:
```java
new PactDslJsonArray()
.array() # open an array
.stringValue(&quot;a1&quot;) # choose the method that is valid for arrays
.stringValue(&quot;a2&quot;) # choose the method that is valid for arrays
.closeArray() # close the array
.array() # open an array
.numberValue(1) # choose the method that is valid for arrays
.numberValue(2) # choose the method that is valid for arrays
.closeArray() # close the array
.array() # open an array
.object() # now we work with an object
.stringValue(&quot;foo&quot;, &quot;Foo&quot;) # choose the method that is valid for objects
.closeObject() # close the object and we&apos;re back in the array
.closeArray() # close the array
```
### The existing DSL is quite error-prone
Methods may only be called in certain states. For example `object()` may only be called when you&apos;re currently working on an array whereas `object(name)`
is only allowed to be called when working on an object. But both of the methods are available. You&apos;ll find out at runtime if you&apos;re using the correct method.
Finally, the need for opening and closing objects and arrays makes usage cumbersome.
The lambda DSL has no ambiguous methods and there&apos;s no need to close objects and arrays as all the work on such an object is wrapped in a lamda call.
### The existing DSL is hard to read
When formatting your source code with an IDE the code becomes hard to read as there&apos;s no indentation possible. Of course, you could do it by hand but we want auto formatting!
Auto formatting works great for the new DSL!
```java
array.object((o) -&gt; {
o.stringValue(&quot;foo&quot;, &quot;Foo&quot;); # an attribute
o.stringValue(&quot;bar&quot;, &quot;Bar&quot;); # an attribute
o.object(&quot;tar&quot;, (tarObject) -&gt; { # an attribute with a nested object
tarObject.stringValue(&quot;a&quot;, &quot;A&quot;); # attribute of the nested object
tarObject.stringValue(&quot;b&quot;, &quot;B&quot;); # attribute of the nested object
})
});
```
## Installation
### Maven
```
&lt;dependency&gt;
&lt;groupId&gt;au.com.dius.pact.consumer&lt;/groupId&gt;
&lt;artifactId&gt;java8&lt;/artifactId&gt;
&lt;version&gt;${pact.version}&lt;/version&gt;
&lt;/dependency&gt;
```
## Usage
Start with a static import of `LambdaDsl`. This class contains factory methods for the lambda dsl extension.
When you come accross the `body()` method of `PactDslWithProvider` builder start using the new extensions.
The call to `LambdaDsl` replaces the call to instance `new PactDslJsonArray()` and `new PactDslJsonBody()` of the pact library.
```java
io.pactfoundation.consumer.dsl.LambdaDsl.*
```
### Response body as json array
```java
import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonArray;
...
PactDslWithProvider builder = ...
builder.given(&quot;some state&quot;)
.uponReceiving(&quot;a request&quot;)
.path(&quot;/my-app/my-service&quot;)
.method(&quot;GET&quot;)
.willRespondWith()
.status(200)
.body(newJsonArray((a) -&gt; {
a.stringValue(&quot;a1&quot;);
a.stringValue(&quot;a2&quot;);
}).build());
```
### Response body as json object
```java
import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonBody;
...
PactDslWithProvider builder = ...
builder.given(&quot;some state&quot;)
.uponReceiving(&quot;a request&quot;)
.path(&quot;/my-app/my-service&quot;)
.method(&quot;GET&quot;)
.willRespondWith()
.status(200)
.body(newJsonBody((o) -&gt; {
o.stringValue(&quot;foo&quot;, &quot;Foo&quot;);
o.stringValue(&quot;bar&quot;, &quot;Bar&quot;);
}).build());
```
### Examples
#### Simple Json object
When creating simple json structures the difference between the two approaches isn&apos;t big.
##### JSON
```json
{
&quot;bar&quot;: &quot;Bar&quot;,
&quot;foo&quot;: &quot;Foo&quot;
}
```
##### Pact DSL
```java
new PactDslJsonBody()
.stringValue(&quot;foo&quot;, &quot;Foo&quot;)
.stringValue(&quot;bar&quot;, &quot;Bar&quot;)
```
##### Lambda DSL
```java
newJsonBody((o) -&gt; {
o.stringValue(&quot;foo&quot;, &quot;Foo&quot;);
o.stringValue(&quot;bar&quot;, &quot;Bar&quot;);
}).build();
```
#### An array of arrays
When we come to more complex constructs with arrays and nested objects the beauty of lambdas become visible!
##### JSON
```json
[
[&quot;a1&quot;, &quot;a2&quot;],
[1, 2],
[{&quot;foo&quot;: &quot;Foo&quot;}]
]
```
##### Pact DSL
```java
new PactDslJsonArray()
.array()
.stringValue(&quot;a1&quot;)
.stringValue(&quot;a2&quot;)
.closeArray()
.array()
.numberValue(1)
.numberValue(2)
.closeArray()
.array()
.object()
.stringValue(&quot;foo&quot;, &quot;Foo&quot;)
.closeObject()
.closeArray();
```
##### Lambda DSL
```java
newJsonArray((rootArray) -&gt; {
rootArray.array((a) -&gt; a.stringValue(&quot;a1&quot;).stringValue(&quot;a2&quot;));
rootArray.array((a) -&gt; a.numberValue(1).numberValue(2));
rootArray.array((a) -&gt; a.object((o) -&gt; o.stringValue(&quot;foo&quot;, &quot;Foo&quot;)));
}).build();
```
##### Kotlin Lambda DSL
```kotlin
newJsonArray {
newArray {
stringValue(&quot;a1&quot;)
stringValue(&quot;a2&quot;)
}
newArray {
numberValue(1)
numberValue(2)
}
newArray {
newObject { stringValue(&quot;foo&quot;, &quot;Foo&quot;) }
}
}
```
</description>
<url>https://github.com/DiUS/pact-jvm</url>
<licenses>
<license>
<name>Apache 2</name>
<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
<distribution>repo</distribution>
</license>
</licenses>
<developers>
<developer>
<id>thetrav</id>
<name>Travis Dixon</name>
<email>the.trav@gmail.com</email>
</developer>
<developer>
<id>rholshausen</id>
<name>Ronald Holshausen</name>
<email>rholshausen@dius.com.au</email>
</developer>
</developers>
<scm>
<connection>https://github.com/DiUS/pact-jvm.git</connection>
<url>https://github.com/DiUS/pact-jvm</url>
</scm>
<dependencies>
<dependency>
<groupId>au.com.dius.pact</groupId>
<artifactId>consumer</artifactId>
<version>4.1.28</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>