j

java8

# 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("a1") # choose the method that is valid for arrays .stringValue("a2") # 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("foo", "Foo") # choose the method that is valid for objects .closeObject() # close the object and we'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'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'll find out at runtime if you'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'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'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) -> { o.stringValue("foo", "Foo"); # an attribute o.stringValue("bar", "Bar"); # an attribute o.object("tar", (tarObject) -> { # an attribute with a nested object tarObject.stringValue("a", "A"); # attribute of the nested object tarObject.stringValue("b", "B"); # attribute of the nested object }) }); ``` ## Installation ### Maven ``` <dependency> <groupId>au.com.dius.pact.consumer</groupId> <artifactId>java8</artifactId> <version>${pact.version}</version> </dependency> ``` ## 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("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonArray((a) -> { a.stringValue("a1"); a.stringValue("a2"); }).build()); ``` ### Response body as json object ```java import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonBody; ... PactDslWithProvider builder = ... builder.given("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).build()); ``` ### Examples #### Simple Json object When creating simple json structures the difference between the two approaches isn't big. ##### JSON ```json { "bar": "Bar", "foo": "Foo" } ``` ##### Pact DSL ```java new PactDslJsonBody() .stringValue("foo", "Foo") .stringValue("bar", "Bar") ``` ##### Lambda DSL ```java newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).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 [ ["a1", "a2"], [1, 2], [{"foo": "Foo"}] ] ``` ##### Pact DSL ```java new PactDslJsonArray() .array() .stringValue("a1") .stringValue("a2") .closeArray() .array() .numberValue(1) .numberValue(2) .closeArray() .array() .object() .stringValue("foo", "Foo") .closeObject() .closeArray(); ``` ##### Lambda DSL ```java newJsonArray((rootArray) -> { rootArray.array((a) -> a.stringValue("a1").stringValue("a2")); rootArray.array((a) -> a.numberValue(1).numberValue(2)); rootArray.array((a) -> a.object((o) -> o.stringValue("foo", "Foo"))); }).build(); ``` ##### Kotlin Lambda DSL ```kotlin newJsonArray { newArray { stringValue("a1") stringValue("a2") } newArray { numberValue(1) numberValue(2) } newArray { newObject { stringValue("foo", "Foo") } } } ``` # Test Analytics We are tracking anonymous analytics to gather important usage statistics like JVM version and operating system. To disable tracking, set the 'pact_do_not_track' system property or environment variable to 'true'.
https://github.com/DiUS/pact-jvm
Apache 2
Travis Dixon Ronald Holshausen
called allowed usage objects lamda your ambiguous issues when tracking artifact path lambda java closing pact complex property whereas state between based closeobject using method dependency work want come version contains extensions system examples stringvalue following creating difference artifactid arrays quot much formatting object status become pactdslwithprovider extension works methods pact_do_not_track willrespondwith example valid pactdsljsonbody default library java8 installation builder lambdas course closearray attribute operating close hand uponreceiving could replaces more makes structures possible sample great call such disable newjsonbody anonymous prone certain open apos statistics auto instance correct beauty available main accross simple newarray source body nested analytics suggests that indentation newjsonarray find solves only quite newobject wrapped group given visible read static test need like maven cleaner finally groupid this runtime gather pactfoundation both becomes important pactdsljsonarray tests lambdadsl name true some request code import provided back choose dius error constructs states central array provides working json rootarray hard class consumer factory junit implementation start kotlin approaches opening cumbersome with existing environment currently build response service there variable numbervalue tarobject
Aggregated version Version Update time
4.1 4.1.42 Jul 28, 2023
4.1.41 Dec 23, 2022
4.1.40 Nov 25, 2022
4.1.39 Aug 02, 2022
4.1.38 May 31, 2022
4.1.37 May 26, 2022
4.1.36 May 13, 2022
4.1.35 Apr 19, 2022
4.1.34 Feb 09, 2022
4.1.33 Jan 12, 2022
4.1.32 Jan 06, 2022
4.1.31 Dec 09, 2021
4.1.30 Dec 08, 2021
4.1.29 Nov 12, 2021
4.1.28 Sep 27, 2021
4.1.27 Sep 19, 2021
4.1.26 Sep 04, 2021
4.1.25 Aug 22, 2021
4.1.24 Aug 01, 2021
4.1.23 Jun 24, 2021
4.1.22 Jun 06, 2021
4.1.21 May 23, 2021
4.1.20 Apr 11, 2021
4.1.19 Mar 28, 2021
4.1.18 Mar 13, 2021
4.1.17 Feb 11, 2021
4.1.16 Feb 02, 2021
4.1.15 Jan 20, 2021
4.1.14 Jan 10, 2021
4.1.13 Dec 28, 2020
4.1.12 Dec 13, 2020
4.1.11 Nov 15, 2020
4.1.10 Nov 06, 2020
4.1.9 Oct 18, 2020
4.1.8 Oct 14, 2020
4.1.7 Aug 09, 2020
4.1.6 Jul 03, 2020
4.1.5 Jun 27, 2020
4.1.4 Jun 20, 2020
4.1.3 Jun 18, 2020
43 Records