com.yaoruozhou:jfactory-repo-mock-server
Advanced tools
JFactory Repo MockServer 有两个作用：
通过Gradle添加依赖
testImplementation 'com.yaoruozhou:jfactory-repo-mock-server:0.1.0'
使用下面的代码可以创建一个将数据存入 MockServer 的 JFactory 实例。
JFactory jfactory=new JFactory(new MockServerDataRepositoryImpl(ClientAndServer.startClientAndServer(9081)));
jfactory.register(YourMockServerApiResponses.Response.class);
JFactory Repo JPA 提供了一个将数据存入数据库的 DataRepository 实现，如果要同时使用这两个实现，那么需要实现一个 CombinedDataRepository 类，如下所示：
public class CombinedDataRepository implements MockServerDataRepository {
private final JPADataRepository jpaDataRepository;
private final MockServerDataRepositoryImpl mockServerDataRepository;
public CombinedDataRepository(EntityManager entityManager, MockServerClient mockServerClient) {
jpaDataRepository = new JPADataRepository(entityManager);
mockServerDataRepository = new MockServerDataRepositoryImpl(mockServerClient);
}
@Override
public void setUrlParams(String urlParams) {
mockServerDataRepository.setUrlParams(urlParams);
}
@Override
public void setRootClass(Class<?> aClass) {
mockServerDataRepository.setRootClass(aClass);
}
@Override
public void setPathVariables(String pathVariables) {
mockServerDataRepository.setPathVariables(pathVariables);
}
@Override
public <T> Collection<T> queryAll(Class<T> aClass) {
if (aClass.getPackage().getName().equals("your.mockserver.class.package")) {
return mockServerDataRepository.queryAll(aClass);
} else {
return jpaDataRepository.queryAll(aClass);
}
}
@Override
public void save(Object o) {
if (o.getClass().getPackage().getName().equals("your.mockserver.class.package")) {
mockServerDataRepository.save(o);
} else {
jpaDataRepository.save(o);
}
}
@Override
public void clear() {
jpaDataRepository.clear();
}
}
关于这个 CombinedDataRepository 类有几点需要说明：
MockServerDataRepository 这个接口。该接口在 DataRepository
的基础上增加了几个方法，这些方式会被MockServerData
调用，提供MockServer数据准备所需要的额外信息有了上面的 CombinedDataRepository，就可以使用下面的代码可以创建一个能将数据存入 MockServer 和数据库的 JFactory 实例。
JFactory jfactory=new JFactory(new CombinedDataRepository(entityManagerFactory.createEntityManager(),ClientAndServer.startClientAndServer(9081)));
jfactory.register(YourMockServerApiResponses.Response.class);
为 MockServer 打桩的 Api 准备数据，与在数据库中准备数据并不完全一样，因此 JFactory Repo MockServer 提供了一系列准备 Api 数据的 Step，其用法与 JFactory-Cucumber 提供的 Step 类似。
假如有下面的实体类，并且工厂类已经注册：
@Getter
@Setter
@Request(path = "/beans")
public class Bean {
private String someString;
private int someInt;
private boolean someBoolean;
}
public class Beans {
public static class Factory extends Spec<Bean> {
@Override
protected String getName() {
return "Bean";
}
}
}
值得注意的是，在Bean类定义中有一个Request注解，其path属性值为/beans。通过这个注解，JFactory Repo MockServer 会在 MockServer 上产生一个 /beans 的 Get
请求，并返回根据Bean生成的数据。
当用如下的 Cucumber Step 来创建对象时：
Exists api data "Bean":
| someString | someInt | someBoolean |
| stringValue | 101 | true |
那么向 /beans 发送 Get 请求会得到 200 的响应以及如下所示的响应体：
{
"someString": "stringValue",
"someInt": 101,
"someBoolean": true
}
假如有下面的实体类，并且工厂类已经注册：
@Getter
@Setter
@Request(path = "/beans")
public class Bean {
private String someString;
private int someInt;
private boolean someBoolean;
}
public class Beans {
public static class Factory extends Spec<Bean> {
@Override
protected String getName() {
return "Bean";
}
}
}
当用如下的 Cucumber Step 来创建对象时：
Exists 1 api data "Bean"
那么向 /beans 发送 Get 请求会得到 200 的响应以及如下所示的响应体：
{
"someString": "someString#1",
"someInt": 1,
"someBoolean": true
}
值得注意的是，这里返回的数据都是由 JFactory 产生的默认值。
假如有下面的实体类，并且工厂类已经注册：
@Getter
@Setter
@Request(path = "/beans")
@Response(type = JsonArray)
public class Bean {
private String someString;
private int someInt;
private boolean someBoolean;
}
public class Beans {
public static class Factory extends Spec<Bean> {
@Override
protected String getName() {
return "Bean";
}
}
}
值得注意的是，在Bean类定义中有一个Request注解，其path属性值为/beans，以及另一个Response注解，其type属性值为JsonArray。通过这两个注解，JFactory Repo
MockServer 会在 MockServer 上产生一个 /beans 的 Get 请求，并返回根据Bean生成的数组数据。
当用如下的 Cucumber Step 来创建对象时：
Exists api data "Bean":
| someString | someInt | someBoolean |
| stringValue | 101 | true |
那么向 /beans 发送 Get 请求会得到 200 的响应以及如下所示的响应体：
[
{
"someString": "stringValue",
"someInt": 101,
"someBoolean": true
}
]
假如有下面的实体类，并且工厂类已经注册：
@Getter
@Setter
@Request(path = "/beans")
@Response(type = JsonArray)
public class Bean {
private String someString;
private int someInt;
private boolean someBoolean;
}
public class Beans {
public static class Factory extends Spec<Bean> {
@Override
protected String getName() {
return "Bean";
}
}
}
当用如下的 Cucumber Step 来创建对象时：
Exists 1 api data "Bean"
那么向 /beans 发送 Get 请求会得到 200 的响应以及如下所示的响应体：
[
{
"someString": "someString#1",
"someInt": 1,
"someBoolean": true
}
]
假如有下面的实体类，并且工厂类已经注册：
@Getter
@Setter
@Request(path = "/beans")
public class Bean {
private String someString;
private int someInt;
private boolean someBoolean;
}
public class Beans {
public static class Factory extends Spec<Bean> {
@Override
protected String getName() {
return "Bean";
}
}
}
当用如下的 Cucumber Step 来创建对象时：
Exists api data "Bean" with params "foo=bar"
| someString | someInt | someBoolean |
| stringValue | 102 | false |
那么向 /beans?foo=bar 发送 Get 请求会得到 200 的响应以及如下所示的响应体：
{
"someString": "stringValue",
"someInt": 102,
"someBoolean": false
}
假如有下面的实体类，并且工厂类已经注册：
@Getter
@Setter
@Request(path = "/beansWithChild")
public class BeanWithChild {
private String someString;
private int someInt;
private boolean someBoolean;
private ChildBean child;
@Getter
@Setter
public static class ChildBean {
private String yaString;
}
}
public class BeansWithChild {
public static class Factory extends Spec<BeanWithChild> {
@Override
protected String getName() {
return "BeanWithChild";
}
}
}
当用如下的 Cucumber Step 来创建对象时：
Exists api data "BeanWithChild":
| someString | someInt | someBoolean | child.yaString |
| stringValue | 101 | true | childValue |
那么向 /beansWithChild 发送 Get 请求会得到 200 的响应以及如下所示的响应体：
{
"someString": "stringValue",
"someInt": 101,
"someBoolean": true,
"child": {
"yaString": "childValue"
}
}
假如有下面的实体类，并且工厂类已经注册：
@Getter
@Setter
@Request(path = "/beans/{foo}")
public class Bean {
private String someString;
private int someInt;
private boolean someBoolean;
}
public class Beans {
public static class Factory extends Spec<Bean> {
@Override
protected String getName() {
return "Bean";
}
}
}
当用如下的 Cucumber Step 来创建对象时：
Exists api data "Bean" with path variables "foo=bar"
| someString | someInt | someBoolean |
| stringValue | 102 | false |
那么向 /beans/bar 发送 Get 请求会得到 200 的响应以及如下所示的响应体：
{
"someString": "stringValue",
"someInt": 102,
"someBoolean": false
}
该注解用来定义 MockServer 打桩的 Api 请求，属性如下：
| 属性名 | 属性值 |
|---|---|
| path | 必填，如 /beans，不能包含 query param |
| method | 选填，默认值为 GET，有效值为 GET，POST，PUT，不区分大小写 |
此注解必须定义。
该注解用来定义 MockServer 打桩的 Api 响应体，属性如下：
| 属性名 | 属性值 |
|---|---|
| type | 选填，默认值为 JsonObject，有效值为 JsonObject 和 JsonArray |
此注解可以不定义。如果不定义，响应体默认返回 JsonObject。
FAQs
Unknown package
We found that com.yaoruozhou:jfactory-repo-mock-server demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.
Security News
The Ultralytics' PyPI Package was compromised four times in one weekend through GitHub Actions cache poisoning and failure to rotate previously compromised API tokens.
Security News
Research
Socket researchers found a malicious Maven package impersonating the legitimate ‘XZ for Java’ library, introducing a backdoor for remote code execution.