此版本仍在开发中,尚不被认为是稳定的。对于最新的稳定版本,请使用 spring-cloud-contract 4.3.0! |
消息
Spring Cloud Contract 允许您验证使用消息传递作为 通讯方式。本文档中显示的所有集成都适用于 Spring, 但您也可以创建自己的一个并使用它。
消息传递 DSL 顶级元素
用于消息传递的 DSL 看起来与专注于 HTTP 的 DSL 略有不同。这 以下部分解释了这些差异:
由方法触发的输出
可以通过调用方法(例如Scheduler
当合同是
started 和发送消息时),如以下示例所示:
def dsl = Contract.make {
// Human readable description
description 'Some description'
// Label by means of which the output message can be triggered
label 'some_label'
// input to the contract
input {
// the contract will be triggered by a method
triggeredBy('bookReturnedTriggered()')
}
// output message of the contract
outputMessage {
// destination to which the output message will be sent
sentTo('output')
// the body of the output message
body('''{ "bookName" : "foo" }''')
// the headers of the output message
headers {
header('BOOK-NAME', 'foo')
}
}
}
# Human readable description
description: Some description
# Label by means of which the output message can be triggered
label: some_label
input:
# the contract will be triggered by a method
triggeredBy: bookReturnedTriggered()
# output message of the contract
outputMessage:
# destination to which the output message will be sent
sentTo: output
# the body of the output message
body:
bookName: foo
# the headers of the output message
headers:
BOOK-NAME: foo
在前面的示例案例中,输出消息被发送到output
如果调用bookReturnedTriggered
被调用。在消息发布者端,我们生成一个
调用该方法以触发消息的测试。在消费者方面,您可以使用some_label
以触发消息。
集成
您可以使用以下集成配置之一:
-
阿帕奇骆驼
-
Spring 集成
-
Spring Cloud Stream
-
弹簧JMS
由于我们使用 Spring Boot,如果您已将其中一个库添加到类路径中,则所有 消息传递配置将自动设置。
记得把@AutoConfigureMessageVerifier 在
生成的测试。否则,Spring Cloud Contract 的消息传递部分不会
工作。 |
如果要使用 Spring Cloud Stream,请记住在 专家
Gradle
|
手动集成测试
测试使用的主要界面是org.springframework.cloud.contract.verifier.messaging.MessageVerifierSender
和org.springframework.cloud.contract.verifier.messaging.MessageVerifierReceiver
.
它定义了如何发送和接收消息。
在测试中,您可以注入一个ContractVerifierMessageExchange
发送和接收
合同后面的消息。然后添加@AutoConfigureMessageVerifier
对你的测试。
以下示例显示了如何执行此作:
@RunWith(SpringTestRunner.class)
@SpringBootTest
@AutoConfigureMessageVerifier
public static class MessagingContractTests {
@Autowired
private MessageVerifier verifier;
...
}
如果您的测试也需要存根,则@AutoConfigureStubRunner 包括
消息传递配置,因此您只需要一个注释。 |
生产者端消息传递测试生成
拥有input
或outputMessage
DSL 中的部分会导致创建测试
在出版商方面。默认情况下,将创建 JUnit 4 测试。但是,还有一个
可以创建 JUnit 5、TestNG 或 Spock 测试。
传递给messageFrom 或sentTo 可以有不同的
不同消息传递实现的含义。对于流和集成,它是
首先解析为destination 频道的。那么,如果没有这样的destination ,
它解析为通道名称。对于 Camel,这是一个特定的组件(例如,jms ). |
考虑以下合同:
def contractDsl = Contract.make {
name "foo"
label 'some_label'
input {
triggeredBy('bookReturnedTriggered()')
}
outputMessage {
sentTo('activemq:output')
body('''{ "bookName" : "foo" }''')
headers {
header('BOOK-NAME', 'foo')
messagingContentType(applicationJson())
}
}
}
label: some_label
input:
triggeredBy: bookReturnedTriggered
outputMessage:
sentTo: activemq:output
body:
bookName: foo
headers:
BOOK-NAME: foo
contentType: application/json
对于前面的示例,将创建以下测试:
import com.jayway.jsonpath.DocumentContext;
import com.jayway.jsonpath.JsonPath;
import org.junit.Test;
import org.junit.Rule;
import javax.inject.Inject;
import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierObjectMapper;
import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierMessage;
import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierMessaging;
import static org.springframework.cloud.contract.verifier.assertion.SpringCloudContractAssertions.assertThat;
import static org.springframework.cloud.contract.verifier.util.ContractVerifierUtil.*;
import static com.toomuchcoding.jsonassert.JsonAssertion.assertThatJson;
import static org.springframework.cloud.contract.verifier.messaging.util.ContractVerifierMessagingUtil.headers;
import static org.springframework.cloud.contract.verifier.util.ContractVerifierUtil.fileToBytes;
public class FooTest {
@Inject ContractVerifierMessaging contractVerifierMessaging;
@Inject ContractVerifierObjectMapper contractVerifierObjectMapper;
@Test
public void validate_foo() throws Exception {
// when:
bookReturnedTriggered();
// then:
ContractVerifierMessage response = contractVerifierMessaging.receive("activemq:output",
contract(this, "foo.yml"));
assertThat(response).isNotNull();
// and:
assertThat(response.getHeader("BOOK-NAME")).isNotNull();
assertThat(response.getHeader("BOOK-NAME").toString()).isEqualTo("foo");
assertThat(response.getHeader("contentType")).isNotNull();
assertThat(response.getHeader("contentType").toString()).isEqualTo("application/json");
// and:
DocumentContext parsedJson = JsonPath.parse(contractVerifierObjectMapper.writeValueAsString(response.getPayload()));
assertThatJson(parsedJson).field("['bookName']").isEqualTo("foo");
}
}
import com.jayway.jsonpath.DocumentContext
import com.jayway.jsonpath.JsonPath
import spock.lang.Specification
import javax.inject.Inject
import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierObjectMapper
import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierMessage
import org.springframework.cloud.contract.verifier.messaging.internal.ContractVerifierMessaging
import static org.springframework.cloud.contract.verifier.assertion.SpringCloudContractAssertions.assertThat
import static org.springframework.cloud.contract.verifier.util.ContractVerifierUtil.*
import static com.toomuchcoding.jsonassert.JsonAssertion.assertThatJson
import static org.springframework.cloud.contract.verifier.messaging.util.ContractVerifierMessagingUtil.headers
import static org.springframework.cloud.contract.verifier.util.ContractVerifierUtil.fileToBytes
class FooSpec extends Specification {
@Inject ContractVerifierMessaging contractVerifierMessaging
@Inject ContractVerifierObjectMapper contractVerifierObjectMapper
def validate_foo() throws Exception {
when:
bookReturnedTriggered()
then:
ContractVerifierMessage response = contractVerifierMessaging.receive("activemq:output",
contract(this, "foo.yml"))
response != null
and:
response.getHeader("BOOK-NAME") != null
response.getHeader("BOOK-NAME").toString() == 'foo'
response.getHeader("contentType") != null
response.getHeader("contentType").toString() == 'application/json'
and:
DocumentContext parsedJson = JsonPath.parse(contractVerifierObjectMapper.writeValueAsString(response.getPayload()))
assertThatJson(parsedJson).field("['bookName']").isEqualTo("foo")
}
}
消费者存根生成
与 HTTP 部分不同,在消息传递中,我们需要在 JAR 中发布合约定义,并使用 存根。然后在消费者端对其进行解析,并创建适当的存根路由。
如果类路径上有多个框架,则存根运行程序需要
定义应该使用哪一个。假设您有 AMQP、Spring Cloud Stream 和 Spring Integration
在类路径上,并且您想要使用 Spring AMQP。然后你需要设置stubrunner.stream.enabled=false 和stubrunner.integration.enabled=false .
这样,唯一剩下的框架就是 Spring AMQP。 |
存根触发
要触发消息,请使用StubTrigger
接口,如以下示例所示:
import java.util.Collection;
import java.util.Map;
/**
* Contract for triggering stub messages.
*
* @author Marcin Grzejszczak
*/
public interface StubTrigger {
/**
* Triggers an event by a given label for a given {@code groupid:artifactid} notation.
* You can use only {@code artifactId} too.
*
* Feature related to messaging.
* @param ivyNotation ivy notation of a stub
* @param labelName name of the label to trigger
* @return true - if managed to run a trigger
*/
boolean trigger(String ivyNotation, String labelName);
/**
* Triggers an event by a given label.
*
* Feature related to messaging.
* @param labelName name of the label to trigger
* @return true - if managed to run a trigger
*/
boolean trigger(String labelName);
/**
* Triggers all possible events.
*
* Feature related to messaging.
* @return true - if managed to run a trigger
*/
boolean trigger();
/**
* Feature related to messaging.
* @return a mapping of ivy notation of a dependency to all the labels it has.
*/
Map<String, Collection<String>> labels();
}
为方便起见,该StubFinder
接口扩展StubTrigger
,所以你只需要一个
或测试中的另一个。
StubTrigger
为您提供以下触发消息的选项:
使用 Apache Camel 进行消费者端消息传递
Spring Cloud Contract Stub Runner 的消息传递模块为您提供了一种与 Apache Camel 集成的简单方法。 对于提供的工件,它会自动下载存根并注册所需的 路线。
将 Apache Camel 添加到项目中
您可以在类路径上同时使用 Apache Camel 和 Spring Cloud Contract Stub Runner。
请记住使用@AutoConfigureStubRunner
.
例子
假设我们有以下 Maven 存储库,其中包含用于camelService
应用:
└── .m2
└── repository
└── io
└── codearte
└── accurest
└── stubs
└── camelService
├── 0.0.1-SNAPSHOT
│ ├── camelService-0.0.1-SNAPSHOT.pom
│ ├── camelService-0.0.1-SNAPSHOT-stubs.jar
│ └── maven-metadata-local.xml
└── maven-metadata-local.xml
此外,假设存根包含以下结构:
├── META-INF
│ └── MANIFEST.MF
└── repository
├── accurest
│ └── bookReturned1.groovy
└── mappings
现在考虑以下合同:
Contract.make {
label 'return_book_1'
input {
triggeredBy('bookReturnedTriggered()')
}
outputMessage {
sentTo('rabbitmq:output?queue=output')
body('''{ "bookName" : "foo" }''')
headers {
header('BOOK-NAME', 'foo')
}
}
}
要从return_book_1
标签,我们使用StubTrigger
接口,如下所示:
stubFinder.trigger("return_book_1")
这将向合约输出消息中描述的目标发送消息。
使用 Spring Integration 的消费者端消息传递
Spring Cloud Contract Stub Runner 的消息传递模块为您提供了一种简单的方法 与 Spring Integration 集成。对于提供的项目,它会自动下载 存根并注册所需的路由。
例子
假设您有以下 Maven 存储库,其中包含用于integrationService
应用:
└── .m2
└── repository
└── io
└── codearte
└── accurest
└── stubs
└── integrationService
├── 0.0.1-SNAPSHOT
│ ├── integrationService-0.0.1-SNAPSHOT.pom
│ ├── integrationService-0.0.1-SNAPSHOT-stubs.jar
│ └── maven-metadata-local.xml
└── maven-metadata-local.xml
进一步假设存根包含以下结构:
├── META-INF
│ └── MANIFEST.MF
└── repository
├── accurest
│ └── bookReturned1.groovy
└── mappings
考虑以下合同:
Contract.make {
label 'return_book_1'
input {
triggeredBy('bookReturnedTriggered()')
}
outputMessage {
sentTo('output')
body('''{ "bookName" : "foo" }''')
headers {
header('BOOK-NAME', 'foo')
}
}
}
现在考虑以下 Spring Integration 路线:
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns="http://www.springframework.org/schema/integration"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/integration
http://www.springframework.org/schema/integration/spring-integration.xsd">
<!-- REQUIRED FOR TESTING -->
<bridge input-channel="output"
output-channel="outputTest"/>
<channel id="outputTest">
<queue/>
</channel>
</beans:beans>
要从return_book_1
标签,请使用StubTrigger
接口,作为
遵循:
stubFinder.trigger('return_book_1')
这将向合约输出消息中描述的目标发送消息。
使用 Spring Cloud Stream 的消费者端消息传递
Spring Cloud Contract Stub Runner 的消息传递模块为您提供了一种简单的方法 与 Spring Stream 集成。对于提供的工件,它会自动下载 存根并注册所需的路由。
如果存根运行器与流的集成messageFrom 或sentTo 字符串
首先解析为destination 频道的,没有这样的destination 存在,则
destination 被解析为通道名称。 |
如果要使用 Spring Cloud Stream,请记住添加一个依赖 专家
Gradle
|
例子
假设您有以下 Maven 存储库,其中包含用于streamService
应用:
└── .m2
└── repository
└── io
└── codearte
└── accurest
└── stubs
└── streamService
├── 0.0.1-SNAPSHOT
│ ├── streamService-0.0.1-SNAPSHOT.pom
│ ├── streamService-0.0.1-SNAPSHOT-stubs.jar
│ └── maven-metadata-local.xml
└── maven-metadata-local.xml
进一步假设存根包含以下结构:
├── META-INF
│ └── MANIFEST.MF
└── repository
├── accurest
│ └── bookReturned1.groovy
└── mappings
考虑以下合同:
Contract.make {
label 'return_book_1'
input { triggeredBy('bookReturnedTriggered()') }
outputMessage {
sentTo('returnBook')
body('''{ "bookName" : "foo" }''')
headers { header('BOOK-NAME', 'foo') }
}
}
现在考虑以下 Spring Cloud Stream 函数配置:
@ImportAutoConfiguration(TestChannelBinderConfiguration.class)
@Configuration(proxyBeanMethods = true)
@EnableAutoConfiguration
protected static class Config {
@Bean
Function<String, String> test1() {
return (input) -> {
println "Test 1 [${input}]"
return input
}
}
}
现在考虑以下 Spring 配置:
stubrunner.repositoryRoot: classpath:m2repo/repository/
stubrunner.ids: org.springframework.cloud.contract.verifier.stubs:streamService:0.0.1-SNAPSHOT:stubs
stubrunner.stubs-mode: remote
spring:
cloud:
stream:
bindings:
test1-in-0:
destination: returnBook
test1-out-0:
destination: outputToAssertBook
function:
definition: test1
server:
port: 0
debug: true
要从return_book_1
标签,请使用StubTrigger
interface 作为
遵循:
stubFinder.trigger('return_book_1')
这将向合约输出消息中描述的目标发送消息。
使用 Spring JMS 进行消费者端消息传递
Spring Cloud Contract Stub Runner 的消息传递模块提供了一种简单的方法 与 Spring JMS 集成。
该集成假定您有一个正在运行的 JMS 代理实例。
将运行器添加到项目中
您需要在类路径上同时具有 Spring JMS 和 Spring Cloud Contract Stub Runner。记得注释你的测试类
跟@AutoConfigureStubRunner
.
例子
假设存根结构如下所示:
├── stubs
└── bookReturned1.groovy
进一步假设以下测试配置:
stubrunner:
repository-root: stubs:classpath:/stubs/
ids: my:stubs
stubs-mode: remote
spring:
activemq:
send-timeout: 1000
jms:
template:
receive-timeout: 1000
现在考虑以下合同:
Contract.make {
label 'return_book_1'
input {
triggeredBy('bookReturnedTriggered()')
}
outputMessage {
sentTo('output')
body('''{ "bookName" : "foo" }''')
headers {
header('BOOKNAME', 'foo')
}
}
}
要从return_book_1
标签,我们使用StubTrigger
接口,如下所示:
stubFinder.trigger('return_book_1')
这将向合约输出消息中描述的目标发送消息。